From 55728e62cb2eaa729b0409c6cce8ed89d7bc9819 Mon Sep 17 00:00:00 2001 From: Joey Dreijer Date: Thu, 7 May 2026 16:23:26 +0200 Subject: [PATCH 1/8] Add CLI command to generate query bundle (#1) * Add CLI command to generate saved searches/query bundle * Add test for saved searches bundle generation --- .pre-commit-hooks.yaml | 11 +++ src/openhound/cli/saved_search.py | 81 +++++++++++++----- src/openhound/core/models/saved_search.py | 59 ++++++++++++- tests/test_cypher_syntax.py | 84 +++++++++++++++++++ .../saved_searches/jamf_query_by_name_2.json | 5 ++ tests/test_saved_searches_bundle.py | 66 +++++++++++++++ 6 files changed, 283 insertions(+), 23 deletions(-) create mode 100644 .pre-commit-hooks.yaml create mode 100644 tests/test_cypher_syntax.py create mode 100644 tests/test_data/extensions/saved_searches/jamf_query_by_name_2.json create mode 100644 tests/test_saved_searches_bundle.py diff --git a/.pre-commit-hooks.yaml b/.pre-commit-hooks.yaml new file mode 100644 index 0000000..c8bf13b --- /dev/null +++ b/.pre-commit-hooks.yaml @@ -0,0 +1,11 @@ +- id: openhound-cypher-bundle + name: OpenHound create a cypher query bundle + entry: scripts/bundle.py + language: python + pass_filenames: false + +- id: openhound-cypher-test + name: OpenHound validate cypher query syntax + entry: pytest tests/test_config_validation.py -q + language: python + pass_filenames: false \ No newline at end of file diff --git a/src/openhound/cli/saved_search.py b/src/openhound/cli/saved_search.py index 9eb27e4..8dcca79 100644 --- a/src/openhound/cli/saved_search.py +++ b/src/openhound/cli/saved_search.py @@ -4,6 +4,7 @@ import typer +from openhound.core.models.saved_search import QueryBundle from openhound.core.progress import Progress from openhound.core.saved_searches import SavedSearches, Strategy @@ -15,30 +16,35 @@ class Format(str, Enum): yaml = "yaml" +class OutputFormat(str, Enum): + json = "json" + zip = "zip" + + @saved_searches.command(help="Upload saved searches to BloodHound") def upload( - path: Annotated[ - Path, - typer.Argument( - exists=True, - file_okay=False, - dir_okay=True, - readable=True, - resolve_path=True, - help="Directory where saved searches are located", + path: Annotated[ + Path, + typer.Argument( + exists=True, + file_okay=False, + dir_okay=True, + readable=True, + resolve_path=True, + help="Directory where saved searches are located", + ), + ], + file_format: Format = typer.Option( + default=Format.json, + help="File format of the saved searches (json or yaml)", + ), + strategy: Strategy = typer.Option( + default=Strategy.skip, + help="Skip or overwrite saved search if the name already exists", + ), + progress: Progress = typer.Option( + Progress.tqdm, help="Select progress tracker option" ), - ], - file_format: Format = typer.Option( - default=Format.json, - help="File format of the saved searches (json or yaml)", - ), - strategy: Strategy = typer.Option( - default=Strategy.skip, - help="Skip or overwrite saved search if the name already exists", - ), - progress: Progress = typer.Option( - Progress.tqdm, help="Select progress tracker option" - ), ): search_files = ( path.rglob("**/*.json") @@ -48,3 +54,36 @@ def upload( pipeline = SavedSearches(progress=progress, strategy=strategy) results = pipeline.run(list(search_files), file_format=file_format) return results + + +@saved_searches.command(help="Create a single saved searches json/zip bundle") +def bundle( + path: Annotated[ + Path, + typer.Argument( + exists=True, + file_okay=False, + dir_okay=True, + readable=True, + resolve_path=True, + help="Directory where saved searches are located", + ), + ], + output_path: Annotated[typer.FileTextWrite, typer.Argument()], + file_format: Format = typer.Option( + default=Format.json, + help="File format of the saved searches (json or yaml)", + ), + output_format: OutputFormat = typer.Option( + default=OutputFormat.json, + help="File format for the saved searches bundle (json or zip)", + ) +): + search_files = ( + path.rglob("**/*.json") + if file_format == Format.json + else path.rglob("**/*.yaml") + ) + + bundle_object = QueryBundle.from_paths(list(search_files), file_format=file_format) + bundle_object.save(output_path, output_format=output_format) diff --git a/src/openhound/core/models/saved_search.py b/src/openhound/core/models/saved_search.py index 8feaf40..4d78717 100644 --- a/src/openhound/core/models/saved_search.py +++ b/src/openhound/core/models/saved_search.py @@ -1,4 +1,7 @@ import json +import zipfile +from enum import Enum +from io import TextIOWrapper from pathlib import Path from typing import Optional, Union @@ -6,6 +9,16 @@ from yaml import safe_load +class Format(str, Enum): + json = "json" + yaml = "yaml" + + +class OutputFormat(str, Enum): + json = "json" + zip = "zip" + + class SavedSearch(BaseModel): model_config = ConfigDict(extra="forbid") # Required for an extension @@ -14,7 +27,7 @@ class SavedSearch(BaseModel): query: str @classmethod - def from_json(cls, file_path: Path) -> "SavedSearch": + def from_file(cls, file_path: Path) -> "SavedSearch": with open(file_path, "r") as file_object: json_object = json.loads(file_object.read()) return cls(**json_object) @@ -52,7 +65,49 @@ def acknowledgementsis_list(cls, value: str | list[str]) -> list[str]: return value if isinstance(value, list) else [value] @classmethod - def from_yaml(cls, file_path: Path) -> "SavedSearchExtended": + def from_file(cls, file_path: Path) -> "SavedSearchExtended": with open(file_path, "r") as file_object: yaml_object = safe_load(file_object.read()) return cls(**yaml_object) + + +class QueryBundle: + def __init__(self, queries: list[SavedSearchExtended | SavedSearch], file_format: Format = Format.json) -> None: + self.queries = queries + self.file_format = file_format + + @classmethod + def from_paths(cls, all_files: list[Path], file_format: Format = Format.json) -> "QueryBundle": + model_choices = { + 'yaml': SavedSearchExtended, + 'json': SavedSearch, + } + + queries = [ + model_choices[file_format].from_file(cypher_query) for cypher_query in + all_files + ] + return cls(queries, file_format) + + def _to_json(self, output_file: TextIOWrapper) -> None: + all_objects = [query.model_dump() for query in self.queries] + output_file.write(json.dumps(all_objects, indent=2)) + + def _to_zip(self, output_file: TextIOWrapper) -> None: + with zipfile.ZipFile( + file=output_file.name, + mode="w", + compression=zipfile.ZIP_DEFLATED, + compresslevel=9, + ) as archive: + for query in self.queries: + archive.writestr( + zinfo_or_arcname=f"{query.name}.json", + data=query.model_dump_json().encode(), + ) + + def save(self, output_file: TextIOWrapper, output_format: OutputFormat = OutputFormat.json) -> None: + if output_format == OutputFormat.json: + self._to_json(output_file) + elif output_format == OutputFormat.zip: + self._to_zip(output_file) diff --git a/tests/test_cypher_syntax.py b/tests/test_cypher_syntax.py new file mode 100644 index 0000000..3c3cbde --- /dev/null +++ b/tests/test_cypher_syntax.py @@ -0,0 +1,84 @@ +import glob +import os +import sys + +import pytest +import yaml +from antlr4 import CommonTokenStream, InputStream +from antlr4.error.ErrorListener import ErrorListener +from pydantic import ValidationError +from schema import CypherQuery + +from grammar.CypherLexer import CypherLexer +from grammar.CypherParser import CypherParser + +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + + +class CypherErrorListener(ErrorListener): + + def __init__(self): + super(CypherErrorListener, self).__init__() + + def syntaxError(self, recognizer, offendingSymbol, line: int, column: int, + msg: str, e: Exception) -> None: + raise ValueError(f"Syntax error at line: {line}, msg: {msg}") + + +def get_query_files(cypher_dir: str = "queries") -> list: + if not os.path.exists(cypher_dir): + return [] + return glob.glob(os.path.join("queries", "**", "*.yml"), recursive=True) + + +@pytest.mark.parametrize("file_path", get_query_files("queries")) +def test_cypher_validation(file_path: str, request: pytest.FixtureRequest) -> None: + with open(file_path, "r") as f: + yaml_object = yaml.safe_load(f) + + try: + # Load the query using the Pydantic schema + validate_schema = CypherQuery(**yaml_object) + except ValidationError as e: + pytest.fail(f"Pydantic validation failed for {file_path}: {str(e)}", pytrace=False) + + # Save the query content for error reports + request.node.user_data = {"query": validate_schema.query} + + # Split query into multiple lines in order to remove line comments + lines = validate_schema.query.splitlines() + uncomment_query = "\n".join(line.split("//")[0].rstrip() for line in lines) + uncomment_query = uncomment_query.lstrip("\n") + + # Attempt to load/parse the query using the CypherParser + lexer = CypherLexer(InputStream(uncomment_query)) + stream = CommonTokenStream(lexer) + parser = CypherParser(stream) + parser.addErrorListener(CypherErrorListener()) + + # Attempt to parse the query or raise a generic exception + try: + parse_query = parser.oC_Query() + assert parse_query.exception is None + + except Exception as e: + pytest.fail(f"Parsing failed for file {file_path}: {str(e)}", pytrace=False) + + +def test_duplicate_guid() -> None: + query_files = get_query_files("queries") + guids = set() + + # Iterate over all query files and check for duplicate GUIDs + for file_path in query_files: + with open(file_path, "r") as f: + yaml_object = yaml.safe_load(f) + + query_guid = yaml_object["guid"] + if query_guid in guids: + pytest.fail(f"Duplicate GUID found: {query_guid} in file {file_path}", pytrace=False) + guids.add(query_guid) + + +if __name__ == "__main__": + pytest.main(["-v", __file__]) diff --git a/tests/test_data/extensions/saved_searches/jamf_query_by_name_2.json b/tests/test_data/extensions/saved_searches/jamf_query_by_name_2.json new file mode 100644 index 0000000..87cb051 --- /dev/null +++ b/tests/test_data/extensions/saved_searches/jamf_query_by_name_2.json @@ -0,0 +1,5 @@ +{ + "name": "Jamf v2: Account Access by Name", + "description": "This is an identical query but duplicated for CICD tests", + "query": "MATCH p=(s:jamf_Account)-[*1..5]->(t)\nWHERE s.name STARTS WITH 'LC'\nRETURN p\nLIMIT 1000" +} diff --git a/tests/test_saved_searches_bundle.py b/tests/test_saved_searches_bundle.py new file mode 100644 index 0000000..83dc1fc --- /dev/null +++ b/tests/test_saved_searches_bundle.py @@ -0,0 +1,66 @@ +import json +import zipfile +from pathlib import Path + +from typer.testing import CliRunner + +from openhound.main import app + +TEST_DATA_DIR = Path(__file__).parent / "test_data" / "extensions" / "saved_searches" + + +def test_saved_search_bundle_writes_json(tmp_path): + output_path = tmp_path / "saved_searches.json" + + result = CliRunner().invoke( + app, + [ + "searches", + "bundle", + str(TEST_DATA_DIR), + str(output_path), + "--file-format", + "json", + "--output-format", + "json", + ], + ) + + assert result.exit_code == 0 + assert output_path.exists() + assert output_path.suffix == ".json" + + saved_searches = json.loads(output_path.read_text()) + assert len(saved_searches) == 2 + + +def test_saved_search_bundle_writes_zip(tmp_path): + output_path = tmp_path / "saved_searches.zip" + + result = CliRunner().invoke( + app, + [ + "searches", + "bundle", + str(TEST_DATA_DIR), + str(output_path), + "--file-format", + "json", + "--output-format", + "zip", + ], + ) + + assert result.exit_code == 0 + assert output_path.exists() + assert output_path.suffix == ".zip" + + with zipfile.ZipFile(output_path) as archive: + archive_names = archive.namelist() + assert len(archive_names) == 2 + assert all(name.endswith(".json") for name in archive_names) + saved_searches = [ + json.loads(archive.read(name).decode()) for name in archive_names + ] + + assert len(saved_searches) == 2 From c1abc52aac0f28bbb0878d465a732f06a9d9b86b Mon Sep 17 00:00:00 2001 From: Joey Dreijer Date: Thu, 7 May 2026 16:29:34 +0200 Subject: [PATCH 2/8] Added console output + help --- src/openhound/cli/saved_search.py | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/src/openhound/cli/saved_search.py b/src/openhound/cli/saved_search.py index 8dcca79..d142a27 100644 --- a/src/openhound/cli/saved_search.py +++ b/src/openhound/cli/saved_search.py @@ -3,6 +3,7 @@ from typing import Annotated import typer +from rich import Console from openhound.core.models.saved_search import QueryBundle from openhound.core.progress import Progress @@ -69,7 +70,8 @@ def bundle( help="Directory where saved searches are located", ), ], - output_path: Annotated[typer.FileTextWrite, typer.Argument()], + output_path: Annotated[typer.FileTextWrite, typer.Argument( + help="Output file path for the generated saved-search bundle (including filename)")], file_format: Format = typer.Option( default=Format.json, help="File format of the saved searches (json or yaml)", @@ -79,11 +81,18 @@ def bundle( help="File format for the saved searches bundle (json or zip)", ) ): - search_files = ( + search_files = list( path.rglob("**/*.json") if file_format == Format.json else path.rglob("**/*.yaml") ) - bundle_object = QueryBundle.from_paths(list(search_files), file_format=file_format) + bundle_object = QueryBundle.from_paths(search_files, file_format=file_format) bundle_object.save(output_path, output_format=output_format) + + console = Console() + console.print("[bold green]Saved-search bundle created[/bold green]") + console.print(f"[bold magenta]Saved searches:[/bold magenta] {len(bundle_object.queries)}") + console.print( + f"[bold magenta]Output path:[/bold magenta] [italic]{Path(output_path.name).resolve()}[/italic]" + ) From 0f1b28f0f8b5783f34310e72a0095c81dc336eb3 Mon Sep 17 00:00:00 2001 From: Joey Dreijer Date: Thu, 7 May 2026 16:30:24 +0200 Subject: [PATCH 3/8] Added console output + help --- src/openhound/cli/saved_search.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/openhound/cli/saved_search.py b/src/openhound/cli/saved_search.py index d142a27..9c1e732 100644 --- a/src/openhound/cli/saved_search.py +++ b/src/openhound/cli/saved_search.py @@ -3,7 +3,7 @@ from typing import Annotated import typer -from rich import Console +from rich.console import Console from openhound.core.models.saved_search import QueryBundle from openhound.core.progress import Progress From 5346e7ab839185fd1b235166acb8a0bb93227518 Mon Sep 17 00:00:00 2001 From: Joey Dreijer Date: Fri, 22 May 2026 20:19:11 +0200 Subject: [PATCH 4/8] Add antlr to dev deps --- pyproject.toml | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 8d93a4d..a69cf8b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,32 +10,31 @@ dependencies = [ "duckdb==1.5.2", "griffe>=1.15.0", "griffe-fieldz>=0.5.0", - "mkdocstrings[python]>=1.0.0", + "mkdocstrings[python]==1.0.4", "psutil>=7.2.1", "pydantic==2.13.3", "tqdm>=4.67.1", - "typer>=0.25.1", + "typer==0.25.1", "cookiecutter>=2.6.0", + "pydantic-extra-types>=2.11.0", "jinja2>=3.1.6", - "types-requests==2.33.0.20260503", - "pydantic-extra-types>=2.11.1", ] [project.optional-dependencies] all = [ - "openhound-jamf==0.1.3", + "openhound-jamf==0.1.0", "openhound-github==0.1.0", - "openhound-okta==0.1.2", + "openhound-okta==0.1.1", ] jamf = [ - "openhound-jamf==0.1.3", + "openhound-jamf==0.1.0", ] github = [ "openhound-github==0.1.0" ] okta = [ - "openhound-okta==0.1.2", + "openhound-okta==0.1.1", ] [project.scripts] @@ -66,17 +65,18 @@ local_scheme = "no-local-version" [dependency-groups] dev = [ - "openhound-faker==0.0.6", - "ipython>=9.13.0", - "pre-commit>=4.5.1", + "openhound-faker==0.0.4", + "ipython>=9.12.0", + "pre-commit==4.6.0", "pytest>=9.0.1", - "marimo>=0.23.5", - "altair>=6.1.0", - "fastapi>=0.136.1", - "zensical>=0.0.40", - "ruff>=0.15.4", - "mypy>=1.19.1", + "marimo==0.23.4", + "altair==6.1.0", + "fastapi==0.136.1", + "zensical>=0.0.38", + "ruff==0.15.12", + "mypy==1.20.2", "types-pyyaml>=6.0.12.20250915", "types-requests>=2.33.0.20260408", "httpx>=0.28.1", + "antlr4-python3-runtime>=4.13.2", ] From 549455e3c8b7cfa19a784ddfdf78ab2306b0d47f Mon Sep 17 00:00:00 2001 From: Joey Dreijer Date: Fri, 22 May 2026 20:19:40 +0200 Subject: [PATCH 5/8] Add Cypher grammar --- tests/grammar/CypherLexer.py | 14101 ++++++++++ tests/grammar/CypherListener.py | 1328 + tests/grammar/CypherParser.py | 32890 ++++++++++++++++++++++ tests/grammar/__init__.py | 0 tests/grammar/cypher/Cypher.g4 | 1013 + tests/grammar/cypher/Cypher.interp | 459 + tests/grammar/cypher/Cypher.tokens | 198 + tests/grammar/cypher/CypherLexer.interp | 490 + tests/grammar/cypher/CypherLexer.tokens | 198 + 9 files changed, 50677 insertions(+) create mode 100644 tests/grammar/CypherLexer.py create mode 100644 tests/grammar/CypherListener.py create mode 100644 tests/grammar/CypherParser.py create mode 100644 tests/grammar/__init__.py create mode 100644 tests/grammar/cypher/Cypher.g4 create mode 100644 tests/grammar/cypher/Cypher.interp create mode 100644 tests/grammar/cypher/Cypher.tokens create mode 100644 tests/grammar/cypher/CypherLexer.interp create mode 100644 tests/grammar/cypher/CypherLexer.tokens diff --git a/tests/grammar/CypherLexer.py b/tests/grammar/CypherLexer.py new file mode 100644 index 0000000..cfbbd8b --- /dev/null +++ b/tests/grammar/CypherLexer.py @@ -0,0 +1,14101 @@ +# Generated from Cypher.g4 by ANTLR 4.13.2 +from antlr4 import * +from io import StringIO +import sys + +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + + +def serializedATN(): + return [ + 4, + 0, + 151, + 1223, + 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, + 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, + 7, + 1, + 8, + 1, + 8, + 1, + 9, + 1, + 9, + 1, + 10, + 1, + 10, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 13, + 1, + 13, + 1, + 14, + 1, + 14, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 18, + 1, + 18, + 1, + 19, + 1, + 19, + 1, + 20, + 1, + 20, + 1, + 21, + 1, + 21, + 1, + 22, + 1, + 22, + 1, + 23, + 1, + 23, + 1, + 24, + 1, + 24, + 1, + 25, + 1, + 25, + 1, + 26, + 1, + 26, + 1, + 27, + 1, + 27, + 1, + 28, + 1, + 28, + 1, + 29, + 1, + 29, + 1, + 30, + 1, + 30, + 1, + 31, + 1, + 31, + 1, + 32, + 1, + 32, + 1, + 33, + 1, + 33, + 1, + 34, + 1, + 34, + 1, + 35, + 1, + 35, + 1, + 36, + 1, + 36, + 1, + 37, + 1, + 37, + 1, + 38, + 1, + 38, + 1, + 39, + 1, + 39, + 1, + 40, + 1, + 40, + 1, + 41, + 1, + 41, + 1, + 42, + 1, + 42, + 1, + 43, + 1, + 43, + 1, + 44, + 1, + 44, + 1, + 45, + 1, + 45, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 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, + 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, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 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, + 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, + 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, + 64, + 1, + 64, + 1, + 64, + 1, + 64, + 1, + 65, + 1, + 65, + 1, + 65, + 1, + 65, + 1, + 65, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 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, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 82, + 1, + 82, + 1, + 82, + 1, + 82, + 1, + 82, + 1, + 82, + 1, + 82, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 85, + 1, + 85, + 1, + 85, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 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, + 92, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 95, + 1, + 95, + 1, + 95, + 1, + 95, + 1, + 95, + 1, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 1, + 97, + 1, + 97, + 1, + 97, + 1, + 97, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 102, + 1, + 102, + 1, + 102, + 1, + 102, + 1, + 103, + 1, + 103, + 1, + 103, + 1, + 103, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 108, + 1, + 108, + 1, + 108, + 1, + 108, + 1, + 108, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 110, + 1, + 110, + 1, + 110, + 1, + 110, + 1, + 110, + 1, + 111, + 1, + 111, + 1, + 111, + 1, + 111, + 1, + 111, + 1, + 112, + 1, + 112, + 1, + 112, + 1, + 112, + 1, + 113, + 1, + 113, + 1, + 113, + 1, + 113, + 1, + 113, + 1, + 114, + 1, + 114, + 1, + 114, + 1, + 114, + 1, + 114, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 116, + 1, + 116, + 1, + 116, + 1, + 116, + 1, + 116, + 1, + 116, + 1, + 116, + 1, + 116, + 1, + 117, + 1, + 117, + 1, + 117, + 1, + 117, + 1, + 117, + 1, + 117, + 1, + 117, + 1, + 118, + 1, + 118, + 1, + 118, + 1, + 118, + 1, + 119, + 1, + 119, + 1, + 119, + 1, + 119, + 1, + 119, + 1, + 120, + 1, + 120, + 1, + 120, + 1, + 120, + 1, + 120, + 1, + 120, + 1, + 120, + 1, + 121, + 1, + 121, + 1, + 121, + 1, + 121, + 1, + 121, + 1, + 122, + 1, + 122, + 1, + 122, + 1, + 122, + 1, + 122, + 1, + 122, + 1, + 123, + 1, + 123, + 1, + 123, + 1, + 123, + 4, + 123, + 938, + 8, + 123, + 11, + 123, + 12, + 123, + 939, + 1, + 124, + 1, + 124, + 1, + 124, + 5, + 124, + 945, + 8, + 124, + 10, + 124, + 12, + 124, + 948, + 9, + 124, + 3, + 124, + 950, + 8, + 124, + 1, + 125, + 1, + 125, + 1, + 125, + 1, + 125, + 4, + 125, + 956, + 8, + 125, + 11, + 125, + 12, + 125, + 957, + 1, + 126, + 3, + 126, + 961, + 8, + 126, + 1, + 127, + 1, + 127, + 3, + 127, + 965, + 8, + 127, + 1, + 128, + 1, + 128, + 3, + 128, + 969, + 8, + 128, + 1, + 129, + 1, + 129, + 3, + 129, + 973, + 8, + 129, + 1, + 130, + 1, + 130, + 1, + 131, + 1, + 131, + 3, + 131, + 979, + 8, + 131, + 1, + 132, + 1, + 132, + 1, + 133, + 4, + 133, + 984, + 8, + 133, + 11, + 133, + 12, + 133, + 985, + 1, + 133, + 4, + 133, + 989, + 8, + 133, + 11, + 133, + 12, + 133, + 990, + 1, + 133, + 1, + 133, + 4, + 133, + 995, + 8, + 133, + 11, + 133, + 12, + 133, + 996, + 1, + 133, + 1, + 133, + 4, + 133, + 1001, + 8, + 133, + 11, + 133, + 12, + 133, + 1002, + 3, + 133, + 1005, + 8, + 133, + 1, + 133, + 1, + 133, + 3, + 133, + 1009, + 8, + 133, + 1, + 133, + 4, + 133, + 1012, + 8, + 133, + 11, + 133, + 12, + 133, + 1013, + 1, + 134, + 5, + 134, + 1017, + 8, + 134, + 10, + 134, + 12, + 134, + 1020, + 9, + 134, + 1, + 134, + 1, + 134, + 4, + 134, + 1024, + 8, + 134, + 11, + 134, + 12, + 134, + 1025, + 1, + 135, + 1, + 135, + 1, + 135, + 5, + 135, + 1031, + 8, + 135, + 10, + 135, + 12, + 135, + 1034, + 9, + 135, + 1, + 135, + 1, + 135, + 1, + 135, + 1, + 135, + 5, + 135, + 1040, + 8, + 135, + 10, + 135, + 12, + 135, + 1043, + 9, + 135, + 1, + 135, + 3, + 135, + 1046, + 8, + 135, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 3, + 136, + 1066, + 8, + 136, + 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, + 139, + 1, + 139, + 1, + 140, + 1, + 140, + 1, + 140, + 1, + 140, + 1, + 140, + 1, + 140, + 1, + 140, + 1, + 140, + 1, + 140, + 1, + 140, + 1, + 141, + 1, + 141, + 1, + 141, + 1, + 141, + 1, + 141, + 1, + 141, + 1, + 141, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 143, + 1, + 143, + 1, + 143, + 1, + 143, + 1, + 144, + 1, + 144, + 5, + 144, + 1109, + 8, + 144, + 10, + 144, + 12, + 144, + 1112, + 9, + 144, + 1, + 145, + 1, + 145, + 3, + 145, + 1116, + 8, + 145, + 1, + 146, + 1, + 146, + 3, + 146, + 1120, + 8, + 146, + 1, + 147, + 1, + 147, + 5, + 147, + 1124, + 8, + 147, + 10, + 147, + 12, + 147, + 1127, + 9, + 147, + 1, + 147, + 4, + 147, + 1130, + 8, + 147, + 11, + 147, + 12, + 147, + 1131, + 1, + 148, + 4, + 148, + 1135, + 8, + 148, + 11, + 148, + 12, + 148, + 1136, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 3, + 149, + 1151, + 8, + 149, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 5, + 150, + 1159, + 8, + 150, + 10, + 150, + 12, + 150, + 1162, + 9, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 5, + 150, + 1170, + 8, + 150, + 10, + 150, + 12, + 150, + 1173, + 9, + 150, + 1, + 150, + 3, + 150, + 1176, + 8, + 150, + 1, + 150, + 1, + 150, + 3, + 150, + 1180, + 8, + 150, + 3, + 150, + 1182, + 8, + 150, + 1, + 151, + 1, + 151, + 1, + 152, + 1, + 152, + 1, + 153, + 1, + 153, + 1, + 154, + 1, + 154, + 1, + 155, + 1, + 155, + 1, + 156, + 1, + 156, + 1, + 157, + 1, + 157, + 1, + 158, + 1, + 158, + 1, + 159, + 1, + 159, + 1, + 160, + 1, + 160, + 1, + 161, + 1, + 161, + 1, + 162, + 1, + 162, + 1, + 163, + 1, + 163, + 1, + 164, + 1, + 164, + 1, + 165, + 1, + 165, + 1, + 166, + 1, + 166, + 1, + 167, + 1, + 167, + 1, + 168, + 1, + 168, + 1, + 169, + 1, + 169, + 1, + 170, + 1, + 170, + 0, + 0, + 171, + 1, + 1, + 3, + 2, + 5, + 3, + 7, + 4, + 9, + 5, + 11, + 6, + 13, + 7, + 15, + 8, + 17, + 9, + 19, + 10, + 21, + 11, + 23, + 12, + 25, + 13, + 27, + 14, + 29, + 15, + 31, + 16, + 33, + 17, + 35, + 18, + 37, + 19, + 39, + 20, + 41, + 21, + 43, + 22, + 45, + 23, + 47, + 24, + 49, + 25, + 51, + 26, + 53, + 27, + 55, + 28, + 57, + 29, + 59, + 30, + 61, + 31, + 63, + 32, + 65, + 33, + 67, + 34, + 69, + 35, + 71, + 36, + 73, + 37, + 75, + 38, + 77, + 39, + 79, + 40, + 81, + 41, + 83, + 42, + 85, + 43, + 87, + 44, + 89, + 45, + 91, + 46, + 93, + 47, + 95, + 48, + 97, + 49, + 99, + 50, + 101, + 51, + 103, + 52, + 105, + 53, + 107, + 54, + 109, + 55, + 111, + 56, + 113, + 57, + 115, + 58, + 117, + 59, + 119, + 60, + 121, + 61, + 123, + 62, + 125, + 63, + 127, + 64, + 129, + 65, + 131, + 66, + 133, + 67, + 135, + 68, + 137, + 69, + 139, + 70, + 141, + 71, + 143, + 72, + 145, + 73, + 147, + 74, + 149, + 75, + 151, + 76, + 153, + 77, + 155, + 78, + 157, + 79, + 159, + 80, + 161, + 81, + 163, + 82, + 165, + 83, + 167, + 84, + 169, + 85, + 171, + 86, + 173, + 87, + 175, + 88, + 177, + 89, + 179, + 90, + 181, + 91, + 183, + 92, + 185, + 93, + 187, + 94, + 189, + 95, + 191, + 96, + 193, + 97, + 195, + 98, + 197, + 99, + 199, + 100, + 201, + 101, + 203, + 102, + 205, + 103, + 207, + 104, + 209, + 105, + 211, + 106, + 213, + 107, + 215, + 108, + 217, + 109, + 219, + 110, + 221, + 111, + 223, + 112, + 225, + 113, + 227, + 114, + 229, + 115, + 231, + 116, + 233, + 117, + 235, + 118, + 237, + 119, + 239, + 120, + 241, + 121, + 243, + 122, + 245, + 123, + 247, + 124, + 249, + 125, + 251, + 126, + 253, + 127, + 255, + 128, + 257, + 129, + 259, + 130, + 261, + 131, + 263, + 132, + 265, + 133, + 267, + 134, + 269, + 135, + 271, + 136, + 273, + 137, + 275, + 138, + 277, + 139, + 279, + 140, + 281, + 141, + 283, + 142, + 285, + 143, + 287, + 144, + 289, + 145, + 291, + 146, + 293, + 147, + 295, + 148, + 297, + 149, + 299, + 150, + 301, + 151, + 303, + 0, + 305, + 0, + 307, + 0, + 309, + 0, + 311, + 0, + 313, + 0, + 315, + 0, + 317, + 0, + 319, + 0, + 321, + 0, + 323, + 0, + 325, + 0, + 327, + 0, + 329, + 0, + 331, + 0, + 333, + 0, + 335, + 0, + 337, + 0, + 339, + 0, + 341, + 0, + 1, + 0, + 48, + 2, + 0, + 67, + 67, + 99, + 99, + 2, + 0, + 89, + 89, + 121, + 121, + 2, + 0, + 80, + 80, + 112, + 112, + 2, + 0, + 72, + 72, + 104, + 104, + 2, + 0, + 69, + 69, + 101, + 101, + 2, + 0, + 82, + 82, + 114, + 114, + 2, + 0, + 88, + 88, + 120, + 120, + 2, + 0, + 76, + 76, + 108, + 108, + 2, + 0, + 65, + 65, + 97, + 97, + 2, + 0, + 73, + 73, + 105, + 105, + 2, + 0, + 78, + 78, + 110, + 110, + 2, + 0, + 79, + 79, + 111, + 111, + 2, + 0, + 70, + 70, + 102, + 102, + 2, + 0, + 85, + 85, + 117, + 117, + 2, + 0, + 83, + 83, + 115, + 115, + 2, + 0, + 71, + 71, + 103, + 103, + 2, + 0, + 68, + 68, + 100, + 100, + 2, + 0, + 77, + 77, + 109, + 109, + 2, + 0, + 84, + 84, + 116, + 116, + 2, + 0, + 81, + 81, + 113, + 113, + 2, + 0, + 86, + 86, + 118, + 118, + 2, + 0, + 87, + 87, + 119, + 119, + 2, + 0, + 66, + 66, + 98, + 98, + 2, + 0, + 75, + 75, + 107, + 107, + 2, + 0, + 74, + 74, + 106, + 106, + 2, + 0, + 65, + 70, + 97, + 102, + 13, + 0, + 34, + 34, + 39, + 39, + 66, + 66, + 70, + 70, + 78, + 78, + 82, + 82, + 84, + 84, + 92, + 92, + 98, + 98, + 102, + 102, + 110, + 110, + 114, + 114, + 116, + 116, + 8, + 0, + 160, + 160, + 5760, + 5760, + 6158, + 6158, + 8192, + 8202, + 8232, + 8233, + 8239, + 8239, + 8287, + 8287, + 12288, + 12288, + 1, + 0, + 12, + 12, + 1, + 0, + 96, + 96, + 1, + 0, + 30, + 30, + 768, + 0, + 48, + 57, + 65, + 90, + 95, + 95, + 97, + 122, + 170, + 170, + 181, + 181, + 183, + 183, + 186, + 186, + 192, + 214, + 216, + 246, + 248, + 705, + 710, + 721, + 736, + 740, + 748, + 748, + 750, + 750, + 768, + 884, + 886, + 887, + 890, + 893, + 895, + 895, + 902, + 906, + 908, + 908, + 910, + 929, + 931, + 1013, + 1015, + 1153, + 1155, + 1159, + 1162, + 1327, + 1329, + 1366, + 1369, + 1369, + 1376, + 1416, + 1425, + 1469, + 1471, + 1471, + 1473, + 1474, + 1476, + 1477, + 1479, + 1479, + 1488, + 1514, + 1519, + 1522, + 1552, + 1562, + 1568, + 1641, + 1646, + 1747, + 1749, + 1756, + 1759, + 1768, + 1770, + 1788, + 1791, + 1791, + 1808, + 1866, + 1869, + 1969, + 1984, + 2037, + 2042, + 2042, + 2045, + 2045, + 2048, + 2093, + 2112, + 2139, + 2144, + 2154, + 2160, + 2183, + 2185, + 2190, + 2200, + 2273, + 2275, + 2403, + 2406, + 2415, + 2417, + 2435, + 2437, + 2444, + 2447, + 2448, + 2451, + 2472, + 2474, + 2480, + 2482, + 2482, + 2486, + 2489, + 2492, + 2500, + 2503, + 2504, + 2507, + 2510, + 2519, + 2519, + 2524, + 2525, + 2527, + 2531, + 2534, + 2545, + 2556, + 2556, + 2558, + 2558, + 2561, + 2563, + 2565, + 2570, + 2575, + 2576, + 2579, + 2600, + 2602, + 2608, + 2610, + 2611, + 2613, + 2614, + 2616, + 2617, + 2620, + 2620, + 2622, + 2626, + 2631, + 2632, + 2635, + 2637, + 2641, + 2641, + 2649, + 2652, + 2654, + 2654, + 2662, + 2677, + 2689, + 2691, + 2693, + 2701, + 2703, + 2705, + 2707, + 2728, + 2730, + 2736, + 2738, + 2739, + 2741, + 2745, + 2748, + 2757, + 2759, + 2761, + 2763, + 2765, + 2768, + 2768, + 2784, + 2787, + 2790, + 2799, + 2809, + 2815, + 2817, + 2819, + 2821, + 2828, + 2831, + 2832, + 2835, + 2856, + 2858, + 2864, + 2866, + 2867, + 2869, + 2873, + 2876, + 2884, + 2887, + 2888, + 2891, + 2893, + 2901, + 2903, + 2908, + 2909, + 2911, + 2915, + 2918, + 2927, + 2929, + 2929, + 2946, + 2947, + 2949, + 2954, + 2958, + 2960, + 2962, + 2965, + 2969, + 2970, + 2972, + 2972, + 2974, + 2975, + 2979, + 2980, + 2984, + 2986, + 2990, + 3001, + 3006, + 3010, + 3014, + 3016, + 3018, + 3021, + 3024, + 3024, + 3031, + 3031, + 3046, + 3055, + 3072, + 3084, + 3086, + 3088, + 3090, + 3112, + 3114, + 3129, + 3132, + 3140, + 3142, + 3144, + 3146, + 3149, + 3157, + 3158, + 3160, + 3162, + 3165, + 3165, + 3168, + 3171, + 3174, + 3183, + 3200, + 3203, + 3205, + 3212, + 3214, + 3216, + 3218, + 3240, + 3242, + 3251, + 3253, + 3257, + 3260, + 3268, + 3270, + 3272, + 3274, + 3277, + 3285, + 3286, + 3293, + 3294, + 3296, + 3299, + 3302, + 3311, + 3313, + 3315, + 3328, + 3340, + 3342, + 3344, + 3346, + 3396, + 3398, + 3400, + 3402, + 3406, + 3412, + 3415, + 3423, + 3427, + 3430, + 3439, + 3450, + 3455, + 3457, + 3459, + 3461, + 3478, + 3482, + 3505, + 3507, + 3515, + 3517, + 3517, + 3520, + 3526, + 3530, + 3530, + 3535, + 3540, + 3542, + 3542, + 3544, + 3551, + 3558, + 3567, + 3570, + 3571, + 3585, + 3642, + 3648, + 3662, + 3664, + 3673, + 3713, + 3714, + 3716, + 3716, + 3718, + 3722, + 3724, + 3747, + 3749, + 3749, + 3751, + 3773, + 3776, + 3780, + 3782, + 3782, + 3784, + 3790, + 3792, + 3801, + 3804, + 3807, + 3840, + 3840, + 3864, + 3865, + 3872, + 3881, + 3893, + 3893, + 3895, + 3895, + 3897, + 3897, + 3902, + 3911, + 3913, + 3948, + 3953, + 3972, + 3974, + 3991, + 3993, + 4028, + 4038, + 4038, + 4096, + 4169, + 4176, + 4253, + 4256, + 4293, + 4295, + 4295, + 4301, + 4301, + 4304, + 4346, + 4348, + 4680, + 4682, + 4685, + 4688, + 4694, + 4696, + 4696, + 4698, + 4701, + 4704, + 4744, + 4746, + 4749, + 4752, + 4784, + 4786, + 4789, + 4792, + 4798, + 4800, + 4800, + 4802, + 4805, + 4808, + 4822, + 4824, + 4880, + 4882, + 4885, + 4888, + 4954, + 4957, + 4959, + 4969, + 4977, + 4992, + 5007, + 5024, + 5109, + 5112, + 5117, + 5121, + 5740, + 5743, + 5759, + 5761, + 5786, + 5792, + 5866, + 5870, + 5880, + 5888, + 5909, + 5919, + 5940, + 5952, + 5971, + 5984, + 5996, + 5998, + 6000, + 6002, + 6003, + 6016, + 6099, + 6103, + 6103, + 6108, + 6109, + 6112, + 6121, + 6155, + 6157, + 6159, + 6169, + 6176, + 6264, + 6272, + 6314, + 6320, + 6389, + 6400, + 6430, + 6432, + 6443, + 6448, + 6459, + 6470, + 6509, + 6512, + 6516, + 6528, + 6571, + 6576, + 6601, + 6608, + 6618, + 6656, + 6683, + 6688, + 6750, + 6752, + 6780, + 6783, + 6793, + 6800, + 6809, + 6823, + 6823, + 6832, + 6845, + 6847, + 6862, + 6912, + 6988, + 6992, + 7001, + 7019, + 7027, + 7040, + 7155, + 7168, + 7223, + 7232, + 7241, + 7245, + 7293, + 7296, + 7304, + 7312, + 7354, + 7357, + 7359, + 7376, + 7378, + 7380, + 7418, + 7424, + 7957, + 7960, + 7965, + 7968, + 8005, + 8008, + 8013, + 8016, + 8023, + 8025, + 8025, + 8027, + 8027, + 8029, + 8029, + 8031, + 8061, + 8064, + 8116, + 8118, + 8124, + 8126, + 8126, + 8130, + 8132, + 8134, + 8140, + 8144, + 8147, + 8150, + 8155, + 8160, + 8172, + 8178, + 8180, + 8182, + 8188, + 8255, + 8256, + 8276, + 8276, + 8305, + 8305, + 8319, + 8319, + 8336, + 8348, + 8400, + 8412, + 8417, + 8417, + 8421, + 8432, + 8450, + 8450, + 8455, + 8455, + 8458, + 8467, + 8469, + 8469, + 8472, + 8477, + 8484, + 8484, + 8486, + 8486, + 8488, + 8488, + 8490, + 8505, + 8508, + 8511, + 8517, + 8521, + 8526, + 8526, + 8544, + 8584, + 11264, + 11492, + 11499, + 11507, + 11520, + 11557, + 11559, + 11559, + 11565, + 11565, + 11568, + 11623, + 11631, + 11631, + 11647, + 11670, + 11680, + 11686, + 11688, + 11694, + 11696, + 11702, + 11704, + 11710, + 11712, + 11718, + 11720, + 11726, + 11728, + 11734, + 11736, + 11742, + 11744, + 11775, + 12293, + 12295, + 12321, + 12335, + 12337, + 12341, + 12344, + 12348, + 12353, + 12438, + 12441, + 12447, + 12449, + 12538, + 12540, + 12543, + 12549, + 12591, + 12593, + 12686, + 12704, + 12735, + 12784, + 12799, + 13312, + 19903, + 19968, + 42124, + 42192, + 42237, + 42240, + 42508, + 42512, + 42539, + 42560, + 42607, + 42612, + 42621, + 42623, + 42737, + 42775, + 42783, + 42786, + 42888, + 42891, + 42954, + 42960, + 42961, + 42963, + 42963, + 42965, + 42969, + 42994, + 43047, + 43052, + 43052, + 43072, + 43123, + 43136, + 43205, + 43216, + 43225, + 43232, + 43255, + 43259, + 43259, + 43261, + 43309, + 43312, + 43347, + 43360, + 43388, + 43392, + 43456, + 43471, + 43481, + 43488, + 43518, + 43520, + 43574, + 43584, + 43597, + 43600, + 43609, + 43616, + 43638, + 43642, + 43714, + 43739, + 43741, + 43744, + 43759, + 43762, + 43766, + 43777, + 43782, + 43785, + 43790, + 43793, + 43798, + 43808, + 43814, + 43816, + 43822, + 43824, + 43866, + 43868, + 43881, + 43888, + 44010, + 44012, + 44013, + 44016, + 44025, + 44032, + 55203, + 55216, + 55238, + 55243, + 55291, + 63744, + 64109, + 64112, + 64217, + 64256, + 64262, + 64275, + 64279, + 64285, + 64296, + 64298, + 64310, + 64312, + 64316, + 64318, + 64318, + 64320, + 64321, + 64323, + 64324, + 64326, + 64433, + 64467, + 64829, + 64848, + 64911, + 64914, + 64967, + 65008, + 65019, + 65024, + 65039, + 65056, + 65071, + 65075, + 65076, + 65101, + 65103, + 65136, + 65140, + 65142, + 65276, + 65296, + 65305, + 65313, + 65338, + 65343, + 65343, + 65345, + 65370, + 65382, + 65470, + 65474, + 65479, + 65482, + 65487, + 65490, + 65495, + 65498, + 65500, + 65536, + 65547, + 65549, + 65574, + 65576, + 65594, + 65596, + 65597, + 65599, + 65613, + 65616, + 65629, + 65664, + 65786, + 65856, + 65908, + 66045, + 66045, + 66176, + 66204, + 66208, + 66256, + 66272, + 66272, + 66304, + 66335, + 66349, + 66378, + 66384, + 66426, + 66432, + 66461, + 66464, + 66499, + 66504, + 66511, + 66513, + 66517, + 66560, + 66717, + 66720, + 66729, + 66736, + 66771, + 66776, + 66811, + 66816, + 66855, + 66864, + 66915, + 66928, + 66938, + 66940, + 66954, + 66956, + 66962, + 66964, + 66965, + 66967, + 66977, + 66979, + 66993, + 66995, + 67001, + 67003, + 67004, + 67072, + 67382, + 67392, + 67413, + 67424, + 67431, + 67456, + 67461, + 67463, + 67504, + 67506, + 67514, + 67584, + 67589, + 67592, + 67592, + 67594, + 67637, + 67639, + 67640, + 67644, + 67644, + 67647, + 67669, + 67680, + 67702, + 67712, + 67742, + 67808, + 67826, + 67828, + 67829, + 67840, + 67861, + 67872, + 67897, + 67968, + 68023, + 68030, + 68031, + 68096, + 68099, + 68101, + 68102, + 68108, + 68115, + 68117, + 68119, + 68121, + 68149, + 68152, + 68154, + 68159, + 68159, + 68192, + 68220, + 68224, + 68252, + 68288, + 68295, + 68297, + 68326, + 68352, + 68405, + 68416, + 68437, + 68448, + 68466, + 68480, + 68497, + 68608, + 68680, + 68736, + 68786, + 68800, + 68850, + 68864, + 68903, + 68912, + 68921, + 69248, + 69289, + 69291, + 69292, + 69296, + 69297, + 69373, + 69404, + 69415, + 69415, + 69424, + 69456, + 69488, + 69509, + 69552, + 69572, + 69600, + 69622, + 69632, + 69702, + 69734, + 69749, + 69759, + 69818, + 69826, + 69826, + 69840, + 69864, + 69872, + 69881, + 69888, + 69940, + 69942, + 69951, + 69956, + 69959, + 69968, + 70003, + 70006, + 70006, + 70016, + 70084, + 70089, + 70092, + 70094, + 70106, + 70108, + 70108, + 70144, + 70161, + 70163, + 70199, + 70206, + 70209, + 70272, + 70278, + 70280, + 70280, + 70282, + 70285, + 70287, + 70301, + 70303, + 70312, + 70320, + 70378, + 70384, + 70393, + 70400, + 70403, + 70405, + 70412, + 70415, + 70416, + 70419, + 70440, + 70442, + 70448, + 70450, + 70451, + 70453, + 70457, + 70459, + 70468, + 70471, + 70472, + 70475, + 70477, + 70480, + 70480, + 70487, + 70487, + 70493, + 70499, + 70502, + 70508, + 70512, + 70516, + 70656, + 70730, + 70736, + 70745, + 70750, + 70753, + 70784, + 70853, + 70855, + 70855, + 70864, + 70873, + 71040, + 71093, + 71096, + 71104, + 71128, + 71133, + 71168, + 71232, + 71236, + 71236, + 71248, + 71257, + 71296, + 71352, + 71360, + 71369, + 71424, + 71450, + 71453, + 71467, + 71472, + 71481, + 71488, + 71494, + 71680, + 71738, + 71840, + 71913, + 71935, + 71942, + 71945, + 71945, + 71948, + 71955, + 71957, + 71958, + 71960, + 71989, + 71991, + 71992, + 71995, + 72003, + 72016, + 72025, + 72096, + 72103, + 72106, + 72151, + 72154, + 72161, + 72163, + 72164, + 72192, + 72254, + 72263, + 72263, + 72272, + 72345, + 72349, + 72349, + 72368, + 72440, + 72704, + 72712, + 72714, + 72758, + 72760, + 72768, + 72784, + 72793, + 72818, + 72847, + 72850, + 72871, + 72873, + 72886, + 72960, + 72966, + 72968, + 72969, + 72971, + 73014, + 73018, + 73018, + 73020, + 73021, + 73023, + 73031, + 73040, + 73049, + 73056, + 73061, + 73063, + 73064, + 73066, + 73102, + 73104, + 73105, + 73107, + 73112, + 73120, + 73129, + 73440, + 73462, + 73472, + 73488, + 73490, + 73530, + 73534, + 73538, + 73552, + 73561, + 73648, + 73648, + 73728, + 74649, + 74752, + 74862, + 74880, + 75075, + 77712, + 77808, + 77824, + 78895, + 78912, + 78933, + 82944, + 83526, + 92160, + 92728, + 92736, + 92766, + 92768, + 92777, + 92784, + 92862, + 92864, + 92873, + 92880, + 92909, + 92912, + 92916, + 92928, + 92982, + 92992, + 92995, + 93008, + 93017, + 93027, + 93047, + 93053, + 93071, + 93760, + 93823, + 93952, + 94026, + 94031, + 94087, + 94095, + 94111, + 94176, + 94177, + 94179, + 94180, + 94192, + 94193, + 94208, + 100343, + 100352, + 101589, + 101632, + 101640, + 110576, + 110579, + 110581, + 110587, + 110589, + 110590, + 110592, + 110882, + 110898, + 110898, + 110928, + 110930, + 110933, + 110933, + 110948, + 110951, + 110960, + 111355, + 113664, + 113770, + 113776, + 113788, + 113792, + 113800, + 113808, + 113817, + 113821, + 113822, + 118528, + 118573, + 118576, + 118598, + 119141, + 119145, + 119149, + 119154, + 119163, + 119170, + 119173, + 119179, + 119210, + 119213, + 119362, + 119364, + 119808, + 119892, + 119894, + 119964, + 119966, + 119967, + 119970, + 119970, + 119973, + 119974, + 119977, + 119980, + 119982, + 119993, + 119995, + 119995, + 119997, + 120003, + 120005, + 120069, + 120071, + 120074, + 120077, + 120084, + 120086, + 120092, + 120094, + 120121, + 120123, + 120126, + 120128, + 120132, + 120134, + 120134, + 120138, + 120144, + 120146, + 120485, + 120488, + 120512, + 120514, + 120538, + 120540, + 120570, + 120572, + 120596, + 120598, + 120628, + 120630, + 120654, + 120656, + 120686, + 120688, + 120712, + 120714, + 120744, + 120746, + 120770, + 120772, + 120779, + 120782, + 120831, + 121344, + 121398, + 121403, + 121452, + 121461, + 121461, + 121476, + 121476, + 121499, + 121503, + 121505, + 121519, + 122624, + 122654, + 122661, + 122666, + 122880, + 122886, + 122888, + 122904, + 122907, + 122913, + 122915, + 122916, + 122918, + 122922, + 122928, + 122989, + 123023, + 123023, + 123136, + 123180, + 123184, + 123197, + 123200, + 123209, + 123214, + 123214, + 123536, + 123566, + 123584, + 123641, + 124112, + 124153, + 124896, + 124902, + 124904, + 124907, + 124909, + 124910, + 124912, + 124926, + 124928, + 125124, + 125136, + 125142, + 125184, + 125259, + 125264, + 125273, + 126464, + 126467, + 126469, + 126495, + 126497, + 126498, + 126500, + 126500, + 126503, + 126503, + 126505, + 126514, + 126516, + 126519, + 126521, + 126521, + 126523, + 126523, + 126530, + 126530, + 126535, + 126535, + 126537, + 126537, + 126539, + 126539, + 126541, + 126543, + 126545, + 126546, + 126548, + 126548, + 126551, + 126551, + 126553, + 126553, + 126555, + 126555, + 126557, + 126557, + 126559, + 126559, + 126561, + 126562, + 126564, + 126564, + 126567, + 126570, + 126572, + 126578, + 126580, + 126583, + 126585, + 126588, + 126590, + 126590, + 126592, + 126601, + 126603, + 126619, + 126625, + 126627, + 126629, + 126633, + 126635, + 126651, + 130032, + 130041, + 131072, + 173791, + 173824, + 177977, + 177984, + 178205, + 178208, + 183969, + 183984, + 191456, + 194560, + 195101, + 196608, + 201546, + 201552, + 205743, + 917760, + 917999, + 1, + 0, + 42, + 42, + 2, + 0, + 39, + 39, + 92, + 92, + 2, + 0, + 10, + 10, + 13, + 13, + 1, + 0, + 47, + 47, + 1, + 0, + 29, + 29, + 1, + 0, + 28, + 28, + 1, + 0, + 13, + 13, + 21, + 0, + 36, + 36, + 162, + 165, + 1423, + 1423, + 1547, + 1547, + 2046, + 2047, + 2546, + 2547, + 2555, + 2555, + 2801, + 2801, + 3065, + 3065, + 3647, + 3647, + 6107, + 6107, + 8352, + 8384, + 43064, + 43064, + 65020, + 65020, + 65129, + 65129, + 65284, + 65284, + 65504, + 65505, + 65509, + 65510, + 73693, + 73696, + 123647, + 123647, + 126128, + 126128, + 1, + 0, + 32, + 32, + 6, + 0, + 95, + 95, + 8255, + 8256, + 8276, + 8276, + 65075, + 65076, + 65101, + 65103, + 65343, + 65343, + 1, + 0, + 9, + 9, + 2, + 0, + 34, + 34, + 92, + 92, + 1, + 0, + 10, + 10, + 1, + 0, + 11, + 11, + 1, + 0, + 31, + 31, + 659, + 0, + 65, + 90, + 97, + 122, + 170, + 170, + 181, + 181, + 186, + 186, + 192, + 214, + 216, + 246, + 248, + 705, + 710, + 721, + 736, + 740, + 748, + 748, + 750, + 750, + 880, + 884, + 886, + 887, + 890, + 893, + 895, + 895, + 902, + 902, + 904, + 906, + 908, + 908, + 910, + 929, + 931, + 1013, + 1015, + 1153, + 1162, + 1327, + 1329, + 1366, + 1369, + 1369, + 1376, + 1416, + 1488, + 1514, + 1519, + 1522, + 1568, + 1610, + 1646, + 1647, + 1649, + 1747, + 1749, + 1749, + 1765, + 1766, + 1774, + 1775, + 1786, + 1788, + 1791, + 1791, + 1808, + 1808, + 1810, + 1839, + 1869, + 1957, + 1969, + 1969, + 1994, + 2026, + 2036, + 2037, + 2042, + 2042, + 2048, + 2069, + 2074, + 2074, + 2084, + 2084, + 2088, + 2088, + 2112, + 2136, + 2144, + 2154, + 2160, + 2183, + 2185, + 2190, + 2208, + 2249, + 2308, + 2361, + 2365, + 2365, + 2384, + 2384, + 2392, + 2401, + 2417, + 2432, + 2437, + 2444, + 2447, + 2448, + 2451, + 2472, + 2474, + 2480, + 2482, + 2482, + 2486, + 2489, + 2493, + 2493, + 2510, + 2510, + 2524, + 2525, + 2527, + 2529, + 2544, + 2545, + 2556, + 2556, + 2565, + 2570, + 2575, + 2576, + 2579, + 2600, + 2602, + 2608, + 2610, + 2611, + 2613, + 2614, + 2616, + 2617, + 2649, + 2652, + 2654, + 2654, + 2674, + 2676, + 2693, + 2701, + 2703, + 2705, + 2707, + 2728, + 2730, + 2736, + 2738, + 2739, + 2741, + 2745, + 2749, + 2749, + 2768, + 2768, + 2784, + 2785, + 2809, + 2809, + 2821, + 2828, + 2831, + 2832, + 2835, + 2856, + 2858, + 2864, + 2866, + 2867, + 2869, + 2873, + 2877, + 2877, + 2908, + 2909, + 2911, + 2913, + 2929, + 2929, + 2947, + 2947, + 2949, + 2954, + 2958, + 2960, + 2962, + 2965, + 2969, + 2970, + 2972, + 2972, + 2974, + 2975, + 2979, + 2980, + 2984, + 2986, + 2990, + 3001, + 3024, + 3024, + 3077, + 3084, + 3086, + 3088, + 3090, + 3112, + 3114, + 3129, + 3133, + 3133, + 3160, + 3162, + 3165, + 3165, + 3168, + 3169, + 3200, + 3200, + 3205, + 3212, + 3214, + 3216, + 3218, + 3240, + 3242, + 3251, + 3253, + 3257, + 3261, + 3261, + 3293, + 3294, + 3296, + 3297, + 3313, + 3314, + 3332, + 3340, + 3342, + 3344, + 3346, + 3386, + 3389, + 3389, + 3406, + 3406, + 3412, + 3414, + 3423, + 3425, + 3450, + 3455, + 3461, + 3478, + 3482, + 3505, + 3507, + 3515, + 3517, + 3517, + 3520, + 3526, + 3585, + 3632, + 3634, + 3635, + 3648, + 3654, + 3713, + 3714, + 3716, + 3716, + 3718, + 3722, + 3724, + 3747, + 3749, + 3749, + 3751, + 3760, + 3762, + 3763, + 3773, + 3773, + 3776, + 3780, + 3782, + 3782, + 3804, + 3807, + 3840, + 3840, + 3904, + 3911, + 3913, + 3948, + 3976, + 3980, + 4096, + 4138, + 4159, + 4159, + 4176, + 4181, + 4186, + 4189, + 4193, + 4193, + 4197, + 4198, + 4206, + 4208, + 4213, + 4225, + 4238, + 4238, + 4256, + 4293, + 4295, + 4295, + 4301, + 4301, + 4304, + 4346, + 4348, + 4680, + 4682, + 4685, + 4688, + 4694, + 4696, + 4696, + 4698, + 4701, + 4704, + 4744, + 4746, + 4749, + 4752, + 4784, + 4786, + 4789, + 4792, + 4798, + 4800, + 4800, + 4802, + 4805, + 4808, + 4822, + 4824, + 4880, + 4882, + 4885, + 4888, + 4954, + 4992, + 5007, + 5024, + 5109, + 5112, + 5117, + 5121, + 5740, + 5743, + 5759, + 5761, + 5786, + 5792, + 5866, + 5870, + 5880, + 5888, + 5905, + 5919, + 5937, + 5952, + 5969, + 5984, + 5996, + 5998, + 6000, + 6016, + 6067, + 6103, + 6103, + 6108, + 6108, + 6176, + 6264, + 6272, + 6312, + 6314, + 6314, + 6320, + 6389, + 6400, + 6430, + 6480, + 6509, + 6512, + 6516, + 6528, + 6571, + 6576, + 6601, + 6656, + 6678, + 6688, + 6740, + 6823, + 6823, + 6917, + 6963, + 6981, + 6988, + 7043, + 7072, + 7086, + 7087, + 7098, + 7141, + 7168, + 7203, + 7245, + 7247, + 7258, + 7293, + 7296, + 7304, + 7312, + 7354, + 7357, + 7359, + 7401, + 7404, + 7406, + 7411, + 7413, + 7414, + 7418, + 7418, + 7424, + 7615, + 7680, + 7957, + 7960, + 7965, + 7968, + 8005, + 8008, + 8013, + 8016, + 8023, + 8025, + 8025, + 8027, + 8027, + 8029, + 8029, + 8031, + 8061, + 8064, + 8116, + 8118, + 8124, + 8126, + 8126, + 8130, + 8132, + 8134, + 8140, + 8144, + 8147, + 8150, + 8155, + 8160, + 8172, + 8178, + 8180, + 8182, + 8188, + 8305, + 8305, + 8319, + 8319, + 8336, + 8348, + 8450, + 8450, + 8455, + 8455, + 8458, + 8467, + 8469, + 8469, + 8472, + 8477, + 8484, + 8484, + 8486, + 8486, + 8488, + 8488, + 8490, + 8505, + 8508, + 8511, + 8517, + 8521, + 8526, + 8526, + 8544, + 8584, + 11264, + 11492, + 11499, + 11502, + 11506, + 11507, + 11520, + 11557, + 11559, + 11559, + 11565, + 11565, + 11568, + 11623, + 11631, + 11631, + 11648, + 11670, + 11680, + 11686, + 11688, + 11694, + 11696, + 11702, + 11704, + 11710, + 11712, + 11718, + 11720, + 11726, + 11728, + 11734, + 11736, + 11742, + 12293, + 12295, + 12321, + 12329, + 12337, + 12341, + 12344, + 12348, + 12353, + 12438, + 12443, + 12447, + 12449, + 12538, + 12540, + 12543, + 12549, + 12591, + 12593, + 12686, + 12704, + 12735, + 12784, + 12799, + 13312, + 19903, + 19968, + 42124, + 42192, + 42237, + 42240, + 42508, + 42512, + 42527, + 42538, + 42539, + 42560, + 42606, + 42623, + 42653, + 42656, + 42735, + 42775, + 42783, + 42786, + 42888, + 42891, + 42954, + 42960, + 42961, + 42963, + 42963, + 42965, + 42969, + 42994, + 43009, + 43011, + 43013, + 43015, + 43018, + 43020, + 43042, + 43072, + 43123, + 43138, + 43187, + 43250, + 43255, + 43259, + 43259, + 43261, + 43262, + 43274, + 43301, + 43312, + 43334, + 43360, + 43388, + 43396, + 43442, + 43471, + 43471, + 43488, + 43492, + 43494, + 43503, + 43514, + 43518, + 43520, + 43560, + 43584, + 43586, + 43588, + 43595, + 43616, + 43638, + 43642, + 43642, + 43646, + 43695, + 43697, + 43697, + 43701, + 43702, + 43705, + 43709, + 43712, + 43712, + 43714, + 43714, + 43739, + 43741, + 43744, + 43754, + 43762, + 43764, + 43777, + 43782, + 43785, + 43790, + 43793, + 43798, + 43808, + 43814, + 43816, + 43822, + 43824, + 43866, + 43868, + 43881, + 43888, + 44002, + 44032, + 55203, + 55216, + 55238, + 55243, + 55291, + 63744, + 64109, + 64112, + 64217, + 64256, + 64262, + 64275, + 64279, + 64285, + 64285, + 64287, + 64296, + 64298, + 64310, + 64312, + 64316, + 64318, + 64318, + 64320, + 64321, + 64323, + 64324, + 64326, + 64433, + 64467, + 64829, + 64848, + 64911, + 64914, + 64967, + 65008, + 65019, + 65136, + 65140, + 65142, + 65276, + 65313, + 65338, + 65345, + 65370, + 65382, + 65470, + 65474, + 65479, + 65482, + 65487, + 65490, + 65495, + 65498, + 65500, + 65536, + 65547, + 65549, + 65574, + 65576, + 65594, + 65596, + 65597, + 65599, + 65613, + 65616, + 65629, + 65664, + 65786, + 65856, + 65908, + 66176, + 66204, + 66208, + 66256, + 66304, + 66335, + 66349, + 66378, + 66384, + 66421, + 66432, + 66461, + 66464, + 66499, + 66504, + 66511, + 66513, + 66517, + 66560, + 66717, + 66736, + 66771, + 66776, + 66811, + 66816, + 66855, + 66864, + 66915, + 66928, + 66938, + 66940, + 66954, + 66956, + 66962, + 66964, + 66965, + 66967, + 66977, + 66979, + 66993, + 66995, + 67001, + 67003, + 67004, + 67072, + 67382, + 67392, + 67413, + 67424, + 67431, + 67456, + 67461, + 67463, + 67504, + 67506, + 67514, + 67584, + 67589, + 67592, + 67592, + 67594, + 67637, + 67639, + 67640, + 67644, + 67644, + 67647, + 67669, + 67680, + 67702, + 67712, + 67742, + 67808, + 67826, + 67828, + 67829, + 67840, + 67861, + 67872, + 67897, + 67968, + 68023, + 68030, + 68031, + 68096, + 68096, + 68112, + 68115, + 68117, + 68119, + 68121, + 68149, + 68192, + 68220, + 68224, + 68252, + 68288, + 68295, + 68297, + 68324, + 68352, + 68405, + 68416, + 68437, + 68448, + 68466, + 68480, + 68497, + 68608, + 68680, + 68736, + 68786, + 68800, + 68850, + 68864, + 68899, + 69248, + 69289, + 69296, + 69297, + 69376, + 69404, + 69415, + 69415, + 69424, + 69445, + 69488, + 69505, + 69552, + 69572, + 69600, + 69622, + 69635, + 69687, + 69745, + 69746, + 69749, + 69749, + 69763, + 69807, + 69840, + 69864, + 69891, + 69926, + 69956, + 69956, + 69959, + 69959, + 69968, + 70002, + 70006, + 70006, + 70019, + 70066, + 70081, + 70084, + 70106, + 70106, + 70108, + 70108, + 70144, + 70161, + 70163, + 70187, + 70207, + 70208, + 70272, + 70278, + 70280, + 70280, + 70282, + 70285, + 70287, + 70301, + 70303, + 70312, + 70320, + 70366, + 70405, + 70412, + 70415, + 70416, + 70419, + 70440, + 70442, + 70448, + 70450, + 70451, + 70453, + 70457, + 70461, + 70461, + 70480, + 70480, + 70493, + 70497, + 70656, + 70708, + 70727, + 70730, + 70751, + 70753, + 70784, + 70831, + 70852, + 70853, + 70855, + 70855, + 71040, + 71086, + 71128, + 71131, + 71168, + 71215, + 71236, + 71236, + 71296, + 71338, + 71352, + 71352, + 71424, + 71450, + 71488, + 71494, + 71680, + 71723, + 71840, + 71903, + 71935, + 71942, + 71945, + 71945, + 71948, + 71955, + 71957, + 71958, + 71960, + 71983, + 71999, + 71999, + 72001, + 72001, + 72096, + 72103, + 72106, + 72144, + 72161, + 72161, + 72163, + 72163, + 72192, + 72192, + 72203, + 72242, + 72250, + 72250, + 72272, + 72272, + 72284, + 72329, + 72349, + 72349, + 72368, + 72440, + 72704, + 72712, + 72714, + 72750, + 72768, + 72768, + 72818, + 72847, + 72960, + 72966, + 72968, + 72969, + 72971, + 73008, + 73030, + 73030, + 73056, + 73061, + 73063, + 73064, + 73066, + 73097, + 73112, + 73112, + 73440, + 73458, + 73474, + 73474, + 73476, + 73488, + 73490, + 73523, + 73648, + 73648, + 73728, + 74649, + 74752, + 74862, + 74880, + 75075, + 77712, + 77808, + 77824, + 78895, + 78913, + 78918, + 82944, + 83526, + 92160, + 92728, + 92736, + 92766, + 92784, + 92862, + 92880, + 92909, + 92928, + 92975, + 92992, + 92995, + 93027, + 93047, + 93053, + 93071, + 93760, + 93823, + 93952, + 94026, + 94032, + 94032, + 94099, + 94111, + 94176, + 94177, + 94179, + 94179, + 94208, + 100343, + 100352, + 101589, + 101632, + 101640, + 110576, + 110579, + 110581, + 110587, + 110589, + 110590, + 110592, + 110882, + 110898, + 110898, + 110928, + 110930, + 110933, + 110933, + 110948, + 110951, + 110960, + 111355, + 113664, + 113770, + 113776, + 113788, + 113792, + 113800, + 113808, + 113817, + 119808, + 119892, + 119894, + 119964, + 119966, + 119967, + 119970, + 119970, + 119973, + 119974, + 119977, + 119980, + 119982, + 119993, + 119995, + 119995, + 119997, + 120003, + 120005, + 120069, + 120071, + 120074, + 120077, + 120084, + 120086, + 120092, + 120094, + 120121, + 120123, + 120126, + 120128, + 120132, + 120134, + 120134, + 120138, + 120144, + 120146, + 120485, + 120488, + 120512, + 120514, + 120538, + 120540, + 120570, + 120572, + 120596, + 120598, + 120628, + 120630, + 120654, + 120656, + 120686, + 120688, + 120712, + 120714, + 120744, + 120746, + 120770, + 120772, + 120779, + 122624, + 122654, + 122661, + 122666, + 122928, + 122989, + 123136, + 123180, + 123191, + 123197, + 123214, + 123214, + 123536, + 123565, + 123584, + 123627, + 124112, + 124139, + 124896, + 124902, + 124904, + 124907, + 124909, + 124910, + 124912, + 124926, + 124928, + 125124, + 125184, + 125251, + 125259, + 125259, + 126464, + 126467, + 126469, + 126495, + 126497, + 126498, + 126500, + 126500, + 126503, + 126503, + 126505, + 126514, + 126516, + 126519, + 126521, + 126521, + 126523, + 126523, + 126530, + 126530, + 126535, + 126535, + 126537, + 126537, + 126539, + 126539, + 126541, + 126543, + 126545, + 126546, + 126548, + 126548, + 126551, + 126551, + 126553, + 126553, + 126555, + 126555, + 126557, + 126557, + 126559, + 126559, + 126561, + 126562, + 126564, + 126564, + 126567, + 126570, + 126572, + 126578, + 126580, + 126583, + 126585, + 126588, + 126590, + 126590, + 126592, + 126601, + 126603, + 126619, + 126625, + 126627, + 126629, + 126633, + 126635, + 126651, + 131072, + 173791, + 173824, + 177977, + 177984, + 178205, + 178208, + 183969, + 183984, + 191456, + 194560, + 195101, + 196608, + 201546, + 201552, + 205743, + 1250, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 3, + 1, + 0, + 0, + 0, + 0, + 5, + 1, + 0, + 0, + 0, + 0, + 7, + 1, + 0, + 0, + 0, + 0, + 9, + 1, + 0, + 0, + 0, + 0, + 11, + 1, + 0, + 0, + 0, + 0, + 13, + 1, + 0, + 0, + 0, + 0, + 15, + 1, + 0, + 0, + 0, + 0, + 17, + 1, + 0, + 0, + 0, + 0, + 19, + 1, + 0, + 0, + 0, + 0, + 21, + 1, + 0, + 0, + 0, + 0, + 23, + 1, + 0, + 0, + 0, + 0, + 25, + 1, + 0, + 0, + 0, + 0, + 27, + 1, + 0, + 0, + 0, + 0, + 29, + 1, + 0, + 0, + 0, + 0, + 31, + 1, + 0, + 0, + 0, + 0, + 33, + 1, + 0, + 0, + 0, + 0, + 35, + 1, + 0, + 0, + 0, + 0, + 37, + 1, + 0, + 0, + 0, + 0, + 39, + 1, + 0, + 0, + 0, + 0, + 41, + 1, + 0, + 0, + 0, + 0, + 43, + 1, + 0, + 0, + 0, + 0, + 45, + 1, + 0, + 0, + 0, + 0, + 47, + 1, + 0, + 0, + 0, + 0, + 49, + 1, + 0, + 0, + 0, + 0, + 51, + 1, + 0, + 0, + 0, + 0, + 53, + 1, + 0, + 0, + 0, + 0, + 55, + 1, + 0, + 0, + 0, + 0, + 57, + 1, + 0, + 0, + 0, + 0, + 59, + 1, + 0, + 0, + 0, + 0, + 61, + 1, + 0, + 0, + 0, + 0, + 63, + 1, + 0, + 0, + 0, + 0, + 65, + 1, + 0, + 0, + 0, + 0, + 67, + 1, + 0, + 0, + 0, + 0, + 69, + 1, + 0, + 0, + 0, + 0, + 71, + 1, + 0, + 0, + 0, + 0, + 73, + 1, + 0, + 0, + 0, + 0, + 75, + 1, + 0, + 0, + 0, + 0, + 77, + 1, + 0, + 0, + 0, + 0, + 79, + 1, + 0, + 0, + 0, + 0, + 81, + 1, + 0, + 0, + 0, + 0, + 83, + 1, + 0, + 0, + 0, + 0, + 85, + 1, + 0, + 0, + 0, + 0, + 87, + 1, + 0, + 0, + 0, + 0, + 89, + 1, + 0, + 0, + 0, + 0, + 91, + 1, + 0, + 0, + 0, + 0, + 93, + 1, + 0, + 0, + 0, + 0, + 95, + 1, + 0, + 0, + 0, + 0, + 97, + 1, + 0, + 0, + 0, + 0, + 99, + 1, + 0, + 0, + 0, + 0, + 101, + 1, + 0, + 0, + 0, + 0, + 103, + 1, + 0, + 0, + 0, + 0, + 105, + 1, + 0, + 0, + 0, + 0, + 107, + 1, + 0, + 0, + 0, + 0, + 109, + 1, + 0, + 0, + 0, + 0, + 111, + 1, + 0, + 0, + 0, + 0, + 113, + 1, + 0, + 0, + 0, + 0, + 115, + 1, + 0, + 0, + 0, + 0, + 117, + 1, + 0, + 0, + 0, + 0, + 119, + 1, + 0, + 0, + 0, + 0, + 121, + 1, + 0, + 0, + 0, + 0, + 123, + 1, + 0, + 0, + 0, + 0, + 125, + 1, + 0, + 0, + 0, + 0, + 127, + 1, + 0, + 0, + 0, + 0, + 129, + 1, + 0, + 0, + 0, + 0, + 131, + 1, + 0, + 0, + 0, + 0, + 133, + 1, + 0, + 0, + 0, + 0, + 135, + 1, + 0, + 0, + 0, + 0, + 137, + 1, + 0, + 0, + 0, + 0, + 139, + 1, + 0, + 0, + 0, + 0, + 141, + 1, + 0, + 0, + 0, + 0, + 143, + 1, + 0, + 0, + 0, + 0, + 145, + 1, + 0, + 0, + 0, + 0, + 147, + 1, + 0, + 0, + 0, + 0, + 149, + 1, + 0, + 0, + 0, + 0, + 151, + 1, + 0, + 0, + 0, + 0, + 153, + 1, + 0, + 0, + 0, + 0, + 155, + 1, + 0, + 0, + 0, + 0, + 157, + 1, + 0, + 0, + 0, + 0, + 159, + 1, + 0, + 0, + 0, + 0, + 161, + 1, + 0, + 0, + 0, + 0, + 163, + 1, + 0, + 0, + 0, + 0, + 165, + 1, + 0, + 0, + 0, + 0, + 167, + 1, + 0, + 0, + 0, + 0, + 169, + 1, + 0, + 0, + 0, + 0, + 171, + 1, + 0, + 0, + 0, + 0, + 173, + 1, + 0, + 0, + 0, + 0, + 175, + 1, + 0, + 0, + 0, + 0, + 177, + 1, + 0, + 0, + 0, + 0, + 179, + 1, + 0, + 0, + 0, + 0, + 181, + 1, + 0, + 0, + 0, + 0, + 183, + 1, + 0, + 0, + 0, + 0, + 185, + 1, + 0, + 0, + 0, + 0, + 187, + 1, + 0, + 0, + 0, + 0, + 189, + 1, + 0, + 0, + 0, + 0, + 191, + 1, + 0, + 0, + 0, + 0, + 193, + 1, + 0, + 0, + 0, + 0, + 195, + 1, + 0, + 0, + 0, + 0, + 197, + 1, + 0, + 0, + 0, + 0, + 199, + 1, + 0, + 0, + 0, + 0, + 201, + 1, + 0, + 0, + 0, + 0, + 203, + 1, + 0, + 0, + 0, + 0, + 205, + 1, + 0, + 0, + 0, + 0, + 207, + 1, + 0, + 0, + 0, + 0, + 209, + 1, + 0, + 0, + 0, + 0, + 211, + 1, + 0, + 0, + 0, + 0, + 213, + 1, + 0, + 0, + 0, + 0, + 215, + 1, + 0, + 0, + 0, + 0, + 217, + 1, + 0, + 0, + 0, + 0, + 219, + 1, + 0, + 0, + 0, + 0, + 221, + 1, + 0, + 0, + 0, + 0, + 223, + 1, + 0, + 0, + 0, + 0, + 225, + 1, + 0, + 0, + 0, + 0, + 227, + 1, + 0, + 0, + 0, + 0, + 229, + 1, + 0, + 0, + 0, + 0, + 231, + 1, + 0, + 0, + 0, + 0, + 233, + 1, + 0, + 0, + 0, + 0, + 235, + 1, + 0, + 0, + 0, + 0, + 237, + 1, + 0, + 0, + 0, + 0, + 239, + 1, + 0, + 0, + 0, + 0, + 241, + 1, + 0, + 0, + 0, + 0, + 243, + 1, + 0, + 0, + 0, + 0, + 245, + 1, + 0, + 0, + 0, + 0, + 247, + 1, + 0, + 0, + 0, + 0, + 249, + 1, + 0, + 0, + 0, + 0, + 251, + 1, + 0, + 0, + 0, + 0, + 253, + 1, + 0, + 0, + 0, + 0, + 255, + 1, + 0, + 0, + 0, + 0, + 257, + 1, + 0, + 0, + 0, + 0, + 259, + 1, + 0, + 0, + 0, + 0, + 261, + 1, + 0, + 0, + 0, + 0, + 263, + 1, + 0, + 0, + 0, + 0, + 265, + 1, + 0, + 0, + 0, + 0, + 267, + 1, + 0, + 0, + 0, + 0, + 269, + 1, + 0, + 0, + 0, + 0, + 271, + 1, + 0, + 0, + 0, + 0, + 273, + 1, + 0, + 0, + 0, + 0, + 275, + 1, + 0, + 0, + 0, + 0, + 277, + 1, + 0, + 0, + 0, + 0, + 279, + 1, + 0, + 0, + 0, + 0, + 281, + 1, + 0, + 0, + 0, + 0, + 283, + 1, + 0, + 0, + 0, + 0, + 285, + 1, + 0, + 0, + 0, + 0, + 287, + 1, + 0, + 0, + 0, + 0, + 289, + 1, + 0, + 0, + 0, + 0, + 291, + 1, + 0, + 0, + 0, + 0, + 293, + 1, + 0, + 0, + 0, + 0, + 295, + 1, + 0, + 0, + 0, + 0, + 297, + 1, + 0, + 0, + 0, + 0, + 299, + 1, + 0, + 0, + 0, + 0, + 301, + 1, + 0, + 0, + 0, + 1, + 343, + 1, + 0, + 0, + 0, + 3, + 345, + 1, + 0, + 0, + 0, + 5, + 347, + 1, + 0, + 0, + 0, + 7, + 349, + 1, + 0, + 0, + 0, + 9, + 351, + 1, + 0, + 0, + 0, + 11, + 353, + 1, + 0, + 0, + 0, + 13, + 355, + 1, + 0, + 0, + 0, + 15, + 357, + 1, + 0, + 0, + 0, + 17, + 360, + 1, + 0, + 0, + 0, + 19, + 362, + 1, + 0, + 0, + 0, + 21, + 364, + 1, + 0, + 0, + 0, + 23, + 366, + 1, + 0, + 0, + 0, + 25, + 369, + 1, + 0, + 0, + 0, + 27, + 372, + 1, + 0, + 0, + 0, + 29, + 374, + 1, + 0, + 0, + 0, + 31, + 376, + 1, + 0, + 0, + 0, + 33, + 379, + 1, + 0, + 0, + 0, + 35, + 382, + 1, + 0, + 0, + 0, + 37, + 385, + 1, + 0, + 0, + 0, + 39, + 387, + 1, + 0, + 0, + 0, + 41, + 389, + 1, + 0, + 0, + 0, + 43, + 391, + 1, + 0, + 0, + 0, + 45, + 393, + 1, + 0, + 0, + 0, + 47, + 395, + 1, + 0, + 0, + 0, + 49, + 397, + 1, + 0, + 0, + 0, + 51, + 399, + 1, + 0, + 0, + 0, + 53, + 401, + 1, + 0, + 0, + 0, + 55, + 403, + 1, + 0, + 0, + 0, + 57, + 405, + 1, + 0, + 0, + 0, + 59, + 407, + 1, + 0, + 0, + 0, + 61, + 409, + 1, + 0, + 0, + 0, + 63, + 411, + 1, + 0, + 0, + 0, + 65, + 413, + 1, + 0, + 0, + 0, + 67, + 415, + 1, + 0, + 0, + 0, + 69, + 417, + 1, + 0, + 0, + 0, + 71, + 419, + 1, + 0, + 0, + 0, + 73, + 421, + 1, + 0, + 0, + 0, + 75, + 423, + 1, + 0, + 0, + 0, + 77, + 425, + 1, + 0, + 0, + 0, + 79, + 427, + 1, + 0, + 0, + 0, + 81, + 429, + 1, + 0, + 0, + 0, + 83, + 431, + 1, + 0, + 0, + 0, + 85, + 433, + 1, + 0, + 0, + 0, + 87, + 435, + 1, + 0, + 0, + 0, + 89, + 437, + 1, + 0, + 0, + 0, + 91, + 439, + 1, + 0, + 0, + 0, + 93, + 441, + 1, + 0, + 0, + 0, + 95, + 448, + 1, + 0, + 0, + 0, + 97, + 456, + 1, + 0, + 0, + 0, + 99, + 464, + 1, + 0, + 0, + 0, + 101, + 470, + 1, + 0, + 0, + 0, + 103, + 479, + 1, + 0, + 0, + 0, + 105, + 486, + 1, + 0, + 0, + 0, + 107, + 492, + 1, + 0, + 0, + 0, + 109, + 496, + 1, + 0, + 0, + 0, + 111, + 503, + 1, + 0, + 0, + 0, + 113, + 508, + 1, + 0, + 0, + 0, + 115, + 514, + 1, + 0, + 0, + 0, + 117, + 517, + 1, + 0, + 0, + 0, + 119, + 528, + 1, + 0, + 0, + 0, + 121, + 535, + 1, + 0, + 0, + 0, + 123, + 538, + 1, + 0, + 0, + 0, + 125, + 545, + 1, + 0, + 0, + 0, + 127, + 552, + 1, + 0, + 0, + 0, + 129, + 557, + 1, + 0, + 0, + 0, + 131, + 561, + 1, + 0, + 0, + 0, + 133, + 566, + 1, + 0, + 0, + 0, + 135, + 574, + 1, + 0, + 0, + 0, + 137, + 579, + 1, + 0, + 0, + 0, + 139, + 582, + 1, + 0, + 0, + 0, + 141, + 598, + 1, + 0, + 0, + 0, + 143, + 607, + 1, + 0, + 0, + 0, + 145, + 613, + 1, + 0, + 0, + 0, + 147, + 620, + 1, + 0, + 0, + 0, + 149, + 626, + 1, + 0, + 0, + 0, + 151, + 630, + 1, + 0, + 0, + 0, + 153, + 637, + 1, + 0, + 0, + 0, + 155, + 644, + 1, + 0, + 0, + 0, + 157, + 651, + 1, + 0, + 0, + 0, + 159, + 659, + 1, + 0, + 0, + 0, + 161, + 662, + 1, + 0, + 0, + 0, + 163, + 667, + 1, + 0, + 0, + 0, + 165, + 673, + 1, + 0, + 0, + 0, + 167, + 680, + 1, + 0, + 0, + 0, + 169, + 689, + 1, + 0, + 0, + 0, + 171, + 695, + 1, + 0, + 0, + 0, + 173, + 698, + 1, + 0, + 0, + 0, + 175, + 703, + 1, + 0, + 0, + 0, + 177, + 709, + 1, + 0, + 0, + 0, + 179, + 719, + 1, + 0, + 0, + 0, + 181, + 723, + 1, + 0, + 0, + 0, + 183, + 734, + 1, + 0, + 0, + 0, + 185, + 739, + 1, + 0, + 0, + 0, + 187, + 744, + 1, + 0, + 0, + 0, + 189, + 749, + 1, + 0, + 0, + 0, + 191, + 755, + 1, + 0, + 0, + 0, + 193, + 760, + 1, + 0, + 0, + 0, + 195, + 773, + 1, + 0, + 0, + 0, + 197, + 777, + 1, + 0, + 0, + 0, + 199, + 783, + 1, + 0, + 0, + 0, + 201, + 796, + 1, + 0, + 0, + 0, + 203, + 813, + 1, + 0, + 0, + 0, + 205, + 816, + 1, + 0, + 0, + 0, + 207, + 820, + 1, + 0, + 0, + 0, + 209, + 824, + 1, + 0, + 0, + 0, + 211, + 828, + 1, + 0, + 0, + 0, + 213, + 835, + 1, + 0, + 0, + 0, + 215, + 840, + 1, + 0, + 0, + 0, + 217, + 849, + 1, + 0, + 0, + 0, + 219, + 854, + 1, + 0, + 0, + 0, + 221, + 860, + 1, + 0, + 0, + 0, + 223, + 865, + 1, + 0, + 0, + 0, + 225, + 870, + 1, + 0, + 0, + 0, + 227, + 874, + 1, + 0, + 0, + 0, + 229, + 879, + 1, + 0, + 0, + 0, + 231, + 884, + 1, + 0, + 0, + 0, + 233, + 891, + 1, + 0, + 0, + 0, + 235, + 899, + 1, + 0, + 0, + 0, + 237, + 906, + 1, + 0, + 0, + 0, + 239, + 910, + 1, + 0, + 0, + 0, + 241, + 915, + 1, + 0, + 0, + 0, + 243, + 922, + 1, + 0, + 0, + 0, + 245, + 927, + 1, + 0, + 0, + 0, + 247, + 933, + 1, + 0, + 0, + 0, + 249, + 949, + 1, + 0, + 0, + 0, + 251, + 951, + 1, + 0, + 0, + 0, + 253, + 960, + 1, + 0, + 0, + 0, + 255, + 964, + 1, + 0, + 0, + 0, + 257, + 968, + 1, + 0, + 0, + 0, + 259, + 972, + 1, + 0, + 0, + 0, + 261, + 974, + 1, + 0, + 0, + 0, + 263, + 978, + 1, + 0, + 0, + 0, + 265, + 980, + 1, + 0, + 0, + 0, + 267, + 1004, + 1, + 0, + 0, + 0, + 269, + 1018, + 1, + 0, + 0, + 0, + 271, + 1045, + 1, + 0, + 0, + 0, + 273, + 1047, + 1, + 0, + 0, + 0, + 275, + 1067, + 1, + 0, + 0, + 0, + 277, + 1070, + 1, + 0, + 0, + 0, + 279, + 1074, + 1, + 0, + 0, + 0, + 281, + 1082, + 1, + 0, + 0, + 0, + 283, + 1092, + 1, + 0, + 0, + 0, + 285, + 1099, + 1, + 0, + 0, + 0, + 287, + 1102, + 1, + 0, + 0, + 0, + 289, + 1106, + 1, + 0, + 0, + 0, + 291, + 1115, + 1, + 0, + 0, + 0, + 293, + 1119, + 1, + 0, + 0, + 0, + 295, + 1129, + 1, + 0, + 0, + 0, + 297, + 1134, + 1, + 0, + 0, + 0, + 299, + 1150, + 1, + 0, + 0, + 0, + 301, + 1181, + 1, + 0, + 0, + 0, + 303, + 1183, + 1, + 0, + 0, + 0, + 305, + 1185, + 1, + 0, + 0, + 0, + 307, + 1187, + 1, + 0, + 0, + 0, + 309, + 1189, + 1, + 0, + 0, + 0, + 311, + 1191, + 1, + 0, + 0, + 0, + 313, + 1193, + 1, + 0, + 0, + 0, + 315, + 1195, + 1, + 0, + 0, + 0, + 317, + 1197, + 1, + 0, + 0, + 0, + 319, + 1199, + 1, + 0, + 0, + 0, + 321, + 1201, + 1, + 0, + 0, + 0, + 323, + 1203, + 1, + 0, + 0, + 0, + 325, + 1205, + 1, + 0, + 0, + 0, + 327, + 1207, + 1, + 0, + 0, + 0, + 329, + 1209, + 1, + 0, + 0, + 0, + 331, + 1211, + 1, + 0, + 0, + 0, + 333, + 1213, + 1, + 0, + 0, + 0, + 335, + 1215, + 1, + 0, + 0, + 0, + 337, + 1217, + 1, + 0, + 0, + 0, + 339, + 1219, + 1, + 0, + 0, + 0, + 341, + 1221, + 1, + 0, + 0, + 0, + 343, + 344, + 5, + 59, + 0, + 0, + 344, + 2, + 1, + 0, + 0, + 0, + 345, + 346, + 5, + 61, + 0, + 0, + 346, + 4, + 1, + 0, + 0, + 0, + 347, + 348, + 5, + 40, + 0, + 0, + 348, + 6, + 1, + 0, + 0, + 0, + 349, + 350, + 5, + 41, + 0, + 0, + 350, + 8, + 1, + 0, + 0, + 0, + 351, + 352, + 5, + 91, + 0, + 0, + 352, + 10, + 1, + 0, + 0, + 0, + 353, + 354, + 5, + 93, + 0, + 0, + 354, + 12, + 1, + 0, + 0, + 0, + 355, + 356, + 5, + 44, + 0, + 0, + 356, + 14, + 1, + 0, + 0, + 0, + 357, + 358, + 5, + 43, + 0, + 0, + 358, + 359, + 5, + 61, + 0, + 0, + 359, + 16, + 1, + 0, + 0, + 0, + 360, + 361, + 5, + 124, + 0, + 0, + 361, + 18, + 1, + 0, + 0, + 0, + 362, + 363, + 5, + 42, + 0, + 0, + 363, + 20, + 1, + 0, + 0, + 0, + 364, + 365, + 5, + 58, + 0, + 0, + 365, + 22, + 1, + 0, + 0, + 0, + 366, + 367, + 5, + 46, + 0, + 0, + 367, + 368, + 5, + 46, + 0, + 0, + 368, + 24, + 1, + 0, + 0, + 0, + 369, + 370, + 5, + 60, + 0, + 0, + 370, + 371, + 5, + 62, + 0, + 0, + 371, + 26, + 1, + 0, + 0, + 0, + 372, + 373, + 5, + 60, + 0, + 0, + 373, + 28, + 1, + 0, + 0, + 0, + 374, + 375, + 5, + 62, + 0, + 0, + 375, + 30, + 1, + 0, + 0, + 0, + 376, + 377, + 5, + 60, + 0, + 0, + 377, + 378, + 5, + 61, + 0, + 0, + 378, + 32, + 1, + 0, + 0, + 0, + 379, + 380, + 5, + 62, + 0, + 0, + 380, + 381, + 5, + 61, + 0, + 0, + 381, + 34, + 1, + 0, + 0, + 0, + 382, + 383, + 5, + 61, + 0, + 0, + 383, + 384, + 5, + 126, + 0, + 0, + 384, + 36, + 1, + 0, + 0, + 0, + 385, + 386, + 5, + 43, + 0, + 0, + 386, + 38, + 1, + 0, + 0, + 0, + 387, + 388, + 5, + 45, + 0, + 0, + 388, + 40, + 1, + 0, + 0, + 0, + 389, + 390, + 5, + 47, + 0, + 0, + 390, + 42, + 1, + 0, + 0, + 0, + 391, + 392, + 5, + 37, + 0, + 0, + 392, + 44, + 1, + 0, + 0, + 0, + 393, + 394, + 5, + 94, + 0, + 0, + 394, + 46, + 1, + 0, + 0, + 0, + 395, + 396, + 5, + 46, + 0, + 0, + 396, + 48, + 1, + 0, + 0, + 0, + 397, + 398, + 5, + 123, + 0, + 0, + 398, + 50, + 1, + 0, + 0, + 0, + 399, + 400, + 5, + 125, + 0, + 0, + 400, + 52, + 1, + 0, + 0, + 0, + 401, + 402, + 5, + 36, + 0, + 0, + 402, + 54, + 1, + 0, + 0, + 0, + 403, + 404, + 5, + 10216, + 0, + 0, + 404, + 56, + 1, + 0, + 0, + 0, + 405, + 406, + 5, + 12296, + 0, + 0, + 406, + 58, + 1, + 0, + 0, + 0, + 407, + 408, + 5, + 65124, + 0, + 0, + 408, + 60, + 1, + 0, + 0, + 0, + 409, + 410, + 5, + 65308, + 0, + 0, + 410, + 62, + 1, + 0, + 0, + 0, + 411, + 412, + 5, + 10217, + 0, + 0, + 412, + 64, + 1, + 0, + 0, + 0, + 413, + 414, + 5, + 12297, + 0, + 0, + 414, + 66, + 1, + 0, + 0, + 0, + 415, + 416, + 5, + 65125, + 0, + 0, + 416, + 68, + 1, + 0, + 0, + 0, + 417, + 418, + 5, + 65310, + 0, + 0, + 418, + 70, + 1, + 0, + 0, + 0, + 419, + 420, + 5, + 173, + 0, + 0, + 420, + 72, + 1, + 0, + 0, + 0, + 421, + 422, + 5, + 8208, + 0, + 0, + 422, + 74, + 1, + 0, + 0, + 0, + 423, + 424, + 5, + 8209, + 0, + 0, + 424, + 76, + 1, + 0, + 0, + 0, + 425, + 426, + 5, + 8210, + 0, + 0, + 426, + 78, + 1, + 0, + 0, + 0, + 427, + 428, + 5, + 8211, + 0, + 0, + 428, + 80, + 1, + 0, + 0, + 0, + 429, + 430, + 5, + 8212, + 0, + 0, + 430, + 82, + 1, + 0, + 0, + 0, + 431, + 432, + 5, + 8213, + 0, + 0, + 432, + 84, + 1, + 0, + 0, + 0, + 433, + 434, + 5, + 8722, + 0, + 0, + 434, + 86, + 1, + 0, + 0, + 0, + 435, + 436, + 5, + 65112, + 0, + 0, + 436, + 88, + 1, + 0, + 0, + 0, + 437, + 438, + 5, + 65123, + 0, + 0, + 438, + 90, + 1, + 0, + 0, + 0, + 439, + 440, + 5, + 65293, + 0, + 0, + 440, + 92, + 1, + 0, + 0, + 0, + 441, + 442, + 7, + 0, + 0, + 0, + 442, + 443, + 7, + 1, + 0, + 0, + 443, + 444, + 7, + 2, + 0, + 0, + 444, + 445, + 7, + 3, + 0, + 0, + 445, + 446, + 7, + 4, + 0, + 0, + 446, + 447, + 7, + 5, + 0, + 0, + 447, + 94, + 1, + 0, + 0, + 0, + 448, + 449, + 7, + 4, + 0, + 0, + 449, + 450, + 7, + 6, + 0, + 0, + 450, + 451, + 7, + 2, + 0, + 0, + 451, + 452, + 7, + 7, + 0, + 0, + 452, + 453, + 7, + 8, + 0, + 0, + 453, + 454, + 7, + 9, + 0, + 0, + 454, + 455, + 7, + 10, + 0, + 0, + 455, + 96, + 1, + 0, + 0, + 0, + 456, + 457, + 7, + 2, + 0, + 0, + 457, + 458, + 7, + 5, + 0, + 0, + 458, + 459, + 7, + 11, + 0, + 0, + 459, + 460, + 7, + 12, + 0, + 0, + 460, + 461, + 7, + 9, + 0, + 0, + 461, + 462, + 7, + 7, + 0, + 0, + 462, + 463, + 7, + 4, + 0, + 0, + 463, + 98, + 1, + 0, + 0, + 0, + 464, + 465, + 7, + 13, + 0, + 0, + 465, + 466, + 7, + 14, + 0, + 0, + 466, + 467, + 7, + 9, + 0, + 0, + 467, + 468, + 7, + 10, + 0, + 0, + 468, + 469, + 7, + 15, + 0, + 0, + 469, + 100, + 1, + 0, + 0, + 0, + 470, + 471, + 7, + 2, + 0, + 0, + 471, + 472, + 7, + 4, + 0, + 0, + 472, + 473, + 7, + 5, + 0, + 0, + 473, + 474, + 7, + 9, + 0, + 0, + 474, + 475, + 7, + 11, + 0, + 0, + 475, + 476, + 7, + 16, + 0, + 0, + 476, + 477, + 7, + 9, + 0, + 0, + 477, + 478, + 7, + 0, + 0, + 0, + 478, + 102, + 1, + 0, + 0, + 0, + 479, + 480, + 7, + 0, + 0, + 0, + 480, + 481, + 7, + 11, + 0, + 0, + 481, + 482, + 7, + 17, + 0, + 0, + 482, + 483, + 7, + 17, + 0, + 0, + 483, + 484, + 7, + 9, + 0, + 0, + 484, + 485, + 7, + 18, + 0, + 0, + 485, + 104, + 1, + 0, + 0, + 0, + 486, + 487, + 7, + 13, + 0, + 0, + 487, + 488, + 7, + 10, + 0, + 0, + 488, + 489, + 7, + 9, + 0, + 0, + 489, + 490, + 7, + 11, + 0, + 0, + 490, + 491, + 7, + 10, + 0, + 0, + 491, + 106, + 1, + 0, + 0, + 0, + 492, + 493, + 7, + 8, + 0, + 0, + 493, + 494, + 7, + 7, + 0, + 0, + 494, + 495, + 7, + 7, + 0, + 0, + 495, + 108, + 1, + 0, + 0, + 0, + 496, + 497, + 7, + 0, + 0, + 0, + 497, + 498, + 7, + 5, + 0, + 0, + 498, + 499, + 7, + 4, + 0, + 0, + 499, + 500, + 7, + 8, + 0, + 0, + 500, + 501, + 7, + 18, + 0, + 0, + 501, + 502, + 7, + 4, + 0, + 0, + 502, + 110, + 1, + 0, + 0, + 0, + 503, + 504, + 7, + 16, + 0, + 0, + 504, + 505, + 7, + 5, + 0, + 0, + 505, + 506, + 7, + 11, + 0, + 0, + 506, + 507, + 7, + 2, + 0, + 0, + 507, + 112, + 1, + 0, + 0, + 0, + 508, + 509, + 7, + 9, + 0, + 0, + 509, + 510, + 7, + 10, + 0, + 0, + 510, + 511, + 7, + 16, + 0, + 0, + 511, + 512, + 7, + 4, + 0, + 0, + 512, + 513, + 7, + 6, + 0, + 0, + 513, + 114, + 1, + 0, + 0, + 0, + 514, + 515, + 7, + 11, + 0, + 0, + 515, + 516, + 7, + 10, + 0, + 0, + 516, + 116, + 1, + 0, + 0, + 0, + 517, + 518, + 7, + 0, + 0, + 0, + 518, + 519, + 7, + 11, + 0, + 0, + 519, + 520, + 7, + 10, + 0, + 0, + 520, + 521, + 7, + 14, + 0, + 0, + 521, + 522, + 7, + 18, + 0, + 0, + 522, + 523, + 7, + 5, + 0, + 0, + 523, + 524, + 7, + 8, + 0, + 0, + 524, + 525, + 7, + 9, + 0, + 0, + 525, + 526, + 7, + 10, + 0, + 0, + 526, + 527, + 7, + 18, + 0, + 0, + 527, + 118, + 1, + 0, + 0, + 0, + 528, + 529, + 7, + 8, + 0, + 0, + 529, + 530, + 7, + 14, + 0, + 0, + 530, + 531, + 7, + 14, + 0, + 0, + 531, + 532, + 7, + 4, + 0, + 0, + 532, + 533, + 7, + 5, + 0, + 0, + 533, + 534, + 7, + 18, + 0, + 0, + 534, + 120, + 1, + 0, + 0, + 0, + 535, + 536, + 7, + 9, + 0, + 0, + 536, + 537, + 7, + 14, + 0, + 0, + 537, + 122, + 1, + 0, + 0, + 0, + 538, + 539, + 7, + 13, + 0, + 0, + 539, + 540, + 7, + 10, + 0, + 0, + 540, + 541, + 7, + 9, + 0, + 0, + 541, + 542, + 7, + 19, + 0, + 0, + 542, + 543, + 7, + 13, + 0, + 0, + 543, + 544, + 7, + 4, + 0, + 0, + 544, + 124, + 1, + 0, + 0, + 0, + 545, + 546, + 7, + 4, + 0, + 0, + 546, + 547, + 7, + 6, + 0, + 0, + 547, + 548, + 7, + 9, + 0, + 0, + 548, + 549, + 7, + 14, + 0, + 0, + 549, + 550, + 7, + 18, + 0, + 0, + 550, + 551, + 7, + 14, + 0, + 0, + 551, + 126, + 1, + 0, + 0, + 0, + 552, + 553, + 7, + 7, + 0, + 0, + 553, + 554, + 7, + 11, + 0, + 0, + 554, + 555, + 7, + 8, + 0, + 0, + 555, + 556, + 7, + 16, + 0, + 0, + 556, + 128, + 1, + 0, + 0, + 0, + 557, + 558, + 7, + 0, + 0, + 0, + 558, + 559, + 7, + 14, + 0, + 0, + 559, + 560, + 7, + 20, + 0, + 0, + 560, + 130, + 1, + 0, + 0, + 0, + 561, + 562, + 7, + 21, + 0, + 0, + 562, + 563, + 7, + 9, + 0, + 0, + 563, + 564, + 7, + 18, + 0, + 0, + 564, + 565, + 7, + 3, + 0, + 0, + 565, + 132, + 1, + 0, + 0, + 0, + 566, + 567, + 7, + 3, + 0, + 0, + 567, + 568, + 7, + 4, + 0, + 0, + 568, + 569, + 7, + 8, + 0, + 0, + 569, + 570, + 7, + 16, + 0, + 0, + 570, + 571, + 7, + 4, + 0, + 0, + 571, + 572, + 7, + 5, + 0, + 0, + 572, + 573, + 7, + 14, + 0, + 0, + 573, + 134, + 1, + 0, + 0, + 0, + 574, + 575, + 7, + 12, + 0, + 0, + 575, + 576, + 7, + 5, + 0, + 0, + 576, + 577, + 7, + 11, + 0, + 0, + 577, + 578, + 7, + 17, + 0, + 0, + 578, + 136, + 1, + 0, + 0, + 0, + 579, + 580, + 7, + 8, + 0, + 0, + 580, + 581, + 7, + 14, + 0, + 0, + 581, + 138, + 1, + 0, + 0, + 0, + 582, + 583, + 7, + 12, + 0, + 0, + 583, + 584, + 7, + 9, + 0, + 0, + 584, + 585, + 7, + 4, + 0, + 0, + 585, + 586, + 7, + 7, + 0, + 0, + 586, + 587, + 7, + 16, + 0, + 0, + 587, + 588, + 7, + 18, + 0, + 0, + 588, + 589, + 7, + 4, + 0, + 0, + 589, + 590, + 7, + 5, + 0, + 0, + 590, + 591, + 7, + 17, + 0, + 0, + 591, + 592, + 7, + 9, + 0, + 0, + 592, + 593, + 7, + 10, + 0, + 0, + 593, + 594, + 7, + 8, + 0, + 0, + 594, + 595, + 7, + 18, + 0, + 0, + 595, + 596, + 7, + 11, + 0, + 0, + 596, + 597, + 7, + 5, + 0, + 0, + 597, + 140, + 1, + 0, + 0, + 0, + 598, + 599, + 7, + 11, + 0, + 0, + 599, + 600, + 7, + 2, + 0, + 0, + 600, + 601, + 7, + 18, + 0, + 0, + 601, + 602, + 7, + 9, + 0, + 0, + 602, + 603, + 7, + 11, + 0, + 0, + 603, + 604, + 7, + 10, + 0, + 0, + 604, + 605, + 7, + 8, + 0, + 0, + 605, + 606, + 7, + 7, + 0, + 0, + 606, + 142, + 1, + 0, + 0, + 0, + 607, + 608, + 7, + 17, + 0, + 0, + 608, + 609, + 7, + 8, + 0, + 0, + 609, + 610, + 7, + 18, + 0, + 0, + 610, + 611, + 7, + 0, + 0, + 0, + 611, + 612, + 7, + 3, + 0, + 0, + 612, + 144, + 1, + 0, + 0, + 0, + 613, + 614, + 7, + 13, + 0, + 0, + 614, + 615, + 7, + 10, + 0, + 0, + 615, + 616, + 7, + 21, + 0, + 0, + 616, + 617, + 7, + 9, + 0, + 0, + 617, + 618, + 7, + 10, + 0, + 0, + 618, + 619, + 7, + 16, + 0, + 0, + 619, + 146, + 1, + 0, + 0, + 0, + 620, + 621, + 7, + 17, + 0, + 0, + 621, + 622, + 7, + 4, + 0, + 0, + 622, + 623, + 7, + 5, + 0, + 0, + 623, + 624, + 7, + 15, + 0, + 0, + 624, + 625, + 7, + 4, + 0, + 0, + 625, + 148, + 1, + 0, + 0, + 0, + 626, + 627, + 7, + 14, + 0, + 0, + 627, + 628, + 7, + 4, + 0, + 0, + 628, + 629, + 7, + 18, + 0, + 0, + 629, + 150, + 1, + 0, + 0, + 0, + 630, + 631, + 7, + 16, + 0, + 0, + 631, + 632, + 7, + 4, + 0, + 0, + 632, + 633, + 7, + 18, + 0, + 0, + 633, + 634, + 7, + 8, + 0, + 0, + 634, + 635, + 7, + 0, + 0, + 0, + 635, + 636, + 7, + 3, + 0, + 0, + 636, + 152, + 1, + 0, + 0, + 0, + 637, + 638, + 7, + 16, + 0, + 0, + 638, + 639, + 7, + 4, + 0, + 0, + 639, + 640, + 7, + 7, + 0, + 0, + 640, + 641, + 7, + 4, + 0, + 0, + 641, + 642, + 7, + 18, + 0, + 0, + 642, + 643, + 7, + 4, + 0, + 0, + 643, + 154, + 1, + 0, + 0, + 0, + 644, + 645, + 7, + 5, + 0, + 0, + 645, + 646, + 7, + 4, + 0, + 0, + 646, + 647, + 7, + 17, + 0, + 0, + 647, + 648, + 7, + 11, + 0, + 0, + 648, + 649, + 7, + 20, + 0, + 0, + 649, + 650, + 7, + 4, + 0, + 0, + 650, + 156, + 1, + 0, + 0, + 0, + 651, + 652, + 7, + 12, + 0, + 0, + 652, + 653, + 7, + 11, + 0, + 0, + 653, + 654, + 7, + 5, + 0, + 0, + 654, + 655, + 7, + 4, + 0, + 0, + 655, + 656, + 7, + 8, + 0, + 0, + 656, + 657, + 7, + 0, + 0, + 0, + 657, + 658, + 7, + 3, + 0, + 0, + 658, + 158, + 1, + 0, + 0, + 0, + 659, + 660, + 7, + 9, + 0, + 0, + 660, + 661, + 7, + 10, + 0, + 0, + 661, + 160, + 1, + 0, + 0, + 0, + 662, + 663, + 7, + 0, + 0, + 0, + 663, + 664, + 7, + 8, + 0, + 0, + 664, + 665, + 7, + 7, + 0, + 0, + 665, + 666, + 7, + 7, + 0, + 0, + 666, + 162, + 1, + 0, + 0, + 0, + 667, + 668, + 7, + 1, + 0, + 0, + 668, + 669, + 7, + 9, + 0, + 0, + 669, + 670, + 7, + 4, + 0, + 0, + 670, + 671, + 7, + 7, + 0, + 0, + 671, + 672, + 7, + 16, + 0, + 0, + 672, + 164, + 1, + 0, + 0, + 0, + 673, + 674, + 7, + 5, + 0, + 0, + 674, + 675, + 7, + 4, + 0, + 0, + 675, + 676, + 7, + 18, + 0, + 0, + 676, + 677, + 7, + 13, + 0, + 0, + 677, + 678, + 7, + 5, + 0, + 0, + 678, + 679, + 7, + 10, + 0, + 0, + 679, + 166, + 1, + 0, + 0, + 0, + 680, + 681, + 7, + 16, + 0, + 0, + 681, + 682, + 7, + 9, + 0, + 0, + 682, + 683, + 7, + 14, + 0, + 0, + 683, + 684, + 7, + 18, + 0, + 0, + 684, + 685, + 7, + 9, + 0, + 0, + 685, + 686, + 7, + 10, + 0, + 0, + 686, + 687, + 7, + 0, + 0, + 0, + 687, + 688, + 7, + 18, + 0, + 0, + 688, + 168, + 1, + 0, + 0, + 0, + 689, + 690, + 7, + 11, + 0, + 0, + 690, + 691, + 7, + 5, + 0, + 0, + 691, + 692, + 7, + 16, + 0, + 0, + 692, + 693, + 7, + 4, + 0, + 0, + 693, + 694, + 7, + 5, + 0, + 0, + 694, + 170, + 1, + 0, + 0, + 0, + 695, + 696, + 7, + 22, + 0, + 0, + 696, + 697, + 7, + 1, + 0, + 0, + 697, + 172, + 1, + 0, + 0, + 0, + 698, + 699, + 7, + 14, + 0, + 0, + 699, + 700, + 7, + 23, + 0, + 0, + 700, + 701, + 7, + 9, + 0, + 0, + 701, + 702, + 7, + 2, + 0, + 0, + 702, + 174, + 1, + 0, + 0, + 0, + 703, + 704, + 7, + 7, + 0, + 0, + 704, + 705, + 7, + 9, + 0, + 0, + 705, + 706, + 7, + 17, + 0, + 0, + 706, + 707, + 7, + 9, + 0, + 0, + 707, + 708, + 7, + 18, + 0, + 0, + 708, + 176, + 1, + 0, + 0, + 0, + 709, + 710, + 7, + 8, + 0, + 0, + 710, + 711, + 7, + 14, + 0, + 0, + 711, + 712, + 7, + 0, + 0, + 0, + 712, + 713, + 7, + 4, + 0, + 0, + 713, + 714, + 7, + 10, + 0, + 0, + 714, + 715, + 7, + 16, + 0, + 0, + 715, + 716, + 7, + 9, + 0, + 0, + 716, + 717, + 7, + 10, + 0, + 0, + 717, + 718, + 7, + 15, + 0, + 0, + 718, + 178, + 1, + 0, + 0, + 0, + 719, + 720, + 7, + 8, + 0, + 0, + 720, + 721, + 7, + 14, + 0, + 0, + 721, + 722, + 7, + 0, + 0, + 0, + 722, + 180, + 1, + 0, + 0, + 0, + 723, + 724, + 7, + 16, + 0, + 0, + 724, + 725, + 7, + 4, + 0, + 0, + 725, + 726, + 7, + 14, + 0, + 0, + 726, + 727, + 7, + 0, + 0, + 0, + 727, + 728, + 7, + 4, + 0, + 0, + 728, + 729, + 7, + 10, + 0, + 0, + 729, + 730, + 7, + 16, + 0, + 0, + 730, + 731, + 7, + 9, + 0, + 0, + 731, + 732, + 7, + 10, + 0, + 0, + 732, + 733, + 7, + 15, + 0, + 0, + 733, + 182, + 1, + 0, + 0, + 0, + 734, + 735, + 7, + 16, + 0, + 0, + 735, + 736, + 7, + 4, + 0, + 0, + 736, + 737, + 7, + 14, + 0, + 0, + 737, + 738, + 7, + 0, + 0, + 0, + 738, + 184, + 1, + 0, + 0, + 0, + 739, + 740, + 7, + 24, + 0, + 0, + 740, + 741, + 7, + 11, + 0, + 0, + 741, + 742, + 7, + 9, + 0, + 0, + 742, + 743, + 7, + 10, + 0, + 0, + 743, + 186, + 1, + 0, + 0, + 0, + 744, + 745, + 7, + 14, + 0, + 0, + 745, + 746, + 7, + 0, + 0, + 0, + 746, + 747, + 7, + 8, + 0, + 0, + 747, + 748, + 7, + 10, + 0, + 0, + 748, + 188, + 1, + 0, + 0, + 0, + 749, + 750, + 7, + 14, + 0, + 0, + 750, + 751, + 7, + 18, + 0, + 0, + 751, + 752, + 7, + 8, + 0, + 0, + 752, + 753, + 7, + 5, + 0, + 0, + 753, + 754, + 7, + 18, + 0, + 0, + 754, + 190, + 1, + 0, + 0, + 0, + 755, + 756, + 7, + 10, + 0, + 0, + 756, + 757, + 7, + 11, + 0, + 0, + 757, + 758, + 7, + 16, + 0, + 0, + 758, + 759, + 7, + 4, + 0, + 0, + 759, + 192, + 1, + 0, + 0, + 0, + 760, + 761, + 7, + 5, + 0, + 0, + 761, + 762, + 7, + 4, + 0, + 0, + 762, + 763, + 7, + 7, + 0, + 0, + 763, + 764, + 7, + 8, + 0, + 0, + 764, + 765, + 7, + 18, + 0, + 0, + 765, + 766, + 7, + 9, + 0, + 0, + 766, + 767, + 7, + 11, + 0, + 0, + 767, + 768, + 7, + 10, + 0, + 0, + 768, + 769, + 7, + 14, + 0, + 0, + 769, + 770, + 7, + 3, + 0, + 0, + 770, + 771, + 7, + 9, + 0, + 0, + 771, + 772, + 7, + 2, + 0, + 0, + 772, + 194, + 1, + 0, + 0, + 0, + 773, + 774, + 7, + 5, + 0, + 0, + 774, + 775, + 7, + 4, + 0, + 0, + 775, + 776, + 7, + 7, + 0, + 0, + 776, + 196, + 1, + 0, + 0, + 0, + 777, + 778, + 7, + 21, + 0, + 0, + 778, + 779, + 7, + 3, + 0, + 0, + 779, + 780, + 7, + 4, + 0, + 0, + 780, + 781, + 7, + 5, + 0, + 0, + 781, + 782, + 7, + 4, + 0, + 0, + 782, + 198, + 1, + 0, + 0, + 0, + 783, + 784, + 7, + 14, + 0, + 0, + 784, + 785, + 7, + 3, + 0, + 0, + 785, + 786, + 7, + 11, + 0, + 0, + 786, + 787, + 7, + 5, + 0, + 0, + 787, + 788, + 7, + 18, + 0, + 0, + 788, + 789, + 7, + 4, + 0, + 0, + 789, + 790, + 7, + 14, + 0, + 0, + 790, + 791, + 7, + 18, + 0, + 0, + 791, + 792, + 7, + 2, + 0, + 0, + 792, + 793, + 7, + 8, + 0, + 0, + 793, + 794, + 7, + 18, + 0, + 0, + 794, + 795, + 7, + 3, + 0, + 0, + 795, + 200, + 1, + 0, + 0, + 0, + 796, + 797, + 7, + 8, + 0, + 0, + 797, + 798, + 7, + 7, + 0, + 0, + 798, + 799, + 7, + 7, + 0, + 0, + 799, + 800, + 7, + 14, + 0, + 0, + 800, + 801, + 7, + 3, + 0, + 0, + 801, + 802, + 7, + 11, + 0, + 0, + 802, + 803, + 7, + 5, + 0, + 0, + 803, + 804, + 7, + 18, + 0, + 0, + 804, + 805, + 7, + 4, + 0, + 0, + 805, + 806, + 7, + 14, + 0, + 0, + 806, + 807, + 7, + 18, + 0, + 0, + 807, + 808, + 7, + 2, + 0, + 0, + 808, + 809, + 7, + 8, + 0, + 0, + 809, + 810, + 7, + 18, + 0, + 0, + 810, + 811, + 7, + 3, + 0, + 0, + 811, + 812, + 7, + 14, + 0, + 0, + 812, + 202, + 1, + 0, + 0, + 0, + 813, + 814, + 7, + 11, + 0, + 0, + 814, + 815, + 7, + 5, + 0, + 0, + 815, + 204, + 1, + 0, + 0, + 0, + 816, + 817, + 7, + 6, + 0, + 0, + 817, + 818, + 7, + 11, + 0, + 0, + 818, + 819, + 7, + 5, + 0, + 0, + 819, + 206, + 1, + 0, + 0, + 0, + 820, + 821, + 7, + 8, + 0, + 0, + 821, + 822, + 7, + 10, + 0, + 0, + 822, + 823, + 7, + 16, + 0, + 0, + 823, + 208, + 1, + 0, + 0, + 0, + 824, + 825, + 7, + 10, + 0, + 0, + 825, + 826, + 7, + 11, + 0, + 0, + 826, + 827, + 7, + 18, + 0, + 0, + 827, + 210, + 1, + 0, + 0, + 0, + 828, + 829, + 7, + 14, + 0, + 0, + 829, + 830, + 7, + 18, + 0, + 0, + 830, + 831, + 7, + 8, + 0, + 0, + 831, + 832, + 7, + 5, + 0, + 0, + 832, + 833, + 7, + 18, + 0, + 0, + 833, + 834, + 7, + 14, + 0, + 0, + 834, + 212, + 1, + 0, + 0, + 0, + 835, + 836, + 7, + 4, + 0, + 0, + 836, + 837, + 7, + 10, + 0, + 0, + 837, + 838, + 7, + 16, + 0, + 0, + 838, + 839, + 7, + 14, + 0, + 0, + 839, + 214, + 1, + 0, + 0, + 0, + 840, + 841, + 7, + 0, + 0, + 0, + 841, + 842, + 7, + 11, + 0, + 0, + 842, + 843, + 7, + 10, + 0, + 0, + 843, + 844, + 7, + 18, + 0, + 0, + 844, + 845, + 7, + 8, + 0, + 0, + 845, + 846, + 7, + 9, + 0, + 0, + 846, + 847, + 7, + 10, + 0, + 0, + 847, + 848, + 7, + 14, + 0, + 0, + 848, + 216, + 1, + 0, + 0, + 0, + 849, + 850, + 7, + 10, + 0, + 0, + 850, + 851, + 7, + 13, + 0, + 0, + 851, + 852, + 7, + 7, + 0, + 0, + 852, + 853, + 7, + 7, + 0, + 0, + 853, + 218, + 1, + 0, + 0, + 0, + 854, + 855, + 7, + 0, + 0, + 0, + 855, + 856, + 7, + 11, + 0, + 0, + 856, + 857, + 7, + 13, + 0, + 0, + 857, + 858, + 7, + 10, + 0, + 0, + 858, + 859, + 7, + 18, + 0, + 0, + 859, + 220, + 1, + 0, + 0, + 0, + 860, + 861, + 7, + 0, + 0, + 0, + 861, + 862, + 7, + 8, + 0, + 0, + 862, + 863, + 7, + 14, + 0, + 0, + 863, + 864, + 7, + 4, + 0, + 0, + 864, + 222, + 1, + 0, + 0, + 0, + 865, + 866, + 7, + 4, + 0, + 0, + 866, + 867, + 7, + 7, + 0, + 0, + 867, + 868, + 7, + 14, + 0, + 0, + 868, + 869, + 7, + 4, + 0, + 0, + 869, + 224, + 1, + 0, + 0, + 0, + 870, + 871, + 7, + 4, + 0, + 0, + 871, + 872, + 7, + 10, + 0, + 0, + 872, + 873, + 7, + 16, + 0, + 0, + 873, + 226, + 1, + 0, + 0, + 0, + 874, + 875, + 7, + 21, + 0, + 0, + 875, + 876, + 7, + 3, + 0, + 0, + 876, + 877, + 7, + 4, + 0, + 0, + 877, + 878, + 7, + 10, + 0, + 0, + 878, + 228, + 1, + 0, + 0, + 0, + 879, + 880, + 7, + 18, + 0, + 0, + 880, + 881, + 7, + 3, + 0, + 0, + 881, + 882, + 7, + 4, + 0, + 0, + 882, + 883, + 7, + 10, + 0, + 0, + 883, + 230, + 1, + 0, + 0, + 0, + 884, + 885, + 7, + 12, + 0, + 0, + 885, + 886, + 7, + 9, + 0, + 0, + 886, + 887, + 7, + 7, + 0, + 0, + 887, + 888, + 7, + 18, + 0, + 0, + 888, + 889, + 7, + 4, + 0, + 0, + 889, + 890, + 7, + 5, + 0, + 0, + 890, + 232, + 1, + 0, + 0, + 0, + 891, + 892, + 7, + 4, + 0, + 0, + 892, + 893, + 7, + 6, + 0, + 0, + 893, + 894, + 7, + 18, + 0, + 0, + 894, + 895, + 7, + 5, + 0, + 0, + 895, + 896, + 7, + 8, + 0, + 0, + 896, + 897, + 7, + 0, + 0, + 0, + 897, + 898, + 7, + 18, + 0, + 0, + 898, + 234, + 1, + 0, + 0, + 0, + 899, + 900, + 7, + 5, + 0, + 0, + 900, + 901, + 7, + 4, + 0, + 0, + 901, + 902, + 7, + 16, + 0, + 0, + 902, + 903, + 7, + 13, + 0, + 0, + 903, + 904, + 7, + 0, + 0, + 0, + 904, + 905, + 7, + 4, + 0, + 0, + 905, + 236, + 1, + 0, + 0, + 0, + 906, + 907, + 7, + 8, + 0, + 0, + 907, + 908, + 7, + 10, + 0, + 0, + 908, + 909, + 7, + 1, + 0, + 0, + 909, + 238, + 1, + 0, + 0, + 0, + 910, + 911, + 7, + 10, + 0, + 0, + 911, + 912, + 7, + 11, + 0, + 0, + 912, + 913, + 7, + 10, + 0, + 0, + 913, + 914, + 7, + 4, + 0, + 0, + 914, + 240, + 1, + 0, + 0, + 0, + 915, + 916, + 7, + 14, + 0, + 0, + 916, + 917, + 7, + 9, + 0, + 0, + 917, + 918, + 7, + 10, + 0, + 0, + 918, + 919, + 7, + 15, + 0, + 0, + 919, + 920, + 7, + 7, + 0, + 0, + 920, + 921, + 7, + 4, + 0, + 0, + 921, + 242, + 1, + 0, + 0, + 0, + 922, + 923, + 7, + 18, + 0, + 0, + 923, + 924, + 7, + 5, + 0, + 0, + 924, + 925, + 7, + 13, + 0, + 0, + 925, + 926, + 7, + 4, + 0, + 0, + 926, + 244, + 1, + 0, + 0, + 0, + 927, + 928, + 7, + 12, + 0, + 0, + 928, + 929, + 7, + 8, + 0, + 0, + 929, + 930, + 7, + 7, + 0, + 0, + 930, + 931, + 7, + 14, + 0, + 0, + 931, + 932, + 7, + 4, + 0, + 0, + 932, + 246, + 1, + 0, + 0, + 0, + 933, + 934, + 5, + 48, + 0, + 0, + 934, + 935, + 5, + 120, + 0, + 0, + 935, + 937, + 1, + 0, + 0, + 0, + 936, + 938, + 3, + 255, + 127, + 0, + 937, + 936, + 1, + 0, + 0, + 0, + 938, + 939, + 1, + 0, + 0, + 0, + 939, + 937, + 1, + 0, + 0, + 0, + 939, + 940, + 1, + 0, + 0, + 0, + 940, + 248, + 1, + 0, + 0, + 0, + 941, + 950, + 3, + 265, + 132, + 0, + 942, + 946, + 3, + 259, + 129, + 0, + 943, + 945, + 3, + 257, + 128, + 0, + 944, + 943, + 1, + 0, + 0, + 0, + 945, + 948, + 1, + 0, + 0, + 0, + 946, + 944, + 1, + 0, + 0, + 0, + 946, + 947, + 1, + 0, + 0, + 0, + 947, + 950, + 1, + 0, + 0, + 0, + 948, + 946, + 1, + 0, + 0, + 0, + 949, + 941, + 1, + 0, + 0, + 0, + 949, + 942, + 1, + 0, + 0, + 0, + 950, + 250, + 1, + 0, + 0, + 0, + 951, + 952, + 5, + 48, + 0, + 0, + 952, + 953, + 5, + 111, + 0, + 0, + 953, + 955, + 1, + 0, + 0, + 0, + 954, + 956, + 3, + 263, + 131, + 0, + 955, + 954, + 1, + 0, + 0, + 0, + 956, + 957, + 1, + 0, + 0, + 0, + 957, + 955, + 1, + 0, + 0, + 0, + 957, + 958, + 1, + 0, + 0, + 0, + 958, + 252, + 1, + 0, + 0, + 0, + 959, + 961, + 7, + 25, + 0, + 0, + 960, + 959, + 1, + 0, + 0, + 0, + 961, + 254, + 1, + 0, + 0, + 0, + 962, + 965, + 3, + 257, + 128, + 0, + 963, + 965, + 3, + 253, + 126, + 0, + 964, + 962, + 1, + 0, + 0, + 0, + 964, + 963, + 1, + 0, + 0, + 0, + 965, + 256, + 1, + 0, + 0, + 0, + 966, + 969, + 3, + 265, + 132, + 0, + 967, + 969, + 3, + 259, + 129, + 0, + 968, + 966, + 1, + 0, + 0, + 0, + 968, + 967, + 1, + 0, + 0, + 0, + 969, + 258, + 1, + 0, + 0, + 0, + 970, + 973, + 3, + 261, + 130, + 0, + 971, + 973, + 2, + 56, + 57, + 0, + 972, + 970, + 1, + 0, + 0, + 0, + 972, + 971, + 1, + 0, + 0, + 0, + 973, + 260, + 1, + 0, + 0, + 0, + 974, + 975, + 2, + 49, + 55, + 0, + 975, + 262, + 1, + 0, + 0, + 0, + 976, + 979, + 3, + 265, + 132, + 0, + 977, + 979, + 3, + 261, + 130, + 0, + 978, + 976, + 1, + 0, + 0, + 0, + 978, + 977, + 1, + 0, + 0, + 0, + 979, + 264, + 1, + 0, + 0, + 0, + 980, + 981, + 5, + 48, + 0, + 0, + 981, + 266, + 1, + 0, + 0, + 0, + 982, + 984, + 3, + 257, + 128, + 0, + 983, + 982, + 1, + 0, + 0, + 0, + 984, + 985, + 1, + 0, + 0, + 0, + 985, + 983, + 1, + 0, + 0, + 0, + 985, + 986, + 1, + 0, + 0, + 0, + 986, + 1005, + 1, + 0, + 0, + 0, + 987, + 989, + 3, + 257, + 128, + 0, + 988, + 987, + 1, + 0, + 0, + 0, + 989, + 990, + 1, + 0, + 0, + 0, + 990, + 988, + 1, + 0, + 0, + 0, + 990, + 991, + 1, + 0, + 0, + 0, + 991, + 992, + 1, + 0, + 0, + 0, + 992, + 994, + 5, + 46, + 0, + 0, + 993, + 995, + 3, + 257, + 128, + 0, + 994, + 993, + 1, + 0, + 0, + 0, + 995, + 996, + 1, + 0, + 0, + 0, + 996, + 994, + 1, + 0, + 0, + 0, + 996, + 997, + 1, + 0, + 0, + 0, + 997, + 1005, + 1, + 0, + 0, + 0, + 998, + 1000, + 5, + 46, + 0, + 0, + 999, + 1001, + 3, + 257, + 128, + 0, + 1000, + 999, + 1, + 0, + 0, + 0, + 1001, + 1002, + 1, + 0, + 0, + 0, + 1002, + 1000, + 1, + 0, + 0, + 0, + 1002, + 1003, + 1, + 0, + 0, + 0, + 1003, + 1005, + 1, + 0, + 0, + 0, + 1004, + 983, + 1, + 0, + 0, + 0, + 1004, + 988, + 1, + 0, + 0, + 0, + 1004, + 998, + 1, + 0, + 0, + 0, + 1005, + 1006, + 1, + 0, + 0, + 0, + 1006, + 1008, + 7, + 4, + 0, + 0, + 1007, + 1009, + 5, + 45, + 0, + 0, + 1008, + 1007, + 1, + 0, + 0, + 0, + 1008, + 1009, + 1, + 0, + 0, + 0, + 1009, + 1011, + 1, + 0, + 0, + 0, + 1010, + 1012, + 3, + 257, + 128, + 0, + 1011, + 1010, + 1, + 0, + 0, + 0, + 1012, + 1013, + 1, + 0, + 0, + 0, + 1013, + 1011, + 1, + 0, + 0, + 0, + 1013, + 1014, + 1, + 0, + 0, + 0, + 1014, + 268, + 1, + 0, + 0, + 0, + 1015, + 1017, + 3, + 257, + 128, + 0, + 1016, + 1015, + 1, + 0, + 0, + 0, + 1017, + 1020, + 1, + 0, + 0, + 0, + 1018, + 1016, + 1, + 0, + 0, + 0, + 1018, + 1019, + 1, + 0, + 0, + 0, + 1019, + 1021, + 1, + 0, + 0, + 0, + 1020, + 1018, + 1, + 0, + 0, + 0, + 1021, + 1023, + 5, + 46, + 0, + 0, + 1022, + 1024, + 3, + 257, + 128, + 0, + 1023, + 1022, + 1, + 0, + 0, + 0, + 1024, + 1025, + 1, + 0, + 0, + 0, + 1025, + 1023, + 1, + 0, + 0, + 0, + 1025, + 1026, + 1, + 0, + 0, + 0, + 1026, + 270, + 1, + 0, + 0, + 0, + 1027, + 1032, + 5, + 34, + 0, + 0, + 1028, + 1031, + 3, + 333, + 166, + 0, + 1029, + 1031, + 3, + 273, + 136, + 0, + 1030, + 1028, + 1, + 0, + 0, + 0, + 1030, + 1029, + 1, + 0, + 0, + 0, + 1031, + 1034, + 1, + 0, + 0, + 0, + 1032, + 1030, + 1, + 0, + 0, + 0, + 1032, + 1033, + 1, + 0, + 0, + 0, + 1033, + 1035, + 1, + 0, + 0, + 0, + 1034, + 1032, + 1, + 0, + 0, + 0, + 1035, + 1046, + 5, + 34, + 0, + 0, + 1036, + 1041, + 5, + 39, + 0, + 0, + 1037, + 1040, + 3, + 313, + 156, + 0, + 1038, + 1040, + 3, + 273, + 136, + 0, + 1039, + 1037, + 1, + 0, + 0, + 0, + 1039, + 1038, + 1, + 0, + 0, + 0, + 1040, + 1043, + 1, + 0, + 0, + 0, + 1041, + 1039, + 1, + 0, + 0, + 0, + 1041, + 1042, + 1, + 0, + 0, + 0, + 1042, + 1044, + 1, + 0, + 0, + 0, + 1043, + 1041, + 1, + 0, + 0, + 0, + 1044, + 1046, + 5, + 39, + 0, + 0, + 1045, + 1027, + 1, + 0, + 0, + 0, + 1045, + 1036, + 1, + 0, + 0, + 0, + 1046, + 272, + 1, + 0, + 0, + 0, + 1047, + 1065, + 5, + 92, + 0, + 0, + 1048, + 1066, + 7, + 26, + 0, + 0, + 1049, + 1050, + 7, + 13, + 0, + 0, + 1050, + 1051, + 3, + 255, + 127, + 0, + 1051, + 1052, + 3, + 255, + 127, + 0, + 1052, + 1053, + 3, + 255, + 127, + 0, + 1053, + 1054, + 3, + 255, + 127, + 0, + 1054, + 1066, + 1, + 0, + 0, + 0, + 1055, + 1056, + 7, + 13, + 0, + 0, + 1056, + 1057, + 3, + 255, + 127, + 0, + 1057, + 1058, + 3, + 255, + 127, + 0, + 1058, + 1059, + 3, + 255, + 127, + 0, + 1059, + 1060, + 3, + 255, + 127, + 0, + 1060, + 1061, + 3, + 255, + 127, + 0, + 1061, + 1062, + 3, + 255, + 127, + 0, + 1062, + 1063, + 3, + 255, + 127, + 0, + 1063, + 1064, + 3, + 255, + 127, + 0, + 1064, + 1066, + 1, + 0, + 0, + 0, + 1065, + 1048, + 1, + 0, + 0, + 0, + 1065, + 1049, + 1, + 0, + 0, + 0, + 1065, + 1055, + 1, + 0, + 0, + 0, + 1066, + 274, + 1, + 0, + 0, + 0, + 1067, + 1068, + 7, + 16, + 0, + 0, + 1068, + 1069, + 7, + 11, + 0, + 0, + 1069, + 276, + 1, + 0, + 0, + 0, + 1070, + 1071, + 7, + 12, + 0, + 0, + 1071, + 1072, + 7, + 11, + 0, + 0, + 1072, + 1073, + 7, + 5, + 0, + 0, + 1073, + 278, + 1, + 0, + 0, + 0, + 1074, + 1075, + 7, + 5, + 0, + 0, + 1075, + 1076, + 7, + 4, + 0, + 0, + 1076, + 1077, + 7, + 19, + 0, + 0, + 1077, + 1078, + 7, + 13, + 0, + 0, + 1078, + 1079, + 7, + 9, + 0, + 0, + 1079, + 1080, + 7, + 5, + 0, + 0, + 1080, + 1081, + 7, + 4, + 0, + 0, + 1081, + 280, + 1, + 0, + 0, + 0, + 1082, + 1083, + 7, + 17, + 0, + 0, + 1083, + 1084, + 7, + 8, + 0, + 0, + 1084, + 1085, + 7, + 10, + 0, + 0, + 1085, + 1086, + 7, + 16, + 0, + 0, + 1086, + 1087, + 7, + 8, + 0, + 0, + 1087, + 1088, + 7, + 18, + 0, + 0, + 1088, + 1089, + 7, + 11, + 0, + 0, + 1089, + 1090, + 7, + 5, + 0, + 0, + 1090, + 1091, + 7, + 1, + 0, + 0, + 1091, + 282, + 1, + 0, + 0, + 0, + 1092, + 1093, + 7, + 14, + 0, + 0, + 1093, + 1094, + 7, + 0, + 0, + 0, + 1094, + 1095, + 7, + 8, + 0, + 0, + 1095, + 1096, + 7, + 7, + 0, + 0, + 1096, + 1097, + 7, + 8, + 0, + 0, + 1097, + 1098, + 7, + 5, + 0, + 0, + 1098, + 284, + 1, + 0, + 0, + 0, + 1099, + 1100, + 7, + 11, + 0, + 0, + 1100, + 1101, + 7, + 12, + 0, + 0, + 1101, + 286, + 1, + 0, + 0, + 0, + 1102, + 1103, + 7, + 8, + 0, + 0, + 1103, + 1104, + 7, + 16, + 0, + 0, + 1104, + 1105, + 7, + 16, + 0, + 0, + 1105, + 288, + 1, + 0, + 0, + 0, + 1106, + 1110, + 3, + 291, + 145, + 0, + 1107, + 1109, + 3, + 293, + 146, + 0, + 1108, + 1107, + 1, + 0, + 0, + 0, + 1109, + 1112, + 1, + 0, + 0, + 0, + 1110, + 1108, + 1, + 0, + 0, + 0, + 1110, + 1111, + 1, + 0, + 0, + 0, + 1111, + 290, + 1, + 0, + 0, + 0, + 1112, + 1110, + 1, + 0, + 0, + 0, + 1113, + 1116, + 3, + 341, + 170, + 0, + 1114, + 1116, + 3, + 329, + 164, + 0, + 1115, + 1113, + 1, + 0, + 0, + 0, + 1115, + 1114, + 1, + 0, + 0, + 0, + 1116, + 292, + 1, + 0, + 0, + 0, + 1117, + 1120, + 3, + 309, + 154, + 0, + 1118, + 1120, + 3, + 325, + 162, + 0, + 1119, + 1117, + 1, + 0, + 0, + 0, + 1119, + 1118, + 1, + 0, + 0, + 0, + 1120, + 294, + 1, + 0, + 0, + 0, + 1121, + 1125, + 5, + 96, + 0, + 0, + 1122, + 1124, + 3, + 305, + 152, + 0, + 1123, + 1122, + 1, + 0, + 0, + 0, + 1124, + 1127, + 1, + 0, + 0, + 0, + 1125, + 1123, + 1, + 0, + 0, + 0, + 1125, + 1126, + 1, + 0, + 0, + 0, + 1126, + 1128, + 1, + 0, + 0, + 0, + 1127, + 1125, + 1, + 0, + 0, + 0, + 1128, + 1130, + 5, + 96, + 0, + 0, + 1129, + 1121, + 1, + 0, + 0, + 0, + 1130, + 1131, + 1, + 0, + 0, + 0, + 1131, + 1129, + 1, + 0, + 0, + 0, + 1131, + 1132, + 1, + 0, + 0, + 0, + 1132, + 296, + 1, + 0, + 0, + 0, + 1133, + 1135, + 3, + 299, + 149, + 0, + 1134, + 1133, + 1, + 0, + 0, + 0, + 1135, + 1136, + 1, + 0, + 0, + 0, + 1136, + 1134, + 1, + 0, + 0, + 0, + 1136, + 1137, + 1, + 0, + 0, + 0, + 1137, + 298, + 1, + 0, + 0, + 0, + 1138, + 1151, + 3, + 327, + 163, + 0, + 1139, + 1151, + 3, + 331, + 165, + 0, + 1140, + 1151, + 3, + 335, + 167, + 0, + 1141, + 1151, + 3, + 337, + 168, + 0, + 1142, + 1151, + 3, + 303, + 151, + 0, + 1143, + 1151, + 3, + 323, + 161, + 0, + 1144, + 1151, + 3, + 321, + 160, + 0, + 1145, + 1151, + 3, + 319, + 159, + 0, + 1146, + 1151, + 3, + 307, + 153, + 0, + 1147, + 1151, + 3, + 339, + 169, + 0, + 1148, + 1151, + 7, + 27, + 0, + 0, + 1149, + 1151, + 3, + 301, + 150, + 0, + 1150, + 1138, + 1, + 0, + 0, + 0, + 1150, + 1139, + 1, + 0, + 0, + 0, + 1150, + 1140, + 1, + 0, + 0, + 0, + 1150, + 1141, + 1, + 0, + 0, + 0, + 1150, + 1142, + 1, + 0, + 0, + 0, + 1150, + 1143, + 1, + 0, + 0, + 0, + 1150, + 1144, + 1, + 0, + 0, + 0, + 1150, + 1145, + 1, + 0, + 0, + 0, + 1150, + 1146, + 1, + 0, + 0, + 0, + 1150, + 1147, + 1, + 0, + 0, + 0, + 1150, + 1148, + 1, + 0, + 0, + 0, + 1150, + 1149, + 1, + 0, + 0, + 0, + 1151, + 300, + 1, + 0, + 0, + 0, + 1152, + 1153, + 5, + 47, + 0, + 0, + 1153, + 1154, + 5, + 42, + 0, + 0, + 1154, + 1160, + 1, + 0, + 0, + 0, + 1155, + 1159, + 3, + 311, + 155, + 0, + 1156, + 1157, + 5, + 42, + 0, + 0, + 1157, + 1159, + 3, + 317, + 158, + 0, + 1158, + 1155, + 1, + 0, + 0, + 0, + 1158, + 1156, + 1, + 0, + 0, + 0, + 1159, + 1162, + 1, + 0, + 0, + 0, + 1160, + 1158, + 1, + 0, + 0, + 0, + 1160, + 1161, + 1, + 0, + 0, + 0, + 1161, + 1163, + 1, + 0, + 0, + 0, + 1162, + 1160, + 1, + 0, + 0, + 0, + 1163, + 1164, + 5, + 42, + 0, + 0, + 1164, + 1182, + 5, + 47, + 0, + 0, + 1165, + 1166, + 5, + 47, + 0, + 0, + 1166, + 1167, + 5, + 47, + 0, + 0, + 1167, + 1171, + 1, + 0, + 0, + 0, + 1168, + 1170, + 3, + 315, + 157, + 0, + 1169, + 1168, + 1, + 0, + 0, + 0, + 1170, + 1173, + 1, + 0, + 0, + 0, + 1171, + 1169, + 1, + 0, + 0, + 0, + 1171, + 1172, + 1, + 0, + 0, + 0, + 1172, + 1175, + 1, + 0, + 0, + 0, + 1173, + 1171, + 1, + 0, + 0, + 0, + 1174, + 1176, + 3, + 323, + 161, + 0, + 1175, + 1174, + 1, + 0, + 0, + 0, + 1175, + 1176, + 1, + 0, + 0, + 0, + 1176, + 1179, + 1, + 0, + 0, + 0, + 1177, + 1180, + 3, + 335, + 167, + 0, + 1178, + 1180, + 5, + 0, + 0, + 1, + 1179, + 1177, + 1, + 0, + 0, + 0, + 1179, + 1178, + 1, + 0, + 0, + 0, + 1180, + 1182, + 1, + 0, + 0, + 0, + 1181, + 1152, + 1, + 0, + 0, + 0, + 1181, + 1165, + 1, + 0, + 0, + 0, + 1182, + 302, + 1, + 0, + 0, + 0, + 1183, + 1184, + 7, + 28, + 0, + 0, + 1184, + 304, + 1, + 0, + 0, + 0, + 1185, + 1186, + 8, + 29, + 0, + 0, + 1186, + 306, + 1, + 0, + 0, + 0, + 1187, + 1188, + 7, + 30, + 0, + 0, + 1188, + 308, + 1, + 0, + 0, + 0, + 1189, + 1190, + 7, + 31, + 0, + 0, + 1190, + 310, + 1, + 0, + 0, + 0, + 1191, + 1192, + 8, + 32, + 0, + 0, + 1192, + 312, + 1, + 0, + 0, + 0, + 1193, + 1194, + 8, + 33, + 0, + 0, + 1194, + 314, + 1, + 0, + 0, + 0, + 1195, + 1196, + 8, + 34, + 0, + 0, + 1196, + 316, + 1, + 0, + 0, + 0, + 1197, + 1198, + 8, + 35, + 0, + 0, + 1198, + 318, + 1, + 0, + 0, + 0, + 1199, + 1200, + 7, + 36, + 0, + 0, + 1200, + 320, + 1, + 0, + 0, + 0, + 1201, + 1202, + 7, + 37, + 0, + 0, + 1202, + 322, + 1, + 0, + 0, + 0, + 1203, + 1204, + 7, + 38, + 0, + 0, + 1204, + 324, + 1, + 0, + 0, + 0, + 1205, + 1206, + 7, + 39, + 0, + 0, + 1206, + 326, + 1, + 0, + 0, + 0, + 1207, + 1208, + 7, + 40, + 0, + 0, + 1208, + 328, + 1, + 0, + 0, + 0, + 1209, + 1210, + 7, + 41, + 0, + 0, + 1210, + 330, + 1, + 0, + 0, + 0, + 1211, + 1212, + 7, + 42, + 0, + 0, + 1212, + 332, + 1, + 0, + 0, + 0, + 1213, + 1214, + 8, + 43, + 0, + 0, + 1214, + 334, + 1, + 0, + 0, + 0, + 1215, + 1216, + 7, + 44, + 0, + 0, + 1216, + 336, + 1, + 0, + 0, + 0, + 1217, + 1218, + 7, + 45, + 0, + 0, + 1218, + 338, + 1, + 0, + 0, + 0, + 1219, + 1220, + 7, + 46, + 0, + 0, + 1220, + 340, + 1, + 0, + 0, + 0, + 1221, + 1222, + 7, + 47, + 0, + 0, + 1222, + 342, + 1, + 0, + 0, + 0, + 38, + 0, + 939, + 946, + 949, + 957, + 960, + 964, + 968, + 972, + 978, + 985, + 990, + 996, + 1002, + 1004, + 1008, + 1013, + 1018, + 1025, + 1030, + 1032, + 1039, + 1041, + 1045, + 1065, + 1110, + 1115, + 1119, + 1125, + 1131, + 1136, + 1150, + 1158, + 1160, + 1171, + 1175, + 1179, + 1181, + 0, + ] + + +class CypherLexer(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] + + T__0 = 1 + T__1 = 2 + T__2 = 3 + T__3 = 4 + T__4 = 5 + T__5 = 6 + T__6 = 7 + T__7 = 8 + T__8 = 9 + T__9 = 10 + T__10 = 11 + T__11 = 12 + T__12 = 13 + T__13 = 14 + T__14 = 15 + T__15 = 16 + T__16 = 17 + T__17 = 18 + T__18 = 19 + T__19 = 20 + T__20 = 21 + T__21 = 22 + T__22 = 23 + T__23 = 24 + T__24 = 25 + T__25 = 26 + T__26 = 27 + T__27 = 28 + T__28 = 29 + T__29 = 30 + T__30 = 31 + T__31 = 32 + T__32 = 33 + T__33 = 34 + T__34 = 35 + T__35 = 36 + T__36 = 37 + T__37 = 38 + T__38 = 39 + T__39 = 40 + T__40 = 41 + T__41 = 42 + T__42 = 43 + T__43 = 44 + T__44 = 45 + T__45 = 46 + CYPHER = 47 + EXPLAIN = 48 + PROFILE = 49 + USING = 50 + PERIODIC = 51 + COMMIT = 52 + UNION = 53 + ALL = 54 + CREATE = 55 + DROP = 56 + INDEX = 57 + ON = 58 + CONSTRAINT = 59 + ASSERT = 60 + IS = 61 + UNIQUE = 62 + EXISTS = 63 + LOAD = 64 + CSV = 65 + WITH = 66 + HEADERS = 67 + FROM = 68 + AS = 69 + FIELDTERMINATOR = 70 + OPTIONAL = 71 + MATCH = 72 + UNWIND = 73 + MERGE = 74 + SET = 75 + DETACH = 76 + DELETE = 77 + REMOVE = 78 + FOREACH = 79 + IN = 80 + CALL = 81 + YIELD = 82 + RETURN = 83 + DISTINCT = 84 + ORDER = 85 + BY = 86 + L_SKIP = 87 + LIMIT = 88 + ASCENDING = 89 + ASC = 90 + DESCENDING = 91 + DESC = 92 + JOIN = 93 + SCAN = 94 + START = 95 + NODE = 96 + RELATIONSHIP = 97 + REL = 98 + WHERE = 99 + SHORTESTPATH = 100 + ALLSHORTESTPATHS = 101 + OR = 102 + XOR = 103 + AND = 104 + NOT = 105 + STARTS = 106 + ENDS = 107 + CONTAINS = 108 + NULL = 109 + COUNT = 110 + CASE = 111 + ELSE = 112 + END = 113 + WHEN = 114 + THEN = 115 + FILTER = 116 + EXTRACT = 117 + REDUCE = 118 + ANY = 119 + NONE = 120 + SINGLE = 121 + TRUE = 122 + FALSE = 123 + HexInteger = 124 + DecimalInteger = 125 + OctalInteger = 126 + HexLetter = 127 + HexDigit = 128 + Digit = 129 + NonZeroDigit = 130 + NonZeroOctDigit = 131 + OctDigit = 132 + ZeroDigit = 133 + ExponentDecimalReal = 134 + RegularDecimalReal = 135 + StringLiteral = 136 + EscapedChar = 137 + DO = 138 + FOR = 139 + REQUIRE = 140 + MANDATORY = 141 + SCALAR = 142 + OF = 143 + ADD = 144 + UnescapedSymbolicName = 145 + IdentifierStart = 146 + IdentifierPart = 147 + EscapedSymbolicName = 148 + SP = 149 + WHITESPACE = 150 + Comment = 151 + + channelNames = ["DEFAULT_TOKEN_CHANNEL", "HIDDEN"] + + modeNames = ["DEFAULT_MODE"] + + literalNames = [ + "", + "';'", + "'='", + "'('", + "')'", + "'['", + "']'", + "','", + "'+='", + "'|'", + "'*'", + "':'", + "'..'", + "'<>'", + "'<'", + "'>'", + "'<='", + "'>='", + "'=~'", + "'+'", + "'-'", + "'/'", + "'%'", + "'^'", + "'.'", + "'{'", + "'}'", + "'$'", + "'\\u27E8'", + "'\\u3008'", + "'\\uFE64'", + "'\\uFF1C'", + "'\\u27E9'", + "'\\u3009'", + "'\\uFE65'", + "'\\uFF1E'", + "'\\u00AD'", + "'\\u2010'", + "'\\u2011'", + "'\\u2012'", + "'\\u2013'", + "'\\u2014'", + "'\\u2015'", + "'\\u2212'", + "'\\uFE58'", + "'\\uFE63'", + "'\\uFF0D'", + "'0'", + ] + + symbolicNames = [ + "", + "CYPHER", + "EXPLAIN", + "PROFILE", + "USING", + "PERIODIC", + "COMMIT", + "UNION", + "ALL", + "CREATE", + "DROP", + "INDEX", + "ON", + "CONSTRAINT", + "ASSERT", + "IS", + "UNIQUE", + "EXISTS", + "LOAD", + "CSV", + "WITH", + "HEADERS", + "FROM", + "AS", + "FIELDTERMINATOR", + "OPTIONAL", + "MATCH", + "UNWIND", + "MERGE", + "SET", + "DETACH", + "DELETE", + "REMOVE", + "FOREACH", + "IN", + "CALL", + "YIELD", + "RETURN", + "DISTINCT", + "ORDER", + "BY", + "L_SKIP", + "LIMIT", + "ASCENDING", + "ASC", + "DESCENDING", + "DESC", + "JOIN", + "SCAN", + "START", + "NODE", + "RELATIONSHIP", + "REL", + "WHERE", + "SHORTESTPATH", + "ALLSHORTESTPATHS", + "OR", + "XOR", + "AND", + "NOT", + "STARTS", + "ENDS", + "CONTAINS", + "NULL", + "COUNT", + "CASE", + "ELSE", + "END", + "WHEN", + "THEN", + "FILTER", + "EXTRACT", + "REDUCE", + "ANY", + "NONE", + "SINGLE", + "TRUE", + "FALSE", + "HexInteger", + "DecimalInteger", + "OctalInteger", + "HexLetter", + "HexDigit", + "Digit", + "NonZeroDigit", + "NonZeroOctDigit", + "OctDigit", + "ZeroDigit", + "ExponentDecimalReal", + "RegularDecimalReal", + "StringLiteral", + "EscapedChar", + "DO", + "FOR", + "REQUIRE", + "MANDATORY", + "SCALAR", + "OF", + "ADD", + "UnescapedSymbolicName", + "IdentifierStart", + "IdentifierPart", + "EscapedSymbolicName", + "SP", + "WHITESPACE", + "Comment", + ] + + ruleNames = [ + "T__0", + "T__1", + "T__2", + "T__3", + "T__4", + "T__5", + "T__6", + "T__7", + "T__8", + "T__9", + "T__10", + "T__11", + "T__12", + "T__13", + "T__14", + "T__15", + "T__16", + "T__17", + "T__18", + "T__19", + "T__20", + "T__21", + "T__22", + "T__23", + "T__24", + "T__25", + "T__26", + "T__27", + "T__28", + "T__29", + "T__30", + "T__31", + "T__32", + "T__33", + "T__34", + "T__35", + "T__36", + "T__37", + "T__38", + "T__39", + "T__40", + "T__41", + "T__42", + "T__43", + "T__44", + "T__45", + "CYPHER", + "EXPLAIN", + "PROFILE", + "USING", + "PERIODIC", + "COMMIT", + "UNION", + "ALL", + "CREATE", + "DROP", + "INDEX", + "ON", + "CONSTRAINT", + "ASSERT", + "IS", + "UNIQUE", + "EXISTS", + "LOAD", + "CSV", + "WITH", + "HEADERS", + "FROM", + "AS", + "FIELDTERMINATOR", + "OPTIONAL", + "MATCH", + "UNWIND", + "MERGE", + "SET", + "DETACH", + "DELETE", + "REMOVE", + "FOREACH", + "IN", + "CALL", + "YIELD", + "RETURN", + "DISTINCT", + "ORDER", + "BY", + "L_SKIP", + "LIMIT", + "ASCENDING", + "ASC", + "DESCENDING", + "DESC", + "JOIN", + "SCAN", + "START", + "NODE", + "RELATIONSHIP", + "REL", + "WHERE", + "SHORTESTPATH", + "ALLSHORTESTPATHS", + "OR", + "XOR", + "AND", + "NOT", + "STARTS", + "ENDS", + "CONTAINS", + "NULL", + "COUNT", + "CASE", + "ELSE", + "END", + "WHEN", + "THEN", + "FILTER", + "EXTRACT", + "REDUCE", + "ANY", + "NONE", + "SINGLE", + "TRUE", + "FALSE", + "HexInteger", + "DecimalInteger", + "OctalInteger", + "HexLetter", + "HexDigit", + "Digit", + "NonZeroDigit", + "NonZeroOctDigit", + "OctDigit", + "ZeroDigit", + "ExponentDecimalReal", + "RegularDecimalReal", + "StringLiteral", + "EscapedChar", + "DO", + "FOR", + "REQUIRE", + "MANDATORY", + "SCALAR", + "OF", + "ADD", + "UnescapedSymbolicName", + "IdentifierStart", + "IdentifierPart", + "EscapedSymbolicName", + "SP", + "WHITESPACE", + "Comment", + "FF", + "EscapedSymbolicName_0", + "RS", + "ID_Continue", + "Comment_1", + "StringLiteral_1", + "Comment_3", + "Comment_2", + "GS", + "FS", + "CR", + "Sc", + "SPACE", + "Pc", + "TAB", + "StringLiteral_0", + "LF", + "VT", + "US", + "ID_Start", + ] + + grammarFileName = "Cypher.g4" + + def __init__(self, input=None, output: TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.13.2") + self._interp = LexerATNSimulator( + self, self.atn, self.decisionsToDFA, PredictionContextCache() + ) + self._actions = None + self._predicates = None diff --git a/tests/grammar/CypherListener.py b/tests/grammar/CypherListener.py new file mode 100644 index 0000000..8b22f89 --- /dev/null +++ b/tests/grammar/CypherListener.py @@ -0,0 +1,1328 @@ +# Generated from Cypher.g4 by ANTLR 4.13.2 +from antlr4 import * + +if "." in __name__: + from .CypherParser import CypherParser +else: + from CypherParser import CypherParser + + +# This class defines a complete listener for a parse tree produced by CypherParser. +class CypherListener(ParseTreeListener): + + # Enter a parse tree produced by CypherParser#oC_Cypher. + def enterOC_Cypher(self, ctx: CypherParser.OC_CypherContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Cypher. + def exitOC_Cypher(self, ctx: CypherParser.OC_CypherContext): + pass + + # Enter a parse tree produced by CypherParser#oC_QueryOptions. + def enterOC_QueryOptions(self, ctx: CypherParser.OC_QueryOptionsContext): + pass + + # Exit a parse tree produced by CypherParser#oC_QueryOptions. + def exitOC_QueryOptions(self, ctx: CypherParser.OC_QueryOptionsContext): + pass + + # Enter a parse tree produced by CypherParser#oC_AnyCypherOption. + def enterOC_AnyCypherOption(self, ctx: CypherParser.OC_AnyCypherOptionContext): + pass + + # Exit a parse tree produced by CypherParser#oC_AnyCypherOption. + def exitOC_AnyCypherOption(self, ctx: CypherParser.OC_AnyCypherOptionContext): + pass + + # Enter a parse tree produced by CypherParser#oC_CypherOption. + def enterOC_CypherOption(self, ctx: CypherParser.OC_CypherOptionContext): + pass + + # Exit a parse tree produced by CypherParser#oC_CypherOption. + def exitOC_CypherOption(self, ctx: CypherParser.OC_CypherOptionContext): + pass + + # Enter a parse tree produced by CypherParser#oC_VersionNumber. + def enterOC_VersionNumber(self, ctx: CypherParser.OC_VersionNumberContext): + pass + + # Exit a parse tree produced by CypherParser#oC_VersionNumber. + def exitOC_VersionNumber(self, ctx: CypherParser.OC_VersionNumberContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Explain. + def enterOC_Explain(self, ctx: CypherParser.OC_ExplainContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Explain. + def exitOC_Explain(self, ctx: CypherParser.OC_ExplainContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Profile. + def enterOC_Profile(self, ctx: CypherParser.OC_ProfileContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Profile. + def exitOC_Profile(self, ctx: CypherParser.OC_ProfileContext): + pass + + # Enter a parse tree produced by CypherParser#oC_ConfigurationOption. + def enterOC_ConfigurationOption( + self, ctx: CypherParser.OC_ConfigurationOptionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_ConfigurationOption. + def exitOC_ConfigurationOption( + self, ctx: CypherParser.OC_ConfigurationOptionContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_Statement. + def enterOC_Statement(self, ctx: CypherParser.OC_StatementContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Statement. + def exitOC_Statement(self, ctx: CypherParser.OC_StatementContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Query. + def enterOC_Query(self, ctx: CypherParser.OC_QueryContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Query. + def exitOC_Query(self, ctx: CypherParser.OC_QueryContext): + pass + + # Enter a parse tree produced by CypherParser#oC_RegularQuery. + def enterOC_RegularQuery(self, ctx: CypherParser.OC_RegularQueryContext): + pass + + # Exit a parse tree produced by CypherParser#oC_RegularQuery. + def exitOC_RegularQuery(self, ctx: CypherParser.OC_RegularQueryContext): + pass + + # Enter a parse tree produced by CypherParser#oC_BulkImportQuery. + def enterOC_BulkImportQuery(self, ctx: CypherParser.OC_BulkImportQueryContext): + pass + + # Exit a parse tree produced by CypherParser#oC_BulkImportQuery. + def exitOC_BulkImportQuery(self, ctx: CypherParser.OC_BulkImportQueryContext): + pass + + # Enter a parse tree produced by CypherParser#oC_PeriodicCommitHint. + def enterOC_PeriodicCommitHint( + self, ctx: CypherParser.OC_PeriodicCommitHintContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_PeriodicCommitHint. + def exitOC_PeriodicCommitHint(self, ctx: CypherParser.OC_PeriodicCommitHintContext): + pass + + # Enter a parse tree produced by CypherParser#oC_LoadCSVQuery. + def enterOC_LoadCSVQuery(self, ctx: CypherParser.OC_LoadCSVQueryContext): + pass + + # Exit a parse tree produced by CypherParser#oC_LoadCSVQuery. + def exitOC_LoadCSVQuery(self, ctx: CypherParser.OC_LoadCSVQueryContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Union. + def enterOC_Union(self, ctx: CypherParser.OC_UnionContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Union. + def exitOC_Union(self, ctx: CypherParser.OC_UnionContext): + pass + + # Enter a parse tree produced by CypherParser#oC_SingleQuery. + def enterOC_SingleQuery(self, ctx: CypherParser.OC_SingleQueryContext): + pass + + # Exit a parse tree produced by CypherParser#oC_SingleQuery. + def exitOC_SingleQuery(self, ctx: CypherParser.OC_SingleQueryContext): + pass + + # Enter a parse tree produced by CypherParser#oC_SinglePartQuery. + def enterOC_SinglePartQuery(self, ctx: CypherParser.OC_SinglePartQueryContext): + pass + + # Exit a parse tree produced by CypherParser#oC_SinglePartQuery. + def exitOC_SinglePartQuery(self, ctx: CypherParser.OC_SinglePartQueryContext): + pass + + # Enter a parse tree produced by CypherParser#oC_MultiPartQuery. + def enterOC_MultiPartQuery(self, ctx: CypherParser.OC_MultiPartQueryContext): + pass + + # Exit a parse tree produced by CypherParser#oC_MultiPartQuery. + def exitOC_MultiPartQuery(self, ctx: CypherParser.OC_MultiPartQueryContext): + pass + + # Enter a parse tree produced by CypherParser#oC_UpdatingClause. + def enterOC_UpdatingClause(self, ctx: CypherParser.OC_UpdatingClauseContext): + pass + + # Exit a parse tree produced by CypherParser#oC_UpdatingClause. + def exitOC_UpdatingClause(self, ctx: CypherParser.OC_UpdatingClauseContext): + pass + + # Enter a parse tree produced by CypherParser#oC_ReadingClause. + def enterOC_ReadingClause(self, ctx: CypherParser.OC_ReadingClauseContext): + pass + + # Exit a parse tree produced by CypherParser#oC_ReadingClause. + def exitOC_ReadingClause(self, ctx: CypherParser.OC_ReadingClauseContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Command. + def enterOC_Command(self, ctx: CypherParser.OC_CommandContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Command. + def exitOC_Command(self, ctx: CypherParser.OC_CommandContext): + pass + + # Enter a parse tree produced by CypherParser#oC_CreateUniqueConstraint. + def enterOC_CreateUniqueConstraint( + self, ctx: CypherParser.OC_CreateUniqueConstraintContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_CreateUniqueConstraint. + def exitOC_CreateUniqueConstraint( + self, ctx: CypherParser.OC_CreateUniqueConstraintContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_CreateNodePropertyExistenceConstraint. + def enterOC_CreateNodePropertyExistenceConstraint( + self, ctx: CypherParser.OC_CreateNodePropertyExistenceConstraintContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_CreateNodePropertyExistenceConstraint. + def exitOC_CreateNodePropertyExistenceConstraint( + self, ctx: CypherParser.OC_CreateNodePropertyExistenceConstraintContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_CreateRelationshipPropertyExistenceConstraint. + def enterOC_CreateRelationshipPropertyExistenceConstraint( + self, ctx: CypherParser.OC_CreateRelationshipPropertyExistenceConstraintContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_CreateRelationshipPropertyExistenceConstraint. + def exitOC_CreateRelationshipPropertyExistenceConstraint( + self, ctx: CypherParser.OC_CreateRelationshipPropertyExistenceConstraintContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_CreateIndex. + def enterOC_CreateIndex(self, ctx: CypherParser.OC_CreateIndexContext): + pass + + # Exit a parse tree produced by CypherParser#oC_CreateIndex. + def exitOC_CreateIndex(self, ctx: CypherParser.OC_CreateIndexContext): + pass + + # Enter a parse tree produced by CypherParser#oC_DropUniqueConstraint. + def enterOC_DropUniqueConstraint( + self, ctx: CypherParser.OC_DropUniqueConstraintContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_DropUniqueConstraint. + def exitOC_DropUniqueConstraint( + self, ctx: CypherParser.OC_DropUniqueConstraintContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_DropNodePropertyExistenceConstraint. + def enterOC_DropNodePropertyExistenceConstraint( + self, ctx: CypherParser.OC_DropNodePropertyExistenceConstraintContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_DropNodePropertyExistenceConstraint. + def exitOC_DropNodePropertyExistenceConstraint( + self, ctx: CypherParser.OC_DropNodePropertyExistenceConstraintContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_DropRelationshipPropertyExistenceConstraint. + def enterOC_DropRelationshipPropertyExistenceConstraint( + self, ctx: CypherParser.OC_DropRelationshipPropertyExistenceConstraintContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_DropRelationshipPropertyExistenceConstraint. + def exitOC_DropRelationshipPropertyExistenceConstraint( + self, ctx: CypherParser.OC_DropRelationshipPropertyExistenceConstraintContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_DropIndex. + def enterOC_DropIndex(self, ctx: CypherParser.OC_DropIndexContext): + pass + + # Exit a parse tree produced by CypherParser#oC_DropIndex. + def exitOC_DropIndex(self, ctx: CypherParser.OC_DropIndexContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Index. + def enterOC_Index(self, ctx: CypherParser.OC_IndexContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Index. + def exitOC_Index(self, ctx: CypherParser.OC_IndexContext): + pass + + # Enter a parse tree produced by CypherParser#oC_UniqueConstraint. + def enterOC_UniqueConstraint(self, ctx: CypherParser.OC_UniqueConstraintContext): + pass + + # Exit a parse tree produced by CypherParser#oC_UniqueConstraint. + def exitOC_UniqueConstraint(self, ctx: CypherParser.OC_UniqueConstraintContext): + pass + + # Enter a parse tree produced by CypherParser#oC_NodePropertyExistenceConstraint. + def enterOC_NodePropertyExistenceConstraint( + self, ctx: CypherParser.OC_NodePropertyExistenceConstraintContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_NodePropertyExistenceConstraint. + def exitOC_NodePropertyExistenceConstraint( + self, ctx: CypherParser.OC_NodePropertyExistenceConstraintContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_RelationshipPropertyExistenceConstraint. + def enterOC_RelationshipPropertyExistenceConstraint( + self, ctx: CypherParser.OC_RelationshipPropertyExistenceConstraintContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_RelationshipPropertyExistenceConstraint. + def exitOC_RelationshipPropertyExistenceConstraint( + self, ctx: CypherParser.OC_RelationshipPropertyExistenceConstraintContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_RelationshipPatternSyntax. + def enterOC_RelationshipPatternSyntax( + self, ctx: CypherParser.OC_RelationshipPatternSyntaxContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_RelationshipPatternSyntax. + def exitOC_RelationshipPatternSyntax( + self, ctx: CypherParser.OC_RelationshipPatternSyntaxContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_LoadCSV. + def enterOC_LoadCSV(self, ctx: CypherParser.OC_LoadCSVContext): + pass + + # Exit a parse tree produced by CypherParser#oC_LoadCSV. + def exitOC_LoadCSV(self, ctx: CypherParser.OC_LoadCSVContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Match. + def enterOC_Match(self, ctx: CypherParser.OC_MatchContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Match. + def exitOC_Match(self, ctx: CypherParser.OC_MatchContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Unwind. + def enterOC_Unwind(self, ctx: CypherParser.OC_UnwindContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Unwind. + def exitOC_Unwind(self, ctx: CypherParser.OC_UnwindContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Merge. + def enterOC_Merge(self, ctx: CypherParser.OC_MergeContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Merge. + def exitOC_Merge(self, ctx: CypherParser.OC_MergeContext): + pass + + # Enter a parse tree produced by CypherParser#oC_MergeAction. + def enterOC_MergeAction(self, ctx: CypherParser.OC_MergeActionContext): + pass + + # Exit a parse tree produced by CypherParser#oC_MergeAction. + def exitOC_MergeAction(self, ctx: CypherParser.OC_MergeActionContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Create. + def enterOC_Create(self, ctx: CypherParser.OC_CreateContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Create. + def exitOC_Create(self, ctx: CypherParser.OC_CreateContext): + pass + + # Enter a parse tree produced by CypherParser#oC_CreateUnique. + def enterOC_CreateUnique(self, ctx: CypherParser.OC_CreateUniqueContext): + pass + + # Exit a parse tree produced by CypherParser#oC_CreateUnique. + def exitOC_CreateUnique(self, ctx: CypherParser.OC_CreateUniqueContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Set. + def enterOC_Set(self, ctx: CypherParser.OC_SetContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Set. + def exitOC_Set(self, ctx: CypherParser.OC_SetContext): + pass + + # Enter a parse tree produced by CypherParser#oC_SetItem. + def enterOC_SetItem(self, ctx: CypherParser.OC_SetItemContext): + pass + + # Exit a parse tree produced by CypherParser#oC_SetItem. + def exitOC_SetItem(self, ctx: CypherParser.OC_SetItemContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Delete. + def enterOC_Delete(self, ctx: CypherParser.OC_DeleteContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Delete. + def exitOC_Delete(self, ctx: CypherParser.OC_DeleteContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Remove. + def enterOC_Remove(self, ctx: CypherParser.OC_RemoveContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Remove. + def exitOC_Remove(self, ctx: CypherParser.OC_RemoveContext): + pass + + # Enter a parse tree produced by CypherParser#oC_RemoveItem. + def enterOC_RemoveItem(self, ctx: CypherParser.OC_RemoveItemContext): + pass + + # Exit a parse tree produced by CypherParser#oC_RemoveItem. + def exitOC_RemoveItem(self, ctx: CypherParser.OC_RemoveItemContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Foreach. + def enterOC_Foreach(self, ctx: CypherParser.OC_ForeachContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Foreach. + def exitOC_Foreach(self, ctx: CypherParser.OC_ForeachContext): + pass + + # Enter a parse tree produced by CypherParser#oC_InQueryCall. + def enterOC_InQueryCall(self, ctx: CypherParser.OC_InQueryCallContext): + pass + + # Exit a parse tree produced by CypherParser#oC_InQueryCall. + def exitOC_InQueryCall(self, ctx: CypherParser.OC_InQueryCallContext): + pass + + # Enter a parse tree produced by CypherParser#oC_StandaloneCall. + def enterOC_StandaloneCall(self, ctx: CypherParser.OC_StandaloneCallContext): + pass + + # Exit a parse tree produced by CypherParser#oC_StandaloneCall. + def exitOC_StandaloneCall(self, ctx: CypherParser.OC_StandaloneCallContext): + pass + + # Enter a parse tree produced by CypherParser#oC_YieldItems. + def enterOC_YieldItems(self, ctx: CypherParser.OC_YieldItemsContext): + pass + + # Exit a parse tree produced by CypherParser#oC_YieldItems. + def exitOC_YieldItems(self, ctx: CypherParser.OC_YieldItemsContext): + pass + + # Enter a parse tree produced by CypherParser#oC_YieldItem. + def enterOC_YieldItem(self, ctx: CypherParser.OC_YieldItemContext): + pass + + # Exit a parse tree produced by CypherParser#oC_YieldItem. + def exitOC_YieldItem(self, ctx: CypherParser.OC_YieldItemContext): + pass + + # Enter a parse tree produced by CypherParser#oC_With. + def enterOC_With(self, ctx: CypherParser.OC_WithContext): + pass + + # Exit a parse tree produced by CypherParser#oC_With. + def exitOC_With(self, ctx: CypherParser.OC_WithContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Return. + def enterOC_Return(self, ctx: CypherParser.OC_ReturnContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Return. + def exitOC_Return(self, ctx: CypherParser.OC_ReturnContext): + pass + + # Enter a parse tree produced by CypherParser#oC_ProjectionBody. + def enterOC_ProjectionBody(self, ctx: CypherParser.OC_ProjectionBodyContext): + pass + + # Exit a parse tree produced by CypherParser#oC_ProjectionBody. + def exitOC_ProjectionBody(self, ctx: CypherParser.OC_ProjectionBodyContext): + pass + + # Enter a parse tree produced by CypherParser#oC_ProjectionItems. + def enterOC_ProjectionItems(self, ctx: CypherParser.OC_ProjectionItemsContext): + pass + + # Exit a parse tree produced by CypherParser#oC_ProjectionItems. + def exitOC_ProjectionItems(self, ctx: CypherParser.OC_ProjectionItemsContext): + pass + + # Enter a parse tree produced by CypherParser#oC_ProjectionItem. + def enterOC_ProjectionItem(self, ctx: CypherParser.OC_ProjectionItemContext): + pass + + # Exit a parse tree produced by CypherParser#oC_ProjectionItem. + def exitOC_ProjectionItem(self, ctx: CypherParser.OC_ProjectionItemContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Order. + def enterOC_Order(self, ctx: CypherParser.OC_OrderContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Order. + def exitOC_Order(self, ctx: CypherParser.OC_OrderContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Skip. + def enterOC_Skip(self, ctx: CypherParser.OC_SkipContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Skip. + def exitOC_Skip(self, ctx: CypherParser.OC_SkipContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Limit. + def enterOC_Limit(self, ctx: CypherParser.OC_LimitContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Limit. + def exitOC_Limit(self, ctx: CypherParser.OC_LimitContext): + pass + + # Enter a parse tree produced by CypherParser#oC_SortItem. + def enterOC_SortItem(self, ctx: CypherParser.OC_SortItemContext): + pass + + # Exit a parse tree produced by CypherParser#oC_SortItem. + def exitOC_SortItem(self, ctx: CypherParser.OC_SortItemContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Hint. + def enterOC_Hint(self, ctx: CypherParser.OC_HintContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Hint. + def exitOC_Hint(self, ctx: CypherParser.OC_HintContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Start. + def enterOC_Start(self, ctx: CypherParser.OC_StartContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Start. + def exitOC_Start(self, ctx: CypherParser.OC_StartContext): + pass + + # Enter a parse tree produced by CypherParser#oC_StartPoint. + def enterOC_StartPoint(self, ctx: CypherParser.OC_StartPointContext): + pass + + # Exit a parse tree produced by CypherParser#oC_StartPoint. + def exitOC_StartPoint(self, ctx: CypherParser.OC_StartPointContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Lookup. + def enterOC_Lookup(self, ctx: CypherParser.OC_LookupContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Lookup. + def exitOC_Lookup(self, ctx: CypherParser.OC_LookupContext): + pass + + # Enter a parse tree produced by CypherParser#oC_NodeLookup. + def enterOC_NodeLookup(self, ctx: CypherParser.OC_NodeLookupContext): + pass + + # Exit a parse tree produced by CypherParser#oC_NodeLookup. + def exitOC_NodeLookup(self, ctx: CypherParser.OC_NodeLookupContext): + pass + + # Enter a parse tree produced by CypherParser#oC_RelationshipLookup. + def enterOC_RelationshipLookup( + self, ctx: CypherParser.OC_RelationshipLookupContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_RelationshipLookup. + def exitOC_RelationshipLookup(self, ctx: CypherParser.OC_RelationshipLookupContext): + pass + + # Enter a parse tree produced by CypherParser#oC_IdentifiedIndexLookup. + def enterOC_IdentifiedIndexLookup( + self, ctx: CypherParser.OC_IdentifiedIndexLookupContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_IdentifiedIndexLookup. + def exitOC_IdentifiedIndexLookup( + self, ctx: CypherParser.OC_IdentifiedIndexLookupContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_IndexQuery. + def enterOC_IndexQuery(self, ctx: CypherParser.OC_IndexQueryContext): + pass + + # Exit a parse tree produced by CypherParser#oC_IndexQuery. + def exitOC_IndexQuery(self, ctx: CypherParser.OC_IndexQueryContext): + pass + + # Enter a parse tree produced by CypherParser#oC_IdLookup. + def enterOC_IdLookup(self, ctx: CypherParser.OC_IdLookupContext): + pass + + # Exit a parse tree produced by CypherParser#oC_IdLookup. + def exitOC_IdLookup(self, ctx: CypherParser.OC_IdLookupContext): + pass + + # Enter a parse tree produced by CypherParser#oC_LiteralIds. + def enterOC_LiteralIds(self, ctx: CypherParser.OC_LiteralIdsContext): + pass + + # Exit a parse tree produced by CypherParser#oC_LiteralIds. + def exitOC_LiteralIds(self, ctx: CypherParser.OC_LiteralIdsContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Where. + def enterOC_Where(self, ctx: CypherParser.OC_WhereContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Where. + def exitOC_Where(self, ctx: CypherParser.OC_WhereContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Pattern. + def enterOC_Pattern(self, ctx: CypherParser.OC_PatternContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Pattern. + def exitOC_Pattern(self, ctx: CypherParser.OC_PatternContext): + pass + + # Enter a parse tree produced by CypherParser#oC_PatternPart. + def enterOC_PatternPart(self, ctx: CypherParser.OC_PatternPartContext): + pass + + # Exit a parse tree produced by CypherParser#oC_PatternPart. + def exitOC_PatternPart(self, ctx: CypherParser.OC_PatternPartContext): + pass + + # Enter a parse tree produced by CypherParser#oC_AnonymousPatternPart. + def enterOC_AnonymousPatternPart( + self, ctx: CypherParser.OC_AnonymousPatternPartContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_AnonymousPatternPart. + def exitOC_AnonymousPatternPart( + self, ctx: CypherParser.OC_AnonymousPatternPartContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_ShortestPathPattern. + def enterOC_ShortestPathPattern( + self, ctx: CypherParser.OC_ShortestPathPatternContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_ShortestPathPattern. + def exitOC_ShortestPathPattern( + self, ctx: CypherParser.OC_ShortestPathPatternContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_PatternElement. + def enterOC_PatternElement(self, ctx: CypherParser.OC_PatternElementContext): + pass + + # Exit a parse tree produced by CypherParser#oC_PatternElement. + def exitOC_PatternElement(self, ctx: CypherParser.OC_PatternElementContext): + pass + + # Enter a parse tree produced by CypherParser#oC_RelationshipsPattern. + def enterOC_RelationshipsPattern( + self, ctx: CypherParser.OC_RelationshipsPatternContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_RelationshipsPattern. + def exitOC_RelationshipsPattern( + self, ctx: CypherParser.OC_RelationshipsPatternContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_NodePattern. + def enterOC_NodePattern(self, ctx: CypherParser.OC_NodePatternContext): + pass + + # Exit a parse tree produced by CypherParser#oC_NodePattern. + def exitOC_NodePattern(self, ctx: CypherParser.OC_NodePatternContext): + pass + + # Enter a parse tree produced by CypherParser#oC_PatternElementChain. + def enterOC_PatternElementChain( + self, ctx: CypherParser.OC_PatternElementChainContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_PatternElementChain. + def exitOC_PatternElementChain( + self, ctx: CypherParser.OC_PatternElementChainContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_RelationshipPattern. + def enterOC_RelationshipPattern( + self, ctx: CypherParser.OC_RelationshipPatternContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_RelationshipPattern. + def exitOC_RelationshipPattern( + self, ctx: CypherParser.OC_RelationshipPatternContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_RelationshipDetail. + def enterOC_RelationshipDetail( + self, ctx: CypherParser.OC_RelationshipDetailContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_RelationshipDetail. + def exitOC_RelationshipDetail(self, ctx: CypherParser.OC_RelationshipDetailContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Properties. + def enterOC_Properties(self, ctx: CypherParser.OC_PropertiesContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Properties. + def exitOC_Properties(self, ctx: CypherParser.OC_PropertiesContext): + pass + + # Enter a parse tree produced by CypherParser#oC_RelType. + def enterOC_RelType(self, ctx: CypherParser.OC_RelTypeContext): + pass + + # Exit a parse tree produced by CypherParser#oC_RelType. + def exitOC_RelType(self, ctx: CypherParser.OC_RelTypeContext): + pass + + # Enter a parse tree produced by CypherParser#oC_RelationshipTypes. + def enterOC_RelationshipTypes(self, ctx: CypherParser.OC_RelationshipTypesContext): + pass + + # Exit a parse tree produced by CypherParser#oC_RelationshipTypes. + def exitOC_RelationshipTypes(self, ctx: CypherParser.OC_RelationshipTypesContext): + pass + + # Enter a parse tree produced by CypherParser#oC_NodeLabels. + def enterOC_NodeLabels(self, ctx: CypherParser.OC_NodeLabelsContext): + pass + + # Exit a parse tree produced by CypherParser#oC_NodeLabels. + def exitOC_NodeLabels(self, ctx: CypherParser.OC_NodeLabelsContext): + pass + + # Enter a parse tree produced by CypherParser#oC_NodeLabel. + def enterOC_NodeLabel(self, ctx: CypherParser.OC_NodeLabelContext): + pass + + # Exit a parse tree produced by CypherParser#oC_NodeLabel. + def exitOC_NodeLabel(self, ctx: CypherParser.OC_NodeLabelContext): + pass + + # Enter a parse tree produced by CypherParser#oC_RangeLiteral. + def enterOC_RangeLiteral(self, ctx: CypherParser.OC_RangeLiteralContext): + pass + + # Exit a parse tree produced by CypherParser#oC_RangeLiteral. + def exitOC_RangeLiteral(self, ctx: CypherParser.OC_RangeLiteralContext): + pass + + # Enter a parse tree produced by CypherParser#oC_LabelName. + def enterOC_LabelName(self, ctx: CypherParser.OC_LabelNameContext): + pass + + # Exit a parse tree produced by CypherParser#oC_LabelName. + def exitOC_LabelName(self, ctx: CypherParser.OC_LabelNameContext): + pass + + # Enter a parse tree produced by CypherParser#oC_RelTypeName. + def enterOC_RelTypeName(self, ctx: CypherParser.OC_RelTypeNameContext): + pass + + # Exit a parse tree produced by CypherParser#oC_RelTypeName. + def exitOC_RelTypeName(self, ctx: CypherParser.OC_RelTypeNameContext): + pass + + # Enter a parse tree produced by CypherParser#oC_PropertyExpression. + def enterOC_PropertyExpression( + self, ctx: CypherParser.OC_PropertyExpressionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_PropertyExpression. + def exitOC_PropertyExpression(self, ctx: CypherParser.OC_PropertyExpressionContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Expression. + def enterOC_Expression(self, ctx: CypherParser.OC_ExpressionContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Expression. + def exitOC_Expression(self, ctx: CypherParser.OC_ExpressionContext): + pass + + # Enter a parse tree produced by CypherParser#oC_OrExpression. + def enterOC_OrExpression(self, ctx: CypherParser.OC_OrExpressionContext): + pass + + # Exit a parse tree produced by CypherParser#oC_OrExpression. + def exitOC_OrExpression(self, ctx: CypherParser.OC_OrExpressionContext): + pass + + # Enter a parse tree produced by CypherParser#oC_XorExpression. + def enterOC_XorExpression(self, ctx: CypherParser.OC_XorExpressionContext): + pass + + # Exit a parse tree produced by CypherParser#oC_XorExpression. + def exitOC_XorExpression(self, ctx: CypherParser.OC_XorExpressionContext): + pass + + # Enter a parse tree produced by CypherParser#oC_AndExpression. + def enterOC_AndExpression(self, ctx: CypherParser.OC_AndExpressionContext): + pass + + # Exit a parse tree produced by CypherParser#oC_AndExpression. + def exitOC_AndExpression(self, ctx: CypherParser.OC_AndExpressionContext): + pass + + # Enter a parse tree produced by CypherParser#oC_NotExpression. + def enterOC_NotExpression(self, ctx: CypherParser.OC_NotExpressionContext): + pass + + # Exit a parse tree produced by CypherParser#oC_NotExpression. + def exitOC_NotExpression(self, ctx: CypherParser.OC_NotExpressionContext): + pass + + # Enter a parse tree produced by CypherParser#oC_ComparisonExpression. + def enterOC_ComparisonExpression( + self, ctx: CypherParser.OC_ComparisonExpressionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_ComparisonExpression. + def exitOC_ComparisonExpression( + self, ctx: CypherParser.OC_ComparisonExpressionContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_PartialComparisonExpression. + def enterOC_PartialComparisonExpression( + self, ctx: CypherParser.OC_PartialComparisonExpressionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_PartialComparisonExpression. + def exitOC_PartialComparisonExpression( + self, ctx: CypherParser.OC_PartialComparisonExpressionContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_StringListNullPredicateExpression. + def enterOC_StringListNullPredicateExpression( + self, ctx: CypherParser.OC_StringListNullPredicateExpressionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_StringListNullPredicateExpression. + def exitOC_StringListNullPredicateExpression( + self, ctx: CypherParser.OC_StringListNullPredicateExpressionContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_StringPredicateExpression. + def enterOC_StringPredicateExpression( + self, ctx: CypherParser.OC_StringPredicateExpressionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_StringPredicateExpression. + def exitOC_StringPredicateExpression( + self, ctx: CypherParser.OC_StringPredicateExpressionContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_ListPredicateExpression. + def enterOC_ListPredicateExpression( + self, ctx: CypherParser.OC_ListPredicateExpressionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_ListPredicateExpression. + def exitOC_ListPredicateExpression( + self, ctx: CypherParser.OC_ListPredicateExpressionContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_NullPredicateExpression. + def enterOC_NullPredicateExpression( + self, ctx: CypherParser.OC_NullPredicateExpressionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_NullPredicateExpression. + def exitOC_NullPredicateExpression( + self, ctx: CypherParser.OC_NullPredicateExpressionContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_RegularExpression. + def enterOC_RegularExpression(self, ctx: CypherParser.OC_RegularExpressionContext): + pass + + # Exit a parse tree produced by CypherParser#oC_RegularExpression. + def exitOC_RegularExpression(self, ctx: CypherParser.OC_RegularExpressionContext): + pass + + # Enter a parse tree produced by CypherParser#oC_AddOrSubtractExpression. + def enterOC_AddOrSubtractExpression( + self, ctx: CypherParser.OC_AddOrSubtractExpressionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_AddOrSubtractExpression. + def exitOC_AddOrSubtractExpression( + self, ctx: CypherParser.OC_AddOrSubtractExpressionContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_MultiplyDivideModuloExpression. + def enterOC_MultiplyDivideModuloExpression( + self, ctx: CypherParser.OC_MultiplyDivideModuloExpressionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_MultiplyDivideModuloExpression. + def exitOC_MultiplyDivideModuloExpression( + self, ctx: CypherParser.OC_MultiplyDivideModuloExpressionContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_PowerOfExpression. + def enterOC_PowerOfExpression(self, ctx: CypherParser.OC_PowerOfExpressionContext): + pass + + # Exit a parse tree produced by CypherParser#oC_PowerOfExpression. + def exitOC_PowerOfExpression(self, ctx: CypherParser.OC_PowerOfExpressionContext): + pass + + # Enter a parse tree produced by CypherParser#oC_UnaryAddOrSubtractExpression. + def enterOC_UnaryAddOrSubtractExpression( + self, ctx: CypherParser.OC_UnaryAddOrSubtractExpressionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_UnaryAddOrSubtractExpression. + def exitOC_UnaryAddOrSubtractExpression( + self, ctx: CypherParser.OC_UnaryAddOrSubtractExpressionContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_NonArithmeticOperatorExpression. + def enterOC_NonArithmeticOperatorExpression( + self, ctx: CypherParser.OC_NonArithmeticOperatorExpressionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_NonArithmeticOperatorExpression. + def exitOC_NonArithmeticOperatorExpression( + self, ctx: CypherParser.OC_NonArithmeticOperatorExpressionContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_ListOperatorExpression. + def enterOC_ListOperatorExpression( + self, ctx: CypherParser.OC_ListOperatorExpressionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_ListOperatorExpression. + def exitOC_ListOperatorExpression( + self, ctx: CypherParser.OC_ListOperatorExpressionContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_PropertyLookup. + def enterOC_PropertyLookup(self, ctx: CypherParser.OC_PropertyLookupContext): + pass + + # Exit a parse tree produced by CypherParser#oC_PropertyLookup. + def exitOC_PropertyLookup(self, ctx: CypherParser.OC_PropertyLookupContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Atom. + def enterOC_Atom(self, ctx: CypherParser.OC_AtomContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Atom. + def exitOC_Atom(self, ctx: CypherParser.OC_AtomContext): + pass + + # Enter a parse tree produced by CypherParser#oC_CaseExpression. + def enterOC_CaseExpression(self, ctx: CypherParser.OC_CaseExpressionContext): + pass + + # Exit a parse tree produced by CypherParser#oC_CaseExpression. + def exitOC_CaseExpression(self, ctx: CypherParser.OC_CaseExpressionContext): + pass + + # Enter a parse tree produced by CypherParser#oC_CaseAlternative. + def enterOC_CaseAlternative(self, ctx: CypherParser.OC_CaseAlternativeContext): + pass + + # Exit a parse tree produced by CypherParser#oC_CaseAlternative. + def exitOC_CaseAlternative(self, ctx: CypherParser.OC_CaseAlternativeContext): + pass + + # Enter a parse tree produced by CypherParser#oC_ListComprehension. + def enterOC_ListComprehension(self, ctx: CypherParser.OC_ListComprehensionContext): + pass + + # Exit a parse tree produced by CypherParser#oC_ListComprehension. + def exitOC_ListComprehension(self, ctx: CypherParser.OC_ListComprehensionContext): + pass + + # Enter a parse tree produced by CypherParser#oC_PatternComprehension. + def enterOC_PatternComprehension( + self, ctx: CypherParser.OC_PatternComprehensionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_PatternComprehension. + def exitOC_PatternComprehension( + self, ctx: CypherParser.OC_PatternComprehensionContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_LegacyListExpression. + def enterOC_LegacyListExpression( + self, ctx: CypherParser.OC_LegacyListExpressionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_LegacyListExpression. + def exitOC_LegacyListExpression( + self, ctx: CypherParser.OC_LegacyListExpressionContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_Reduce. + def enterOC_Reduce(self, ctx: CypherParser.OC_ReduceContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Reduce. + def exitOC_Reduce(self, ctx: CypherParser.OC_ReduceContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Quantifier. + def enterOC_Quantifier(self, ctx: CypherParser.OC_QuantifierContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Quantifier. + def exitOC_Quantifier(self, ctx: CypherParser.OC_QuantifierContext): + pass + + # Enter a parse tree produced by CypherParser#oC_FilterExpression. + def enterOC_FilterExpression(self, ctx: CypherParser.OC_FilterExpressionContext): + pass + + # Exit a parse tree produced by CypherParser#oC_FilterExpression. + def exitOC_FilterExpression(self, ctx: CypherParser.OC_FilterExpressionContext): + pass + + # Enter a parse tree produced by CypherParser#oC_PatternPredicate. + def enterOC_PatternPredicate(self, ctx: CypherParser.OC_PatternPredicateContext): + pass + + # Exit a parse tree produced by CypherParser#oC_PatternPredicate. + def exitOC_PatternPredicate(self, ctx: CypherParser.OC_PatternPredicateContext): + pass + + # Enter a parse tree produced by CypherParser#oC_ParenthesizedExpression. + def enterOC_ParenthesizedExpression( + self, ctx: CypherParser.OC_ParenthesizedExpressionContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_ParenthesizedExpression. + def exitOC_ParenthesizedExpression( + self, ctx: CypherParser.OC_ParenthesizedExpressionContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_IdInColl. + def enterOC_IdInColl(self, ctx: CypherParser.OC_IdInCollContext): + pass + + # Exit a parse tree produced by CypherParser#oC_IdInColl. + def exitOC_IdInColl(self, ctx: CypherParser.OC_IdInCollContext): + pass + + # Enter a parse tree produced by CypherParser#oC_FunctionInvocation. + def enterOC_FunctionInvocation( + self, ctx: CypherParser.OC_FunctionInvocationContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_FunctionInvocation. + def exitOC_FunctionInvocation(self, ctx: CypherParser.OC_FunctionInvocationContext): + pass + + # Enter a parse tree produced by CypherParser#oC_FunctionName. + def enterOC_FunctionName(self, ctx: CypherParser.OC_FunctionNameContext): + pass + + # Exit a parse tree produced by CypherParser#oC_FunctionName. + def exitOC_FunctionName(self, ctx: CypherParser.OC_FunctionNameContext): + pass + + # Enter a parse tree produced by CypherParser#oC_ExistentialSubquery. + def enterOC_ExistentialSubquery( + self, ctx: CypherParser.OC_ExistentialSubqueryContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_ExistentialSubquery. + def exitOC_ExistentialSubquery( + self, ctx: CypherParser.OC_ExistentialSubqueryContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_ExplicitProcedureInvocation. + def enterOC_ExplicitProcedureInvocation( + self, ctx: CypherParser.OC_ExplicitProcedureInvocationContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_ExplicitProcedureInvocation. + def exitOC_ExplicitProcedureInvocation( + self, ctx: CypherParser.OC_ExplicitProcedureInvocationContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_ImplicitProcedureInvocation. + def enterOC_ImplicitProcedureInvocation( + self, ctx: CypherParser.OC_ImplicitProcedureInvocationContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_ImplicitProcedureInvocation. + def exitOC_ImplicitProcedureInvocation( + self, ctx: CypherParser.OC_ImplicitProcedureInvocationContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_ProcedureResultField. + def enterOC_ProcedureResultField( + self, ctx: CypherParser.OC_ProcedureResultFieldContext + ): + pass + + # Exit a parse tree produced by CypherParser#oC_ProcedureResultField. + def exitOC_ProcedureResultField( + self, ctx: CypherParser.OC_ProcedureResultFieldContext + ): + pass + + # Enter a parse tree produced by CypherParser#oC_ProcedureName. + def enterOC_ProcedureName(self, ctx: CypherParser.OC_ProcedureNameContext): + pass + + # Exit a parse tree produced by CypherParser#oC_ProcedureName. + def exitOC_ProcedureName(self, ctx: CypherParser.OC_ProcedureNameContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Namespace. + def enterOC_Namespace(self, ctx: CypherParser.OC_NamespaceContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Namespace. + def exitOC_Namespace(self, ctx: CypherParser.OC_NamespaceContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Variable. + def enterOC_Variable(self, ctx: CypherParser.OC_VariableContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Variable. + def exitOC_Variable(self, ctx: CypherParser.OC_VariableContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Literal. + def enterOC_Literal(self, ctx: CypherParser.OC_LiteralContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Literal. + def exitOC_Literal(self, ctx: CypherParser.OC_LiteralContext): + pass + + # Enter a parse tree produced by CypherParser#oC_BooleanLiteral. + def enterOC_BooleanLiteral(self, ctx: CypherParser.OC_BooleanLiteralContext): + pass + + # Exit a parse tree produced by CypherParser#oC_BooleanLiteral. + def exitOC_BooleanLiteral(self, ctx: CypherParser.OC_BooleanLiteralContext): + pass + + # Enter a parse tree produced by CypherParser#oC_NumberLiteral. + def enterOC_NumberLiteral(self, ctx: CypherParser.OC_NumberLiteralContext): + pass + + # Exit a parse tree produced by CypherParser#oC_NumberLiteral. + def exitOC_NumberLiteral(self, ctx: CypherParser.OC_NumberLiteralContext): + pass + + # Enter a parse tree produced by CypherParser#oC_IntegerLiteral. + def enterOC_IntegerLiteral(self, ctx: CypherParser.OC_IntegerLiteralContext): + pass + + # Exit a parse tree produced by CypherParser#oC_IntegerLiteral. + def exitOC_IntegerLiteral(self, ctx: CypherParser.OC_IntegerLiteralContext): + pass + + # Enter a parse tree produced by CypherParser#oC_DoubleLiteral. + def enterOC_DoubleLiteral(self, ctx: CypherParser.OC_DoubleLiteralContext): + pass + + # Exit a parse tree produced by CypherParser#oC_DoubleLiteral. + def exitOC_DoubleLiteral(self, ctx: CypherParser.OC_DoubleLiteralContext): + pass + + # Enter a parse tree produced by CypherParser#oC_ListLiteral. + def enterOC_ListLiteral(self, ctx: CypherParser.OC_ListLiteralContext): + pass + + # Exit a parse tree produced by CypherParser#oC_ListLiteral. + def exitOC_ListLiteral(self, ctx: CypherParser.OC_ListLiteralContext): + pass + + # Enter a parse tree produced by CypherParser#oC_MapLiteral. + def enterOC_MapLiteral(self, ctx: CypherParser.OC_MapLiteralContext): + pass + + # Exit a parse tree produced by CypherParser#oC_MapLiteral. + def exitOC_MapLiteral(self, ctx: CypherParser.OC_MapLiteralContext): + pass + + # Enter a parse tree produced by CypherParser#oC_PropertyKeyName. + def enterOC_PropertyKeyName(self, ctx: CypherParser.OC_PropertyKeyNameContext): + pass + + # Exit a parse tree produced by CypherParser#oC_PropertyKeyName. + def exitOC_PropertyKeyName(self, ctx: CypherParser.OC_PropertyKeyNameContext): + pass + + # Enter a parse tree produced by CypherParser#oC_LegacyParameter. + def enterOC_LegacyParameter(self, ctx: CypherParser.OC_LegacyParameterContext): + pass + + # Exit a parse tree produced by CypherParser#oC_LegacyParameter. + def exitOC_LegacyParameter(self, ctx: CypherParser.OC_LegacyParameterContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Parameter. + def enterOC_Parameter(self, ctx: CypherParser.OC_ParameterContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Parameter. + def exitOC_Parameter(self, ctx: CypherParser.OC_ParameterContext): + pass + + # Enter a parse tree produced by CypherParser#oC_SchemaName. + def enterOC_SchemaName(self, ctx: CypherParser.OC_SchemaNameContext): + pass + + # Exit a parse tree produced by CypherParser#oC_SchemaName. + def exitOC_SchemaName(self, ctx: CypherParser.OC_SchemaNameContext): + pass + + # Enter a parse tree produced by CypherParser#oC_ReservedWord. + def enterOC_ReservedWord(self, ctx: CypherParser.OC_ReservedWordContext): + pass + + # Exit a parse tree produced by CypherParser#oC_ReservedWord. + def exitOC_ReservedWord(self, ctx: CypherParser.OC_ReservedWordContext): + pass + + # Enter a parse tree produced by CypherParser#oC_SymbolicName. + def enterOC_SymbolicName(self, ctx: CypherParser.OC_SymbolicNameContext): + pass + + # Exit a parse tree produced by CypherParser#oC_SymbolicName. + def exitOC_SymbolicName(self, ctx: CypherParser.OC_SymbolicNameContext): + pass + + # Enter a parse tree produced by CypherParser#oC_LeftArrowHead. + def enterOC_LeftArrowHead(self, ctx: CypherParser.OC_LeftArrowHeadContext): + pass + + # Exit a parse tree produced by CypherParser#oC_LeftArrowHead. + def exitOC_LeftArrowHead(self, ctx: CypherParser.OC_LeftArrowHeadContext): + pass + + # Enter a parse tree produced by CypherParser#oC_RightArrowHead. + def enterOC_RightArrowHead(self, ctx: CypherParser.OC_RightArrowHeadContext): + pass + + # Exit a parse tree produced by CypherParser#oC_RightArrowHead. + def exitOC_RightArrowHead(self, ctx: CypherParser.OC_RightArrowHeadContext): + pass + + # Enter a parse tree produced by CypherParser#oC_Dash. + def enterOC_Dash(self, ctx: CypherParser.OC_DashContext): + pass + + # Exit a parse tree produced by CypherParser#oC_Dash. + def exitOC_Dash(self, ctx: CypherParser.OC_DashContext): + pass + + +del CypherParser diff --git a/tests/grammar/CypherParser.py b/tests/grammar/CypherParser.py new file mode 100644 index 0000000..80c71cb --- /dev/null +++ b/tests/grammar/CypherParser.py @@ -0,0 +1,32890 @@ +# Generated from Cypher.g4 by ANTLR 4.13.2 +# encoding: utf-8 +from antlr4 import * +from io import StringIO +import sys + +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + + +def serializedATN(): + return [ + 4, + 1, + 151, + 2193, + 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, + 1, + 0, + 3, + 0, + 294, + 8, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 3, + 0, + 299, + 8, + 0, + 1, + 0, + 3, + 0, + 302, + 8, + 0, + 1, + 0, + 3, + 0, + 305, + 8, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 3, + 1, + 311, + 8, + 1, + 5, + 1, + 313, + 8, + 1, + 10, + 1, + 12, + 1, + 316, + 9, + 1, + 1, + 2, + 1, + 2, + 1, + 2, + 3, + 2, + 321, + 8, + 2, + 1, + 3, + 1, + 3, + 1, + 3, + 3, + 3, + 326, + 8, + 3, + 1, + 3, + 1, + 3, + 5, + 3, + 330, + 8, + 3, + 10, + 3, + 12, + 3, + 333, + 9, + 3, + 1, + 4, + 1, + 4, + 1, + 5, + 1, + 5, + 1, + 6, + 1, + 6, + 1, + 7, + 1, + 7, + 3, + 7, + 343, + 8, + 7, + 1, + 7, + 1, + 7, + 3, + 7, + 347, + 8, + 7, + 1, + 7, + 1, + 7, + 1, + 8, + 1, + 8, + 3, + 8, + 353, + 8, + 8, + 1, + 9, + 1, + 9, + 1, + 9, + 3, + 9, + 358, + 8, + 9, + 1, + 10, + 1, + 10, + 3, + 10, + 362, + 8, + 10, + 1, + 10, + 5, + 10, + 365, + 8, + 10, + 10, + 10, + 12, + 10, + 368, + 9, + 10, + 1, + 11, + 1, + 11, + 3, + 11, + 372, + 8, + 11, + 1, + 11, + 1, + 11, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 3, + 12, + 383, + 8, + 12, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 3, + 14, + 392, + 8, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 3, + 14, + 397, + 8, + 14, + 1, + 14, + 3, + 14, + 400, + 8, + 14, + 1, + 15, + 1, + 15, + 3, + 15, + 404, + 8, + 15, + 1, + 16, + 1, + 16, + 3, + 16, + 408, + 8, + 16, + 5, + 16, + 410, + 8, + 16, + 10, + 16, + 12, + 16, + 413, + 9, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 3, + 16, + 418, + 8, + 16, + 5, + 16, + 420, + 8, + 16, + 10, + 16, + 12, + 16, + 423, + 9, + 16, + 1, + 16, + 1, + 16, + 3, + 16, + 427, + 8, + 16, + 1, + 16, + 5, + 16, + 430, + 8, + 16, + 10, + 16, + 12, + 16, + 433, + 9, + 16, + 1, + 16, + 3, + 16, + 436, + 8, + 16, + 1, + 16, + 3, + 16, + 439, + 8, + 16, + 3, + 16, + 441, + 8, + 16, + 1, + 17, + 1, + 17, + 3, + 17, + 445, + 8, + 17, + 5, + 17, + 447, + 8, + 17, + 10, + 17, + 12, + 17, + 450, + 9, + 17, + 1, + 17, + 1, + 17, + 3, + 17, + 454, + 8, + 17, + 5, + 17, + 456, + 8, + 17, + 10, + 17, + 12, + 17, + 459, + 9, + 17, + 1, + 17, + 1, + 17, + 3, + 17, + 463, + 8, + 17, + 4, + 17, + 465, + 8, + 17, + 11, + 17, + 12, + 17, + 466, + 1, + 17, + 1, + 17, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 18, + 3, + 18, + 478, + 8, + 18, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 3, + 19, + 485, + 8, + 19, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 3, + 20, + 495, + 8, + 20, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 24, + 1, + 24, + 1, + 24, + 1, + 24, + 1, + 25, + 1, + 25, + 1, + 25, + 1, + 25, + 1, + 26, + 1, + 26, + 1, + 26, + 1, + 26, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 3, + 29, + 533, + 8, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 3, + 30, + 544, + 8, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 3, + 30, + 551, + 8, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 3, + 31, + 565, + 8, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 3, + 31, + 572, + 8, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 3, + 31, + 578, + 8, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 3, + 32, + 588, + 8, + 32, + 1, + 32, + 1, + 32, + 3, + 32, + 592, + 8, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 3, + 32, + 598, + 8, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 33, + 1, + 33, + 3, + 33, + 606, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 617, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 623, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 635, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 641, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 653, + 8, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 657, + 8, + 33, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 3, + 34, + 667, + 8, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 3, + 34, + 680, + 8, + 34, + 1, + 35, + 1, + 35, + 3, + 35, + 684, + 8, + 35, + 1, + 35, + 1, + 35, + 3, + 35, + 688, + 8, + 35, + 1, + 35, + 1, + 35, + 5, + 35, + 692, + 8, + 35, + 10, + 35, + 12, + 35, + 695, + 9, + 35, + 1, + 35, + 3, + 35, + 698, + 8, + 35, + 1, + 35, + 3, + 35, + 701, + 8, + 35, + 1, + 36, + 1, + 36, + 3, + 36, + 705, + 8, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 37, + 1, + 37, + 3, + 37, + 715, + 8, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 5, + 37, + 720, + 8, + 37, + 10, + 37, + 12, + 37, + 723, + 9, + 37, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 3, + 38, + 735, + 8, + 38, + 1, + 39, + 1, + 39, + 3, + 39, + 739, + 8, + 39, + 1, + 39, + 1, + 39, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 3, + 40, + 747, + 8, + 40, + 1, + 40, + 1, + 40, + 1, + 41, + 1, + 41, + 3, + 41, + 753, + 8, + 41, + 1, + 41, + 1, + 41, + 3, + 41, + 757, + 8, + 41, + 1, + 41, + 1, + 41, + 3, + 41, + 761, + 8, + 41, + 1, + 41, + 5, + 41, + 764, + 8, + 41, + 10, + 41, + 12, + 41, + 767, + 9, + 41, + 1, + 42, + 1, + 42, + 3, + 42, + 771, + 8, + 42, + 1, + 42, + 1, + 42, + 3, + 42, + 775, + 8, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 3, + 42, + 781, + 8, + 42, + 1, + 42, + 1, + 42, + 3, + 42, + 785, + 8, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 3, + 42, + 791, + 8, + 42, + 1, + 42, + 1, + 42, + 3, + 42, + 795, + 8, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 3, + 42, + 801, + 8, + 42, + 1, + 42, + 1, + 42, + 3, + 42, + 805, + 8, + 42, + 1, + 43, + 1, + 43, + 3, + 43, + 809, + 8, + 43, + 1, + 43, + 1, + 43, + 3, + 43, + 813, + 8, + 43, + 1, + 43, + 1, + 43, + 3, + 43, + 817, + 8, + 43, + 1, + 43, + 1, + 43, + 3, + 43, + 821, + 8, + 43, + 1, + 43, + 5, + 43, + 824, + 8, + 43, + 10, + 43, + 12, + 43, + 827, + 9, + 43, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 3, + 44, + 833, + 8, + 44, + 1, + 44, + 1, + 44, + 3, + 44, + 837, + 8, + 44, + 1, + 44, + 5, + 44, + 840, + 8, + 44, + 10, + 44, + 12, + 44, + 843, + 9, + 44, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 3, + 45, + 849, + 8, + 45, + 1, + 46, + 1, + 46, + 3, + 46, + 853, + 8, + 46, + 1, + 46, + 1, + 46, + 3, + 46, + 857, + 8, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 3, + 46, + 865, + 8, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 4, + 46, + 870, + 8, + 46, + 11, + 46, + 12, + 46, + 871, + 1, + 46, + 3, + 46, + 875, + 8, + 46, + 1, + 46, + 1, + 46, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 3, + 47, + 883, + 8, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 3, + 47, + 888, + 8, + 47, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 3, + 48, + 894, + 8, + 48, + 1, + 48, + 3, + 48, + 897, + 8, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 3, + 48, + 903, + 8, + 48, + 3, + 48, + 905, + 8, + 48, + 1, + 49, + 1, + 49, + 3, + 49, + 909, + 8, + 49, + 1, + 49, + 1, + 49, + 3, + 49, + 913, + 8, + 49, + 1, + 49, + 5, + 49, + 916, + 8, + 49, + 10, + 49, + 12, + 49, + 919, + 9, + 49, + 1, + 49, + 3, + 49, + 922, + 8, + 49, + 1, + 49, + 3, + 49, + 925, + 8, + 49, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 3, + 50, + 932, + 8, + 50, + 1, + 50, + 1, + 50, + 1, + 51, + 1, + 51, + 1, + 51, + 3, + 51, + 939, + 8, + 51, + 1, + 51, + 3, + 51, + 942, + 8, + 51, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 53, + 3, + 53, + 948, + 8, + 53, + 1, + 53, + 3, + 53, + 951, + 8, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 3, + 53, + 957, + 8, + 53, + 1, + 53, + 1, + 53, + 3, + 53, + 961, + 8, + 53, + 1, + 53, + 1, + 53, + 3, + 53, + 965, + 8, + 53, + 1, + 54, + 1, + 54, + 3, + 54, + 969, + 8, + 54, + 1, + 54, + 1, + 54, + 3, + 54, + 973, + 8, + 54, + 1, + 54, + 5, + 54, + 976, + 8, + 54, + 10, + 54, + 12, + 54, + 979, + 9, + 54, + 1, + 54, + 1, + 54, + 3, + 54, + 983, + 8, + 54, + 1, + 54, + 1, + 54, + 3, + 54, + 987, + 8, + 54, + 1, + 54, + 5, + 54, + 990, + 8, + 54, + 10, + 54, + 12, + 54, + 993, + 9, + 54, + 3, + 54, + 995, + 8, + 54, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 3, + 55, + 1004, + 8, + 55, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 3, + 56, + 1013, + 8, + 56, + 1, + 56, + 5, + 56, + 1016, + 8, + 56, + 10, + 56, + 12, + 56, + 1019, + 9, + 56, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 59, + 1, + 59, + 3, + 59, + 1031, + 8, + 59, + 1, + 59, + 3, + 59, + 1034, + 8, + 59, + 1, + 60, + 3, + 60, + 1037, + 8, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 3, + 60, + 1057, + 8, + 60, + 1, + 60, + 1, + 60, + 3, + 60, + 1061, + 8, + 60, + 1, + 60, + 5, + 60, + 1064, + 8, + 60, + 10, + 60, + 12, + 60, + 1067, + 9, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 3, + 60, + 1076, + 8, + 60, + 1, + 61, + 1, + 61, + 1, + 61, + 1, + 61, + 3, + 61, + 1082, + 8, + 61, + 1, + 61, + 1, + 61, + 3, + 61, + 1086, + 8, + 61, + 1, + 61, + 5, + 61, + 1089, + 8, + 61, + 10, + 61, + 12, + 61, + 1092, + 9, + 61, + 1, + 61, + 3, + 61, + 1095, + 8, + 61, + 1, + 62, + 1, + 62, + 3, + 62, + 1099, + 8, + 62, + 1, + 62, + 1, + 62, + 3, + 62, + 1103, + 8, + 62, + 1, + 62, + 1, + 62, + 1, + 63, + 1, + 63, + 3, + 63, + 1109, + 8, + 63, + 1, + 64, + 1, + 64, + 3, + 64, + 1113, + 8, + 64, + 1, + 64, + 1, + 64, + 1, + 64, + 3, + 64, + 1118, + 8, + 64, + 1, + 65, + 1, + 65, + 1, + 65, + 1, + 65, + 3, + 65, + 1124, + 8, + 65, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 3, + 66, + 1133, + 8, + 66, + 1, + 66, + 1, + 66, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 3, + 67, + 1142, + 8, + 67, + 1, + 67, + 1, + 67, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 3, + 68, + 1150, + 8, + 68, + 1, + 68, + 1, + 68, + 1, + 69, + 1, + 69, + 3, + 69, + 1156, + 8, + 69, + 1, + 69, + 1, + 69, + 3, + 69, + 1160, + 8, + 69, + 1, + 69, + 5, + 69, + 1163, + 8, + 69, + 10, + 69, + 12, + 69, + 1166, + 9, + 69, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 71, + 1, + 71, + 3, + 71, + 1174, + 8, + 71, + 1, + 71, + 1, + 71, + 3, + 71, + 1178, + 8, + 71, + 1, + 71, + 5, + 71, + 1181, + 8, + 71, + 10, + 71, + 12, + 71, + 1184, + 9, + 71, + 1, + 72, + 1, + 72, + 3, + 72, + 1188, + 8, + 72, + 1, + 72, + 1, + 72, + 3, + 72, + 1192, + 8, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 3, + 72, + 1197, + 8, + 72, + 1, + 73, + 1, + 73, + 3, + 73, + 1201, + 8, + 73, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 3, + 74, + 1213, + 8, + 74, + 1, + 75, + 1, + 75, + 3, + 75, + 1217, + 8, + 75, + 1, + 75, + 5, + 75, + 1220, + 8, + 75, + 10, + 75, + 12, + 75, + 1223, + 9, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 3, + 75, + 1229, + 8, + 75, + 1, + 76, + 1, + 76, + 3, + 76, + 1233, + 8, + 76, + 1, + 76, + 4, + 76, + 1236, + 8, + 76, + 11, + 76, + 12, + 76, + 1237, + 1, + 77, + 1, + 77, + 3, + 77, + 1242, + 8, + 77, + 1, + 77, + 1, + 77, + 3, + 77, + 1246, + 8, + 77, + 3, + 77, + 1248, + 8, + 77, + 1, + 77, + 1, + 77, + 3, + 77, + 1252, + 8, + 77, + 3, + 77, + 1254, + 8, + 77, + 1, + 77, + 1, + 77, + 3, + 77, + 1258, + 8, + 77, + 3, + 77, + 1260, + 8, + 77, + 1, + 77, + 1, + 77, + 1, + 78, + 1, + 78, + 3, + 78, + 1266, + 8, + 78, + 1, + 78, + 1, + 78, + 1, + 79, + 1, + 79, + 3, + 79, + 1272, + 8, + 79, + 1, + 79, + 1, + 79, + 3, + 79, + 1276, + 8, + 79, + 1, + 79, + 3, + 79, + 1279, + 8, + 79, + 1, + 79, + 3, + 79, + 1282, + 8, + 79, + 1, + 79, + 1, + 79, + 3, + 79, + 1286, + 8, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 3, + 79, + 1292, + 8, + 79, + 1, + 79, + 1, + 79, + 3, + 79, + 1296, + 8, + 79, + 1, + 79, + 3, + 79, + 1299, + 8, + 79, + 1, + 79, + 3, + 79, + 1302, + 8, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 3, + 79, + 1308, + 8, + 79, + 1, + 79, + 3, + 79, + 1311, + 8, + 79, + 1, + 79, + 3, + 79, + 1314, + 8, + 79, + 1, + 79, + 1, + 79, + 3, + 79, + 1318, + 8, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 3, + 79, + 1324, + 8, + 79, + 1, + 79, + 3, + 79, + 1327, + 8, + 79, + 1, + 79, + 3, + 79, + 1330, + 8, + 79, + 1, + 79, + 1, + 79, + 3, + 79, + 1334, + 8, + 79, + 1, + 80, + 1, + 80, + 3, + 80, + 1338, + 8, + 80, + 1, + 80, + 1, + 80, + 3, + 80, + 1342, + 8, + 80, + 3, + 80, + 1344, + 8, + 80, + 1, + 80, + 1, + 80, + 3, + 80, + 1348, + 8, + 80, + 3, + 80, + 1350, + 8, + 80, + 1, + 80, + 3, + 80, + 1353, + 8, + 80, + 1, + 80, + 1, + 80, + 3, + 80, + 1357, + 8, + 80, + 3, + 80, + 1359, + 8, + 80, + 1, + 80, + 1, + 80, + 1, + 81, + 1, + 81, + 1, + 81, + 3, + 81, + 1366, + 8, + 81, + 1, + 82, + 1, + 82, + 3, + 82, + 1370, + 8, + 82, + 1, + 82, + 1, + 82, + 1, + 83, + 1, + 83, + 3, + 83, + 1376, + 8, + 83, + 1, + 83, + 1, + 83, + 3, + 83, + 1380, + 8, + 83, + 1, + 83, + 1, + 83, + 3, + 83, + 1384, + 8, + 83, + 1, + 83, + 3, + 83, + 1387, + 8, + 83, + 1, + 83, + 5, + 83, + 1390, + 8, + 83, + 10, + 83, + 12, + 83, + 1393, + 9, + 83, + 1, + 84, + 1, + 84, + 3, + 84, + 1397, + 8, + 84, + 1, + 84, + 5, + 84, + 1400, + 8, + 84, + 10, + 84, + 12, + 84, + 1403, + 9, + 84, + 1, + 85, + 1, + 85, + 3, + 85, + 1407, + 8, + 85, + 1, + 85, + 1, + 85, + 1, + 86, + 1, + 86, + 3, + 86, + 1413, + 8, + 86, + 1, + 86, + 1, + 86, + 3, + 86, + 1417, + 8, + 86, + 3, + 86, + 1419, + 8, + 86, + 1, + 86, + 1, + 86, + 3, + 86, + 1423, + 8, + 86, + 1, + 86, + 1, + 86, + 3, + 86, + 1427, + 8, + 86, + 3, + 86, + 1429, + 8, + 86, + 3, + 86, + 1431, + 8, + 86, + 1, + 87, + 1, + 87, + 1, + 88, + 1, + 88, + 1, + 89, + 1, + 89, + 3, + 89, + 1439, + 8, + 89, + 1, + 89, + 4, + 89, + 1442, + 8, + 89, + 11, + 89, + 12, + 89, + 1443, + 1, + 90, + 1, + 90, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 5, + 91, + 1453, + 8, + 91, + 10, + 91, + 12, + 91, + 1456, + 9, + 91, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 92, + 5, + 92, + 1463, + 8, + 92, + 10, + 92, + 12, + 92, + 1466, + 9, + 92, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 5, + 93, + 1473, + 8, + 93, + 10, + 93, + 12, + 93, + 1476, + 9, + 93, + 1, + 94, + 1, + 94, + 3, + 94, + 1480, + 8, + 94, + 5, + 94, + 1482, + 8, + 94, + 10, + 94, + 12, + 94, + 1485, + 9, + 94, + 1, + 94, + 1, + 94, + 1, + 95, + 1, + 95, + 3, + 95, + 1491, + 8, + 95, + 1, + 95, + 5, + 95, + 1494, + 8, + 95, + 10, + 95, + 12, + 95, + 1497, + 9, + 95, + 1, + 96, + 1, + 96, + 3, + 96, + 1501, + 8, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 3, + 96, + 1506, + 8, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 3, + 96, + 1511, + 8, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 3, + 96, + 1516, + 8, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 3, + 96, + 1521, + 8, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 3, + 96, + 1526, + 8, + 96, + 1, + 96, + 3, + 96, + 1529, + 8, + 96, + 1, + 97, + 1, + 97, + 1, + 97, + 1, + 97, + 5, + 97, + 1535, + 8, + 97, + 10, + 97, + 12, + 97, + 1538, + 9, + 97, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 3, + 98, + 1551, + 8, + 98, + 1, + 98, + 3, + 98, + 1554, + 8, + 98, + 1, + 98, + 1, + 98, + 1, + 99, + 1, + 99, + 1, + 99, + 3, + 99, + 1561, + 8, + 99, + 1, + 99, + 1, + 99, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 3, + 100, + 1575, + 8, + 100, + 1, + 101, + 3, + 101, + 1578, + 8, + 101, + 1, + 101, + 1, + 101, + 1, + 102, + 1, + 102, + 3, + 102, + 1584, + 8, + 102, + 1, + 102, + 1, + 102, + 3, + 102, + 1588, + 8, + 102, + 1, + 102, + 1, + 102, + 3, + 102, + 1592, + 8, + 102, + 1, + 102, + 1, + 102, + 3, + 102, + 1596, + 8, + 102, + 1, + 102, + 5, + 102, + 1599, + 8, + 102, + 10, + 102, + 12, + 102, + 1602, + 9, + 102, + 1, + 103, + 1, + 103, + 3, + 103, + 1606, + 8, + 103, + 1, + 103, + 1, + 103, + 3, + 103, + 1610, + 8, + 103, + 1, + 103, + 1, + 103, + 3, + 103, + 1614, + 8, + 103, + 1, + 103, + 1, + 103, + 3, + 103, + 1618, + 8, + 103, + 1, + 103, + 1, + 103, + 3, + 103, + 1622, + 8, + 103, + 1, + 103, + 1, + 103, + 3, + 103, + 1626, + 8, + 103, + 1, + 103, + 5, + 103, + 1629, + 8, + 103, + 10, + 103, + 12, + 103, + 1632, + 9, + 103, + 1, + 104, + 1, + 104, + 3, + 104, + 1636, + 8, + 104, + 1, + 104, + 1, + 104, + 3, + 104, + 1640, + 8, + 104, + 1, + 104, + 5, + 104, + 1643, + 8, + 104, + 10, + 104, + 12, + 104, + 1646, + 9, + 104, + 1, + 105, + 1, + 105, + 1, + 105, + 3, + 105, + 1651, + 8, + 105, + 1, + 105, + 3, + 105, + 1654, + 8, + 105, + 1, + 106, + 1, + 106, + 3, + 106, + 1658, + 8, + 106, + 1, + 106, + 1, + 106, + 3, + 106, + 1662, + 8, + 106, + 1, + 106, + 5, + 106, + 1665, + 8, + 106, + 10, + 106, + 12, + 106, + 1668, + 9, + 106, + 1, + 106, + 3, + 106, + 1671, + 8, + 106, + 1, + 106, + 3, + 106, + 1674, + 8, + 106, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 107, + 3, + 107, + 1682, + 8, + 107, + 1, + 107, + 1, + 107, + 3, + 107, + 1686, + 8, + 107, + 1, + 107, + 3, + 107, + 1689, + 8, + 107, + 1, + 108, + 1, + 108, + 3, + 108, + 1693, + 8, + 108, + 1, + 108, + 1, + 108, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 3, + 109, + 1703, + 8, + 109, + 1, + 109, + 1, + 109, + 3, + 109, + 1707, + 8, + 109, + 1, + 109, + 1, + 109, + 3, + 109, + 1711, + 8, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 3, + 109, + 1725, + 8, + 109, + 1, + 110, + 1, + 110, + 3, + 110, + 1729, + 8, + 110, + 1, + 110, + 4, + 110, + 1732, + 8, + 110, + 11, + 110, + 12, + 110, + 1733, + 1, + 110, + 1, + 110, + 3, + 110, + 1738, + 8, + 110, + 1, + 110, + 1, + 110, + 3, + 110, + 1742, + 8, + 110, + 1, + 110, + 4, + 110, + 1745, + 8, + 110, + 11, + 110, + 12, + 110, + 1746, + 3, + 110, + 1749, + 8, + 110, + 1, + 110, + 3, + 110, + 1752, + 8, + 110, + 1, + 110, + 1, + 110, + 3, + 110, + 1756, + 8, + 110, + 1, + 110, + 3, + 110, + 1759, + 8, + 110, + 1, + 110, + 3, + 110, + 1762, + 8, + 110, + 1, + 110, + 1, + 110, + 1, + 111, + 1, + 111, + 3, + 111, + 1768, + 8, + 111, + 1, + 111, + 1, + 111, + 3, + 111, + 1772, + 8, + 111, + 1, + 111, + 1, + 111, + 3, + 111, + 1776, + 8, + 111, + 1, + 111, + 1, + 111, + 1, + 112, + 1, + 112, + 3, + 112, + 1782, + 8, + 112, + 1, + 112, + 1, + 112, + 3, + 112, + 1786, + 8, + 112, + 1, + 112, + 1, + 112, + 3, + 112, + 1790, + 8, + 112, + 1, + 112, + 3, + 112, + 1793, + 8, + 112, + 1, + 112, + 3, + 112, + 1796, + 8, + 112, + 1, + 112, + 1, + 112, + 1, + 113, + 1, + 113, + 3, + 113, + 1802, + 8, + 113, + 1, + 113, + 1, + 113, + 3, + 113, + 1806, + 8, + 113, + 1, + 113, + 1, + 113, + 3, + 113, + 1810, + 8, + 113, + 3, + 113, + 1812, + 8, + 113, + 1, + 113, + 1, + 113, + 3, + 113, + 1816, + 8, + 113, + 1, + 113, + 1, + 113, + 3, + 113, + 1820, + 8, + 113, + 3, + 113, + 1822, + 8, + 113, + 1, + 113, + 1, + 113, + 3, + 113, + 1826, + 8, + 113, + 1, + 113, + 1, + 113, + 3, + 113, + 1830, + 8, + 113, + 1, + 113, + 1, + 113, + 1, + 114, + 1, + 114, + 3, + 114, + 1836, + 8, + 114, + 1, + 114, + 1, + 114, + 3, + 114, + 1840, + 8, + 114, + 1, + 114, + 1, + 114, + 3, + 114, + 1844, + 8, + 114, + 1, + 114, + 1, + 114, + 1, + 114, + 1, + 114, + 3, + 114, + 1850, + 8, + 114, + 1, + 114, + 1, + 114, + 3, + 114, + 1854, + 8, + 114, + 1, + 114, + 1, + 114, + 3, + 114, + 1858, + 8, + 114, + 1, + 114, + 3, + 114, + 1861, + 8, + 114, + 1, + 114, + 1, + 114, + 3, + 114, + 1865, + 8, + 114, + 1, + 114, + 1, + 114, + 3, + 114, + 1869, + 8, + 114, + 1, + 115, + 1, + 115, + 3, + 115, + 1873, + 8, + 115, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 116, + 1, + 116, + 3, + 116, + 1887, + 8, + 116, + 1, + 116, + 1, + 116, + 3, + 116, + 1891, + 8, + 116, + 1, + 116, + 1, + 116, + 3, + 116, + 1895, + 8, + 116, + 1, + 116, + 1, + 116, + 1, + 116, + 1, + 116, + 3, + 116, + 1901, + 8, + 116, + 1, + 116, + 1, + 116, + 3, + 116, + 1905, + 8, + 116, + 1, + 116, + 1, + 116, + 3, + 116, + 1909, + 8, + 116, + 1, + 116, + 1, + 116, + 1, + 116, + 1, + 116, + 3, + 116, + 1915, + 8, + 116, + 1, + 116, + 1, + 116, + 3, + 116, + 1919, + 8, + 116, + 1, + 116, + 1, + 116, + 3, + 116, + 1923, + 8, + 116, + 1, + 116, + 1, + 116, + 1, + 116, + 1, + 116, + 3, + 116, + 1929, + 8, + 116, + 1, + 116, + 1, + 116, + 3, + 116, + 1933, + 8, + 116, + 1, + 116, + 1, + 116, + 3, + 116, + 1937, + 8, + 116, + 1, + 116, + 1, + 116, + 3, + 116, + 1941, + 8, + 116, + 1, + 117, + 1, + 117, + 3, + 117, + 1945, + 8, + 117, + 1, + 117, + 3, + 117, + 1948, + 8, + 117, + 1, + 118, + 1, + 118, + 1, + 119, + 1, + 119, + 3, + 119, + 1954, + 8, + 119, + 1, + 119, + 1, + 119, + 3, + 119, + 1958, + 8, + 119, + 1, + 119, + 1, + 119, + 1, + 120, + 1, + 120, + 1, + 120, + 1, + 120, + 1, + 120, + 1, + 120, + 1, + 121, + 1, + 121, + 3, + 121, + 1970, + 8, + 121, + 1, + 121, + 1, + 121, + 3, + 121, + 1974, + 8, + 121, + 1, + 121, + 1, + 121, + 3, + 121, + 1978, + 8, + 121, + 3, + 121, + 1980, + 8, + 121, + 1, + 121, + 1, + 121, + 3, + 121, + 1984, + 8, + 121, + 1, + 121, + 1, + 121, + 3, + 121, + 1988, + 8, + 121, + 1, + 121, + 1, + 121, + 3, + 121, + 1992, + 8, + 121, + 5, + 121, + 1994, + 8, + 121, + 10, + 121, + 12, + 121, + 1997, + 9, + 121, + 3, + 121, + 1999, + 8, + 121, + 1, + 121, + 1, + 121, + 1, + 122, + 1, + 122, + 1, + 122, + 1, + 123, + 1, + 123, + 3, + 123, + 2008, + 8, + 123, + 1, + 123, + 1, + 123, + 3, + 123, + 2012, + 8, + 123, + 1, + 123, + 1, + 123, + 1, + 123, + 3, + 123, + 2017, + 8, + 123, + 1, + 123, + 3, + 123, + 2020, + 8, + 123, + 3, + 123, + 2022, + 8, + 123, + 1, + 123, + 3, + 123, + 2025, + 8, + 123, + 1, + 123, + 1, + 123, + 1, + 124, + 1, + 124, + 3, + 124, + 2031, + 8, + 124, + 1, + 124, + 1, + 124, + 3, + 124, + 2035, + 8, + 124, + 1, + 124, + 1, + 124, + 3, + 124, + 2039, + 8, + 124, + 1, + 124, + 1, + 124, + 3, + 124, + 2043, + 8, + 124, + 1, + 124, + 1, + 124, + 3, + 124, + 2047, + 8, + 124, + 5, + 124, + 2049, + 8, + 124, + 10, + 124, + 12, + 124, + 2052, + 9, + 124, + 3, + 124, + 2054, + 8, + 124, + 1, + 124, + 1, + 124, + 1, + 125, + 1, + 125, + 1, + 126, + 1, + 126, + 1, + 127, + 1, + 127, + 1, + 127, + 1, + 128, + 1, + 128, + 1, + 128, + 5, + 128, + 2068, + 8, + 128, + 10, + 128, + 12, + 128, + 2071, + 9, + 128, + 1, + 129, + 1, + 129, + 1, + 130, + 1, + 130, + 1, + 130, + 1, + 130, + 1, + 130, + 1, + 130, + 3, + 130, + 2081, + 8, + 130, + 1, + 131, + 1, + 131, + 1, + 132, + 1, + 132, + 3, + 132, + 2087, + 8, + 132, + 1, + 133, + 1, + 133, + 1, + 134, + 1, + 134, + 1, + 135, + 1, + 135, + 3, + 135, + 2095, + 8, + 135, + 1, + 135, + 1, + 135, + 3, + 135, + 2099, + 8, + 135, + 1, + 135, + 1, + 135, + 3, + 135, + 2103, + 8, + 135, + 1, + 135, + 1, + 135, + 3, + 135, + 2107, + 8, + 135, + 5, + 135, + 2109, + 8, + 135, + 10, + 135, + 12, + 135, + 2112, + 9, + 135, + 3, + 135, + 2114, + 8, + 135, + 1, + 135, + 1, + 135, + 1, + 136, + 1, + 136, + 3, + 136, + 2120, + 8, + 136, + 1, + 136, + 1, + 136, + 3, + 136, + 2124, + 8, + 136, + 1, + 136, + 1, + 136, + 3, + 136, + 2128, + 8, + 136, + 1, + 136, + 1, + 136, + 3, + 136, + 2132, + 8, + 136, + 1, + 136, + 1, + 136, + 3, + 136, + 2136, + 8, + 136, + 1, + 136, + 1, + 136, + 3, + 136, + 2140, + 8, + 136, + 1, + 136, + 1, + 136, + 3, + 136, + 2144, + 8, + 136, + 1, + 136, + 1, + 136, + 3, + 136, + 2148, + 8, + 136, + 5, + 136, + 2150, + 8, + 136, + 10, + 136, + 12, + 136, + 2153, + 9, + 136, + 3, + 136, + 2155, + 8, + 136, + 1, + 136, + 1, + 136, + 1, + 137, + 1, + 137, + 1, + 138, + 1, + 138, + 3, + 138, + 2163, + 8, + 138, + 1, + 138, + 1, + 138, + 3, + 138, + 2167, + 8, + 138, + 1, + 138, + 3, + 138, + 2170, + 8, + 138, + 1, + 138, + 1, + 138, + 1, + 139, + 1, + 139, + 1, + 139, + 3, + 139, + 2177, + 8, + 139, + 1, + 140, + 1, + 140, + 3, + 140, + 2181, + 8, + 140, + 1, + 141, + 1, + 141, + 1, + 142, + 1, + 142, + 1, + 143, + 1, + 143, + 1, + 144, + 1, + 144, + 1, + 145, + 1, + 145, + 1, + 145, + 0, + 0, + 146, + 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, + 0, + 11, + 1, + 0, + 89, + 92, + 1, + 0, + 97, + 98, + 1, + 0, + 19, + 20, + 1, + 0, + 122, + 123, + 1, + 0, + 124, + 126, + 1, + 0, + 134, + 135, + 13, + 0, + 53, + 56, + 58, + 59, + 61, + 63, + 66, + 66, + 69, + 69, + 71, + 78, + 80, + 80, + 83, + 92, + 99, + 99, + 102, + 109, + 111, + 115, + 122, + 123, + 138, + 144, + 6, + 0, + 110, + 110, + 116, + 117, + 119, + 121, + 127, + 127, + 145, + 145, + 148, + 148, + 2, + 0, + 14, + 14, + 28, + 31, + 2, + 0, + 15, + 15, + 32, + 35, + 2, + 0, + 20, + 20, + 36, + 46, + 2465, + 0, + 293, + 1, + 0, + 0, + 0, + 2, + 314, + 1, + 0, + 0, + 0, + 4, + 320, + 1, + 0, + 0, + 0, + 6, + 322, + 1, + 0, + 0, + 0, + 8, + 334, + 1, + 0, + 0, + 0, + 10, + 336, + 1, + 0, + 0, + 0, + 12, + 338, + 1, + 0, + 0, + 0, + 14, + 340, + 1, + 0, + 0, + 0, + 16, + 352, + 1, + 0, + 0, + 0, + 18, + 357, + 1, + 0, + 0, + 0, + 20, + 359, + 1, + 0, + 0, + 0, + 22, + 369, + 1, + 0, + 0, + 0, + 24, + 375, + 1, + 0, + 0, + 0, + 26, + 384, + 1, + 0, + 0, + 0, + 28, + 399, + 1, + 0, + 0, + 0, + 30, + 403, + 1, + 0, + 0, + 0, + 32, + 440, + 1, + 0, + 0, + 0, + 34, + 464, + 1, + 0, + 0, + 0, + 36, + 477, + 1, + 0, + 0, + 0, + 38, + 484, + 1, + 0, + 0, + 0, + 40, + 494, + 1, + 0, + 0, + 0, + 42, + 496, + 1, + 0, + 0, + 0, + 44, + 500, + 1, + 0, + 0, + 0, + 46, + 504, + 1, + 0, + 0, + 0, + 48, + 508, + 1, + 0, + 0, + 0, + 50, + 512, + 1, + 0, + 0, + 0, + 52, + 516, + 1, + 0, + 0, + 0, + 54, + 520, + 1, + 0, + 0, + 0, + 56, + 524, + 1, + 0, + 0, + 0, + 58, + 528, + 1, + 0, + 0, + 0, + 60, + 539, + 1, + 0, + 0, + 0, + 62, + 560, + 1, + 0, + 0, + 0, + 64, + 583, + 1, + 0, + 0, + 0, + 66, + 656, + 1, + 0, + 0, + 0, + 68, + 658, + 1, + 0, + 0, + 0, + 70, + 683, + 1, + 0, + 0, + 0, + 72, + 702, + 1, + 0, + 0, + 0, + 74, + 712, + 1, + 0, + 0, + 0, + 76, + 734, + 1, + 0, + 0, + 0, + 78, + 736, + 1, + 0, + 0, + 0, + 80, + 742, + 1, + 0, + 0, + 0, + 82, + 750, + 1, + 0, + 0, + 0, + 84, + 804, + 1, + 0, + 0, + 0, + 86, + 808, + 1, + 0, + 0, + 0, + 88, + 828, + 1, + 0, + 0, + 0, + 90, + 848, + 1, + 0, + 0, + 0, + 92, + 850, + 1, + 0, + 0, + 0, + 94, + 878, + 1, + 0, + 0, + 0, + 96, + 889, + 1, + 0, + 0, + 0, + 98, + 906, + 1, + 0, + 0, + 0, + 100, + 931, + 1, + 0, + 0, + 0, + 102, + 935, + 1, + 0, + 0, + 0, + 104, + 943, + 1, + 0, + 0, + 0, + 106, + 950, + 1, + 0, + 0, + 0, + 108, + 994, + 1, + 0, + 0, + 0, + 110, + 1003, + 1, + 0, + 0, + 0, + 112, + 1005, + 1, + 0, + 0, + 0, + 114, + 1020, + 1, + 0, + 0, + 0, + 116, + 1024, + 1, + 0, + 0, + 0, + 118, + 1028, + 1, + 0, + 0, + 0, + 120, + 1036, + 1, + 0, + 0, + 0, + 122, + 1077, + 1, + 0, + 0, + 0, + 124, + 1096, + 1, + 0, + 0, + 0, + 126, + 1108, + 1, + 0, + 0, + 0, + 128, + 1110, + 1, + 0, + 0, + 0, + 130, + 1119, + 1, + 0, + 0, + 0, + 132, + 1125, + 1, + 0, + 0, + 0, + 134, + 1136, + 1, + 0, + 0, + 0, + 136, + 1145, + 1, + 0, + 0, + 0, + 138, + 1153, + 1, + 0, + 0, + 0, + 140, + 1167, + 1, + 0, + 0, + 0, + 142, + 1171, + 1, + 0, + 0, + 0, + 144, + 1196, + 1, + 0, + 0, + 0, + 146, + 1200, + 1, + 0, + 0, + 0, + 148, + 1212, + 1, + 0, + 0, + 0, + 150, + 1228, + 1, + 0, + 0, + 0, + 152, + 1230, + 1, + 0, + 0, + 0, + 154, + 1239, + 1, + 0, + 0, + 0, + 156, + 1263, + 1, + 0, + 0, + 0, + 158, + 1333, + 1, + 0, + 0, + 0, + 160, + 1335, + 1, + 0, + 0, + 0, + 162, + 1365, + 1, + 0, + 0, + 0, + 164, + 1367, + 1, + 0, + 0, + 0, + 166, + 1373, + 1, + 0, + 0, + 0, + 168, + 1394, + 1, + 0, + 0, + 0, + 170, + 1404, + 1, + 0, + 0, + 0, + 172, + 1410, + 1, + 0, + 0, + 0, + 174, + 1432, + 1, + 0, + 0, + 0, + 176, + 1434, + 1, + 0, + 0, + 0, + 178, + 1436, + 1, + 0, + 0, + 0, + 180, + 1445, + 1, + 0, + 0, + 0, + 182, + 1447, + 1, + 0, + 0, + 0, + 184, + 1457, + 1, + 0, + 0, + 0, + 186, + 1467, + 1, + 0, + 0, + 0, + 188, + 1483, + 1, + 0, + 0, + 0, + 190, + 1488, + 1, + 0, + 0, + 0, + 192, + 1528, + 1, + 0, + 0, + 0, + 194, + 1530, + 1, + 0, + 0, + 0, + 196, + 1550, + 1, + 0, + 0, + 0, + 198, + 1557, + 1, + 0, + 0, + 0, + 200, + 1574, + 1, + 0, + 0, + 0, + 202, + 1577, + 1, + 0, + 0, + 0, + 204, + 1581, + 1, + 0, + 0, + 0, + 206, + 1603, + 1, + 0, + 0, + 0, + 208, + 1633, + 1, + 0, + 0, + 0, + 210, + 1653, + 1, + 0, + 0, + 0, + 212, + 1655, + 1, + 0, + 0, + 0, + 214, + 1688, + 1, + 0, + 0, + 0, + 216, + 1690, + 1, + 0, + 0, + 0, + 218, + 1724, + 1, + 0, + 0, + 0, + 220, + 1748, + 1, + 0, + 0, + 0, + 222, + 1765, + 1, + 0, + 0, + 0, + 224, + 1779, + 1, + 0, + 0, + 0, + 226, + 1799, + 1, + 0, + 0, + 0, + 228, + 1868, + 1, + 0, + 0, + 0, + 230, + 1870, + 1, + 0, + 0, + 0, + 232, + 1940, + 1, + 0, + 0, + 0, + 234, + 1942, + 1, + 0, + 0, + 0, + 236, + 1949, + 1, + 0, + 0, + 0, + 238, + 1951, + 1, + 0, + 0, + 0, + 240, + 1961, + 1, + 0, + 0, + 0, + 242, + 1967, + 1, + 0, + 0, + 0, + 244, + 2002, + 1, + 0, + 0, + 0, + 246, + 2005, + 1, + 0, + 0, + 0, + 248, + 2028, + 1, + 0, + 0, + 0, + 250, + 2057, + 1, + 0, + 0, + 0, + 252, + 2059, + 1, + 0, + 0, + 0, + 254, + 2061, + 1, + 0, + 0, + 0, + 256, + 2069, + 1, + 0, + 0, + 0, + 258, + 2072, + 1, + 0, + 0, + 0, + 260, + 2080, + 1, + 0, + 0, + 0, + 262, + 2082, + 1, + 0, + 0, + 0, + 264, + 2086, + 1, + 0, + 0, + 0, + 266, + 2088, + 1, + 0, + 0, + 0, + 268, + 2090, + 1, + 0, + 0, + 0, + 270, + 2092, + 1, + 0, + 0, + 0, + 272, + 2117, + 1, + 0, + 0, + 0, + 274, + 2158, + 1, + 0, + 0, + 0, + 276, + 2160, + 1, + 0, + 0, + 0, + 278, + 2173, + 1, + 0, + 0, + 0, + 280, + 2180, + 1, + 0, + 0, + 0, + 282, + 2182, + 1, + 0, + 0, + 0, + 284, + 2184, + 1, + 0, + 0, + 0, + 286, + 2186, + 1, + 0, + 0, + 0, + 288, + 2188, + 1, + 0, + 0, + 0, + 290, + 2190, + 1, + 0, + 0, + 0, + 292, + 294, + 5, + 149, + 0, + 0, + 293, + 292, + 1, + 0, + 0, + 0, + 293, + 294, + 1, + 0, + 0, + 0, + 294, + 295, + 1, + 0, + 0, + 0, + 295, + 296, + 3, + 2, + 1, + 0, + 296, + 301, + 3, + 16, + 8, + 0, + 297, + 299, + 5, + 149, + 0, + 0, + 298, + 297, + 1, + 0, + 0, + 0, + 298, + 299, + 1, + 0, + 0, + 0, + 299, + 300, + 1, + 0, + 0, + 0, + 300, + 302, + 5, + 1, + 0, + 0, + 301, + 298, + 1, + 0, + 0, + 0, + 301, + 302, + 1, + 0, + 0, + 0, + 302, + 304, + 1, + 0, + 0, + 0, + 303, + 305, + 5, + 149, + 0, + 0, + 304, + 303, + 1, + 0, + 0, + 0, + 304, + 305, + 1, + 0, + 0, + 0, + 305, + 306, + 1, + 0, + 0, + 0, + 306, + 307, + 5, + 0, + 0, + 1, + 307, + 1, + 1, + 0, + 0, + 0, + 308, + 310, + 3, + 4, + 2, + 0, + 309, + 311, + 5, + 149, + 0, + 0, + 310, + 309, + 1, + 0, + 0, + 0, + 310, + 311, + 1, + 0, + 0, + 0, + 311, + 313, + 1, + 0, + 0, + 0, + 312, + 308, + 1, + 0, + 0, + 0, + 313, + 316, + 1, + 0, + 0, + 0, + 314, + 312, + 1, + 0, + 0, + 0, + 314, + 315, + 1, + 0, + 0, + 0, + 315, + 3, + 1, + 0, + 0, + 0, + 316, + 314, + 1, + 0, + 0, + 0, + 317, + 321, + 3, + 6, + 3, + 0, + 318, + 321, + 3, + 10, + 5, + 0, + 319, + 321, + 3, + 12, + 6, + 0, + 320, + 317, + 1, + 0, + 0, + 0, + 320, + 318, + 1, + 0, + 0, + 0, + 320, + 319, + 1, + 0, + 0, + 0, + 321, + 5, + 1, + 0, + 0, + 0, + 322, + 325, + 5, + 47, + 0, + 0, + 323, + 324, + 5, + 149, + 0, + 0, + 324, + 326, + 3, + 8, + 4, + 0, + 325, + 323, + 1, + 0, + 0, + 0, + 325, + 326, + 1, + 0, + 0, + 0, + 326, + 331, + 1, + 0, + 0, + 0, + 327, + 328, + 5, + 149, + 0, + 0, + 328, + 330, + 3, + 14, + 7, + 0, + 329, + 327, + 1, + 0, + 0, + 0, + 330, + 333, + 1, + 0, + 0, + 0, + 331, + 329, + 1, + 0, + 0, + 0, + 331, + 332, + 1, + 0, + 0, + 0, + 332, + 7, + 1, + 0, + 0, + 0, + 333, + 331, + 1, + 0, + 0, + 0, + 334, + 335, + 5, + 135, + 0, + 0, + 335, + 9, + 1, + 0, + 0, + 0, + 336, + 337, + 5, + 48, + 0, + 0, + 337, + 11, + 1, + 0, + 0, + 0, + 338, + 339, + 5, + 49, + 0, + 0, + 339, + 13, + 1, + 0, + 0, + 0, + 340, + 342, + 3, + 284, + 142, + 0, + 341, + 343, + 5, + 149, + 0, + 0, + 342, + 341, + 1, + 0, + 0, + 0, + 342, + 343, + 1, + 0, + 0, + 0, + 343, + 344, + 1, + 0, + 0, + 0, + 344, + 346, + 5, + 2, + 0, + 0, + 345, + 347, + 5, + 149, + 0, + 0, + 346, + 345, + 1, + 0, + 0, + 0, + 346, + 347, + 1, + 0, + 0, + 0, + 347, + 348, + 1, + 0, + 0, + 0, + 348, + 349, + 3, + 284, + 142, + 0, + 349, + 15, + 1, + 0, + 0, + 0, + 350, + 353, + 3, + 40, + 20, + 0, + 351, + 353, + 3, + 18, + 9, + 0, + 352, + 350, + 1, + 0, + 0, + 0, + 352, + 351, + 1, + 0, + 0, + 0, + 353, + 17, + 1, + 0, + 0, + 0, + 354, + 358, + 3, + 20, + 10, + 0, + 355, + 358, + 3, + 96, + 48, + 0, + 356, + 358, + 3, + 22, + 11, + 0, + 357, + 354, + 1, + 0, + 0, + 0, + 357, + 355, + 1, + 0, + 0, + 0, + 357, + 356, + 1, + 0, + 0, + 0, + 358, + 19, + 1, + 0, + 0, + 0, + 359, + 366, + 3, + 30, + 15, + 0, + 360, + 362, + 5, + 149, + 0, + 0, + 361, + 360, + 1, + 0, + 0, + 0, + 361, + 362, + 1, + 0, + 0, + 0, + 362, + 363, + 1, + 0, + 0, + 0, + 363, + 365, + 3, + 28, + 14, + 0, + 364, + 361, + 1, + 0, + 0, + 0, + 365, + 368, + 1, + 0, + 0, + 0, + 366, + 364, + 1, + 0, + 0, + 0, + 366, + 367, + 1, + 0, + 0, + 0, + 367, + 21, + 1, + 0, + 0, + 0, + 368, + 366, + 1, + 0, + 0, + 0, + 369, + 371, + 3, + 24, + 12, + 0, + 370, + 372, + 5, + 149, + 0, + 0, + 371, + 370, + 1, + 0, + 0, + 0, + 371, + 372, + 1, + 0, + 0, + 0, + 372, + 373, + 1, + 0, + 0, + 0, + 373, + 374, + 3, + 26, + 13, + 0, + 374, + 23, + 1, + 0, + 0, + 0, + 375, + 376, + 5, + 50, + 0, + 0, + 376, + 377, + 5, + 149, + 0, + 0, + 377, + 378, + 5, + 51, + 0, + 0, + 378, + 379, + 5, + 149, + 0, + 0, + 379, + 382, + 5, + 52, + 0, + 0, + 380, + 381, + 5, + 149, + 0, + 0, + 381, + 383, + 3, + 266, + 133, + 0, + 382, + 380, + 1, + 0, + 0, + 0, + 382, + 383, + 1, + 0, + 0, + 0, + 383, + 25, + 1, + 0, + 0, + 0, + 384, + 385, + 3, + 68, + 34, + 0, + 385, + 386, + 3, + 30, + 15, + 0, + 386, + 27, + 1, + 0, + 0, + 0, + 387, + 388, + 5, + 53, + 0, + 0, + 388, + 389, + 5, + 149, + 0, + 0, + 389, + 391, + 5, + 54, + 0, + 0, + 390, + 392, + 5, + 149, + 0, + 0, + 391, + 390, + 1, + 0, + 0, + 0, + 391, + 392, + 1, + 0, + 0, + 0, + 392, + 393, + 1, + 0, + 0, + 0, + 393, + 400, + 3, + 30, + 15, + 0, + 394, + 396, + 5, + 53, + 0, + 0, + 395, + 397, + 5, + 149, + 0, + 0, + 396, + 395, + 1, + 0, + 0, + 0, + 396, + 397, + 1, + 0, + 0, + 0, + 397, + 398, + 1, + 0, + 0, + 0, + 398, + 400, + 3, + 30, + 15, + 0, + 399, + 387, + 1, + 0, + 0, + 0, + 399, + 394, + 1, + 0, + 0, + 0, + 400, + 29, + 1, + 0, + 0, + 0, + 401, + 404, + 3, + 32, + 16, + 0, + 402, + 404, + 3, + 34, + 17, + 0, + 403, + 401, + 1, + 0, + 0, + 0, + 403, + 402, + 1, + 0, + 0, + 0, + 404, + 31, + 1, + 0, + 0, + 0, + 405, + 407, + 3, + 38, + 19, + 0, + 406, + 408, + 5, + 149, + 0, + 0, + 407, + 406, + 1, + 0, + 0, + 0, + 407, + 408, + 1, + 0, + 0, + 0, + 408, + 410, + 1, + 0, + 0, + 0, + 409, + 405, + 1, + 0, + 0, + 0, + 410, + 413, + 1, + 0, + 0, + 0, + 411, + 409, + 1, + 0, + 0, + 0, + 411, + 412, + 1, + 0, + 0, + 0, + 412, + 414, + 1, + 0, + 0, + 0, + 413, + 411, + 1, + 0, + 0, + 0, + 414, + 441, + 3, + 104, + 52, + 0, + 415, + 417, + 3, + 38, + 19, + 0, + 416, + 418, + 5, + 149, + 0, + 0, + 417, + 416, + 1, + 0, + 0, + 0, + 417, + 418, + 1, + 0, + 0, + 0, + 418, + 420, + 1, + 0, + 0, + 0, + 419, + 415, + 1, + 0, + 0, + 0, + 420, + 423, + 1, + 0, + 0, + 0, + 421, + 419, + 1, + 0, + 0, + 0, + 421, + 422, + 1, + 0, + 0, + 0, + 422, + 424, + 1, + 0, + 0, + 0, + 423, + 421, + 1, + 0, + 0, + 0, + 424, + 431, + 3, + 36, + 18, + 0, + 425, + 427, + 5, + 149, + 0, + 0, + 426, + 425, + 1, + 0, + 0, + 0, + 426, + 427, + 1, + 0, + 0, + 0, + 427, + 428, + 1, + 0, + 0, + 0, + 428, + 430, + 3, + 36, + 18, + 0, + 429, + 426, + 1, + 0, + 0, + 0, + 430, + 433, + 1, + 0, + 0, + 0, + 431, + 429, + 1, + 0, + 0, + 0, + 431, + 432, + 1, + 0, + 0, + 0, + 432, + 438, + 1, + 0, + 0, + 0, + 433, + 431, + 1, + 0, + 0, + 0, + 434, + 436, + 5, + 149, + 0, + 0, + 435, + 434, + 1, + 0, + 0, + 0, + 435, + 436, + 1, + 0, + 0, + 0, + 436, + 437, + 1, + 0, + 0, + 0, + 437, + 439, + 3, + 104, + 52, + 0, + 438, + 435, + 1, + 0, + 0, + 0, + 438, + 439, + 1, + 0, + 0, + 0, + 439, + 441, + 1, + 0, + 0, + 0, + 440, + 411, + 1, + 0, + 0, + 0, + 440, + 421, + 1, + 0, + 0, + 0, + 441, + 33, + 1, + 0, + 0, + 0, + 442, + 444, + 3, + 38, + 19, + 0, + 443, + 445, + 5, + 149, + 0, + 0, + 444, + 443, + 1, + 0, + 0, + 0, + 444, + 445, + 1, + 0, + 0, + 0, + 445, + 447, + 1, + 0, + 0, + 0, + 446, + 442, + 1, + 0, + 0, + 0, + 447, + 450, + 1, + 0, + 0, + 0, + 448, + 446, + 1, + 0, + 0, + 0, + 448, + 449, + 1, + 0, + 0, + 0, + 449, + 457, + 1, + 0, + 0, + 0, + 450, + 448, + 1, + 0, + 0, + 0, + 451, + 453, + 3, + 36, + 18, + 0, + 452, + 454, + 5, + 149, + 0, + 0, + 453, + 452, + 1, + 0, + 0, + 0, + 453, + 454, + 1, + 0, + 0, + 0, + 454, + 456, + 1, + 0, + 0, + 0, + 455, + 451, + 1, + 0, + 0, + 0, + 456, + 459, + 1, + 0, + 0, + 0, + 457, + 455, + 1, + 0, + 0, + 0, + 457, + 458, + 1, + 0, + 0, + 0, + 458, + 460, + 1, + 0, + 0, + 0, + 459, + 457, + 1, + 0, + 0, + 0, + 460, + 462, + 3, + 102, + 51, + 0, + 461, + 463, + 5, + 149, + 0, + 0, + 462, + 461, + 1, + 0, + 0, + 0, + 462, + 463, + 1, + 0, + 0, + 0, + 463, + 465, + 1, + 0, + 0, + 0, + 464, + 448, + 1, + 0, + 0, + 0, + 465, + 466, + 1, + 0, + 0, + 0, + 466, + 464, + 1, + 0, + 0, + 0, + 466, + 467, + 1, + 0, + 0, + 0, + 467, + 468, + 1, + 0, + 0, + 0, + 468, + 469, + 3, + 32, + 16, + 0, + 469, + 35, + 1, + 0, + 0, + 0, + 470, + 478, + 3, + 78, + 39, + 0, + 471, + 478, + 3, + 74, + 37, + 0, + 472, + 478, + 3, + 80, + 40, + 0, + 473, + 478, + 3, + 92, + 46, + 0, + 474, + 478, + 3, + 86, + 43, + 0, + 475, + 478, + 3, + 82, + 41, + 0, + 476, + 478, + 3, + 88, + 44, + 0, + 477, + 470, + 1, + 0, + 0, + 0, + 477, + 471, + 1, + 0, + 0, + 0, + 477, + 472, + 1, + 0, + 0, + 0, + 477, + 473, + 1, + 0, + 0, + 0, + 477, + 474, + 1, + 0, + 0, + 0, + 477, + 475, + 1, + 0, + 0, + 0, + 477, + 476, + 1, + 0, + 0, + 0, + 478, + 37, + 1, + 0, + 0, + 0, + 479, + 485, + 3, + 68, + 34, + 0, + 480, + 485, + 3, + 122, + 61, + 0, + 481, + 485, + 3, + 70, + 35, + 0, + 482, + 485, + 3, + 72, + 36, + 0, + 483, + 485, + 3, + 94, + 47, + 0, + 484, + 479, + 1, + 0, + 0, + 0, + 484, + 480, + 1, + 0, + 0, + 0, + 484, + 481, + 1, + 0, + 0, + 0, + 484, + 482, + 1, + 0, + 0, + 0, + 484, + 483, + 1, + 0, + 0, + 0, + 485, + 39, + 1, + 0, + 0, + 0, + 486, + 495, + 3, + 48, + 24, + 0, + 487, + 495, + 3, + 56, + 28, + 0, + 488, + 495, + 3, + 42, + 21, + 0, + 489, + 495, + 3, + 50, + 25, + 0, + 490, + 495, + 3, + 44, + 22, + 0, + 491, + 495, + 3, + 52, + 26, + 0, + 492, + 495, + 3, + 46, + 23, + 0, + 493, + 495, + 3, + 54, + 27, + 0, + 494, + 486, + 1, + 0, + 0, + 0, + 494, + 487, + 1, + 0, + 0, + 0, + 494, + 488, + 1, + 0, + 0, + 0, + 494, + 489, + 1, + 0, + 0, + 0, + 494, + 490, + 1, + 0, + 0, + 0, + 494, + 491, + 1, + 0, + 0, + 0, + 494, + 492, + 1, + 0, + 0, + 0, + 494, + 493, + 1, + 0, + 0, + 0, + 495, + 41, + 1, + 0, + 0, + 0, + 496, + 497, + 5, + 55, + 0, + 0, + 497, + 498, + 5, + 149, + 0, + 0, + 498, + 499, + 3, + 60, + 30, + 0, + 499, + 43, + 1, + 0, + 0, + 0, + 500, + 501, + 5, + 55, + 0, + 0, + 501, + 502, + 5, + 149, + 0, + 0, + 502, + 503, + 3, + 62, + 31, + 0, + 503, + 45, + 1, + 0, + 0, + 0, + 504, + 505, + 5, + 55, + 0, + 0, + 505, + 506, + 5, + 149, + 0, + 0, + 506, + 507, + 3, + 64, + 32, + 0, + 507, + 47, + 1, + 0, + 0, + 0, + 508, + 509, + 5, + 55, + 0, + 0, + 509, + 510, + 5, + 149, + 0, + 0, + 510, + 511, + 3, + 58, + 29, + 0, + 511, + 49, + 1, + 0, + 0, + 0, + 512, + 513, + 5, + 56, + 0, + 0, + 513, + 514, + 5, + 149, + 0, + 0, + 514, + 515, + 3, + 60, + 30, + 0, + 515, + 51, + 1, + 0, + 0, + 0, + 516, + 517, + 5, + 56, + 0, + 0, + 517, + 518, + 5, + 149, + 0, + 0, + 518, + 519, + 3, + 62, + 31, + 0, + 519, + 53, + 1, + 0, + 0, + 0, + 520, + 521, + 5, + 56, + 0, + 0, + 521, + 522, + 5, + 149, + 0, + 0, + 522, + 523, + 3, + 64, + 32, + 0, + 523, + 55, + 1, + 0, + 0, + 0, + 524, + 525, + 5, + 56, + 0, + 0, + 525, + 526, + 5, + 149, + 0, + 0, + 526, + 527, + 3, + 58, + 29, + 0, + 527, + 57, + 1, + 0, + 0, + 0, + 528, + 529, + 5, + 57, + 0, + 0, + 529, + 530, + 5, + 149, + 0, + 0, + 530, + 532, + 5, + 58, + 0, + 0, + 531, + 533, + 5, + 149, + 0, + 0, + 532, + 531, + 1, + 0, + 0, + 0, + 532, + 533, + 1, + 0, + 0, + 0, + 533, + 534, + 1, + 0, + 0, + 0, + 534, + 535, + 3, + 170, + 85, + 0, + 535, + 536, + 5, + 3, + 0, + 0, + 536, + 537, + 3, + 274, + 137, + 0, + 537, + 538, + 5, + 4, + 0, + 0, + 538, + 59, + 1, + 0, + 0, + 0, + 539, + 540, + 5, + 59, + 0, + 0, + 540, + 541, + 5, + 149, + 0, + 0, + 541, + 543, + 5, + 58, + 0, + 0, + 542, + 544, + 5, + 149, + 0, + 0, + 543, + 542, + 1, + 0, + 0, + 0, + 543, + 544, + 1, + 0, + 0, + 0, + 544, + 545, + 1, + 0, + 0, + 0, + 545, + 546, + 5, + 3, + 0, + 0, + 546, + 547, + 3, + 258, + 129, + 0, + 547, + 548, + 3, + 170, + 85, + 0, + 548, + 550, + 5, + 4, + 0, + 0, + 549, + 551, + 5, + 149, + 0, + 0, + 550, + 549, + 1, + 0, + 0, + 0, + 550, + 551, + 1, + 0, + 0, + 0, + 551, + 552, + 1, + 0, + 0, + 0, + 552, + 553, + 5, + 60, + 0, + 0, + 553, + 554, + 5, + 149, + 0, + 0, + 554, + 555, + 3, + 178, + 89, + 0, + 555, + 556, + 5, + 149, + 0, + 0, + 556, + 557, + 5, + 61, + 0, + 0, + 557, + 558, + 5, + 149, + 0, + 0, + 558, + 559, + 5, + 62, + 0, + 0, + 559, + 61, + 1, + 0, + 0, + 0, + 560, + 561, + 5, + 59, + 0, + 0, + 561, + 562, + 5, + 149, + 0, + 0, + 562, + 564, + 5, + 58, + 0, + 0, + 563, + 565, + 5, + 149, + 0, + 0, + 564, + 563, + 1, + 0, + 0, + 0, + 564, + 565, + 1, + 0, + 0, + 0, + 565, + 566, + 1, + 0, + 0, + 0, + 566, + 567, + 5, + 3, + 0, + 0, + 567, + 568, + 3, + 258, + 129, + 0, + 568, + 569, + 3, + 170, + 85, + 0, + 569, + 571, + 5, + 4, + 0, + 0, + 570, + 572, + 5, + 149, + 0, + 0, + 571, + 570, + 1, + 0, + 0, + 0, + 571, + 572, + 1, + 0, + 0, + 0, + 572, + 573, + 1, + 0, + 0, + 0, + 573, + 574, + 5, + 60, + 0, + 0, + 574, + 575, + 5, + 149, + 0, + 0, + 575, + 577, + 5, + 63, + 0, + 0, + 576, + 578, + 5, + 149, + 0, + 0, + 577, + 576, + 1, + 0, + 0, + 0, + 577, + 578, + 1, + 0, + 0, + 0, + 578, + 579, + 1, + 0, + 0, + 0, + 579, + 580, + 5, + 3, + 0, + 0, + 580, + 581, + 3, + 178, + 89, + 0, + 581, + 582, + 5, + 4, + 0, + 0, + 582, + 63, + 1, + 0, + 0, + 0, + 583, + 584, + 5, + 59, + 0, + 0, + 584, + 585, + 5, + 149, + 0, + 0, + 585, + 587, + 5, + 58, + 0, + 0, + 586, + 588, + 5, + 149, + 0, + 0, + 587, + 586, + 1, + 0, + 0, + 0, + 587, + 588, + 1, + 0, + 0, + 0, + 588, + 589, + 1, + 0, + 0, + 0, + 589, + 591, + 3, + 66, + 33, + 0, + 590, + 592, + 5, + 149, + 0, + 0, + 591, + 590, + 1, + 0, + 0, + 0, + 591, + 592, + 1, + 0, + 0, + 0, + 592, + 593, + 1, + 0, + 0, + 0, + 593, + 594, + 5, + 60, + 0, + 0, + 594, + 595, + 5, + 149, + 0, + 0, + 595, + 597, + 5, + 63, + 0, + 0, + 596, + 598, + 5, + 149, + 0, + 0, + 597, + 596, + 1, + 0, + 0, + 0, + 597, + 598, + 1, + 0, + 0, + 0, + 598, + 599, + 1, + 0, + 0, + 0, + 599, + 600, + 5, + 3, + 0, + 0, + 600, + 601, + 3, + 178, + 89, + 0, + 601, + 602, + 5, + 4, + 0, + 0, + 602, + 65, + 1, + 0, + 0, + 0, + 603, + 605, + 5, + 3, + 0, + 0, + 604, + 606, + 5, + 149, + 0, + 0, + 605, + 604, + 1, + 0, + 0, + 0, + 605, + 606, + 1, + 0, + 0, + 0, + 606, + 607, + 1, + 0, + 0, + 0, + 607, + 608, + 5, + 4, + 0, + 0, + 608, + 609, + 3, + 290, + 145, + 0, + 609, + 610, + 5, + 5, + 0, + 0, + 610, + 611, + 3, + 258, + 129, + 0, + 611, + 612, + 3, + 164, + 82, + 0, + 612, + 613, + 5, + 6, + 0, + 0, + 613, + 614, + 3, + 290, + 145, + 0, + 614, + 616, + 5, + 3, + 0, + 0, + 615, + 617, + 5, + 149, + 0, + 0, + 616, + 615, + 1, + 0, + 0, + 0, + 616, + 617, + 1, + 0, + 0, + 0, + 617, + 618, + 1, + 0, + 0, + 0, + 618, + 619, + 5, + 4, + 0, + 0, + 619, + 657, + 1, + 0, + 0, + 0, + 620, + 622, + 5, + 3, + 0, + 0, + 621, + 623, + 5, + 149, + 0, + 0, + 622, + 621, + 1, + 0, + 0, + 0, + 622, + 623, + 1, + 0, + 0, + 0, + 623, + 624, + 1, + 0, + 0, + 0, + 624, + 625, + 5, + 4, + 0, + 0, + 625, + 626, + 3, + 290, + 145, + 0, + 626, + 627, + 5, + 5, + 0, + 0, + 627, + 628, + 3, + 258, + 129, + 0, + 628, + 629, + 3, + 164, + 82, + 0, + 629, + 630, + 5, + 6, + 0, + 0, + 630, + 631, + 3, + 290, + 145, + 0, + 631, + 632, + 3, + 288, + 144, + 0, + 632, + 634, + 5, + 3, + 0, + 0, + 633, + 635, + 5, + 149, + 0, + 0, + 634, + 633, + 1, + 0, + 0, + 0, + 634, + 635, + 1, + 0, + 0, + 0, + 635, + 636, + 1, + 0, + 0, + 0, + 636, + 637, + 5, + 4, + 0, + 0, + 637, + 657, + 1, + 0, + 0, + 0, + 638, + 640, + 5, + 3, + 0, + 0, + 639, + 641, + 5, + 149, + 0, + 0, + 640, + 639, + 1, + 0, + 0, + 0, + 640, + 641, + 1, + 0, + 0, + 0, + 641, + 642, + 1, + 0, + 0, + 0, + 642, + 643, + 5, + 4, + 0, + 0, + 643, + 644, + 3, + 286, + 143, + 0, + 644, + 645, + 3, + 290, + 145, + 0, + 645, + 646, + 5, + 5, + 0, + 0, + 646, + 647, + 3, + 258, + 129, + 0, + 647, + 648, + 3, + 164, + 82, + 0, + 648, + 649, + 5, + 6, + 0, + 0, + 649, + 650, + 3, + 290, + 145, + 0, + 650, + 652, + 5, + 3, + 0, + 0, + 651, + 653, + 5, + 149, + 0, + 0, + 652, + 651, + 1, + 0, + 0, + 0, + 652, + 653, + 1, + 0, + 0, + 0, + 653, + 654, + 1, + 0, + 0, + 0, + 654, + 655, + 5, + 4, + 0, + 0, + 655, + 657, + 1, + 0, + 0, + 0, + 656, + 603, + 1, + 0, + 0, + 0, + 656, + 620, + 1, + 0, + 0, + 0, + 656, + 638, + 1, + 0, + 0, + 0, + 657, + 67, + 1, + 0, + 0, + 0, + 658, + 659, + 5, + 64, + 0, + 0, + 659, + 660, + 5, + 149, + 0, + 0, + 660, + 661, + 5, + 65, + 0, + 0, + 661, + 666, + 5, + 149, + 0, + 0, + 662, + 663, + 5, + 66, + 0, + 0, + 663, + 664, + 5, + 149, + 0, + 0, + 664, + 665, + 5, + 67, + 0, + 0, + 665, + 667, + 5, + 149, + 0, + 0, + 666, + 662, + 1, + 0, + 0, + 0, + 666, + 667, + 1, + 0, + 0, + 0, + 667, + 668, + 1, + 0, + 0, + 0, + 668, + 669, + 5, + 68, + 0, + 0, + 669, + 670, + 5, + 149, + 0, + 0, + 670, + 671, + 3, + 180, + 90, + 0, + 671, + 672, + 5, + 149, + 0, + 0, + 672, + 673, + 5, + 69, + 0, + 0, + 673, + 674, + 5, + 149, + 0, + 0, + 674, + 675, + 3, + 258, + 129, + 0, + 675, + 679, + 5, + 149, + 0, + 0, + 676, + 677, + 5, + 70, + 0, + 0, + 677, + 678, + 5, + 149, + 0, + 0, + 678, + 680, + 5, + 136, + 0, + 0, + 679, + 676, + 1, + 0, + 0, + 0, + 679, + 680, + 1, + 0, + 0, + 0, + 680, + 69, + 1, + 0, + 0, + 0, + 681, + 682, + 5, + 71, + 0, + 0, + 682, + 684, + 5, + 149, + 0, + 0, + 683, + 681, + 1, + 0, + 0, + 0, + 683, + 684, + 1, + 0, + 0, + 0, + 684, + 685, + 1, + 0, + 0, + 0, + 685, + 687, + 5, + 72, + 0, + 0, + 686, + 688, + 5, + 149, + 0, + 0, + 687, + 686, + 1, + 0, + 0, + 0, + 687, + 688, + 1, + 0, + 0, + 0, + 688, + 689, + 1, + 0, + 0, + 0, + 689, + 693, + 3, + 142, + 71, + 0, + 690, + 692, + 3, + 120, + 60, + 0, + 691, + 690, + 1, + 0, + 0, + 0, + 692, + 695, + 1, + 0, + 0, + 0, + 693, + 691, + 1, + 0, + 0, + 0, + 693, + 694, + 1, + 0, + 0, + 0, + 694, + 700, + 1, + 0, + 0, + 0, + 695, + 693, + 1, + 0, + 0, + 0, + 696, + 698, + 5, + 149, + 0, + 0, + 697, + 696, + 1, + 0, + 0, + 0, + 697, + 698, + 1, + 0, + 0, + 0, + 698, + 699, + 1, + 0, + 0, + 0, + 699, + 701, + 3, + 140, + 70, + 0, + 700, + 697, + 1, + 0, + 0, + 0, + 700, + 701, + 1, + 0, + 0, + 0, + 701, + 71, + 1, + 0, + 0, + 0, + 702, + 704, + 5, + 73, + 0, + 0, + 703, + 705, + 5, + 149, + 0, + 0, + 704, + 703, + 1, + 0, + 0, + 0, + 704, + 705, + 1, + 0, + 0, + 0, + 705, + 706, + 1, + 0, + 0, + 0, + 706, + 707, + 3, + 180, + 90, + 0, + 707, + 708, + 5, + 149, + 0, + 0, + 708, + 709, + 5, + 69, + 0, + 0, + 709, + 710, + 5, + 149, + 0, + 0, + 710, + 711, + 3, + 258, + 129, + 0, + 711, + 73, + 1, + 0, + 0, + 0, + 712, + 714, + 5, + 74, + 0, + 0, + 713, + 715, + 5, + 149, + 0, + 0, + 714, + 713, + 1, + 0, + 0, + 0, + 714, + 715, + 1, + 0, + 0, + 0, + 715, + 716, + 1, + 0, + 0, + 0, + 716, + 721, + 3, + 144, + 72, + 0, + 717, + 718, + 5, + 149, + 0, + 0, + 718, + 720, + 3, + 76, + 38, + 0, + 719, + 717, + 1, + 0, + 0, + 0, + 720, + 723, + 1, + 0, + 0, + 0, + 721, + 719, + 1, + 0, + 0, + 0, + 721, + 722, + 1, + 0, + 0, + 0, + 722, + 75, + 1, + 0, + 0, + 0, + 723, + 721, + 1, + 0, + 0, + 0, + 724, + 725, + 5, + 58, + 0, + 0, + 725, + 726, + 5, + 149, + 0, + 0, + 726, + 727, + 5, + 72, + 0, + 0, + 727, + 728, + 5, + 149, + 0, + 0, + 728, + 735, + 3, + 82, + 41, + 0, + 729, + 730, + 5, + 58, + 0, + 0, + 730, + 731, + 5, + 149, + 0, + 0, + 731, + 732, + 5, + 55, + 0, + 0, + 732, + 733, + 5, + 149, + 0, + 0, + 733, + 735, + 3, + 82, + 41, + 0, + 734, + 724, + 1, + 0, + 0, + 0, + 734, + 729, + 1, + 0, + 0, + 0, + 735, + 77, + 1, + 0, + 0, + 0, + 736, + 738, + 5, + 55, + 0, + 0, + 737, + 739, + 5, + 149, + 0, + 0, + 738, + 737, + 1, + 0, + 0, + 0, + 738, + 739, + 1, + 0, + 0, + 0, + 739, + 740, + 1, + 0, + 0, + 0, + 740, + 741, + 3, + 142, + 71, + 0, + 741, + 79, + 1, + 0, + 0, + 0, + 742, + 743, + 5, + 55, + 0, + 0, + 743, + 744, + 5, + 149, + 0, + 0, + 744, + 746, + 5, + 62, + 0, + 0, + 745, + 747, + 5, + 149, + 0, + 0, + 746, + 745, + 1, + 0, + 0, + 0, + 746, + 747, + 1, + 0, + 0, + 0, + 747, + 748, + 1, + 0, + 0, + 0, + 748, + 749, + 3, + 142, + 71, + 0, + 749, + 81, + 1, + 0, + 0, + 0, + 750, + 752, + 5, + 75, + 0, + 0, + 751, + 753, + 5, + 149, + 0, + 0, + 752, + 751, + 1, + 0, + 0, + 0, + 752, + 753, + 1, + 0, + 0, + 0, + 753, + 754, + 1, + 0, + 0, + 0, + 754, + 765, + 3, + 84, + 42, + 0, + 755, + 757, + 5, + 149, + 0, + 0, + 756, + 755, + 1, + 0, + 0, + 0, + 756, + 757, + 1, + 0, + 0, + 0, + 757, + 758, + 1, + 0, + 0, + 0, + 758, + 760, + 5, + 7, + 0, + 0, + 759, + 761, + 5, + 149, + 0, + 0, + 760, + 759, + 1, + 0, + 0, + 0, + 760, + 761, + 1, + 0, + 0, + 0, + 761, + 762, + 1, + 0, + 0, + 0, + 762, + 764, + 3, + 84, + 42, + 0, + 763, + 756, + 1, + 0, + 0, + 0, + 764, + 767, + 1, + 0, + 0, + 0, + 765, + 763, + 1, + 0, + 0, + 0, + 765, + 766, + 1, + 0, + 0, + 0, + 766, + 83, + 1, + 0, + 0, + 0, + 767, + 765, + 1, + 0, + 0, + 0, + 768, + 770, + 3, + 178, + 89, + 0, + 769, + 771, + 5, + 149, + 0, + 0, + 770, + 769, + 1, + 0, + 0, + 0, + 770, + 771, + 1, + 0, + 0, + 0, + 771, + 772, + 1, + 0, + 0, + 0, + 772, + 774, + 5, + 2, + 0, + 0, + 773, + 775, + 5, + 149, + 0, + 0, + 774, + 773, + 1, + 0, + 0, + 0, + 774, + 775, + 1, + 0, + 0, + 0, + 775, + 776, + 1, + 0, + 0, + 0, + 776, + 777, + 3, + 180, + 90, + 0, + 777, + 805, + 1, + 0, + 0, + 0, + 778, + 780, + 3, + 258, + 129, + 0, + 779, + 781, + 5, + 149, + 0, + 0, + 780, + 779, + 1, + 0, + 0, + 0, + 780, + 781, + 1, + 0, + 0, + 0, + 781, + 782, + 1, + 0, + 0, + 0, + 782, + 784, + 5, + 2, + 0, + 0, + 783, + 785, + 5, + 149, + 0, + 0, + 784, + 783, + 1, + 0, + 0, + 0, + 784, + 785, + 1, + 0, + 0, + 0, + 785, + 786, + 1, + 0, + 0, + 0, + 786, + 787, + 3, + 180, + 90, + 0, + 787, + 805, + 1, + 0, + 0, + 0, + 788, + 790, + 3, + 258, + 129, + 0, + 789, + 791, + 5, + 149, + 0, + 0, + 790, + 789, + 1, + 0, + 0, + 0, + 790, + 791, + 1, + 0, + 0, + 0, + 791, + 792, + 1, + 0, + 0, + 0, + 792, + 794, + 5, + 8, + 0, + 0, + 793, + 795, + 5, + 149, + 0, + 0, + 794, + 793, + 1, + 0, + 0, + 0, + 794, + 795, + 1, + 0, + 0, + 0, + 795, + 796, + 1, + 0, + 0, + 0, + 796, + 797, + 3, + 180, + 90, + 0, + 797, + 805, + 1, + 0, + 0, + 0, + 798, + 800, + 3, + 258, + 129, + 0, + 799, + 801, + 5, + 149, + 0, + 0, + 800, + 799, + 1, + 0, + 0, + 0, + 800, + 801, + 1, + 0, + 0, + 0, + 801, + 802, + 1, + 0, + 0, + 0, + 802, + 803, + 3, + 168, + 84, + 0, + 803, + 805, + 1, + 0, + 0, + 0, + 804, + 768, + 1, + 0, + 0, + 0, + 804, + 778, + 1, + 0, + 0, + 0, + 804, + 788, + 1, + 0, + 0, + 0, + 804, + 798, + 1, + 0, + 0, + 0, + 805, + 85, + 1, + 0, + 0, + 0, + 806, + 807, + 5, + 76, + 0, + 0, + 807, + 809, + 5, + 149, + 0, + 0, + 808, + 806, + 1, + 0, + 0, + 0, + 808, + 809, + 1, + 0, + 0, + 0, + 809, + 810, + 1, + 0, + 0, + 0, + 810, + 812, + 5, + 77, + 0, + 0, + 811, + 813, + 5, + 149, + 0, + 0, + 812, + 811, + 1, + 0, + 0, + 0, + 812, + 813, + 1, + 0, + 0, + 0, + 813, + 814, + 1, + 0, + 0, + 0, + 814, + 825, + 3, + 180, + 90, + 0, + 815, + 817, + 5, + 149, + 0, + 0, + 816, + 815, + 1, + 0, + 0, + 0, + 816, + 817, + 1, + 0, + 0, + 0, + 817, + 818, + 1, + 0, + 0, + 0, + 818, + 820, + 5, + 7, + 0, + 0, + 819, + 821, + 5, + 149, + 0, + 0, + 820, + 819, + 1, + 0, + 0, + 0, + 820, + 821, + 1, + 0, + 0, + 0, + 821, + 822, + 1, + 0, + 0, + 0, + 822, + 824, + 3, + 180, + 90, + 0, + 823, + 816, + 1, + 0, + 0, + 0, + 824, + 827, + 1, + 0, + 0, + 0, + 825, + 823, + 1, + 0, + 0, + 0, + 825, + 826, + 1, + 0, + 0, + 0, + 826, + 87, + 1, + 0, + 0, + 0, + 827, + 825, + 1, + 0, + 0, + 0, + 828, + 829, + 5, + 78, + 0, + 0, + 829, + 830, + 5, + 149, + 0, + 0, + 830, + 841, + 3, + 90, + 45, + 0, + 831, + 833, + 5, + 149, + 0, + 0, + 832, + 831, + 1, + 0, + 0, + 0, + 832, + 833, + 1, + 0, + 0, + 0, + 833, + 834, + 1, + 0, + 0, + 0, + 834, + 836, + 5, + 7, + 0, + 0, + 835, + 837, + 5, + 149, + 0, + 0, + 836, + 835, + 1, + 0, + 0, + 0, + 836, + 837, + 1, + 0, + 0, + 0, + 837, + 838, + 1, + 0, + 0, + 0, + 838, + 840, + 3, + 90, + 45, + 0, + 839, + 832, + 1, + 0, + 0, + 0, + 840, + 843, + 1, + 0, + 0, + 0, + 841, + 839, + 1, + 0, + 0, + 0, + 841, + 842, + 1, + 0, + 0, + 0, + 842, + 89, + 1, + 0, + 0, + 0, + 843, + 841, + 1, + 0, + 0, + 0, + 844, + 845, + 3, + 258, + 129, + 0, + 845, + 846, + 3, + 168, + 84, + 0, + 846, + 849, + 1, + 0, + 0, + 0, + 847, + 849, + 3, + 178, + 89, + 0, + 848, + 844, + 1, + 0, + 0, + 0, + 848, + 847, + 1, + 0, + 0, + 0, + 849, + 91, + 1, + 0, + 0, + 0, + 850, + 852, + 5, + 79, + 0, + 0, + 851, + 853, + 5, + 149, + 0, + 0, + 852, + 851, + 1, + 0, + 0, + 0, + 852, + 853, + 1, + 0, + 0, + 0, + 853, + 854, + 1, + 0, + 0, + 0, + 854, + 856, + 5, + 3, + 0, + 0, + 855, + 857, + 5, + 149, + 0, + 0, + 856, + 855, + 1, + 0, + 0, + 0, + 856, + 857, + 1, + 0, + 0, + 0, + 857, + 858, + 1, + 0, + 0, + 0, + 858, + 859, + 3, + 258, + 129, + 0, + 859, + 860, + 5, + 149, + 0, + 0, + 860, + 861, + 5, + 80, + 0, + 0, + 861, + 862, + 5, + 149, + 0, + 0, + 862, + 864, + 3, + 180, + 90, + 0, + 863, + 865, + 5, + 149, + 0, + 0, + 864, + 863, + 1, + 0, + 0, + 0, + 864, + 865, + 1, + 0, + 0, + 0, + 865, + 866, + 1, + 0, + 0, + 0, + 866, + 869, + 5, + 9, + 0, + 0, + 867, + 868, + 5, + 149, + 0, + 0, + 868, + 870, + 3, + 36, + 18, + 0, + 869, + 867, + 1, + 0, + 0, + 0, + 870, + 871, + 1, + 0, + 0, + 0, + 871, + 869, + 1, + 0, + 0, + 0, + 871, + 872, + 1, + 0, + 0, + 0, + 872, + 874, + 1, + 0, + 0, + 0, + 873, + 875, + 5, + 149, + 0, + 0, + 874, + 873, + 1, + 0, + 0, + 0, + 874, + 875, + 1, + 0, + 0, + 0, + 875, + 876, + 1, + 0, + 0, + 0, + 876, + 877, + 5, + 4, + 0, + 0, + 877, + 93, + 1, + 0, + 0, + 0, + 878, + 879, + 5, + 81, + 0, + 0, + 879, + 880, + 5, + 149, + 0, + 0, + 880, + 887, + 3, + 248, + 124, + 0, + 881, + 883, + 5, + 149, + 0, + 0, + 882, + 881, + 1, + 0, + 0, + 0, + 882, + 883, + 1, + 0, + 0, + 0, + 883, + 884, + 1, + 0, + 0, + 0, + 884, + 885, + 5, + 82, + 0, + 0, + 885, + 886, + 5, + 149, + 0, + 0, + 886, + 888, + 3, + 98, + 49, + 0, + 887, + 882, + 1, + 0, + 0, + 0, + 887, + 888, + 1, + 0, + 0, + 0, + 888, + 95, + 1, + 0, + 0, + 0, + 889, + 890, + 5, + 81, + 0, + 0, + 890, + 893, + 5, + 149, + 0, + 0, + 891, + 894, + 3, + 248, + 124, + 0, + 892, + 894, + 3, + 250, + 125, + 0, + 893, + 891, + 1, + 0, + 0, + 0, + 893, + 892, + 1, + 0, + 0, + 0, + 894, + 904, + 1, + 0, + 0, + 0, + 895, + 897, + 5, + 149, + 0, + 0, + 896, + 895, + 1, + 0, + 0, + 0, + 896, + 897, + 1, + 0, + 0, + 0, + 897, + 898, + 1, + 0, + 0, + 0, + 898, + 899, + 5, + 82, + 0, + 0, + 899, + 902, + 5, + 149, + 0, + 0, + 900, + 903, + 5, + 10, + 0, + 0, + 901, + 903, + 3, + 98, + 49, + 0, + 902, + 900, + 1, + 0, + 0, + 0, + 902, + 901, + 1, + 0, + 0, + 0, + 903, + 905, + 1, + 0, + 0, + 0, + 904, + 896, + 1, + 0, + 0, + 0, + 904, + 905, + 1, + 0, + 0, + 0, + 905, + 97, + 1, + 0, + 0, + 0, + 906, + 917, + 3, + 100, + 50, + 0, + 907, + 909, + 5, + 149, + 0, + 0, + 908, + 907, + 1, + 0, + 0, + 0, + 908, + 909, + 1, + 0, + 0, + 0, + 909, + 910, + 1, + 0, + 0, + 0, + 910, + 912, + 5, + 7, + 0, + 0, + 911, + 913, + 5, + 149, + 0, + 0, + 912, + 911, + 1, + 0, + 0, + 0, + 912, + 913, + 1, + 0, + 0, + 0, + 913, + 914, + 1, + 0, + 0, + 0, + 914, + 916, + 3, + 100, + 50, + 0, + 915, + 908, + 1, + 0, + 0, + 0, + 916, + 919, + 1, + 0, + 0, + 0, + 917, + 915, + 1, + 0, + 0, + 0, + 917, + 918, + 1, + 0, + 0, + 0, + 918, + 924, + 1, + 0, + 0, + 0, + 919, + 917, + 1, + 0, + 0, + 0, + 920, + 922, + 5, + 149, + 0, + 0, + 921, + 920, + 1, + 0, + 0, + 0, + 921, + 922, + 1, + 0, + 0, + 0, + 922, + 923, + 1, + 0, + 0, + 0, + 923, + 925, + 3, + 140, + 70, + 0, + 924, + 921, + 1, + 0, + 0, + 0, + 924, + 925, + 1, + 0, + 0, + 0, + 925, + 99, + 1, + 0, + 0, + 0, + 926, + 927, + 3, + 252, + 126, + 0, + 927, + 928, + 5, + 149, + 0, + 0, + 928, + 929, + 5, + 69, + 0, + 0, + 929, + 930, + 5, + 149, + 0, + 0, + 930, + 932, + 1, + 0, + 0, + 0, + 931, + 926, + 1, + 0, + 0, + 0, + 931, + 932, + 1, + 0, + 0, + 0, + 932, + 933, + 1, + 0, + 0, + 0, + 933, + 934, + 3, + 258, + 129, + 0, + 934, + 101, + 1, + 0, + 0, + 0, + 935, + 936, + 5, + 66, + 0, + 0, + 936, + 941, + 3, + 106, + 53, + 0, + 937, + 939, + 5, + 149, + 0, + 0, + 938, + 937, + 1, + 0, + 0, + 0, + 938, + 939, + 1, + 0, + 0, + 0, + 939, + 940, + 1, + 0, + 0, + 0, + 940, + 942, + 3, + 140, + 70, + 0, + 941, + 938, + 1, + 0, + 0, + 0, + 941, + 942, + 1, + 0, + 0, + 0, + 942, + 103, + 1, + 0, + 0, + 0, + 943, + 944, + 5, + 83, + 0, + 0, + 944, + 945, + 3, + 106, + 53, + 0, + 945, + 105, + 1, + 0, + 0, + 0, + 946, + 948, + 5, + 149, + 0, + 0, + 947, + 946, + 1, + 0, + 0, + 0, + 947, + 948, + 1, + 0, + 0, + 0, + 948, + 949, + 1, + 0, + 0, + 0, + 949, + 951, + 5, + 84, + 0, + 0, + 950, + 947, + 1, + 0, + 0, + 0, + 950, + 951, + 1, + 0, + 0, + 0, + 951, + 952, + 1, + 0, + 0, + 0, + 952, + 953, + 5, + 149, + 0, + 0, + 953, + 956, + 3, + 108, + 54, + 0, + 954, + 955, + 5, + 149, + 0, + 0, + 955, + 957, + 3, + 112, + 56, + 0, + 956, + 954, + 1, + 0, + 0, + 0, + 956, + 957, + 1, + 0, + 0, + 0, + 957, + 960, + 1, + 0, + 0, + 0, + 958, + 959, + 5, + 149, + 0, + 0, + 959, + 961, + 3, + 114, + 57, + 0, + 960, + 958, + 1, + 0, + 0, + 0, + 960, + 961, + 1, + 0, + 0, + 0, + 961, + 964, + 1, + 0, + 0, + 0, + 962, + 963, + 5, + 149, + 0, + 0, + 963, + 965, + 3, + 116, + 58, + 0, + 964, + 962, + 1, + 0, + 0, + 0, + 964, + 965, + 1, + 0, + 0, + 0, + 965, + 107, + 1, + 0, + 0, + 0, + 966, + 977, + 5, + 10, + 0, + 0, + 967, + 969, + 5, + 149, + 0, + 0, + 968, + 967, + 1, + 0, + 0, + 0, + 968, + 969, + 1, + 0, + 0, + 0, + 969, + 970, + 1, + 0, + 0, + 0, + 970, + 972, + 5, + 7, + 0, + 0, + 971, + 973, + 5, + 149, + 0, + 0, + 972, + 971, + 1, + 0, + 0, + 0, + 972, + 973, + 1, + 0, + 0, + 0, + 973, + 974, + 1, + 0, + 0, + 0, + 974, + 976, + 3, + 110, + 55, + 0, + 975, + 968, + 1, + 0, + 0, + 0, + 976, + 979, + 1, + 0, + 0, + 0, + 977, + 975, + 1, + 0, + 0, + 0, + 977, + 978, + 1, + 0, + 0, + 0, + 978, + 995, + 1, + 0, + 0, + 0, + 979, + 977, + 1, + 0, + 0, + 0, + 980, + 991, + 3, + 110, + 55, + 0, + 981, + 983, + 5, + 149, + 0, + 0, + 982, + 981, + 1, + 0, + 0, + 0, + 982, + 983, + 1, + 0, + 0, + 0, + 983, + 984, + 1, + 0, + 0, + 0, + 984, + 986, + 5, + 7, + 0, + 0, + 985, + 987, + 5, + 149, + 0, + 0, + 986, + 985, + 1, + 0, + 0, + 0, + 986, + 987, + 1, + 0, + 0, + 0, + 987, + 988, + 1, + 0, + 0, + 0, + 988, + 990, + 3, + 110, + 55, + 0, + 989, + 982, + 1, + 0, + 0, + 0, + 990, + 993, + 1, + 0, + 0, + 0, + 991, + 989, + 1, + 0, + 0, + 0, + 991, + 992, + 1, + 0, + 0, + 0, + 992, + 995, + 1, + 0, + 0, + 0, + 993, + 991, + 1, + 0, + 0, + 0, + 994, + 966, + 1, + 0, + 0, + 0, + 994, + 980, + 1, + 0, + 0, + 0, + 995, + 109, + 1, + 0, + 0, + 0, + 996, + 997, + 3, + 180, + 90, + 0, + 997, + 998, + 5, + 149, + 0, + 0, + 998, + 999, + 5, + 69, + 0, + 0, + 999, + 1000, + 5, + 149, + 0, + 0, + 1000, + 1001, + 3, + 258, + 129, + 0, + 1001, + 1004, + 1, + 0, + 0, + 0, + 1002, + 1004, + 3, + 180, + 90, + 0, + 1003, + 996, + 1, + 0, + 0, + 0, + 1003, + 1002, + 1, + 0, + 0, + 0, + 1004, + 111, + 1, + 0, + 0, + 0, + 1005, + 1006, + 5, + 85, + 0, + 0, + 1006, + 1007, + 5, + 149, + 0, + 0, + 1007, + 1008, + 5, + 86, + 0, + 0, + 1008, + 1009, + 5, + 149, + 0, + 0, + 1009, + 1017, + 3, + 118, + 59, + 0, + 1010, + 1012, + 5, + 7, + 0, + 0, + 1011, + 1013, + 5, + 149, + 0, + 0, + 1012, + 1011, + 1, + 0, + 0, + 0, + 1012, + 1013, + 1, + 0, + 0, + 0, + 1013, + 1014, + 1, + 0, + 0, + 0, + 1014, + 1016, + 3, + 118, + 59, + 0, + 1015, + 1010, + 1, + 0, + 0, + 0, + 1016, + 1019, + 1, + 0, + 0, + 0, + 1017, + 1015, + 1, + 0, + 0, + 0, + 1017, + 1018, + 1, + 0, + 0, + 0, + 1018, + 113, + 1, + 0, + 0, + 0, + 1019, + 1017, + 1, + 0, + 0, + 0, + 1020, + 1021, + 5, + 87, + 0, + 0, + 1021, + 1022, + 5, + 149, + 0, + 0, + 1022, + 1023, + 3, + 180, + 90, + 0, + 1023, + 115, + 1, + 0, + 0, + 0, + 1024, + 1025, + 5, + 88, + 0, + 0, + 1025, + 1026, + 5, + 149, + 0, + 0, + 1026, + 1027, + 3, + 180, + 90, + 0, + 1027, + 117, + 1, + 0, + 0, + 0, + 1028, + 1033, + 3, + 180, + 90, + 0, + 1029, + 1031, + 5, + 149, + 0, + 0, + 1030, + 1029, + 1, + 0, + 0, + 0, + 1030, + 1031, + 1, + 0, + 0, + 0, + 1031, + 1032, + 1, + 0, + 0, + 0, + 1032, + 1034, + 7, + 0, + 0, + 0, + 1033, + 1030, + 1, + 0, + 0, + 0, + 1033, + 1034, + 1, + 0, + 0, + 0, + 1034, + 119, + 1, + 0, + 0, + 0, + 1035, + 1037, + 5, + 149, + 0, + 0, + 1036, + 1035, + 1, + 0, + 0, + 0, + 1036, + 1037, + 1, + 0, + 0, + 0, + 1037, + 1075, + 1, + 0, + 0, + 0, + 1038, + 1039, + 5, + 50, + 0, + 0, + 1039, + 1040, + 5, + 149, + 0, + 0, + 1040, + 1041, + 5, + 57, + 0, + 0, + 1041, + 1042, + 5, + 149, + 0, + 0, + 1042, + 1043, + 3, + 258, + 129, + 0, + 1043, + 1044, + 3, + 170, + 85, + 0, + 1044, + 1045, + 5, + 3, + 0, + 0, + 1045, + 1046, + 3, + 274, + 137, + 0, + 1046, + 1047, + 5, + 4, + 0, + 0, + 1047, + 1076, + 1, + 0, + 0, + 0, + 1048, + 1049, + 5, + 50, + 0, + 0, + 1049, + 1050, + 5, + 149, + 0, + 0, + 1050, + 1051, + 5, + 93, + 0, + 0, + 1051, + 1052, + 5, + 149, + 0, + 0, + 1052, + 1053, + 5, + 58, + 0, + 0, + 1053, + 1054, + 5, + 149, + 0, + 0, + 1054, + 1065, + 3, + 258, + 129, + 0, + 1055, + 1057, + 5, + 149, + 0, + 0, + 1056, + 1055, + 1, + 0, + 0, + 0, + 1056, + 1057, + 1, + 0, + 0, + 0, + 1057, + 1058, + 1, + 0, + 0, + 0, + 1058, + 1060, + 5, + 7, + 0, + 0, + 1059, + 1061, + 5, + 149, + 0, + 0, + 1060, + 1059, + 1, + 0, + 0, + 0, + 1060, + 1061, + 1, + 0, + 0, + 0, + 1061, + 1062, + 1, + 0, + 0, + 0, + 1062, + 1064, + 3, + 258, + 129, + 0, + 1063, + 1056, + 1, + 0, + 0, + 0, + 1064, + 1067, + 1, + 0, + 0, + 0, + 1065, + 1063, + 1, + 0, + 0, + 0, + 1065, + 1066, + 1, + 0, + 0, + 0, + 1066, + 1076, + 1, + 0, + 0, + 0, + 1067, + 1065, + 1, + 0, + 0, + 0, + 1068, + 1069, + 5, + 50, + 0, + 0, + 1069, + 1070, + 5, + 149, + 0, + 0, + 1070, + 1071, + 5, + 94, + 0, + 0, + 1071, + 1072, + 5, + 149, + 0, + 0, + 1072, + 1073, + 3, + 258, + 129, + 0, + 1073, + 1074, + 3, + 170, + 85, + 0, + 1074, + 1076, + 1, + 0, + 0, + 0, + 1075, + 1038, + 1, + 0, + 0, + 0, + 1075, + 1048, + 1, + 0, + 0, + 0, + 1075, + 1068, + 1, + 0, + 0, + 0, + 1076, + 121, + 1, + 0, + 0, + 0, + 1077, + 1078, + 5, + 95, + 0, + 0, + 1078, + 1079, + 5, + 149, + 0, + 0, + 1079, + 1090, + 3, + 124, + 62, + 0, + 1080, + 1082, + 5, + 149, + 0, + 0, + 1081, + 1080, + 1, + 0, + 0, + 0, + 1081, + 1082, + 1, + 0, + 0, + 0, + 1082, + 1083, + 1, + 0, + 0, + 0, + 1083, + 1085, + 5, + 7, + 0, + 0, + 1084, + 1086, + 5, + 149, + 0, + 0, + 1085, + 1084, + 1, + 0, + 0, + 0, + 1085, + 1086, + 1, + 0, + 0, + 0, + 1086, + 1087, + 1, + 0, + 0, + 0, + 1087, + 1089, + 3, + 124, + 62, + 0, + 1088, + 1081, + 1, + 0, + 0, + 0, + 1089, + 1092, + 1, + 0, + 0, + 0, + 1090, + 1088, + 1, + 0, + 0, + 0, + 1090, + 1091, + 1, + 0, + 0, + 0, + 1091, + 1094, + 1, + 0, + 0, + 0, + 1092, + 1090, + 1, + 0, + 0, + 0, + 1093, + 1095, + 3, + 140, + 70, + 0, + 1094, + 1093, + 1, + 0, + 0, + 0, + 1094, + 1095, + 1, + 0, + 0, + 0, + 1095, + 123, + 1, + 0, + 0, + 0, + 1096, + 1098, + 3, + 258, + 129, + 0, + 1097, + 1099, + 5, + 149, + 0, + 0, + 1098, + 1097, + 1, + 0, + 0, + 0, + 1098, + 1099, + 1, + 0, + 0, + 0, + 1099, + 1100, + 1, + 0, + 0, + 0, + 1100, + 1102, + 5, + 2, + 0, + 0, + 1101, + 1103, + 5, + 149, + 0, + 0, + 1102, + 1101, + 1, + 0, + 0, + 0, + 1102, + 1103, + 1, + 0, + 0, + 0, + 1103, + 1104, + 1, + 0, + 0, + 0, + 1104, + 1105, + 3, + 126, + 63, + 0, + 1105, + 125, + 1, + 0, + 0, + 0, + 1106, + 1109, + 3, + 128, + 64, + 0, + 1107, + 1109, + 3, + 130, + 65, + 0, + 1108, + 1106, + 1, + 0, + 0, + 0, + 1108, + 1107, + 1, + 0, + 0, + 0, + 1109, + 127, + 1, + 0, + 0, + 0, + 1110, + 1112, + 5, + 96, + 0, + 0, + 1111, + 1113, + 5, + 149, + 0, + 0, + 1112, + 1111, + 1, + 0, + 0, + 0, + 1112, + 1113, + 1, + 0, + 0, + 0, + 1113, + 1117, + 1, + 0, + 0, + 0, + 1114, + 1118, + 3, + 132, + 66, + 0, + 1115, + 1118, + 3, + 134, + 67, + 0, + 1116, + 1118, + 3, + 136, + 68, + 0, + 1117, + 1114, + 1, + 0, + 0, + 0, + 1117, + 1115, + 1, + 0, + 0, + 0, + 1117, + 1116, + 1, + 0, + 0, + 0, + 1118, + 129, + 1, + 0, + 0, + 0, + 1119, + 1123, + 7, + 1, + 0, + 0, + 1120, + 1124, + 3, + 132, + 66, + 0, + 1121, + 1124, + 3, + 134, + 67, + 0, + 1122, + 1124, + 3, + 136, + 68, + 0, + 1123, + 1120, + 1, + 0, + 0, + 0, + 1123, + 1121, + 1, + 0, + 0, + 0, + 1123, + 1122, + 1, + 0, + 0, + 0, + 1124, + 131, + 1, + 0, + 0, + 0, + 1125, + 1126, + 5, + 11, + 0, + 0, + 1126, + 1127, + 3, + 284, + 142, + 0, + 1127, + 1128, + 5, + 3, + 0, + 0, + 1128, + 1129, + 3, + 284, + 142, + 0, + 1129, + 1132, + 5, + 2, + 0, + 0, + 1130, + 1133, + 5, + 136, + 0, + 0, + 1131, + 1133, + 3, + 276, + 138, + 0, + 1132, + 1130, + 1, + 0, + 0, + 0, + 1132, + 1131, + 1, + 0, + 0, + 0, + 1133, + 1134, + 1, + 0, + 0, + 0, + 1134, + 1135, + 5, + 4, + 0, + 0, + 1135, + 133, + 1, + 0, + 0, + 0, + 1136, + 1137, + 5, + 11, + 0, + 0, + 1137, + 1138, + 3, + 284, + 142, + 0, + 1138, + 1141, + 5, + 3, + 0, + 0, + 1139, + 1142, + 5, + 136, + 0, + 0, + 1140, + 1142, + 3, + 276, + 138, + 0, + 1141, + 1139, + 1, + 0, + 0, + 0, + 1141, + 1140, + 1, + 0, + 0, + 0, + 1142, + 1143, + 1, + 0, + 0, + 0, + 1143, + 1144, + 5, + 4, + 0, + 0, + 1144, + 135, + 1, + 0, + 0, + 0, + 1145, + 1149, + 5, + 3, + 0, + 0, + 1146, + 1150, + 3, + 138, + 69, + 0, + 1147, + 1150, + 3, + 276, + 138, + 0, + 1148, + 1150, + 5, + 10, + 0, + 0, + 1149, + 1146, + 1, + 0, + 0, + 0, + 1149, + 1147, + 1, + 0, + 0, + 0, + 1149, + 1148, + 1, + 0, + 0, + 0, + 1150, + 1151, + 1, + 0, + 0, + 0, + 1151, + 1152, + 5, + 4, + 0, + 0, + 1152, + 137, + 1, + 0, + 0, + 0, + 1153, + 1164, + 3, + 266, + 133, + 0, + 1154, + 1156, + 5, + 149, + 0, + 0, + 1155, + 1154, + 1, + 0, + 0, + 0, + 1155, + 1156, + 1, + 0, + 0, + 0, + 1156, + 1157, + 1, + 0, + 0, + 0, + 1157, + 1159, + 5, + 7, + 0, + 0, + 1158, + 1160, + 5, + 149, + 0, + 0, + 1159, + 1158, + 1, + 0, + 0, + 0, + 1159, + 1160, + 1, + 0, + 0, + 0, + 1160, + 1161, + 1, + 0, + 0, + 0, + 1161, + 1163, + 3, + 266, + 133, + 0, + 1162, + 1155, + 1, + 0, + 0, + 0, + 1163, + 1166, + 1, + 0, + 0, + 0, + 1164, + 1162, + 1, + 0, + 0, + 0, + 1164, + 1165, + 1, + 0, + 0, + 0, + 1165, + 139, + 1, + 0, + 0, + 0, + 1166, + 1164, + 1, + 0, + 0, + 0, + 1167, + 1168, + 5, + 99, + 0, + 0, + 1168, + 1169, + 5, + 149, + 0, + 0, + 1169, + 1170, + 3, + 180, + 90, + 0, + 1170, + 141, + 1, + 0, + 0, + 0, + 1171, + 1182, + 3, + 144, + 72, + 0, + 1172, + 1174, + 5, + 149, + 0, + 0, + 1173, + 1172, + 1, + 0, + 0, + 0, + 1173, + 1174, + 1, + 0, + 0, + 0, + 1174, + 1175, + 1, + 0, + 0, + 0, + 1175, + 1177, + 5, + 7, + 0, + 0, + 1176, + 1178, + 5, + 149, + 0, + 0, + 1177, + 1176, + 1, + 0, + 0, + 0, + 1177, + 1178, + 1, + 0, + 0, + 0, + 1178, + 1179, + 1, + 0, + 0, + 0, + 1179, + 1181, + 3, + 144, + 72, + 0, + 1180, + 1173, + 1, + 0, + 0, + 0, + 1181, + 1184, + 1, + 0, + 0, + 0, + 1182, + 1180, + 1, + 0, + 0, + 0, + 1182, + 1183, + 1, + 0, + 0, + 0, + 1183, + 143, + 1, + 0, + 0, + 0, + 1184, + 1182, + 1, + 0, + 0, + 0, + 1185, + 1187, + 3, + 258, + 129, + 0, + 1186, + 1188, + 5, + 149, + 0, + 0, + 1187, + 1186, + 1, + 0, + 0, + 0, + 1187, + 1188, + 1, + 0, + 0, + 0, + 1188, + 1189, + 1, + 0, + 0, + 0, + 1189, + 1191, + 5, + 2, + 0, + 0, + 1190, + 1192, + 5, + 149, + 0, + 0, + 1191, + 1190, + 1, + 0, + 0, + 0, + 1191, + 1192, + 1, + 0, + 0, + 0, + 1192, + 1193, + 1, + 0, + 0, + 0, + 1193, + 1194, + 3, + 146, + 73, + 0, + 1194, + 1197, + 1, + 0, + 0, + 0, + 1195, + 1197, + 3, + 146, + 73, + 0, + 1196, + 1185, + 1, + 0, + 0, + 0, + 1196, + 1195, + 1, + 0, + 0, + 0, + 1197, + 145, + 1, + 0, + 0, + 0, + 1198, + 1201, + 3, + 148, + 74, + 0, + 1199, + 1201, + 3, + 150, + 75, + 0, + 1200, + 1198, + 1, + 0, + 0, + 0, + 1200, + 1199, + 1, + 0, + 0, + 0, + 1201, + 147, + 1, + 0, + 0, + 0, + 1202, + 1203, + 5, + 100, + 0, + 0, + 1203, + 1204, + 5, + 3, + 0, + 0, + 1204, + 1205, + 3, + 150, + 75, + 0, + 1205, + 1206, + 5, + 4, + 0, + 0, + 1206, + 1213, + 1, + 0, + 0, + 0, + 1207, + 1208, + 5, + 101, + 0, + 0, + 1208, + 1209, + 5, + 3, + 0, + 0, + 1209, + 1210, + 3, + 150, + 75, + 0, + 1210, + 1211, + 5, + 4, + 0, + 0, + 1211, + 1213, + 1, + 0, + 0, + 0, + 1212, + 1202, + 1, + 0, + 0, + 0, + 1212, + 1207, + 1, + 0, + 0, + 0, + 1213, + 149, + 1, + 0, + 0, + 0, + 1214, + 1221, + 3, + 154, + 77, + 0, + 1215, + 1217, + 5, + 149, + 0, + 0, + 1216, + 1215, + 1, + 0, + 0, + 0, + 1216, + 1217, + 1, + 0, + 0, + 0, + 1217, + 1218, + 1, + 0, + 0, + 0, + 1218, + 1220, + 3, + 156, + 78, + 0, + 1219, + 1216, + 1, + 0, + 0, + 0, + 1220, + 1223, + 1, + 0, + 0, + 0, + 1221, + 1219, + 1, + 0, + 0, + 0, + 1221, + 1222, + 1, + 0, + 0, + 0, + 1222, + 1229, + 1, + 0, + 0, + 0, + 1223, + 1221, + 1, + 0, + 0, + 0, + 1224, + 1225, + 5, + 3, + 0, + 0, + 1225, + 1226, + 3, + 150, + 75, + 0, + 1226, + 1227, + 5, + 4, + 0, + 0, + 1227, + 1229, + 1, + 0, + 0, + 0, + 1228, + 1214, + 1, + 0, + 0, + 0, + 1228, + 1224, + 1, + 0, + 0, + 0, + 1229, + 151, + 1, + 0, + 0, + 0, + 1230, + 1235, + 3, + 154, + 77, + 0, + 1231, + 1233, + 5, + 149, + 0, + 0, + 1232, + 1231, + 1, + 0, + 0, + 0, + 1232, + 1233, + 1, + 0, + 0, + 0, + 1233, + 1234, + 1, + 0, + 0, + 0, + 1234, + 1236, + 3, + 156, + 78, + 0, + 1235, + 1232, + 1, + 0, + 0, + 0, + 1236, + 1237, + 1, + 0, + 0, + 0, + 1237, + 1235, + 1, + 0, + 0, + 0, + 1237, + 1238, + 1, + 0, + 0, + 0, + 1238, + 153, + 1, + 0, + 0, + 0, + 1239, + 1241, + 5, + 3, + 0, + 0, + 1240, + 1242, + 5, + 149, + 0, + 0, + 1241, + 1240, + 1, + 0, + 0, + 0, + 1241, + 1242, + 1, + 0, + 0, + 0, + 1242, + 1247, + 1, + 0, + 0, + 0, + 1243, + 1245, + 3, + 258, + 129, + 0, + 1244, + 1246, + 5, + 149, + 0, + 0, + 1245, + 1244, + 1, + 0, + 0, + 0, + 1245, + 1246, + 1, + 0, + 0, + 0, + 1246, + 1248, + 1, + 0, + 0, + 0, + 1247, + 1243, + 1, + 0, + 0, + 0, + 1247, + 1248, + 1, + 0, + 0, + 0, + 1248, + 1253, + 1, + 0, + 0, + 0, + 1249, + 1251, + 3, + 168, + 84, + 0, + 1250, + 1252, + 5, + 149, + 0, + 0, + 1251, + 1250, + 1, + 0, + 0, + 0, + 1251, + 1252, + 1, + 0, + 0, + 0, + 1252, + 1254, + 1, + 0, + 0, + 0, + 1253, + 1249, + 1, + 0, + 0, + 0, + 1253, + 1254, + 1, + 0, + 0, + 0, + 1254, + 1259, + 1, + 0, + 0, + 0, + 1255, + 1257, + 3, + 162, + 81, + 0, + 1256, + 1258, + 5, + 149, + 0, + 0, + 1257, + 1256, + 1, + 0, + 0, + 0, + 1257, + 1258, + 1, + 0, + 0, + 0, + 1258, + 1260, + 1, + 0, + 0, + 0, + 1259, + 1255, + 1, + 0, + 0, + 0, + 1259, + 1260, + 1, + 0, + 0, + 0, + 1260, + 1261, + 1, + 0, + 0, + 0, + 1261, + 1262, + 5, + 4, + 0, + 0, + 1262, + 155, + 1, + 0, + 0, + 0, + 1263, + 1265, + 3, + 158, + 79, + 0, + 1264, + 1266, + 5, + 149, + 0, + 0, + 1265, + 1264, + 1, + 0, + 0, + 0, + 1265, + 1266, + 1, + 0, + 0, + 0, + 1266, + 1267, + 1, + 0, + 0, + 0, + 1267, + 1268, + 3, + 154, + 77, + 0, + 1268, + 157, + 1, + 0, + 0, + 0, + 1269, + 1271, + 3, + 286, + 143, + 0, + 1270, + 1272, + 5, + 149, + 0, + 0, + 1271, + 1270, + 1, + 0, + 0, + 0, + 1271, + 1272, + 1, + 0, + 0, + 0, + 1272, + 1273, + 1, + 0, + 0, + 0, + 1273, + 1275, + 3, + 290, + 145, + 0, + 1274, + 1276, + 5, + 149, + 0, + 0, + 1275, + 1274, + 1, + 0, + 0, + 0, + 1275, + 1276, + 1, + 0, + 0, + 0, + 1276, + 1278, + 1, + 0, + 0, + 0, + 1277, + 1279, + 3, + 160, + 80, + 0, + 1278, + 1277, + 1, + 0, + 0, + 0, + 1278, + 1279, + 1, + 0, + 0, + 0, + 1279, + 1281, + 1, + 0, + 0, + 0, + 1280, + 1282, + 5, + 149, + 0, + 0, + 1281, + 1280, + 1, + 0, + 0, + 0, + 1281, + 1282, + 1, + 0, + 0, + 0, + 1282, + 1283, + 1, + 0, + 0, + 0, + 1283, + 1285, + 3, + 290, + 145, + 0, + 1284, + 1286, + 5, + 149, + 0, + 0, + 1285, + 1284, + 1, + 0, + 0, + 0, + 1285, + 1286, + 1, + 0, + 0, + 0, + 1286, + 1287, + 1, + 0, + 0, + 0, + 1287, + 1288, + 3, + 288, + 144, + 0, + 1288, + 1334, + 1, + 0, + 0, + 0, + 1289, + 1291, + 3, + 286, + 143, + 0, + 1290, + 1292, + 5, + 149, + 0, + 0, + 1291, + 1290, + 1, + 0, + 0, + 0, + 1291, + 1292, + 1, + 0, + 0, + 0, + 1292, + 1293, + 1, + 0, + 0, + 0, + 1293, + 1295, + 3, + 290, + 145, + 0, + 1294, + 1296, + 5, + 149, + 0, + 0, + 1295, + 1294, + 1, + 0, + 0, + 0, + 1295, + 1296, + 1, + 0, + 0, + 0, + 1296, + 1298, + 1, + 0, + 0, + 0, + 1297, + 1299, + 3, + 160, + 80, + 0, + 1298, + 1297, + 1, + 0, + 0, + 0, + 1298, + 1299, + 1, + 0, + 0, + 0, + 1299, + 1301, + 1, + 0, + 0, + 0, + 1300, + 1302, + 5, + 149, + 0, + 0, + 1301, + 1300, + 1, + 0, + 0, + 0, + 1301, + 1302, + 1, + 0, + 0, + 0, + 1302, + 1303, + 1, + 0, + 0, + 0, + 1303, + 1304, + 3, + 290, + 145, + 0, + 1304, + 1334, + 1, + 0, + 0, + 0, + 1305, + 1307, + 3, + 290, + 145, + 0, + 1306, + 1308, + 5, + 149, + 0, + 0, + 1307, + 1306, + 1, + 0, + 0, + 0, + 1307, + 1308, + 1, + 0, + 0, + 0, + 1308, + 1310, + 1, + 0, + 0, + 0, + 1309, + 1311, + 3, + 160, + 80, + 0, + 1310, + 1309, + 1, + 0, + 0, + 0, + 1310, + 1311, + 1, + 0, + 0, + 0, + 1311, + 1313, + 1, + 0, + 0, + 0, + 1312, + 1314, + 5, + 149, + 0, + 0, + 1313, + 1312, + 1, + 0, + 0, + 0, + 1313, + 1314, + 1, + 0, + 0, + 0, + 1314, + 1315, + 1, + 0, + 0, + 0, + 1315, + 1317, + 3, + 290, + 145, + 0, + 1316, + 1318, + 5, + 149, + 0, + 0, + 1317, + 1316, + 1, + 0, + 0, + 0, + 1317, + 1318, + 1, + 0, + 0, + 0, + 1318, + 1319, + 1, + 0, + 0, + 0, + 1319, + 1320, + 3, + 288, + 144, + 0, + 1320, + 1334, + 1, + 0, + 0, + 0, + 1321, + 1323, + 3, + 290, + 145, + 0, + 1322, + 1324, + 5, + 149, + 0, + 0, + 1323, + 1322, + 1, + 0, + 0, + 0, + 1323, + 1324, + 1, + 0, + 0, + 0, + 1324, + 1326, + 1, + 0, + 0, + 0, + 1325, + 1327, + 3, + 160, + 80, + 0, + 1326, + 1325, + 1, + 0, + 0, + 0, + 1326, + 1327, + 1, + 0, + 0, + 0, + 1327, + 1329, + 1, + 0, + 0, + 0, + 1328, + 1330, + 5, + 149, + 0, + 0, + 1329, + 1328, + 1, + 0, + 0, + 0, + 1329, + 1330, + 1, + 0, + 0, + 0, + 1330, + 1331, + 1, + 0, + 0, + 0, + 1331, + 1332, + 3, + 290, + 145, + 0, + 1332, + 1334, + 1, + 0, + 0, + 0, + 1333, + 1269, + 1, + 0, + 0, + 0, + 1333, + 1289, + 1, + 0, + 0, + 0, + 1333, + 1305, + 1, + 0, + 0, + 0, + 1333, + 1321, + 1, + 0, + 0, + 0, + 1334, + 159, + 1, + 0, + 0, + 0, + 1335, + 1337, + 5, + 5, + 0, + 0, + 1336, + 1338, + 5, + 149, + 0, + 0, + 1337, + 1336, + 1, + 0, + 0, + 0, + 1337, + 1338, + 1, + 0, + 0, + 0, + 1338, + 1343, + 1, + 0, + 0, + 0, + 1339, + 1341, + 3, + 258, + 129, + 0, + 1340, + 1342, + 5, + 149, + 0, + 0, + 1341, + 1340, + 1, + 0, + 0, + 0, + 1341, + 1342, + 1, + 0, + 0, + 0, + 1342, + 1344, + 1, + 0, + 0, + 0, + 1343, + 1339, + 1, + 0, + 0, + 0, + 1343, + 1344, + 1, + 0, + 0, + 0, + 1344, + 1349, + 1, + 0, + 0, + 0, + 1345, + 1347, + 3, + 166, + 83, + 0, + 1346, + 1348, + 5, + 149, + 0, + 0, + 1347, + 1346, + 1, + 0, + 0, + 0, + 1347, + 1348, + 1, + 0, + 0, + 0, + 1348, + 1350, + 1, + 0, + 0, + 0, + 1349, + 1345, + 1, + 0, + 0, + 0, + 1349, + 1350, + 1, + 0, + 0, + 0, + 1350, + 1352, + 1, + 0, + 0, + 0, + 1351, + 1353, + 3, + 172, + 86, + 0, + 1352, + 1351, + 1, + 0, + 0, + 0, + 1352, + 1353, + 1, + 0, + 0, + 0, + 1353, + 1358, + 1, + 0, + 0, + 0, + 1354, + 1356, + 3, + 162, + 81, + 0, + 1355, + 1357, + 5, + 149, + 0, + 0, + 1356, + 1355, + 1, + 0, + 0, + 0, + 1356, + 1357, + 1, + 0, + 0, + 0, + 1357, + 1359, + 1, + 0, + 0, + 0, + 1358, + 1354, + 1, + 0, + 0, + 0, + 1358, + 1359, + 1, + 0, + 0, + 0, + 1359, + 1360, + 1, + 0, + 0, + 0, + 1360, + 1361, + 5, + 6, + 0, + 0, + 1361, + 161, + 1, + 0, + 0, + 0, + 1362, + 1366, + 3, + 272, + 136, + 0, + 1363, + 1366, + 3, + 278, + 139, + 0, + 1364, + 1366, + 3, + 276, + 138, + 0, + 1365, + 1362, + 1, + 0, + 0, + 0, + 1365, + 1363, + 1, + 0, + 0, + 0, + 1365, + 1364, + 1, + 0, + 0, + 0, + 1366, + 163, + 1, + 0, + 0, + 0, + 1367, + 1369, + 5, + 11, + 0, + 0, + 1368, + 1370, + 5, + 149, + 0, + 0, + 1369, + 1368, + 1, + 0, + 0, + 0, + 1369, + 1370, + 1, + 0, + 0, + 0, + 1370, + 1371, + 1, + 0, + 0, + 0, + 1371, + 1372, + 3, + 176, + 88, + 0, + 1372, + 165, + 1, + 0, + 0, + 0, + 1373, + 1375, + 5, + 11, + 0, + 0, + 1374, + 1376, + 5, + 149, + 0, + 0, + 1375, + 1374, + 1, + 0, + 0, + 0, + 1375, + 1376, + 1, + 0, + 0, + 0, + 1376, + 1377, + 1, + 0, + 0, + 0, + 1377, + 1391, + 3, + 176, + 88, + 0, + 1378, + 1380, + 5, + 149, + 0, + 0, + 1379, + 1378, + 1, + 0, + 0, + 0, + 1379, + 1380, + 1, + 0, + 0, + 0, + 1380, + 1381, + 1, + 0, + 0, + 0, + 1381, + 1383, + 5, + 9, + 0, + 0, + 1382, + 1384, + 5, + 11, + 0, + 0, + 1383, + 1382, + 1, + 0, + 0, + 0, + 1383, + 1384, + 1, + 0, + 0, + 0, + 1384, + 1386, + 1, + 0, + 0, + 0, + 1385, + 1387, + 5, + 149, + 0, + 0, + 1386, + 1385, + 1, + 0, + 0, + 0, + 1386, + 1387, + 1, + 0, + 0, + 0, + 1387, + 1388, + 1, + 0, + 0, + 0, + 1388, + 1390, + 3, + 176, + 88, + 0, + 1389, + 1379, + 1, + 0, + 0, + 0, + 1390, + 1393, + 1, + 0, + 0, + 0, + 1391, + 1389, + 1, + 0, + 0, + 0, + 1391, + 1392, + 1, + 0, + 0, + 0, + 1392, + 167, + 1, + 0, + 0, + 0, + 1393, + 1391, + 1, + 0, + 0, + 0, + 1394, + 1401, + 3, + 170, + 85, + 0, + 1395, + 1397, + 5, + 149, + 0, + 0, + 1396, + 1395, + 1, + 0, + 0, + 0, + 1396, + 1397, + 1, + 0, + 0, + 0, + 1397, + 1398, + 1, + 0, + 0, + 0, + 1398, + 1400, + 3, + 170, + 85, + 0, + 1399, + 1396, + 1, + 0, + 0, + 0, + 1400, + 1403, + 1, + 0, + 0, + 0, + 1401, + 1399, + 1, + 0, + 0, + 0, + 1401, + 1402, + 1, + 0, + 0, + 0, + 1402, + 169, + 1, + 0, + 0, + 0, + 1403, + 1401, + 1, + 0, + 0, + 0, + 1404, + 1406, + 5, + 11, + 0, + 0, + 1405, + 1407, + 5, + 149, + 0, + 0, + 1406, + 1405, + 1, + 0, + 0, + 0, + 1406, + 1407, + 1, + 0, + 0, + 0, + 1407, + 1408, + 1, + 0, + 0, + 0, + 1408, + 1409, + 3, + 174, + 87, + 0, + 1409, + 171, + 1, + 0, + 0, + 0, + 1410, + 1412, + 5, + 10, + 0, + 0, + 1411, + 1413, + 5, + 149, + 0, + 0, + 1412, + 1411, + 1, + 0, + 0, + 0, + 1412, + 1413, + 1, + 0, + 0, + 0, + 1413, + 1418, + 1, + 0, + 0, + 0, + 1414, + 1416, + 3, + 266, + 133, + 0, + 1415, + 1417, + 5, + 149, + 0, + 0, + 1416, + 1415, + 1, + 0, + 0, + 0, + 1416, + 1417, + 1, + 0, + 0, + 0, + 1417, + 1419, + 1, + 0, + 0, + 0, + 1418, + 1414, + 1, + 0, + 0, + 0, + 1418, + 1419, + 1, + 0, + 0, + 0, + 1419, + 1430, + 1, + 0, + 0, + 0, + 1420, + 1422, + 5, + 12, + 0, + 0, + 1421, + 1423, + 5, + 149, + 0, + 0, + 1422, + 1421, + 1, + 0, + 0, + 0, + 1422, + 1423, + 1, + 0, + 0, + 0, + 1423, + 1428, + 1, + 0, + 0, + 0, + 1424, + 1426, + 3, + 266, + 133, + 0, + 1425, + 1427, + 5, + 149, + 0, + 0, + 1426, + 1425, + 1, + 0, + 0, + 0, + 1426, + 1427, + 1, + 0, + 0, + 0, + 1427, + 1429, + 1, + 0, + 0, + 0, + 1428, + 1424, + 1, + 0, + 0, + 0, + 1428, + 1429, + 1, + 0, + 0, + 0, + 1429, + 1431, + 1, + 0, + 0, + 0, + 1430, + 1420, + 1, + 0, + 0, + 0, + 1430, + 1431, + 1, + 0, + 0, + 0, + 1431, + 173, + 1, + 0, + 0, + 0, + 1432, + 1433, + 3, + 280, + 140, + 0, + 1433, + 175, + 1, + 0, + 0, + 0, + 1434, + 1435, + 3, + 280, + 140, + 0, + 1435, + 177, + 1, + 0, + 0, + 0, + 1436, + 1441, + 3, + 218, + 109, + 0, + 1437, + 1439, + 5, + 149, + 0, + 0, + 1438, + 1437, + 1, + 0, + 0, + 0, + 1438, + 1439, + 1, + 0, + 0, + 0, + 1439, + 1440, + 1, + 0, + 0, + 0, + 1440, + 1442, + 3, + 216, + 108, + 0, + 1441, + 1438, + 1, + 0, + 0, + 0, + 1442, + 1443, + 1, + 0, + 0, + 0, + 1443, + 1441, + 1, + 0, + 0, + 0, + 1443, + 1444, + 1, + 0, + 0, + 0, + 1444, + 179, + 1, + 0, + 0, + 0, + 1445, + 1446, + 3, + 182, + 91, + 0, + 1446, + 181, + 1, + 0, + 0, + 0, + 1447, + 1454, + 3, + 184, + 92, + 0, + 1448, + 1449, + 5, + 149, + 0, + 0, + 1449, + 1450, + 5, + 102, + 0, + 0, + 1450, + 1451, + 5, + 149, + 0, + 0, + 1451, + 1453, + 3, + 184, + 92, + 0, + 1452, + 1448, + 1, + 0, + 0, + 0, + 1453, + 1456, + 1, + 0, + 0, + 0, + 1454, + 1452, + 1, + 0, + 0, + 0, + 1454, + 1455, + 1, + 0, + 0, + 0, + 1455, + 183, + 1, + 0, + 0, + 0, + 1456, + 1454, + 1, + 0, + 0, + 0, + 1457, + 1464, + 3, + 186, + 93, + 0, + 1458, + 1459, + 5, + 149, + 0, + 0, + 1459, + 1460, + 5, + 103, + 0, + 0, + 1460, + 1461, + 5, + 149, + 0, + 0, + 1461, + 1463, + 3, + 186, + 93, + 0, + 1462, + 1458, + 1, + 0, + 0, + 0, + 1463, + 1466, + 1, + 0, + 0, + 0, + 1464, + 1462, + 1, + 0, + 0, + 0, + 1464, + 1465, + 1, + 0, + 0, + 0, + 1465, + 185, + 1, + 0, + 0, + 0, + 1466, + 1464, + 1, + 0, + 0, + 0, + 1467, + 1474, + 3, + 188, + 94, + 0, + 1468, + 1469, + 5, + 149, + 0, + 0, + 1469, + 1470, + 5, + 104, + 0, + 0, + 1470, + 1471, + 5, + 149, + 0, + 0, + 1471, + 1473, + 3, + 188, + 94, + 0, + 1472, + 1468, + 1, + 0, + 0, + 0, + 1473, + 1476, + 1, + 0, + 0, + 0, + 1474, + 1472, + 1, + 0, + 0, + 0, + 1474, + 1475, + 1, + 0, + 0, + 0, + 1475, + 187, + 1, + 0, + 0, + 0, + 1476, + 1474, + 1, + 0, + 0, + 0, + 1477, + 1479, + 5, + 105, + 0, + 0, + 1478, + 1480, + 5, + 149, + 0, + 0, + 1479, + 1478, + 1, + 0, + 0, + 0, + 1479, + 1480, + 1, + 0, + 0, + 0, + 1480, + 1482, + 1, + 0, + 0, + 0, + 1481, + 1477, + 1, + 0, + 0, + 0, + 1482, + 1485, + 1, + 0, + 0, + 0, + 1483, + 1481, + 1, + 0, + 0, + 0, + 1483, + 1484, + 1, + 0, + 0, + 0, + 1484, + 1486, + 1, + 0, + 0, + 0, + 1485, + 1483, + 1, + 0, + 0, + 0, + 1486, + 1487, + 3, + 190, + 95, + 0, + 1487, + 189, + 1, + 0, + 0, + 0, + 1488, + 1495, + 3, + 194, + 97, + 0, + 1489, + 1491, + 5, + 149, + 0, + 0, + 1490, + 1489, + 1, + 0, + 0, + 0, + 1490, + 1491, + 1, + 0, + 0, + 0, + 1491, + 1492, + 1, + 0, + 0, + 0, + 1492, + 1494, + 3, + 192, + 96, + 0, + 1493, + 1490, + 1, + 0, + 0, + 0, + 1494, + 1497, + 1, + 0, + 0, + 0, + 1495, + 1493, + 1, + 0, + 0, + 0, + 1495, + 1496, + 1, + 0, + 0, + 0, + 1496, + 191, + 1, + 0, + 0, + 0, + 1497, + 1495, + 1, + 0, + 0, + 0, + 1498, + 1500, + 5, + 2, + 0, + 0, + 1499, + 1501, + 5, + 149, + 0, + 0, + 1500, + 1499, + 1, + 0, + 0, + 0, + 1500, + 1501, + 1, + 0, + 0, + 0, + 1501, + 1502, + 1, + 0, + 0, + 0, + 1502, + 1529, + 3, + 194, + 97, + 0, + 1503, + 1505, + 5, + 13, + 0, + 0, + 1504, + 1506, + 5, + 149, + 0, + 0, + 1505, + 1504, + 1, + 0, + 0, + 0, + 1505, + 1506, + 1, + 0, + 0, + 0, + 1506, + 1507, + 1, + 0, + 0, + 0, + 1507, + 1529, + 3, + 194, + 97, + 0, + 1508, + 1510, + 5, + 14, + 0, + 0, + 1509, + 1511, + 5, + 149, + 0, + 0, + 1510, + 1509, + 1, + 0, + 0, + 0, + 1510, + 1511, + 1, + 0, + 0, + 0, + 1511, + 1512, + 1, + 0, + 0, + 0, + 1512, + 1529, + 3, + 194, + 97, + 0, + 1513, + 1515, + 5, + 15, + 0, + 0, + 1514, + 1516, + 5, + 149, + 0, + 0, + 1515, + 1514, + 1, + 0, + 0, + 0, + 1515, + 1516, + 1, + 0, + 0, + 0, + 1516, + 1517, + 1, + 0, + 0, + 0, + 1517, + 1529, + 3, + 194, + 97, + 0, + 1518, + 1520, + 5, + 16, + 0, + 0, + 1519, + 1521, + 5, + 149, + 0, + 0, + 1520, + 1519, + 1, + 0, + 0, + 0, + 1520, + 1521, + 1, + 0, + 0, + 0, + 1521, + 1522, + 1, + 0, + 0, + 0, + 1522, + 1529, + 3, + 194, + 97, + 0, + 1523, + 1525, + 5, + 17, + 0, + 0, + 1524, + 1526, + 5, + 149, + 0, + 0, + 1525, + 1524, + 1, + 0, + 0, + 0, + 1525, + 1526, + 1, + 0, + 0, + 0, + 1526, + 1527, + 1, + 0, + 0, + 0, + 1527, + 1529, + 3, + 194, + 97, + 0, + 1528, + 1498, + 1, + 0, + 0, + 0, + 1528, + 1503, + 1, + 0, + 0, + 0, + 1528, + 1508, + 1, + 0, + 0, + 0, + 1528, + 1513, + 1, + 0, + 0, + 0, + 1528, + 1518, + 1, + 0, + 0, + 0, + 1528, + 1523, + 1, + 0, + 0, + 0, + 1529, + 193, + 1, + 0, + 0, + 0, + 1530, + 1536, + 3, + 204, + 102, + 0, + 1531, + 1535, + 3, + 196, + 98, + 0, + 1532, + 1535, + 3, + 198, + 99, + 0, + 1533, + 1535, + 3, + 200, + 100, + 0, + 1534, + 1531, + 1, + 0, + 0, + 0, + 1534, + 1532, + 1, + 0, + 0, + 0, + 1534, + 1533, + 1, + 0, + 0, + 0, + 1535, + 1538, + 1, + 0, + 0, + 0, + 1536, + 1534, + 1, + 0, + 0, + 0, + 1536, + 1537, + 1, + 0, + 0, + 0, + 1537, + 195, + 1, + 0, + 0, + 0, + 1538, + 1536, + 1, + 0, + 0, + 0, + 1539, + 1551, + 3, + 202, + 101, + 0, + 1540, + 1541, + 5, + 149, + 0, + 0, + 1541, + 1542, + 5, + 106, + 0, + 0, + 1542, + 1543, + 5, + 149, + 0, + 0, + 1543, + 1551, + 5, + 66, + 0, + 0, + 1544, + 1545, + 5, + 149, + 0, + 0, + 1545, + 1546, + 5, + 107, + 0, + 0, + 1546, + 1547, + 5, + 149, + 0, + 0, + 1547, + 1551, + 5, + 66, + 0, + 0, + 1548, + 1549, + 5, + 149, + 0, + 0, + 1549, + 1551, + 5, + 108, + 0, + 0, + 1550, + 1539, + 1, + 0, + 0, + 0, + 1550, + 1540, + 1, + 0, + 0, + 0, + 1550, + 1544, + 1, + 0, + 0, + 0, + 1550, + 1548, + 1, + 0, + 0, + 0, + 1551, + 1553, + 1, + 0, + 0, + 0, + 1552, + 1554, + 5, + 149, + 0, + 0, + 1553, + 1552, + 1, + 0, + 0, + 0, + 1553, + 1554, + 1, + 0, + 0, + 0, + 1554, + 1555, + 1, + 0, + 0, + 0, + 1555, + 1556, + 3, + 204, + 102, + 0, + 1556, + 197, + 1, + 0, + 0, + 0, + 1557, + 1558, + 5, + 149, + 0, + 0, + 1558, + 1560, + 5, + 80, + 0, + 0, + 1559, + 1561, + 5, + 149, + 0, + 0, + 1560, + 1559, + 1, + 0, + 0, + 0, + 1560, + 1561, + 1, + 0, + 0, + 0, + 1561, + 1562, + 1, + 0, + 0, + 0, + 1562, + 1563, + 3, + 204, + 102, + 0, + 1563, + 199, + 1, + 0, + 0, + 0, + 1564, + 1565, + 5, + 149, + 0, + 0, + 1565, + 1566, + 5, + 61, + 0, + 0, + 1566, + 1567, + 5, + 149, + 0, + 0, + 1567, + 1575, + 5, + 109, + 0, + 0, + 1568, + 1569, + 5, + 149, + 0, + 0, + 1569, + 1570, + 5, + 61, + 0, + 0, + 1570, + 1571, + 5, + 149, + 0, + 0, + 1571, + 1572, + 5, + 105, + 0, + 0, + 1572, + 1573, + 5, + 149, + 0, + 0, + 1573, + 1575, + 5, + 109, + 0, + 0, + 1574, + 1564, + 1, + 0, + 0, + 0, + 1574, + 1568, + 1, + 0, + 0, + 0, + 1575, + 201, + 1, + 0, + 0, + 0, + 1576, + 1578, + 5, + 149, + 0, + 0, + 1577, + 1576, + 1, + 0, + 0, + 0, + 1577, + 1578, + 1, + 0, + 0, + 0, + 1578, + 1579, + 1, + 0, + 0, + 0, + 1579, + 1580, + 5, + 18, + 0, + 0, + 1580, + 203, + 1, + 0, + 0, + 0, + 1581, + 1600, + 3, + 206, + 103, + 0, + 1582, + 1584, + 5, + 149, + 0, + 0, + 1583, + 1582, + 1, + 0, + 0, + 0, + 1583, + 1584, + 1, + 0, + 0, + 0, + 1584, + 1585, + 1, + 0, + 0, + 0, + 1585, + 1587, + 5, + 19, + 0, + 0, + 1586, + 1588, + 5, + 149, + 0, + 0, + 1587, + 1586, + 1, + 0, + 0, + 0, + 1587, + 1588, + 1, + 0, + 0, + 0, + 1588, + 1589, + 1, + 0, + 0, + 0, + 1589, + 1599, + 3, + 206, + 103, + 0, + 1590, + 1592, + 5, + 149, + 0, + 0, + 1591, + 1590, + 1, + 0, + 0, + 0, + 1591, + 1592, + 1, + 0, + 0, + 0, + 1592, + 1593, + 1, + 0, + 0, + 0, + 1593, + 1595, + 5, + 20, + 0, + 0, + 1594, + 1596, + 5, + 149, + 0, + 0, + 1595, + 1594, + 1, + 0, + 0, + 0, + 1595, + 1596, + 1, + 0, + 0, + 0, + 1596, + 1597, + 1, + 0, + 0, + 0, + 1597, + 1599, + 3, + 206, + 103, + 0, + 1598, + 1583, + 1, + 0, + 0, + 0, + 1598, + 1591, + 1, + 0, + 0, + 0, + 1599, + 1602, + 1, + 0, + 0, + 0, + 1600, + 1598, + 1, + 0, + 0, + 0, + 1600, + 1601, + 1, + 0, + 0, + 0, + 1601, + 205, + 1, + 0, + 0, + 0, + 1602, + 1600, + 1, + 0, + 0, + 0, + 1603, + 1630, + 3, + 208, + 104, + 0, + 1604, + 1606, + 5, + 149, + 0, + 0, + 1605, + 1604, + 1, + 0, + 0, + 0, + 1605, + 1606, + 1, + 0, + 0, + 0, + 1606, + 1607, + 1, + 0, + 0, + 0, + 1607, + 1609, + 5, + 10, + 0, + 0, + 1608, + 1610, + 5, + 149, + 0, + 0, + 1609, + 1608, + 1, + 0, + 0, + 0, + 1609, + 1610, + 1, + 0, + 0, + 0, + 1610, + 1611, + 1, + 0, + 0, + 0, + 1611, + 1629, + 3, + 208, + 104, + 0, + 1612, + 1614, + 5, + 149, + 0, + 0, + 1613, + 1612, + 1, + 0, + 0, + 0, + 1613, + 1614, + 1, + 0, + 0, + 0, + 1614, + 1615, + 1, + 0, + 0, + 0, + 1615, + 1617, + 5, + 21, + 0, + 0, + 1616, + 1618, + 5, + 149, + 0, + 0, + 1617, + 1616, + 1, + 0, + 0, + 0, + 1617, + 1618, + 1, + 0, + 0, + 0, + 1618, + 1619, + 1, + 0, + 0, + 0, + 1619, + 1629, + 3, + 208, + 104, + 0, + 1620, + 1622, + 5, + 149, + 0, + 0, + 1621, + 1620, + 1, + 0, + 0, + 0, + 1621, + 1622, + 1, + 0, + 0, + 0, + 1622, + 1623, + 1, + 0, + 0, + 0, + 1623, + 1625, + 5, + 22, + 0, + 0, + 1624, + 1626, + 5, + 149, + 0, + 0, + 1625, + 1624, + 1, + 0, + 0, + 0, + 1625, + 1626, + 1, + 0, + 0, + 0, + 1626, + 1627, + 1, + 0, + 0, + 0, + 1627, + 1629, + 3, + 208, + 104, + 0, + 1628, + 1605, + 1, + 0, + 0, + 0, + 1628, + 1613, + 1, + 0, + 0, + 0, + 1628, + 1621, + 1, + 0, + 0, + 0, + 1629, + 1632, + 1, + 0, + 0, + 0, + 1630, + 1628, + 1, + 0, + 0, + 0, + 1630, + 1631, + 1, + 0, + 0, + 0, + 1631, + 207, + 1, + 0, + 0, + 0, + 1632, + 1630, + 1, + 0, + 0, + 0, + 1633, + 1644, + 3, + 210, + 105, + 0, + 1634, + 1636, + 5, + 149, + 0, + 0, + 1635, + 1634, + 1, + 0, + 0, + 0, + 1635, + 1636, + 1, + 0, + 0, + 0, + 1636, + 1637, + 1, + 0, + 0, + 0, + 1637, + 1639, + 5, + 23, + 0, + 0, + 1638, + 1640, + 5, + 149, + 0, + 0, + 1639, + 1638, + 1, + 0, + 0, + 0, + 1639, + 1640, + 1, + 0, + 0, + 0, + 1640, + 1641, + 1, + 0, + 0, + 0, + 1641, + 1643, + 3, + 210, + 105, + 0, + 1642, + 1635, + 1, + 0, + 0, + 0, + 1643, + 1646, + 1, + 0, + 0, + 0, + 1644, + 1642, + 1, + 0, + 0, + 0, + 1644, + 1645, + 1, + 0, + 0, + 0, + 1645, + 209, + 1, + 0, + 0, + 0, + 1646, + 1644, + 1, + 0, + 0, + 0, + 1647, + 1654, + 3, + 212, + 106, + 0, + 1648, + 1650, + 7, + 2, + 0, + 0, + 1649, + 1651, + 5, + 149, + 0, + 0, + 1650, + 1649, + 1, + 0, + 0, + 0, + 1650, + 1651, + 1, + 0, + 0, + 0, + 1651, + 1652, + 1, + 0, + 0, + 0, + 1652, + 1654, + 3, + 212, + 106, + 0, + 1653, + 1647, + 1, + 0, + 0, + 0, + 1653, + 1648, + 1, + 0, + 0, + 0, + 1654, + 211, + 1, + 0, + 0, + 0, + 1655, + 1666, + 3, + 218, + 109, + 0, + 1656, + 1658, + 5, + 149, + 0, + 0, + 1657, + 1656, + 1, + 0, + 0, + 0, + 1657, + 1658, + 1, + 0, + 0, + 0, + 1658, + 1659, + 1, + 0, + 0, + 0, + 1659, + 1665, + 3, + 214, + 107, + 0, + 1660, + 1662, + 5, + 149, + 0, + 0, + 1661, + 1660, + 1, + 0, + 0, + 0, + 1661, + 1662, + 1, + 0, + 0, + 0, + 1662, + 1663, + 1, + 0, + 0, + 0, + 1663, + 1665, + 3, + 216, + 108, + 0, + 1664, + 1657, + 1, + 0, + 0, + 0, + 1664, + 1661, + 1, + 0, + 0, + 0, + 1665, + 1668, + 1, + 0, + 0, + 0, + 1666, + 1664, + 1, + 0, + 0, + 0, + 1666, + 1667, + 1, + 0, + 0, + 0, + 1667, + 1673, + 1, + 0, + 0, + 0, + 1668, + 1666, + 1, + 0, + 0, + 0, + 1669, + 1671, + 5, + 149, + 0, + 0, + 1670, + 1669, + 1, + 0, + 0, + 0, + 1670, + 1671, + 1, + 0, + 0, + 0, + 1671, + 1672, + 1, + 0, + 0, + 0, + 1672, + 1674, + 3, + 168, + 84, + 0, + 1673, + 1670, + 1, + 0, + 0, + 0, + 1673, + 1674, + 1, + 0, + 0, + 0, + 1674, + 213, + 1, + 0, + 0, + 0, + 1675, + 1676, + 5, + 5, + 0, + 0, + 1676, + 1677, + 3, + 180, + 90, + 0, + 1677, + 1678, + 5, + 6, + 0, + 0, + 1678, + 1689, + 1, + 0, + 0, + 0, + 1679, + 1681, + 5, + 5, + 0, + 0, + 1680, + 1682, + 3, + 180, + 90, + 0, + 1681, + 1680, + 1, + 0, + 0, + 0, + 1681, + 1682, + 1, + 0, + 0, + 0, + 1682, + 1683, + 1, + 0, + 0, + 0, + 1683, + 1685, + 5, + 12, + 0, + 0, + 1684, + 1686, + 3, + 180, + 90, + 0, + 1685, + 1684, + 1, + 0, + 0, + 0, + 1685, + 1686, + 1, + 0, + 0, + 0, + 1686, + 1687, + 1, + 0, + 0, + 0, + 1687, + 1689, + 5, + 6, + 0, + 0, + 1688, + 1675, + 1, + 0, + 0, + 0, + 1688, + 1679, + 1, + 0, + 0, + 0, + 1689, + 215, + 1, + 0, + 0, + 0, + 1690, + 1692, + 5, + 24, + 0, + 0, + 1691, + 1693, + 5, + 149, + 0, + 0, + 1692, + 1691, + 1, + 0, + 0, + 0, + 1692, + 1693, + 1, + 0, + 0, + 0, + 1693, + 1694, + 1, + 0, + 0, + 0, + 1694, + 1695, + 3, + 274, + 137, + 0, + 1695, + 217, + 1, + 0, + 0, + 0, + 1696, + 1725, + 3, + 260, + 130, + 0, + 1697, + 1725, + 3, + 278, + 139, + 0, + 1698, + 1725, + 3, + 276, + 138, + 0, + 1699, + 1725, + 3, + 220, + 110, + 0, + 1700, + 1702, + 5, + 110, + 0, + 0, + 1701, + 1703, + 5, + 149, + 0, + 0, + 1702, + 1701, + 1, + 0, + 0, + 0, + 1702, + 1703, + 1, + 0, + 0, + 0, + 1703, + 1704, + 1, + 0, + 0, + 0, + 1704, + 1706, + 5, + 3, + 0, + 0, + 1705, + 1707, + 5, + 149, + 0, + 0, + 1706, + 1705, + 1, + 0, + 0, + 0, + 1706, + 1707, + 1, + 0, + 0, + 0, + 1707, + 1708, + 1, + 0, + 0, + 0, + 1708, + 1710, + 5, + 10, + 0, + 0, + 1709, + 1711, + 5, + 149, + 0, + 0, + 1710, + 1709, + 1, + 0, + 0, + 0, + 1710, + 1711, + 1, + 0, + 0, + 0, + 1711, + 1712, + 1, + 0, + 0, + 0, + 1712, + 1725, + 5, + 4, + 0, + 0, + 1713, + 1725, + 3, + 224, + 112, + 0, + 1714, + 1725, + 3, + 226, + 113, + 0, + 1715, + 1725, + 3, + 228, + 114, + 0, + 1716, + 1725, + 3, + 230, + 115, + 0, + 1717, + 1725, + 3, + 232, + 116, + 0, + 1718, + 1725, + 3, + 148, + 74, + 0, + 1719, + 1725, + 3, + 236, + 118, + 0, + 1720, + 1725, + 3, + 238, + 119, + 0, + 1721, + 1725, + 3, + 242, + 121, + 0, + 1722, + 1725, + 3, + 246, + 123, + 0, + 1723, + 1725, + 3, + 258, + 129, + 0, + 1724, + 1696, + 1, + 0, + 0, + 0, + 1724, + 1697, + 1, + 0, + 0, + 0, + 1724, + 1698, + 1, + 0, + 0, + 0, + 1724, + 1699, + 1, + 0, + 0, + 0, + 1724, + 1700, + 1, + 0, + 0, + 0, + 1724, + 1713, + 1, + 0, + 0, + 0, + 1724, + 1714, + 1, + 0, + 0, + 0, + 1724, + 1715, + 1, + 0, + 0, + 0, + 1724, + 1716, + 1, + 0, + 0, + 0, + 1724, + 1717, + 1, + 0, + 0, + 0, + 1724, + 1718, + 1, + 0, + 0, + 0, + 1724, + 1719, + 1, + 0, + 0, + 0, + 1724, + 1720, + 1, + 0, + 0, + 0, + 1724, + 1721, + 1, + 0, + 0, + 0, + 1724, + 1722, + 1, + 0, + 0, + 0, + 1724, + 1723, + 1, + 0, + 0, + 0, + 1725, + 219, + 1, + 0, + 0, + 0, + 1726, + 1731, + 5, + 111, + 0, + 0, + 1727, + 1729, + 5, + 149, + 0, + 0, + 1728, + 1727, + 1, + 0, + 0, + 0, + 1728, + 1729, + 1, + 0, + 0, + 0, + 1729, + 1730, + 1, + 0, + 0, + 0, + 1730, + 1732, + 3, + 222, + 111, + 0, + 1731, + 1728, + 1, + 0, + 0, + 0, + 1732, + 1733, + 1, + 0, + 0, + 0, + 1733, + 1731, + 1, + 0, + 0, + 0, + 1733, + 1734, + 1, + 0, + 0, + 0, + 1734, + 1749, + 1, + 0, + 0, + 0, + 1735, + 1737, + 5, + 111, + 0, + 0, + 1736, + 1738, + 5, + 149, + 0, + 0, + 1737, + 1736, + 1, + 0, + 0, + 0, + 1737, + 1738, + 1, + 0, + 0, + 0, + 1738, + 1739, + 1, + 0, + 0, + 0, + 1739, + 1744, + 3, + 180, + 90, + 0, + 1740, + 1742, + 5, + 149, + 0, + 0, + 1741, + 1740, + 1, + 0, + 0, + 0, + 1741, + 1742, + 1, + 0, + 0, + 0, + 1742, + 1743, + 1, + 0, + 0, + 0, + 1743, + 1745, + 3, + 222, + 111, + 0, + 1744, + 1741, + 1, + 0, + 0, + 0, + 1745, + 1746, + 1, + 0, + 0, + 0, + 1746, + 1744, + 1, + 0, + 0, + 0, + 1746, + 1747, + 1, + 0, + 0, + 0, + 1747, + 1749, + 1, + 0, + 0, + 0, + 1748, + 1726, + 1, + 0, + 0, + 0, + 1748, + 1735, + 1, + 0, + 0, + 0, + 1749, + 1758, + 1, + 0, + 0, + 0, + 1750, + 1752, + 5, + 149, + 0, + 0, + 1751, + 1750, + 1, + 0, + 0, + 0, + 1751, + 1752, + 1, + 0, + 0, + 0, + 1752, + 1753, + 1, + 0, + 0, + 0, + 1753, + 1755, + 5, + 112, + 0, + 0, + 1754, + 1756, + 5, + 149, + 0, + 0, + 1755, + 1754, + 1, + 0, + 0, + 0, + 1755, + 1756, + 1, + 0, + 0, + 0, + 1756, + 1757, + 1, + 0, + 0, + 0, + 1757, + 1759, + 3, + 180, + 90, + 0, + 1758, + 1751, + 1, + 0, + 0, + 0, + 1758, + 1759, + 1, + 0, + 0, + 0, + 1759, + 1761, + 1, + 0, + 0, + 0, + 1760, + 1762, + 5, + 149, + 0, + 0, + 1761, + 1760, + 1, + 0, + 0, + 0, + 1761, + 1762, + 1, + 0, + 0, + 0, + 1762, + 1763, + 1, + 0, + 0, + 0, + 1763, + 1764, + 5, + 113, + 0, + 0, + 1764, + 221, + 1, + 0, + 0, + 0, + 1765, + 1767, + 5, + 114, + 0, + 0, + 1766, + 1768, + 5, + 149, + 0, + 0, + 1767, + 1766, + 1, + 0, + 0, + 0, + 1767, + 1768, + 1, + 0, + 0, + 0, + 1768, + 1769, + 1, + 0, + 0, + 0, + 1769, + 1771, + 3, + 180, + 90, + 0, + 1770, + 1772, + 5, + 149, + 0, + 0, + 1771, + 1770, + 1, + 0, + 0, + 0, + 1771, + 1772, + 1, + 0, + 0, + 0, + 1772, + 1773, + 1, + 0, + 0, + 0, + 1773, + 1775, + 5, + 115, + 0, + 0, + 1774, + 1776, + 5, + 149, + 0, + 0, + 1775, + 1774, + 1, + 0, + 0, + 0, + 1775, + 1776, + 1, + 0, + 0, + 0, + 1776, + 1777, + 1, + 0, + 0, + 0, + 1777, + 1778, + 3, + 180, + 90, + 0, + 1778, + 223, + 1, + 0, + 0, + 0, + 1779, + 1781, + 5, + 5, + 0, + 0, + 1780, + 1782, + 5, + 149, + 0, + 0, + 1781, + 1780, + 1, + 0, + 0, + 0, + 1781, + 1782, + 1, + 0, + 0, + 0, + 1782, + 1783, + 1, + 0, + 0, + 0, + 1783, + 1792, + 3, + 234, + 117, + 0, + 1784, + 1786, + 5, + 149, + 0, + 0, + 1785, + 1784, + 1, + 0, + 0, + 0, + 1785, + 1786, + 1, + 0, + 0, + 0, + 1786, + 1787, + 1, + 0, + 0, + 0, + 1787, + 1789, + 5, + 9, + 0, + 0, + 1788, + 1790, + 5, + 149, + 0, + 0, + 1789, + 1788, + 1, + 0, + 0, + 0, + 1789, + 1790, + 1, + 0, + 0, + 0, + 1790, + 1791, + 1, + 0, + 0, + 0, + 1791, + 1793, + 3, + 180, + 90, + 0, + 1792, + 1785, + 1, + 0, + 0, + 0, + 1792, + 1793, + 1, + 0, + 0, + 0, + 1793, + 1795, + 1, + 0, + 0, + 0, + 1794, + 1796, + 5, + 149, + 0, + 0, + 1795, + 1794, + 1, + 0, + 0, + 0, + 1795, + 1796, + 1, + 0, + 0, + 0, + 1796, + 1797, + 1, + 0, + 0, + 0, + 1797, + 1798, + 5, + 6, + 0, + 0, + 1798, + 225, + 1, + 0, + 0, + 0, + 1799, + 1801, + 5, + 5, + 0, + 0, + 1800, + 1802, + 5, + 149, + 0, + 0, + 1801, + 1800, + 1, + 0, + 0, + 0, + 1801, + 1802, + 1, + 0, + 0, + 0, + 1802, + 1811, + 1, + 0, + 0, + 0, + 1803, + 1805, + 3, + 258, + 129, + 0, + 1804, + 1806, + 5, + 149, + 0, + 0, + 1805, + 1804, + 1, + 0, + 0, + 0, + 1805, + 1806, + 1, + 0, + 0, + 0, + 1806, + 1807, + 1, + 0, + 0, + 0, + 1807, + 1809, + 5, + 2, + 0, + 0, + 1808, + 1810, + 5, + 149, + 0, + 0, + 1809, + 1808, + 1, + 0, + 0, + 0, + 1809, + 1810, + 1, + 0, + 0, + 0, + 1810, + 1812, + 1, + 0, + 0, + 0, + 1811, + 1803, + 1, + 0, + 0, + 0, + 1811, + 1812, + 1, + 0, + 0, + 0, + 1812, + 1813, + 1, + 0, + 0, + 0, + 1813, + 1815, + 3, + 152, + 76, + 0, + 1814, + 1816, + 5, + 149, + 0, + 0, + 1815, + 1814, + 1, + 0, + 0, + 0, + 1815, + 1816, + 1, + 0, + 0, + 0, + 1816, + 1821, + 1, + 0, + 0, + 0, + 1817, + 1819, + 3, + 140, + 70, + 0, + 1818, + 1820, + 5, + 149, + 0, + 0, + 1819, + 1818, + 1, + 0, + 0, + 0, + 1819, + 1820, + 1, + 0, + 0, + 0, + 1820, + 1822, + 1, + 0, + 0, + 0, + 1821, + 1817, + 1, + 0, + 0, + 0, + 1821, + 1822, + 1, + 0, + 0, + 0, + 1822, + 1823, + 1, + 0, + 0, + 0, + 1823, + 1825, + 5, + 9, + 0, + 0, + 1824, + 1826, + 5, + 149, + 0, + 0, + 1825, + 1824, + 1, + 0, + 0, + 0, + 1825, + 1826, + 1, + 0, + 0, + 0, + 1826, + 1827, + 1, + 0, + 0, + 0, + 1827, + 1829, + 3, + 180, + 90, + 0, + 1828, + 1830, + 5, + 149, + 0, + 0, + 1829, + 1828, + 1, + 0, + 0, + 0, + 1829, + 1830, + 1, + 0, + 0, + 0, + 1830, + 1831, + 1, + 0, + 0, + 0, + 1831, + 1832, + 5, + 6, + 0, + 0, + 1832, + 227, + 1, + 0, + 0, + 0, + 1833, + 1835, + 5, + 116, + 0, + 0, + 1834, + 1836, + 5, + 149, + 0, + 0, + 1835, + 1834, + 1, + 0, + 0, + 0, + 1835, + 1836, + 1, + 0, + 0, + 0, + 1836, + 1837, + 1, + 0, + 0, + 0, + 1837, + 1839, + 5, + 3, + 0, + 0, + 1838, + 1840, + 5, + 149, + 0, + 0, + 1839, + 1838, + 1, + 0, + 0, + 0, + 1839, + 1840, + 1, + 0, + 0, + 0, + 1840, + 1841, + 1, + 0, + 0, + 0, + 1841, + 1843, + 3, + 234, + 117, + 0, + 1842, + 1844, + 5, + 149, + 0, + 0, + 1843, + 1842, + 1, + 0, + 0, + 0, + 1843, + 1844, + 1, + 0, + 0, + 0, + 1844, + 1845, + 1, + 0, + 0, + 0, + 1845, + 1846, + 5, + 4, + 0, + 0, + 1846, + 1869, + 1, + 0, + 0, + 0, + 1847, + 1849, + 5, + 117, + 0, + 0, + 1848, + 1850, + 5, + 149, + 0, + 0, + 1849, + 1848, + 1, + 0, + 0, + 0, + 1849, + 1850, + 1, + 0, + 0, + 0, + 1850, + 1851, + 1, + 0, + 0, + 0, + 1851, + 1853, + 5, + 3, + 0, + 0, + 1852, + 1854, + 5, + 149, + 0, + 0, + 1853, + 1852, + 1, + 0, + 0, + 0, + 1853, + 1854, + 1, + 0, + 0, + 0, + 1854, + 1855, + 1, + 0, + 0, + 0, + 1855, + 1857, + 3, + 234, + 117, + 0, + 1856, + 1858, + 5, + 149, + 0, + 0, + 1857, + 1856, + 1, + 0, + 0, + 0, + 1857, + 1858, + 1, + 0, + 0, + 0, + 1858, + 1864, + 1, + 0, + 0, + 0, + 1859, + 1861, + 5, + 149, + 0, + 0, + 1860, + 1859, + 1, + 0, + 0, + 0, + 1860, + 1861, + 1, + 0, + 0, + 0, + 1861, + 1862, + 1, + 0, + 0, + 0, + 1862, + 1863, + 5, + 9, + 0, + 0, + 1863, + 1865, + 3, + 180, + 90, + 0, + 1864, + 1860, + 1, + 0, + 0, + 0, + 1864, + 1865, + 1, + 0, + 0, + 0, + 1865, + 1866, + 1, + 0, + 0, + 0, + 1866, + 1867, + 5, + 4, + 0, + 0, + 1867, + 1869, + 1, + 0, + 0, + 0, + 1868, + 1833, + 1, + 0, + 0, + 0, + 1868, + 1847, + 1, + 0, + 0, + 0, + 1869, + 229, + 1, + 0, + 0, + 0, + 1870, + 1872, + 5, + 118, + 0, + 0, + 1871, + 1873, + 5, + 149, + 0, + 0, + 1872, + 1871, + 1, + 0, + 0, + 0, + 1872, + 1873, + 1, + 0, + 0, + 0, + 1873, + 1874, + 1, + 0, + 0, + 0, + 1874, + 1875, + 5, + 3, + 0, + 0, + 1875, + 1876, + 3, + 258, + 129, + 0, + 1876, + 1877, + 5, + 2, + 0, + 0, + 1877, + 1878, + 3, + 180, + 90, + 0, + 1878, + 1879, + 5, + 7, + 0, + 0, + 1879, + 1880, + 3, + 240, + 120, + 0, + 1880, + 1881, + 5, + 9, + 0, + 0, + 1881, + 1882, + 3, + 180, + 90, + 0, + 1882, + 1883, + 5, + 4, + 0, + 0, + 1883, + 231, + 1, + 0, + 0, + 0, + 1884, + 1886, + 5, + 54, + 0, + 0, + 1885, + 1887, + 5, + 149, + 0, + 0, + 1886, + 1885, + 1, + 0, + 0, + 0, + 1886, + 1887, + 1, + 0, + 0, + 0, + 1887, + 1888, + 1, + 0, + 0, + 0, + 1888, + 1890, + 5, + 3, + 0, + 0, + 1889, + 1891, + 5, + 149, + 0, + 0, + 1890, + 1889, + 1, + 0, + 0, + 0, + 1890, + 1891, + 1, + 0, + 0, + 0, + 1891, + 1892, + 1, + 0, + 0, + 0, + 1892, + 1894, + 3, + 234, + 117, + 0, + 1893, + 1895, + 5, + 149, + 0, + 0, + 1894, + 1893, + 1, + 0, + 0, + 0, + 1894, + 1895, + 1, + 0, + 0, + 0, + 1895, + 1896, + 1, + 0, + 0, + 0, + 1896, + 1897, + 5, + 4, + 0, + 0, + 1897, + 1941, + 1, + 0, + 0, + 0, + 1898, + 1900, + 5, + 119, + 0, + 0, + 1899, + 1901, + 5, + 149, + 0, + 0, + 1900, + 1899, + 1, + 0, + 0, + 0, + 1900, + 1901, + 1, + 0, + 0, + 0, + 1901, + 1902, + 1, + 0, + 0, + 0, + 1902, + 1904, + 5, + 3, + 0, + 0, + 1903, + 1905, + 5, + 149, + 0, + 0, + 1904, + 1903, + 1, + 0, + 0, + 0, + 1904, + 1905, + 1, + 0, + 0, + 0, + 1905, + 1906, + 1, + 0, + 0, + 0, + 1906, + 1908, + 3, + 234, + 117, + 0, + 1907, + 1909, + 5, + 149, + 0, + 0, + 1908, + 1907, + 1, + 0, + 0, + 0, + 1908, + 1909, + 1, + 0, + 0, + 0, + 1909, + 1910, + 1, + 0, + 0, + 0, + 1910, + 1911, + 5, + 4, + 0, + 0, + 1911, + 1941, + 1, + 0, + 0, + 0, + 1912, + 1914, + 5, + 120, + 0, + 0, + 1913, + 1915, + 5, + 149, + 0, + 0, + 1914, + 1913, + 1, + 0, + 0, + 0, + 1914, + 1915, + 1, + 0, + 0, + 0, + 1915, + 1916, + 1, + 0, + 0, + 0, + 1916, + 1918, + 5, + 3, + 0, + 0, + 1917, + 1919, + 5, + 149, + 0, + 0, + 1918, + 1917, + 1, + 0, + 0, + 0, + 1918, + 1919, + 1, + 0, + 0, + 0, + 1919, + 1920, + 1, + 0, + 0, + 0, + 1920, + 1922, + 3, + 234, + 117, + 0, + 1921, + 1923, + 5, + 149, + 0, + 0, + 1922, + 1921, + 1, + 0, + 0, + 0, + 1922, + 1923, + 1, + 0, + 0, + 0, + 1923, + 1924, + 1, + 0, + 0, + 0, + 1924, + 1925, + 5, + 4, + 0, + 0, + 1925, + 1941, + 1, + 0, + 0, + 0, + 1926, + 1928, + 5, + 121, + 0, + 0, + 1927, + 1929, + 5, + 149, + 0, + 0, + 1928, + 1927, + 1, + 0, + 0, + 0, + 1928, + 1929, + 1, + 0, + 0, + 0, + 1929, + 1930, + 1, + 0, + 0, + 0, + 1930, + 1932, + 5, + 3, + 0, + 0, + 1931, + 1933, + 5, + 149, + 0, + 0, + 1932, + 1931, + 1, + 0, + 0, + 0, + 1932, + 1933, + 1, + 0, + 0, + 0, + 1933, + 1934, + 1, + 0, + 0, + 0, + 1934, + 1936, + 3, + 234, + 117, + 0, + 1935, + 1937, + 5, + 149, + 0, + 0, + 1936, + 1935, + 1, + 0, + 0, + 0, + 1936, + 1937, + 1, + 0, + 0, + 0, + 1937, + 1938, + 1, + 0, + 0, + 0, + 1938, + 1939, + 5, + 4, + 0, + 0, + 1939, + 1941, + 1, + 0, + 0, + 0, + 1940, + 1884, + 1, + 0, + 0, + 0, + 1940, + 1898, + 1, + 0, + 0, + 0, + 1940, + 1912, + 1, + 0, + 0, + 0, + 1940, + 1926, + 1, + 0, + 0, + 0, + 1941, + 233, + 1, + 0, + 0, + 0, + 1942, + 1947, + 3, + 240, + 120, + 0, + 1943, + 1945, + 5, + 149, + 0, + 0, + 1944, + 1943, + 1, + 0, + 0, + 0, + 1944, + 1945, + 1, + 0, + 0, + 0, + 1945, + 1946, + 1, + 0, + 0, + 0, + 1946, + 1948, + 3, + 140, + 70, + 0, + 1947, + 1944, + 1, + 0, + 0, + 0, + 1947, + 1948, + 1, + 0, + 0, + 0, + 1948, + 235, + 1, + 0, + 0, + 0, + 1949, + 1950, + 3, + 152, + 76, + 0, + 1950, + 237, + 1, + 0, + 0, + 0, + 1951, + 1953, + 5, + 3, + 0, + 0, + 1952, + 1954, + 5, + 149, + 0, + 0, + 1953, + 1952, + 1, + 0, + 0, + 0, + 1953, + 1954, + 1, + 0, + 0, + 0, + 1954, + 1955, + 1, + 0, + 0, + 0, + 1955, + 1957, + 3, + 180, + 90, + 0, + 1956, + 1958, + 5, + 149, + 0, + 0, + 1957, + 1956, + 1, + 0, + 0, + 0, + 1957, + 1958, + 1, + 0, + 0, + 0, + 1958, + 1959, + 1, + 0, + 0, + 0, + 1959, + 1960, + 5, + 4, + 0, + 0, + 1960, + 239, + 1, + 0, + 0, + 0, + 1961, + 1962, + 3, + 258, + 129, + 0, + 1962, + 1963, + 5, + 149, + 0, + 0, + 1963, + 1964, + 5, + 80, + 0, + 0, + 1964, + 1965, + 5, + 149, + 0, + 0, + 1965, + 1966, + 3, + 180, + 90, + 0, + 1966, + 241, + 1, + 0, + 0, + 0, + 1967, + 1969, + 3, + 244, + 122, + 0, + 1968, + 1970, + 5, + 149, + 0, + 0, + 1969, + 1968, + 1, + 0, + 0, + 0, + 1969, + 1970, + 1, + 0, + 0, + 0, + 1970, + 1971, + 1, + 0, + 0, + 0, + 1971, + 1973, + 5, + 3, + 0, + 0, + 1972, + 1974, + 5, + 149, + 0, + 0, + 1973, + 1972, + 1, + 0, + 0, + 0, + 1973, + 1974, + 1, + 0, + 0, + 0, + 1974, + 1979, + 1, + 0, + 0, + 0, + 1975, + 1977, + 5, + 84, + 0, + 0, + 1976, + 1978, + 5, + 149, + 0, + 0, + 1977, + 1976, + 1, + 0, + 0, + 0, + 1977, + 1978, + 1, + 0, + 0, + 0, + 1978, + 1980, + 1, + 0, + 0, + 0, + 1979, + 1975, + 1, + 0, + 0, + 0, + 1979, + 1980, + 1, + 0, + 0, + 0, + 1980, + 1998, + 1, + 0, + 0, + 0, + 1981, + 1983, + 3, + 180, + 90, + 0, + 1982, + 1984, + 5, + 149, + 0, + 0, + 1983, + 1982, + 1, + 0, + 0, + 0, + 1983, + 1984, + 1, + 0, + 0, + 0, + 1984, + 1995, + 1, + 0, + 0, + 0, + 1985, + 1987, + 5, + 7, + 0, + 0, + 1986, + 1988, + 5, + 149, + 0, + 0, + 1987, + 1986, + 1, + 0, + 0, + 0, + 1987, + 1988, + 1, + 0, + 0, + 0, + 1988, + 1989, + 1, + 0, + 0, + 0, + 1989, + 1991, + 3, + 180, + 90, + 0, + 1990, + 1992, + 5, + 149, + 0, + 0, + 1991, + 1990, + 1, + 0, + 0, + 0, + 1991, + 1992, + 1, + 0, + 0, + 0, + 1992, + 1994, + 1, + 0, + 0, + 0, + 1993, + 1985, + 1, + 0, + 0, + 0, + 1994, + 1997, + 1, + 0, + 0, + 0, + 1995, + 1993, + 1, + 0, + 0, + 0, + 1995, + 1996, + 1, + 0, + 0, + 0, + 1996, + 1999, + 1, + 0, + 0, + 0, + 1997, + 1995, + 1, + 0, + 0, + 0, + 1998, + 1981, + 1, + 0, + 0, + 0, + 1998, + 1999, + 1, + 0, + 0, + 0, + 1999, + 2000, + 1, + 0, + 0, + 0, + 2000, + 2001, + 5, + 4, + 0, + 0, + 2001, + 243, + 1, + 0, + 0, + 0, + 2002, + 2003, + 3, + 256, + 128, + 0, + 2003, + 2004, + 3, + 284, + 142, + 0, + 2004, + 245, + 1, + 0, + 0, + 0, + 2005, + 2007, + 5, + 63, + 0, + 0, + 2006, + 2008, + 5, + 149, + 0, + 0, + 2007, + 2006, + 1, + 0, + 0, + 0, + 2007, + 2008, + 1, + 0, + 0, + 0, + 2008, + 2009, + 1, + 0, + 0, + 0, + 2009, + 2011, + 5, + 25, + 0, + 0, + 2010, + 2012, + 5, + 149, + 0, + 0, + 2011, + 2010, + 1, + 0, + 0, + 0, + 2011, + 2012, + 1, + 0, + 0, + 0, + 2012, + 2021, + 1, + 0, + 0, + 0, + 2013, + 2022, + 3, + 20, + 10, + 0, + 2014, + 2019, + 3, + 142, + 71, + 0, + 2015, + 2017, + 5, + 149, + 0, + 0, + 2016, + 2015, + 1, + 0, + 0, + 0, + 2016, + 2017, + 1, + 0, + 0, + 0, + 2017, + 2018, + 1, + 0, + 0, + 0, + 2018, + 2020, + 3, + 140, + 70, + 0, + 2019, + 2016, + 1, + 0, + 0, + 0, + 2019, + 2020, + 1, + 0, + 0, + 0, + 2020, + 2022, + 1, + 0, + 0, + 0, + 2021, + 2013, + 1, + 0, + 0, + 0, + 2021, + 2014, + 1, + 0, + 0, + 0, + 2022, + 2024, + 1, + 0, + 0, + 0, + 2023, + 2025, + 5, + 149, + 0, + 0, + 2024, + 2023, + 1, + 0, + 0, + 0, + 2024, + 2025, + 1, + 0, + 0, + 0, + 2025, + 2026, + 1, + 0, + 0, + 0, + 2026, + 2027, + 5, + 26, + 0, + 0, + 2027, + 247, + 1, + 0, + 0, + 0, + 2028, + 2030, + 3, + 254, + 127, + 0, + 2029, + 2031, + 5, + 149, + 0, + 0, + 2030, + 2029, + 1, + 0, + 0, + 0, + 2030, + 2031, + 1, + 0, + 0, + 0, + 2031, + 2032, + 1, + 0, + 0, + 0, + 2032, + 2034, + 5, + 3, + 0, + 0, + 2033, + 2035, + 5, + 149, + 0, + 0, + 2034, + 2033, + 1, + 0, + 0, + 0, + 2034, + 2035, + 1, + 0, + 0, + 0, + 2035, + 2053, + 1, + 0, + 0, + 0, + 2036, + 2038, + 3, + 180, + 90, + 0, + 2037, + 2039, + 5, + 149, + 0, + 0, + 2038, + 2037, + 1, + 0, + 0, + 0, + 2038, + 2039, + 1, + 0, + 0, + 0, + 2039, + 2050, + 1, + 0, + 0, + 0, + 2040, + 2042, + 5, + 7, + 0, + 0, + 2041, + 2043, + 5, + 149, + 0, + 0, + 2042, + 2041, + 1, + 0, + 0, + 0, + 2042, + 2043, + 1, + 0, + 0, + 0, + 2043, + 2044, + 1, + 0, + 0, + 0, + 2044, + 2046, + 3, + 180, + 90, + 0, + 2045, + 2047, + 5, + 149, + 0, + 0, + 2046, + 2045, + 1, + 0, + 0, + 0, + 2046, + 2047, + 1, + 0, + 0, + 0, + 2047, + 2049, + 1, + 0, + 0, + 0, + 2048, + 2040, + 1, + 0, + 0, + 0, + 2049, + 2052, + 1, + 0, + 0, + 0, + 2050, + 2048, + 1, + 0, + 0, + 0, + 2050, + 2051, + 1, + 0, + 0, + 0, + 2051, + 2054, + 1, + 0, + 0, + 0, + 2052, + 2050, + 1, + 0, + 0, + 0, + 2053, + 2036, + 1, + 0, + 0, + 0, + 2053, + 2054, + 1, + 0, + 0, + 0, + 2054, + 2055, + 1, + 0, + 0, + 0, + 2055, + 2056, + 5, + 4, + 0, + 0, + 2056, + 249, + 1, + 0, + 0, + 0, + 2057, + 2058, + 3, + 254, + 127, + 0, + 2058, + 251, + 1, + 0, + 0, + 0, + 2059, + 2060, + 3, + 284, + 142, + 0, + 2060, + 253, + 1, + 0, + 0, + 0, + 2061, + 2062, + 3, + 256, + 128, + 0, + 2062, + 2063, + 3, + 284, + 142, + 0, + 2063, + 255, + 1, + 0, + 0, + 0, + 2064, + 2065, + 3, + 284, + 142, + 0, + 2065, + 2066, + 5, + 24, + 0, + 0, + 2066, + 2068, + 1, + 0, + 0, + 0, + 2067, + 2064, + 1, + 0, + 0, + 0, + 2068, + 2071, + 1, + 0, + 0, + 0, + 2069, + 2067, + 1, + 0, + 0, + 0, + 2069, + 2070, + 1, + 0, + 0, + 0, + 2070, + 257, + 1, + 0, + 0, + 0, + 2071, + 2069, + 1, + 0, + 0, + 0, + 2072, + 2073, + 3, + 284, + 142, + 0, + 2073, + 259, + 1, + 0, + 0, + 0, + 2074, + 2081, + 3, + 262, + 131, + 0, + 2075, + 2081, + 5, + 109, + 0, + 0, + 2076, + 2081, + 3, + 264, + 132, + 0, + 2077, + 2081, + 5, + 136, + 0, + 0, + 2078, + 2081, + 3, + 270, + 135, + 0, + 2079, + 2081, + 3, + 272, + 136, + 0, + 2080, + 2074, + 1, + 0, + 0, + 0, + 2080, + 2075, + 1, + 0, + 0, + 0, + 2080, + 2076, + 1, + 0, + 0, + 0, + 2080, + 2077, + 1, + 0, + 0, + 0, + 2080, + 2078, + 1, + 0, + 0, + 0, + 2080, + 2079, + 1, + 0, + 0, + 0, + 2081, + 261, + 1, + 0, + 0, + 0, + 2082, + 2083, + 7, + 3, + 0, + 0, + 2083, + 263, + 1, + 0, + 0, + 0, + 2084, + 2087, + 3, + 268, + 134, + 0, + 2085, + 2087, + 3, + 266, + 133, + 0, + 2086, + 2084, + 1, + 0, + 0, + 0, + 2086, + 2085, + 1, + 0, + 0, + 0, + 2087, + 265, + 1, + 0, + 0, + 0, + 2088, + 2089, + 7, + 4, + 0, + 0, + 2089, + 267, + 1, + 0, + 0, + 0, + 2090, + 2091, + 7, + 5, + 0, + 0, + 2091, + 269, + 1, + 0, + 0, + 0, + 2092, + 2094, + 5, + 5, + 0, + 0, + 2093, + 2095, + 5, + 149, + 0, + 0, + 2094, + 2093, + 1, + 0, + 0, + 0, + 2094, + 2095, + 1, + 0, + 0, + 0, + 2095, + 2113, + 1, + 0, + 0, + 0, + 2096, + 2098, + 3, + 180, + 90, + 0, + 2097, + 2099, + 5, + 149, + 0, + 0, + 2098, + 2097, + 1, + 0, + 0, + 0, + 2098, + 2099, + 1, + 0, + 0, + 0, + 2099, + 2110, + 1, + 0, + 0, + 0, + 2100, + 2102, + 5, + 7, + 0, + 0, + 2101, + 2103, + 5, + 149, + 0, + 0, + 2102, + 2101, + 1, + 0, + 0, + 0, + 2102, + 2103, + 1, + 0, + 0, + 0, + 2103, + 2104, + 1, + 0, + 0, + 0, + 2104, + 2106, + 3, + 180, + 90, + 0, + 2105, + 2107, + 5, + 149, + 0, + 0, + 2106, + 2105, + 1, + 0, + 0, + 0, + 2106, + 2107, + 1, + 0, + 0, + 0, + 2107, + 2109, + 1, + 0, + 0, + 0, + 2108, + 2100, + 1, + 0, + 0, + 0, + 2109, + 2112, + 1, + 0, + 0, + 0, + 2110, + 2108, + 1, + 0, + 0, + 0, + 2110, + 2111, + 1, + 0, + 0, + 0, + 2111, + 2114, + 1, + 0, + 0, + 0, + 2112, + 2110, + 1, + 0, + 0, + 0, + 2113, + 2096, + 1, + 0, + 0, + 0, + 2113, + 2114, + 1, + 0, + 0, + 0, + 2114, + 2115, + 1, + 0, + 0, + 0, + 2115, + 2116, + 5, + 6, + 0, + 0, + 2116, + 271, + 1, + 0, + 0, + 0, + 2117, + 2119, + 5, + 25, + 0, + 0, + 2118, + 2120, + 5, + 149, + 0, + 0, + 2119, + 2118, + 1, + 0, + 0, + 0, + 2119, + 2120, + 1, + 0, + 0, + 0, + 2120, + 2154, + 1, + 0, + 0, + 0, + 2121, + 2123, + 3, + 274, + 137, + 0, + 2122, + 2124, + 5, + 149, + 0, + 0, + 2123, + 2122, + 1, + 0, + 0, + 0, + 2123, + 2124, + 1, + 0, + 0, + 0, + 2124, + 2125, + 1, + 0, + 0, + 0, + 2125, + 2127, + 5, + 11, + 0, + 0, + 2126, + 2128, + 5, + 149, + 0, + 0, + 2127, + 2126, + 1, + 0, + 0, + 0, + 2127, + 2128, + 1, + 0, + 0, + 0, + 2128, + 2129, + 1, + 0, + 0, + 0, + 2129, + 2131, + 3, + 180, + 90, + 0, + 2130, + 2132, + 5, + 149, + 0, + 0, + 2131, + 2130, + 1, + 0, + 0, + 0, + 2131, + 2132, + 1, + 0, + 0, + 0, + 2132, + 2151, + 1, + 0, + 0, + 0, + 2133, + 2135, + 5, + 7, + 0, + 0, + 2134, + 2136, + 5, + 149, + 0, + 0, + 2135, + 2134, + 1, + 0, + 0, + 0, + 2135, + 2136, + 1, + 0, + 0, + 0, + 2136, + 2137, + 1, + 0, + 0, + 0, + 2137, + 2139, + 3, + 274, + 137, + 0, + 2138, + 2140, + 5, + 149, + 0, + 0, + 2139, + 2138, + 1, + 0, + 0, + 0, + 2139, + 2140, + 1, + 0, + 0, + 0, + 2140, + 2141, + 1, + 0, + 0, + 0, + 2141, + 2143, + 5, + 11, + 0, + 0, + 2142, + 2144, + 5, + 149, + 0, + 0, + 2143, + 2142, + 1, + 0, + 0, + 0, + 2143, + 2144, + 1, + 0, + 0, + 0, + 2144, + 2145, + 1, + 0, + 0, + 0, + 2145, + 2147, + 3, + 180, + 90, + 0, + 2146, + 2148, + 5, + 149, + 0, + 0, + 2147, + 2146, + 1, + 0, + 0, + 0, + 2147, + 2148, + 1, + 0, + 0, + 0, + 2148, + 2150, + 1, + 0, + 0, + 0, + 2149, + 2133, + 1, + 0, + 0, + 0, + 2150, + 2153, + 1, + 0, + 0, + 0, + 2151, + 2149, + 1, + 0, + 0, + 0, + 2151, + 2152, + 1, + 0, + 0, + 0, + 2152, + 2155, + 1, + 0, + 0, + 0, + 2153, + 2151, + 1, + 0, + 0, + 0, + 2154, + 2121, + 1, + 0, + 0, + 0, + 2154, + 2155, + 1, + 0, + 0, + 0, + 2155, + 2156, + 1, + 0, + 0, + 0, + 2156, + 2157, + 5, + 26, + 0, + 0, + 2157, + 273, + 1, + 0, + 0, + 0, + 2158, + 2159, + 3, + 280, + 140, + 0, + 2159, + 275, + 1, + 0, + 0, + 0, + 2160, + 2162, + 5, + 25, + 0, + 0, + 2161, + 2163, + 5, + 149, + 0, + 0, + 2162, + 2161, + 1, + 0, + 0, + 0, + 2162, + 2163, + 1, + 0, + 0, + 0, + 2163, + 2166, + 1, + 0, + 0, + 0, + 2164, + 2167, + 3, + 284, + 142, + 0, + 2165, + 2167, + 5, + 125, + 0, + 0, + 2166, + 2164, + 1, + 0, + 0, + 0, + 2166, + 2165, + 1, + 0, + 0, + 0, + 2167, + 2169, + 1, + 0, + 0, + 0, + 2168, + 2170, + 5, + 149, + 0, + 0, + 2169, + 2168, + 1, + 0, + 0, + 0, + 2169, + 2170, + 1, + 0, + 0, + 0, + 2170, + 2171, + 1, + 0, + 0, + 0, + 2171, + 2172, + 5, + 26, + 0, + 0, + 2172, + 277, + 1, + 0, + 0, + 0, + 2173, + 2176, + 5, + 27, + 0, + 0, + 2174, + 2177, + 3, + 284, + 142, + 0, + 2175, + 2177, + 5, + 125, + 0, + 0, + 2176, + 2174, + 1, + 0, + 0, + 0, + 2176, + 2175, + 1, + 0, + 0, + 0, + 2177, + 279, + 1, + 0, + 0, + 0, + 2178, + 2181, + 3, + 284, + 142, + 0, + 2179, + 2181, + 3, + 282, + 141, + 0, + 2180, + 2178, + 1, + 0, + 0, + 0, + 2180, + 2179, + 1, + 0, + 0, + 0, + 2181, + 281, + 1, + 0, + 0, + 0, + 2182, + 2183, + 7, + 6, + 0, + 0, + 2183, + 283, + 1, + 0, + 0, + 0, + 2184, + 2185, + 7, + 7, + 0, + 0, + 2185, + 285, + 1, + 0, + 0, + 0, + 2186, + 2187, + 7, + 8, + 0, + 0, + 2187, + 287, + 1, + 0, + 0, + 0, + 2188, + 2189, + 7, + 9, + 0, + 0, + 2189, + 289, + 1, + 0, + 0, + 0, + 2190, + 2191, + 7, + 10, + 0, + 0, + 2191, + 291, + 1, + 0, + 0, + 0, + 365, + 293, + 298, + 301, + 304, + 310, + 314, + 320, + 325, + 331, + 342, + 346, + 352, + 357, + 361, + 366, + 371, + 382, + 391, + 396, + 399, + 403, + 407, + 411, + 417, + 421, + 426, + 431, + 435, + 438, + 440, + 444, + 448, + 453, + 457, + 462, + 466, + 477, + 484, + 494, + 532, + 543, + 550, + 564, + 571, + 577, + 587, + 591, + 597, + 605, + 616, + 622, + 634, + 640, + 652, + 656, + 666, + 679, + 683, + 687, + 693, + 697, + 700, + 704, + 714, + 721, + 734, + 738, + 746, + 752, + 756, + 760, + 765, + 770, + 774, + 780, + 784, + 790, + 794, + 800, + 804, + 808, + 812, + 816, + 820, + 825, + 832, + 836, + 841, + 848, + 852, + 856, + 864, + 871, + 874, + 882, + 887, + 893, + 896, + 902, + 904, + 908, + 912, + 917, + 921, + 924, + 931, + 938, + 941, + 947, + 950, + 956, + 960, + 964, + 968, + 972, + 977, + 982, + 986, + 991, + 994, + 1003, + 1012, + 1017, + 1030, + 1033, + 1036, + 1056, + 1060, + 1065, + 1075, + 1081, + 1085, + 1090, + 1094, + 1098, + 1102, + 1108, + 1112, + 1117, + 1123, + 1132, + 1141, + 1149, + 1155, + 1159, + 1164, + 1173, + 1177, + 1182, + 1187, + 1191, + 1196, + 1200, + 1212, + 1216, + 1221, + 1228, + 1232, + 1237, + 1241, + 1245, + 1247, + 1251, + 1253, + 1257, + 1259, + 1265, + 1271, + 1275, + 1278, + 1281, + 1285, + 1291, + 1295, + 1298, + 1301, + 1307, + 1310, + 1313, + 1317, + 1323, + 1326, + 1329, + 1333, + 1337, + 1341, + 1343, + 1347, + 1349, + 1352, + 1356, + 1358, + 1365, + 1369, + 1375, + 1379, + 1383, + 1386, + 1391, + 1396, + 1401, + 1406, + 1412, + 1416, + 1418, + 1422, + 1426, + 1428, + 1430, + 1438, + 1443, + 1454, + 1464, + 1474, + 1479, + 1483, + 1490, + 1495, + 1500, + 1505, + 1510, + 1515, + 1520, + 1525, + 1528, + 1534, + 1536, + 1550, + 1553, + 1560, + 1574, + 1577, + 1583, + 1587, + 1591, + 1595, + 1598, + 1600, + 1605, + 1609, + 1613, + 1617, + 1621, + 1625, + 1628, + 1630, + 1635, + 1639, + 1644, + 1650, + 1653, + 1657, + 1661, + 1664, + 1666, + 1670, + 1673, + 1681, + 1685, + 1688, + 1692, + 1702, + 1706, + 1710, + 1724, + 1728, + 1733, + 1737, + 1741, + 1746, + 1748, + 1751, + 1755, + 1758, + 1761, + 1767, + 1771, + 1775, + 1781, + 1785, + 1789, + 1792, + 1795, + 1801, + 1805, + 1809, + 1811, + 1815, + 1819, + 1821, + 1825, + 1829, + 1835, + 1839, + 1843, + 1849, + 1853, + 1857, + 1860, + 1864, + 1868, + 1872, + 1886, + 1890, + 1894, + 1900, + 1904, + 1908, + 1914, + 1918, + 1922, + 1928, + 1932, + 1936, + 1940, + 1944, + 1947, + 1953, + 1957, + 1969, + 1973, + 1977, + 1979, + 1983, + 1987, + 1991, + 1995, + 1998, + 2007, + 2011, + 2016, + 2019, + 2021, + 2024, + 2030, + 2034, + 2038, + 2042, + 2046, + 2050, + 2053, + 2069, + 2080, + 2086, + 2094, + 2098, + 2102, + 2106, + 2110, + 2113, + 2119, + 2123, + 2127, + 2131, + 2135, + 2139, + 2143, + 2147, + 2151, + 2154, + 2162, + 2166, + 2169, + 2176, + 2180, + ] + + +class CypherParser(Parser): + + grammarFileName = "Cypher.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] + + sharedContextCache = PredictionContextCache() + + literalNames = [ + "", + "';'", + "'='", + "'('", + "')'", + "'['", + "']'", + "','", + "'+='", + "'|'", + "'*'", + "':'", + "'..'", + "'<>'", + "'<'", + "'>'", + "'<='", + "'>='", + "'=~'", + "'+'", + "'-'", + "'/'", + "'%'", + "'^'", + "'.'", + "'{'", + "'}'", + "'$'", + "'\\u27E8'", + "'\\u3008'", + "'\\uFE64'", + "'\\uFF1C'", + "'\\u27E9'", + "'\\u3009'", + "'\\uFE65'", + "'\\uFF1E'", + "'\\u00AD'", + "'\\u2010'", + "'\\u2011'", + "'\\u2012'", + "'\\u2013'", + "'\\u2014'", + "'\\u2015'", + "'\\u2212'", + "'\\uFE58'", + "'\\uFE63'", + "'\\uFF0D'", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "'0'", + ] + + symbolicNames = [ + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "CYPHER", + "EXPLAIN", + "PROFILE", + "USING", + "PERIODIC", + "COMMIT", + "UNION", + "ALL", + "CREATE", + "DROP", + "INDEX", + "ON", + "CONSTRAINT", + "ASSERT", + "IS", + "UNIQUE", + "EXISTS", + "LOAD", + "CSV", + "WITH", + "HEADERS", + "FROM", + "AS", + "FIELDTERMINATOR", + "OPTIONAL", + "MATCH", + "UNWIND", + "MERGE", + "SET", + "DETACH", + "DELETE", + "REMOVE", + "FOREACH", + "IN", + "CALL", + "YIELD", + "RETURN", + "DISTINCT", + "ORDER", + "BY", + "L_SKIP", + "LIMIT", + "ASCENDING", + "ASC", + "DESCENDING", + "DESC", + "JOIN", + "SCAN", + "START", + "NODE", + "RELATIONSHIP", + "REL", + "WHERE", + "SHORTESTPATH", + "ALLSHORTESTPATHS", + "OR", + "XOR", + "AND", + "NOT", + "STARTS", + "ENDS", + "CONTAINS", + "NULL", + "COUNT", + "CASE", + "ELSE", + "END", + "WHEN", + "THEN", + "FILTER", + "EXTRACT", + "REDUCE", + "ANY", + "NONE", + "SINGLE", + "TRUE", + "FALSE", + "HexInteger", + "DecimalInteger", + "OctalInteger", + "HexLetter", + "HexDigit", + "Digit", + "NonZeroDigit", + "NonZeroOctDigit", + "OctDigit", + "ZeroDigit", + "ExponentDecimalReal", + "RegularDecimalReal", + "StringLiteral", + "EscapedChar", + "DO", + "FOR", + "REQUIRE", + "MANDATORY", + "SCALAR", + "OF", + "ADD", + "UnescapedSymbolicName", + "IdentifierStart", + "IdentifierPart", + "EscapedSymbolicName", + "SP", + "WHITESPACE", + "Comment", + ] + + RULE_oC_Cypher = 0 + RULE_oC_QueryOptions = 1 + RULE_oC_AnyCypherOption = 2 + RULE_oC_CypherOption = 3 + RULE_oC_VersionNumber = 4 + RULE_oC_Explain = 5 + RULE_oC_Profile = 6 + RULE_oC_ConfigurationOption = 7 + RULE_oC_Statement = 8 + RULE_oC_Query = 9 + RULE_oC_RegularQuery = 10 + RULE_oC_BulkImportQuery = 11 + RULE_oC_PeriodicCommitHint = 12 + RULE_oC_LoadCSVQuery = 13 + RULE_oC_Union = 14 + RULE_oC_SingleQuery = 15 + RULE_oC_SinglePartQuery = 16 + RULE_oC_MultiPartQuery = 17 + RULE_oC_UpdatingClause = 18 + RULE_oC_ReadingClause = 19 + RULE_oC_Command = 20 + RULE_oC_CreateUniqueConstraint = 21 + RULE_oC_CreateNodePropertyExistenceConstraint = 22 + RULE_oC_CreateRelationshipPropertyExistenceConstraint = 23 + RULE_oC_CreateIndex = 24 + RULE_oC_DropUniqueConstraint = 25 + RULE_oC_DropNodePropertyExistenceConstraint = 26 + RULE_oC_DropRelationshipPropertyExistenceConstraint = 27 + RULE_oC_DropIndex = 28 + RULE_oC_Index = 29 + RULE_oC_UniqueConstraint = 30 + RULE_oC_NodePropertyExistenceConstraint = 31 + RULE_oC_RelationshipPropertyExistenceConstraint = 32 + RULE_oC_RelationshipPatternSyntax = 33 + RULE_oC_LoadCSV = 34 + RULE_oC_Match = 35 + RULE_oC_Unwind = 36 + RULE_oC_Merge = 37 + RULE_oC_MergeAction = 38 + RULE_oC_Create = 39 + RULE_oC_CreateUnique = 40 + RULE_oC_Set = 41 + RULE_oC_SetItem = 42 + RULE_oC_Delete = 43 + RULE_oC_Remove = 44 + RULE_oC_RemoveItem = 45 + RULE_oC_Foreach = 46 + RULE_oC_InQueryCall = 47 + RULE_oC_StandaloneCall = 48 + RULE_oC_YieldItems = 49 + RULE_oC_YieldItem = 50 + RULE_oC_With = 51 + RULE_oC_Return = 52 + RULE_oC_ProjectionBody = 53 + RULE_oC_ProjectionItems = 54 + RULE_oC_ProjectionItem = 55 + RULE_oC_Order = 56 + RULE_oC_Skip = 57 + RULE_oC_Limit = 58 + RULE_oC_SortItem = 59 + RULE_oC_Hint = 60 + RULE_oC_Start = 61 + RULE_oC_StartPoint = 62 + RULE_oC_Lookup = 63 + RULE_oC_NodeLookup = 64 + RULE_oC_RelationshipLookup = 65 + RULE_oC_IdentifiedIndexLookup = 66 + RULE_oC_IndexQuery = 67 + RULE_oC_IdLookup = 68 + RULE_oC_LiteralIds = 69 + RULE_oC_Where = 70 + RULE_oC_Pattern = 71 + RULE_oC_PatternPart = 72 + RULE_oC_AnonymousPatternPart = 73 + RULE_oC_ShortestPathPattern = 74 + RULE_oC_PatternElement = 75 + RULE_oC_RelationshipsPattern = 76 + RULE_oC_NodePattern = 77 + RULE_oC_PatternElementChain = 78 + RULE_oC_RelationshipPattern = 79 + RULE_oC_RelationshipDetail = 80 + RULE_oC_Properties = 81 + RULE_oC_RelType = 82 + RULE_oC_RelationshipTypes = 83 + RULE_oC_NodeLabels = 84 + RULE_oC_NodeLabel = 85 + RULE_oC_RangeLiteral = 86 + RULE_oC_LabelName = 87 + RULE_oC_RelTypeName = 88 + RULE_oC_PropertyExpression = 89 + RULE_oC_Expression = 90 + RULE_oC_OrExpression = 91 + RULE_oC_XorExpression = 92 + RULE_oC_AndExpression = 93 + RULE_oC_NotExpression = 94 + RULE_oC_ComparisonExpression = 95 + RULE_oC_PartialComparisonExpression = 96 + RULE_oC_StringListNullPredicateExpression = 97 + RULE_oC_StringPredicateExpression = 98 + RULE_oC_ListPredicateExpression = 99 + RULE_oC_NullPredicateExpression = 100 + RULE_oC_RegularExpression = 101 + RULE_oC_AddOrSubtractExpression = 102 + RULE_oC_MultiplyDivideModuloExpression = 103 + RULE_oC_PowerOfExpression = 104 + RULE_oC_UnaryAddOrSubtractExpression = 105 + RULE_oC_NonArithmeticOperatorExpression = 106 + RULE_oC_ListOperatorExpression = 107 + RULE_oC_PropertyLookup = 108 + RULE_oC_Atom = 109 + RULE_oC_CaseExpression = 110 + RULE_oC_CaseAlternative = 111 + RULE_oC_ListComprehension = 112 + RULE_oC_PatternComprehension = 113 + RULE_oC_LegacyListExpression = 114 + RULE_oC_Reduce = 115 + RULE_oC_Quantifier = 116 + RULE_oC_FilterExpression = 117 + RULE_oC_PatternPredicate = 118 + RULE_oC_ParenthesizedExpression = 119 + RULE_oC_IdInColl = 120 + RULE_oC_FunctionInvocation = 121 + RULE_oC_FunctionName = 122 + RULE_oC_ExistentialSubquery = 123 + RULE_oC_ExplicitProcedureInvocation = 124 + RULE_oC_ImplicitProcedureInvocation = 125 + RULE_oC_ProcedureResultField = 126 + RULE_oC_ProcedureName = 127 + RULE_oC_Namespace = 128 + RULE_oC_Variable = 129 + RULE_oC_Literal = 130 + RULE_oC_BooleanLiteral = 131 + RULE_oC_NumberLiteral = 132 + RULE_oC_IntegerLiteral = 133 + RULE_oC_DoubleLiteral = 134 + RULE_oC_ListLiteral = 135 + RULE_oC_MapLiteral = 136 + RULE_oC_PropertyKeyName = 137 + RULE_oC_LegacyParameter = 138 + RULE_oC_Parameter = 139 + RULE_oC_SchemaName = 140 + RULE_oC_ReservedWord = 141 + RULE_oC_SymbolicName = 142 + RULE_oC_LeftArrowHead = 143 + RULE_oC_RightArrowHead = 144 + RULE_oC_Dash = 145 + + ruleNames = [ + "oC_Cypher", + "oC_QueryOptions", + "oC_AnyCypherOption", + "oC_CypherOption", + "oC_VersionNumber", + "oC_Explain", + "oC_Profile", + "oC_ConfigurationOption", + "oC_Statement", + "oC_Query", + "oC_RegularQuery", + "oC_BulkImportQuery", + "oC_PeriodicCommitHint", + "oC_LoadCSVQuery", + "oC_Union", + "oC_SingleQuery", + "oC_SinglePartQuery", + "oC_MultiPartQuery", + "oC_UpdatingClause", + "oC_ReadingClause", + "oC_Command", + "oC_CreateUniqueConstraint", + "oC_CreateNodePropertyExistenceConstraint", + "oC_CreateRelationshipPropertyExistenceConstraint", + "oC_CreateIndex", + "oC_DropUniqueConstraint", + "oC_DropNodePropertyExistenceConstraint", + "oC_DropRelationshipPropertyExistenceConstraint", + "oC_DropIndex", + "oC_Index", + "oC_UniqueConstraint", + "oC_NodePropertyExistenceConstraint", + "oC_RelationshipPropertyExistenceConstraint", + "oC_RelationshipPatternSyntax", + "oC_LoadCSV", + "oC_Match", + "oC_Unwind", + "oC_Merge", + "oC_MergeAction", + "oC_Create", + "oC_CreateUnique", + "oC_Set", + "oC_SetItem", + "oC_Delete", + "oC_Remove", + "oC_RemoveItem", + "oC_Foreach", + "oC_InQueryCall", + "oC_StandaloneCall", + "oC_YieldItems", + "oC_YieldItem", + "oC_With", + "oC_Return", + "oC_ProjectionBody", + "oC_ProjectionItems", + "oC_ProjectionItem", + "oC_Order", + "oC_Skip", + "oC_Limit", + "oC_SortItem", + "oC_Hint", + "oC_Start", + "oC_StartPoint", + "oC_Lookup", + "oC_NodeLookup", + "oC_RelationshipLookup", + "oC_IdentifiedIndexLookup", + "oC_IndexQuery", + "oC_IdLookup", + "oC_LiteralIds", + "oC_Where", + "oC_Pattern", + "oC_PatternPart", + "oC_AnonymousPatternPart", + "oC_ShortestPathPattern", + "oC_PatternElement", + "oC_RelationshipsPattern", + "oC_NodePattern", + "oC_PatternElementChain", + "oC_RelationshipPattern", + "oC_RelationshipDetail", + "oC_Properties", + "oC_RelType", + "oC_RelationshipTypes", + "oC_NodeLabels", + "oC_NodeLabel", + "oC_RangeLiteral", + "oC_LabelName", + "oC_RelTypeName", + "oC_PropertyExpression", + "oC_Expression", + "oC_OrExpression", + "oC_XorExpression", + "oC_AndExpression", + "oC_NotExpression", + "oC_ComparisonExpression", + "oC_PartialComparisonExpression", + "oC_StringListNullPredicateExpression", + "oC_StringPredicateExpression", + "oC_ListPredicateExpression", + "oC_NullPredicateExpression", + "oC_RegularExpression", + "oC_AddOrSubtractExpression", + "oC_MultiplyDivideModuloExpression", + "oC_PowerOfExpression", + "oC_UnaryAddOrSubtractExpression", + "oC_NonArithmeticOperatorExpression", + "oC_ListOperatorExpression", + "oC_PropertyLookup", + "oC_Atom", + "oC_CaseExpression", + "oC_CaseAlternative", + "oC_ListComprehension", + "oC_PatternComprehension", + "oC_LegacyListExpression", + "oC_Reduce", + "oC_Quantifier", + "oC_FilterExpression", + "oC_PatternPredicate", + "oC_ParenthesizedExpression", + "oC_IdInColl", + "oC_FunctionInvocation", + "oC_FunctionName", + "oC_ExistentialSubquery", + "oC_ExplicitProcedureInvocation", + "oC_ImplicitProcedureInvocation", + "oC_ProcedureResultField", + "oC_ProcedureName", + "oC_Namespace", + "oC_Variable", + "oC_Literal", + "oC_BooleanLiteral", + "oC_NumberLiteral", + "oC_IntegerLiteral", + "oC_DoubleLiteral", + "oC_ListLiteral", + "oC_MapLiteral", + "oC_PropertyKeyName", + "oC_LegacyParameter", + "oC_Parameter", + "oC_SchemaName", + "oC_ReservedWord", + "oC_SymbolicName", + "oC_LeftArrowHead", + "oC_RightArrowHead", + "oC_Dash", + ] + + EOF = Token.EOF + T__0 = 1 + T__1 = 2 + T__2 = 3 + T__3 = 4 + T__4 = 5 + T__5 = 6 + T__6 = 7 + T__7 = 8 + T__8 = 9 + T__9 = 10 + T__10 = 11 + T__11 = 12 + T__12 = 13 + T__13 = 14 + T__14 = 15 + T__15 = 16 + T__16 = 17 + T__17 = 18 + T__18 = 19 + T__19 = 20 + T__20 = 21 + T__21 = 22 + T__22 = 23 + T__23 = 24 + T__24 = 25 + T__25 = 26 + T__26 = 27 + T__27 = 28 + T__28 = 29 + T__29 = 30 + T__30 = 31 + T__31 = 32 + T__32 = 33 + T__33 = 34 + T__34 = 35 + T__35 = 36 + T__36 = 37 + T__37 = 38 + T__38 = 39 + T__39 = 40 + T__40 = 41 + T__41 = 42 + T__42 = 43 + T__43 = 44 + T__44 = 45 + T__45 = 46 + CYPHER = 47 + EXPLAIN = 48 + PROFILE = 49 + USING = 50 + PERIODIC = 51 + COMMIT = 52 + UNION = 53 + ALL = 54 + CREATE = 55 + DROP = 56 + INDEX = 57 + ON = 58 + CONSTRAINT = 59 + ASSERT = 60 + IS = 61 + UNIQUE = 62 + EXISTS = 63 + LOAD = 64 + CSV = 65 + WITH = 66 + HEADERS = 67 + FROM = 68 + AS = 69 + FIELDTERMINATOR = 70 + OPTIONAL = 71 + MATCH = 72 + UNWIND = 73 + MERGE = 74 + SET = 75 + DETACH = 76 + DELETE = 77 + REMOVE = 78 + FOREACH = 79 + IN = 80 + CALL = 81 + YIELD = 82 + RETURN = 83 + DISTINCT = 84 + ORDER = 85 + BY = 86 + L_SKIP = 87 + LIMIT = 88 + ASCENDING = 89 + ASC = 90 + DESCENDING = 91 + DESC = 92 + JOIN = 93 + SCAN = 94 + START = 95 + NODE = 96 + RELATIONSHIP = 97 + REL = 98 + WHERE = 99 + SHORTESTPATH = 100 + ALLSHORTESTPATHS = 101 + OR = 102 + XOR = 103 + AND = 104 + NOT = 105 + STARTS = 106 + ENDS = 107 + CONTAINS = 108 + NULL = 109 + COUNT = 110 + CASE = 111 + ELSE = 112 + END = 113 + WHEN = 114 + THEN = 115 + FILTER = 116 + EXTRACT = 117 + REDUCE = 118 + ANY = 119 + NONE = 120 + SINGLE = 121 + TRUE = 122 + FALSE = 123 + HexInteger = 124 + DecimalInteger = 125 + OctalInteger = 126 + HexLetter = 127 + HexDigit = 128 + Digit = 129 + NonZeroDigit = 130 + NonZeroOctDigit = 131 + OctDigit = 132 + ZeroDigit = 133 + ExponentDecimalReal = 134 + RegularDecimalReal = 135 + StringLiteral = 136 + EscapedChar = 137 + DO = 138 + FOR = 139 + REQUIRE = 140 + MANDATORY = 141 + SCALAR = 142 + OF = 143 + ADD = 144 + UnescapedSymbolicName = 145 + IdentifierStart = 146 + IdentifierPart = 147 + EscapedSymbolicName = 148 + SP = 149 + WHITESPACE = 150 + Comment = 151 + + def __init__(self, input: TokenStream, output: TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.13.2") + self._interp = ParserATNSimulator( + self, self.atn, self.decisionsToDFA, self.sharedContextCache + ) + self._predicates = None + + class OC_CypherContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_QueryOptions(self): + return self.getTypedRuleContext(CypherParser.OC_QueryOptionsContext, 0) + + def oC_Statement(self): + return self.getTypedRuleContext(CypherParser.OC_StatementContext, 0) + + def EOF(self): + return self.getToken(CypherParser.EOF, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Cypher + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Cypher"): + listener.enterOC_Cypher(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Cypher"): + listener.exitOC_Cypher(self) + + def oC_Cypher(self): + + localctx = CypherParser.OC_CypherContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_oC_Cypher) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 293 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 292 + self.match(CypherParser.SP) + + self.state = 295 + self.oC_QueryOptions() + self.state = 296 + self.oC_Statement() + self.state = 301 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 2, self._ctx) + if la_ == 1: + self.state = 298 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 297 + self.match(CypherParser.SP) + + self.state = 300 + self.match(CypherParser.T__0) + + self.state = 304 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 303 + self.match(CypherParser.SP) + + self.state = 306 + self.match(CypherParser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_QueryOptionsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_AnyCypherOption(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_AnyCypherOptionContext) + else: + return self.getTypedRuleContext( + CypherParser.OC_AnyCypherOptionContext, i + ) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_QueryOptions + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_QueryOptions"): + listener.enterOC_QueryOptions(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_QueryOptions"): + listener.exitOC_QueryOptions(self) + + def oC_QueryOptions(self): + + localctx = CypherParser.OC_QueryOptionsContext(self, self._ctx, self.state) + self.enterRule(localctx, 2, self.RULE_oC_QueryOptions) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 314 + self._errHandler.sync(self) + _la = self._input.LA(1) + while ((_la) & ~0x3F) == 0 and ((1 << _la) & 985162418487296) != 0: + self.state = 308 + self.oC_AnyCypherOption() + self.state = 310 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 309 + self.match(CypherParser.SP) + + self.state = 316 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_AnyCypherOptionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_CypherOption(self): + return self.getTypedRuleContext(CypherParser.OC_CypherOptionContext, 0) + + def oC_Explain(self): + return self.getTypedRuleContext(CypherParser.OC_ExplainContext, 0) + + def oC_Profile(self): + return self.getTypedRuleContext(CypherParser.OC_ProfileContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_AnyCypherOption + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_AnyCypherOption"): + listener.enterOC_AnyCypherOption(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_AnyCypherOption"): + listener.exitOC_AnyCypherOption(self) + + def oC_AnyCypherOption(self): + + localctx = CypherParser.OC_AnyCypherOptionContext(self, self._ctx, self.state) + self.enterRule(localctx, 4, self.RULE_oC_AnyCypherOption) + try: + self.state = 320 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [47]: + self.enterOuterAlt(localctx, 1) + self.state = 317 + self.oC_CypherOption() + pass + elif token in [48]: + self.enterOuterAlt(localctx, 2) + self.state = 318 + self.oC_Explain() + pass + elif token in [49]: + self.enterOuterAlt(localctx, 3) + self.state = 319 + self.oC_Profile() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_CypherOptionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def CYPHER(self): + return self.getToken(CypherParser.CYPHER, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_VersionNumber(self): + return self.getTypedRuleContext(CypherParser.OC_VersionNumberContext, 0) + + def oC_ConfigurationOption(self, i: int = None): + if i is None: + return self.getTypedRuleContexts( + CypherParser.OC_ConfigurationOptionContext + ) + else: + return self.getTypedRuleContext( + CypherParser.OC_ConfigurationOptionContext, i + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_CypherOption + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_CypherOption"): + listener.enterOC_CypherOption(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_CypherOption"): + listener.exitOC_CypherOption(self) + + def oC_CypherOption(self): + + localctx = CypherParser.OC_CypherOptionContext(self, self._ctx, self.state) + self.enterRule(localctx, 6, self.RULE_oC_CypherOption) + try: + self.enterOuterAlt(localctx, 1) + self.state = 322 + self.match(CypherParser.CYPHER) + self.state = 325 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 7, self._ctx) + if la_ == 1: + self.state = 323 + self.match(CypherParser.SP) + self.state = 324 + self.oC_VersionNumber() + + self.state = 331 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 8, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 327 + self.match(CypherParser.SP) + self.state = 328 + self.oC_ConfigurationOption() + self.state = 333 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 8, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_VersionNumberContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def RegularDecimalReal(self): + return self.getToken(CypherParser.RegularDecimalReal, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_VersionNumber + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_VersionNumber"): + listener.enterOC_VersionNumber(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_VersionNumber"): + listener.exitOC_VersionNumber(self) + + def oC_VersionNumber(self): + + localctx = CypherParser.OC_VersionNumberContext(self, self._ctx, self.state) + self.enterRule(localctx, 8, self.RULE_oC_VersionNumber) + try: + self.enterOuterAlt(localctx, 1) + self.state = 334 + self.match(CypherParser.RegularDecimalReal) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ExplainContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def EXPLAIN(self): + return self.getToken(CypherParser.EXPLAIN, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Explain + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Explain"): + listener.enterOC_Explain(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Explain"): + listener.exitOC_Explain(self) + + def oC_Explain(self): + + localctx = CypherParser.OC_ExplainContext(self, self._ctx, self.state) + self.enterRule(localctx, 10, self.RULE_oC_Explain) + try: + self.enterOuterAlt(localctx, 1) + self.state = 336 + self.match(CypherParser.EXPLAIN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ProfileContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def PROFILE(self): + return self.getToken(CypherParser.PROFILE, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Profile + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Profile"): + listener.enterOC_Profile(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Profile"): + listener.exitOC_Profile(self) + + def oC_Profile(self): + + localctx = CypherParser.OC_ProfileContext(self, self._ctx, self.state) + self.enterRule(localctx, 12, self.RULE_oC_Profile) + try: + self.enterOuterAlt(localctx, 1) + self.state = 338 + self.match(CypherParser.PROFILE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ConfigurationOptionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_SymbolicName(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_SymbolicNameContext) + else: + return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext, i) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ConfigurationOption + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ConfigurationOption"): + listener.enterOC_ConfigurationOption(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ConfigurationOption"): + listener.exitOC_ConfigurationOption(self) + + def oC_ConfigurationOption(self): + + localctx = CypherParser.OC_ConfigurationOptionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 14, self.RULE_oC_ConfigurationOption) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 340 + self.oC_SymbolicName() + self.state = 342 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 341 + self.match(CypherParser.SP) + + self.state = 344 + self.match(CypherParser.T__1) + self.state = 346 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 345 + self.match(CypherParser.SP) + + self.state = 348 + self.oC_SymbolicName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_StatementContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Command(self): + return self.getTypedRuleContext(CypherParser.OC_CommandContext, 0) + + def oC_Query(self): + return self.getTypedRuleContext(CypherParser.OC_QueryContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Statement + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Statement"): + listener.enterOC_Statement(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Statement"): + listener.exitOC_Statement(self) + + def oC_Statement(self): + + localctx = CypherParser.OC_StatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 16, self.RULE_oC_Statement) + try: + self.state = 352 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 11, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 350 + self.oC_Command() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 351 + self.oC_Query() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_QueryContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_RegularQuery(self): + return self.getTypedRuleContext(CypherParser.OC_RegularQueryContext, 0) + + def oC_StandaloneCall(self): + return self.getTypedRuleContext(CypherParser.OC_StandaloneCallContext, 0) + + def oC_BulkImportQuery(self): + return self.getTypedRuleContext(CypherParser.OC_BulkImportQueryContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Query + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Query"): + listener.enterOC_Query(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Query"): + listener.exitOC_Query(self) + + def oC_Query(self): + + localctx = CypherParser.OC_QueryContext(self, self._ctx, self.state) + self.enterRule(localctx, 18, self.RULE_oC_Query) + try: + self.state = 357 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 12, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 354 + self.oC_RegularQuery() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 355 + self.oC_StandaloneCall() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 356 + self.oC_BulkImportQuery() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_RegularQueryContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_SingleQuery(self): + return self.getTypedRuleContext(CypherParser.OC_SingleQueryContext, 0) + + def oC_Union(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_UnionContext) + else: + return self.getTypedRuleContext(CypherParser.OC_UnionContext, i) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_RegularQuery + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_RegularQuery"): + listener.enterOC_RegularQuery(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_RegularQuery"): + listener.exitOC_RegularQuery(self) + + def oC_RegularQuery(self): + + localctx = CypherParser.OC_RegularQueryContext(self, self._ctx, self.state) + self.enterRule(localctx, 20, self.RULE_oC_RegularQuery) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 359 + self.oC_SingleQuery() + self.state = 366 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 14, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 361 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 360 + self.match(CypherParser.SP) + + self.state = 363 + self.oC_Union() + self.state = 368 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 14, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_BulkImportQueryContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_PeriodicCommitHint(self): + return self.getTypedRuleContext( + CypherParser.OC_PeriodicCommitHintContext, 0 + ) + + def oC_LoadCSVQuery(self): + return self.getTypedRuleContext(CypherParser.OC_LoadCSVQueryContext, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_BulkImportQuery + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_BulkImportQuery"): + listener.enterOC_BulkImportQuery(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_BulkImportQuery"): + listener.exitOC_BulkImportQuery(self) + + def oC_BulkImportQuery(self): + + localctx = CypherParser.OC_BulkImportQueryContext(self, self._ctx, self.state) + self.enterRule(localctx, 22, self.RULE_oC_BulkImportQuery) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 369 + self.oC_PeriodicCommitHint() + self.state = 371 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 370 + self.match(CypherParser.SP) + + self.state = 373 + self.oC_LoadCSVQuery() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_PeriodicCommitHintContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def USING(self): + return self.getToken(CypherParser.USING, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def PERIODIC(self): + return self.getToken(CypherParser.PERIODIC, 0) + + def COMMIT(self): + return self.getToken(CypherParser.COMMIT, 0) + + def oC_IntegerLiteral(self): + return self.getTypedRuleContext(CypherParser.OC_IntegerLiteralContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_PeriodicCommitHint + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_PeriodicCommitHint"): + listener.enterOC_PeriodicCommitHint(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_PeriodicCommitHint"): + listener.exitOC_PeriodicCommitHint(self) + + def oC_PeriodicCommitHint(self): + + localctx = CypherParser.OC_PeriodicCommitHintContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 24, self.RULE_oC_PeriodicCommitHint) + try: + self.enterOuterAlt(localctx, 1) + self.state = 375 + self.match(CypherParser.USING) + self.state = 376 + self.match(CypherParser.SP) + self.state = 377 + self.match(CypherParser.PERIODIC) + self.state = 378 + self.match(CypherParser.SP) + self.state = 379 + self.match(CypherParser.COMMIT) + self.state = 382 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 16, self._ctx) + if la_ == 1: + self.state = 380 + self.match(CypherParser.SP) + self.state = 381 + self.oC_IntegerLiteral() + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_LoadCSVQueryContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_LoadCSV(self): + return self.getTypedRuleContext(CypherParser.OC_LoadCSVContext, 0) + + def oC_SingleQuery(self): + return self.getTypedRuleContext(CypherParser.OC_SingleQueryContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_LoadCSVQuery + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_LoadCSVQuery"): + listener.enterOC_LoadCSVQuery(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_LoadCSVQuery"): + listener.exitOC_LoadCSVQuery(self) + + def oC_LoadCSVQuery(self): + + localctx = CypherParser.OC_LoadCSVQueryContext(self, self._ctx, self.state) + self.enterRule(localctx, 26, self.RULE_oC_LoadCSVQuery) + try: + self.enterOuterAlt(localctx, 1) + self.state = 384 + self.oC_LoadCSV() + self.state = 385 + self.oC_SingleQuery() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_UnionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def UNION(self): + return self.getToken(CypherParser.UNION, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def ALL(self): + return self.getToken(CypherParser.ALL, 0) + + def oC_SingleQuery(self): + return self.getTypedRuleContext(CypherParser.OC_SingleQueryContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Union + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Union"): + listener.enterOC_Union(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Union"): + listener.exitOC_Union(self) + + def oC_Union(self): + + localctx = CypherParser.OC_UnionContext(self, self._ctx, self.state) + self.enterRule(localctx, 28, self.RULE_oC_Union) + self._la = 0 # Token type + try: + self.state = 399 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 19, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 387 + self.match(CypherParser.UNION) + self.state = 388 + self.match(CypherParser.SP) + self.state = 389 + self.match(CypherParser.ALL) + self.state = 391 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 390 + self.match(CypherParser.SP) + + self.state = 393 + self.oC_SingleQuery() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 394 + self.match(CypherParser.UNION) + self.state = 396 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 395 + self.match(CypherParser.SP) + + self.state = 398 + self.oC_SingleQuery() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_SingleQueryContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_SinglePartQuery(self): + return self.getTypedRuleContext(CypherParser.OC_SinglePartQueryContext, 0) + + def oC_MultiPartQuery(self): + return self.getTypedRuleContext(CypherParser.OC_MultiPartQueryContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_SingleQuery + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_SingleQuery"): + listener.enterOC_SingleQuery(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_SingleQuery"): + listener.exitOC_SingleQuery(self) + + def oC_SingleQuery(self): + + localctx = CypherParser.OC_SingleQueryContext(self, self._ctx, self.state) + self.enterRule(localctx, 30, self.RULE_oC_SingleQuery) + try: + self.state = 403 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 20, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 401 + self.oC_SinglePartQuery() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 402 + self.oC_MultiPartQuery() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_SinglePartQueryContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Return(self): + return self.getTypedRuleContext(CypherParser.OC_ReturnContext, 0) + + def oC_ReadingClause(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_ReadingClauseContext) + else: + return self.getTypedRuleContext(CypherParser.OC_ReadingClauseContext, i) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_UpdatingClause(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_UpdatingClauseContext) + else: + return self.getTypedRuleContext( + CypherParser.OC_UpdatingClauseContext, i + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_SinglePartQuery + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_SinglePartQuery"): + listener.enterOC_SinglePartQuery(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_SinglePartQuery"): + listener.exitOC_SinglePartQuery(self) + + def oC_SinglePartQuery(self): + + localctx = CypherParser.OC_SinglePartQueryContext(self, self._ctx, self.state) + self.enterRule(localctx, 32, self.RULE_oC_SinglePartQuery) + self._la = 0 # Token type + try: + self.state = 440 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 29, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 411 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la - 64)) & ~0x3F) == 0 and ( + (1 << (_la - 64)) & 2147615617 + ) != 0: + self.state = 405 + self.oC_ReadingClause() + self.state = 407 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 406 + self.match(CypherParser.SP) + + self.state = 413 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 414 + self.oC_Return() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 421 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la - 64)) & ~0x3F) == 0 and ( + (1 << (_la - 64)) & 2147615617 + ) != 0: + self.state = 415 + self.oC_ReadingClause() + self.state = 417 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 416 + self.match(CypherParser.SP) + + self.state = 423 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 424 + self.oC_UpdatingClause() + self.state = 431 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 26, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 426 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 425 + self.match(CypherParser.SP) + + self.state = 428 + self.oC_UpdatingClause() + self.state = 433 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 26, self._ctx) + + self.state = 438 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 28, self._ctx) + if la_ == 1: + self.state = 435 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 434 + self.match(CypherParser.SP) + + self.state = 437 + self.oC_Return() + + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_MultiPartQueryContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_SinglePartQuery(self): + return self.getTypedRuleContext(CypherParser.OC_SinglePartQueryContext, 0) + + def oC_With(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_WithContext) + else: + return self.getTypedRuleContext(CypherParser.OC_WithContext, i) + + def oC_ReadingClause(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_ReadingClauseContext) + else: + return self.getTypedRuleContext(CypherParser.OC_ReadingClauseContext, i) + + def oC_UpdatingClause(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_UpdatingClauseContext) + else: + return self.getTypedRuleContext( + CypherParser.OC_UpdatingClauseContext, i + ) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_MultiPartQuery + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_MultiPartQuery"): + listener.enterOC_MultiPartQuery(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_MultiPartQuery"): + listener.exitOC_MultiPartQuery(self) + + def oC_MultiPartQuery(self): + + localctx = CypherParser.OC_MultiPartQueryContext(self, self._ctx, self.state) + self.enterRule(localctx, 34, self.RULE_oC_MultiPartQuery) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 464 + self._errHandler.sync(self) + _alt = 1 + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 448 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la - 64)) & ~0x3F) == 0 and ( + (1 << (_la - 64)) & 2147615617 + ) != 0: + self.state = 442 + self.oC_ReadingClause() + self.state = 444 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 443 + self.match(CypherParser.SP) + + self.state = 450 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 457 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la - 55)) & ~0x3F) == 0 and ( + (1 << (_la - 55)) & 33030145 + ) != 0: + self.state = 451 + self.oC_UpdatingClause() + self.state = 453 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 452 + self.match(CypherParser.SP) + + self.state = 459 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 460 + self.oC_With() + self.state = 462 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 461 + self.match(CypherParser.SP) + + else: + raise NoViableAltException(self) + self.state = 466 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 35, self._ctx) + + self.state = 468 + self.oC_SinglePartQuery() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_UpdatingClauseContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Create(self): + return self.getTypedRuleContext(CypherParser.OC_CreateContext, 0) + + def oC_Merge(self): + return self.getTypedRuleContext(CypherParser.OC_MergeContext, 0) + + def oC_CreateUnique(self): + return self.getTypedRuleContext(CypherParser.OC_CreateUniqueContext, 0) + + def oC_Foreach(self): + return self.getTypedRuleContext(CypherParser.OC_ForeachContext, 0) + + def oC_Delete(self): + return self.getTypedRuleContext(CypherParser.OC_DeleteContext, 0) + + def oC_Set(self): + return self.getTypedRuleContext(CypherParser.OC_SetContext, 0) + + def oC_Remove(self): + return self.getTypedRuleContext(CypherParser.OC_RemoveContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_UpdatingClause + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_UpdatingClause"): + listener.enterOC_UpdatingClause(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_UpdatingClause"): + listener.exitOC_UpdatingClause(self) + + def oC_UpdatingClause(self): + + localctx = CypherParser.OC_UpdatingClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 36, self.RULE_oC_UpdatingClause) + try: + self.state = 477 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 36, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 470 + self.oC_Create() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 471 + self.oC_Merge() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 472 + self.oC_CreateUnique() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 473 + self.oC_Foreach() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 474 + self.oC_Delete() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 475 + self.oC_Set() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 476 + self.oC_Remove() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ReadingClauseContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_LoadCSV(self): + return self.getTypedRuleContext(CypherParser.OC_LoadCSVContext, 0) + + def oC_Start(self): + return self.getTypedRuleContext(CypherParser.OC_StartContext, 0) + + def oC_Match(self): + return self.getTypedRuleContext(CypherParser.OC_MatchContext, 0) + + def oC_Unwind(self): + return self.getTypedRuleContext(CypherParser.OC_UnwindContext, 0) + + def oC_InQueryCall(self): + return self.getTypedRuleContext(CypherParser.OC_InQueryCallContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ReadingClause + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ReadingClause"): + listener.enterOC_ReadingClause(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ReadingClause"): + listener.exitOC_ReadingClause(self) + + def oC_ReadingClause(self): + + localctx = CypherParser.OC_ReadingClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 38, self.RULE_oC_ReadingClause) + try: + self.state = 484 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [64]: + self.enterOuterAlt(localctx, 1) + self.state = 479 + self.oC_LoadCSV() + pass + elif token in [95]: + self.enterOuterAlt(localctx, 2) + self.state = 480 + self.oC_Start() + pass + elif token in [71, 72]: + self.enterOuterAlt(localctx, 3) + self.state = 481 + self.oC_Match() + pass + elif token in [73]: + self.enterOuterAlt(localctx, 4) + self.state = 482 + self.oC_Unwind() + pass + elif token in [81]: + self.enterOuterAlt(localctx, 5) + self.state = 483 + self.oC_InQueryCall() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_CommandContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_CreateIndex(self): + return self.getTypedRuleContext(CypherParser.OC_CreateIndexContext, 0) + + def oC_DropIndex(self): + return self.getTypedRuleContext(CypherParser.OC_DropIndexContext, 0) + + def oC_CreateUniqueConstraint(self): + return self.getTypedRuleContext( + CypherParser.OC_CreateUniqueConstraintContext, 0 + ) + + def oC_DropUniqueConstraint(self): + return self.getTypedRuleContext( + CypherParser.OC_DropUniqueConstraintContext, 0 + ) + + def oC_CreateNodePropertyExistenceConstraint(self): + return self.getTypedRuleContext( + CypherParser.OC_CreateNodePropertyExistenceConstraintContext, 0 + ) + + def oC_DropNodePropertyExistenceConstraint(self): + return self.getTypedRuleContext( + CypherParser.OC_DropNodePropertyExistenceConstraintContext, 0 + ) + + def oC_CreateRelationshipPropertyExistenceConstraint(self): + return self.getTypedRuleContext( + CypherParser.OC_CreateRelationshipPropertyExistenceConstraintContext, 0 + ) + + def oC_DropRelationshipPropertyExistenceConstraint(self): + return self.getTypedRuleContext( + CypherParser.OC_DropRelationshipPropertyExistenceConstraintContext, 0 + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Command + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Command"): + listener.enterOC_Command(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Command"): + listener.exitOC_Command(self) + + def oC_Command(self): + + localctx = CypherParser.OC_CommandContext(self, self._ctx, self.state) + self.enterRule(localctx, 40, self.RULE_oC_Command) + try: + self.state = 494 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 38, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 486 + self.oC_CreateIndex() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 487 + self.oC_DropIndex() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 488 + self.oC_CreateUniqueConstraint() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 489 + self.oC_DropUniqueConstraint() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 490 + self.oC_CreateNodePropertyExistenceConstraint() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 491 + self.oC_DropNodePropertyExistenceConstraint() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 492 + self.oC_CreateRelationshipPropertyExistenceConstraint() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 493 + self.oC_DropRelationshipPropertyExistenceConstraint() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_CreateUniqueConstraintContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def CREATE(self): + return self.getToken(CypherParser.CREATE, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def oC_UniqueConstraint(self): + return self.getTypedRuleContext(CypherParser.OC_UniqueConstraintContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_CreateUniqueConstraint + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_CreateUniqueConstraint"): + listener.enterOC_CreateUniqueConstraint(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_CreateUniqueConstraint"): + listener.exitOC_CreateUniqueConstraint(self) + + def oC_CreateUniqueConstraint(self): + + localctx = CypherParser.OC_CreateUniqueConstraintContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 42, self.RULE_oC_CreateUniqueConstraint) + try: + self.enterOuterAlt(localctx, 1) + self.state = 496 + self.match(CypherParser.CREATE) + self.state = 497 + self.match(CypherParser.SP) + self.state = 498 + self.oC_UniqueConstraint() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_CreateNodePropertyExistenceConstraintContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def CREATE(self): + return self.getToken(CypherParser.CREATE, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def oC_NodePropertyExistenceConstraint(self): + return self.getTypedRuleContext( + CypherParser.OC_NodePropertyExistenceConstraintContext, 0 + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_CreateNodePropertyExistenceConstraint + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_CreateNodePropertyExistenceConstraint"): + listener.enterOC_CreateNodePropertyExistenceConstraint(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_CreateNodePropertyExistenceConstraint"): + listener.exitOC_CreateNodePropertyExistenceConstraint(self) + + def oC_CreateNodePropertyExistenceConstraint(self): + + localctx = CypherParser.OC_CreateNodePropertyExistenceConstraintContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 44, self.RULE_oC_CreateNodePropertyExistenceConstraint) + try: + self.enterOuterAlt(localctx, 1) + self.state = 500 + self.match(CypherParser.CREATE) + self.state = 501 + self.match(CypherParser.SP) + self.state = 502 + self.oC_NodePropertyExistenceConstraint() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_CreateRelationshipPropertyExistenceConstraintContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def CREATE(self): + return self.getToken(CypherParser.CREATE, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def oC_RelationshipPropertyExistenceConstraint(self): + return self.getTypedRuleContext( + CypherParser.OC_RelationshipPropertyExistenceConstraintContext, 0 + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_CreateRelationshipPropertyExistenceConstraint + + def enterRule(self, listener: ParseTreeListener): + if hasattr( + listener, "enterOC_CreateRelationshipPropertyExistenceConstraint" + ): + listener.enterOC_CreateRelationshipPropertyExistenceConstraint(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr( + listener, "exitOC_CreateRelationshipPropertyExistenceConstraint" + ): + listener.exitOC_CreateRelationshipPropertyExistenceConstraint(self) + + def oC_CreateRelationshipPropertyExistenceConstraint(self): + + localctx = CypherParser.OC_CreateRelationshipPropertyExistenceConstraintContext( + self, self._ctx, self.state + ) + self.enterRule( + localctx, 46, self.RULE_oC_CreateRelationshipPropertyExistenceConstraint + ) + try: + self.enterOuterAlt(localctx, 1) + self.state = 504 + self.match(CypherParser.CREATE) + self.state = 505 + self.match(CypherParser.SP) + self.state = 506 + self.oC_RelationshipPropertyExistenceConstraint() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_CreateIndexContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def CREATE(self): + return self.getToken(CypherParser.CREATE, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def oC_Index(self): + return self.getTypedRuleContext(CypherParser.OC_IndexContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_CreateIndex + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_CreateIndex"): + listener.enterOC_CreateIndex(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_CreateIndex"): + listener.exitOC_CreateIndex(self) + + def oC_CreateIndex(self): + + localctx = CypherParser.OC_CreateIndexContext(self, self._ctx, self.state) + self.enterRule(localctx, 48, self.RULE_oC_CreateIndex) + try: + self.enterOuterAlt(localctx, 1) + self.state = 508 + self.match(CypherParser.CREATE) + self.state = 509 + self.match(CypherParser.SP) + self.state = 510 + self.oC_Index() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_DropUniqueConstraintContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def DROP(self): + return self.getToken(CypherParser.DROP, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def oC_UniqueConstraint(self): + return self.getTypedRuleContext(CypherParser.OC_UniqueConstraintContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_DropUniqueConstraint + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_DropUniqueConstraint"): + listener.enterOC_DropUniqueConstraint(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_DropUniqueConstraint"): + listener.exitOC_DropUniqueConstraint(self) + + def oC_DropUniqueConstraint(self): + + localctx = CypherParser.OC_DropUniqueConstraintContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 50, self.RULE_oC_DropUniqueConstraint) + try: + self.enterOuterAlt(localctx, 1) + self.state = 512 + self.match(CypherParser.DROP) + self.state = 513 + self.match(CypherParser.SP) + self.state = 514 + self.oC_UniqueConstraint() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_DropNodePropertyExistenceConstraintContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def DROP(self): + return self.getToken(CypherParser.DROP, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def oC_NodePropertyExistenceConstraint(self): + return self.getTypedRuleContext( + CypherParser.OC_NodePropertyExistenceConstraintContext, 0 + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_DropNodePropertyExistenceConstraint + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_DropNodePropertyExistenceConstraint"): + listener.enterOC_DropNodePropertyExistenceConstraint(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_DropNodePropertyExistenceConstraint"): + listener.exitOC_DropNodePropertyExistenceConstraint(self) + + def oC_DropNodePropertyExistenceConstraint(self): + + localctx = CypherParser.OC_DropNodePropertyExistenceConstraintContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 52, self.RULE_oC_DropNodePropertyExistenceConstraint) + try: + self.enterOuterAlt(localctx, 1) + self.state = 516 + self.match(CypherParser.DROP) + self.state = 517 + self.match(CypherParser.SP) + self.state = 518 + self.oC_NodePropertyExistenceConstraint() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_DropRelationshipPropertyExistenceConstraintContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def DROP(self): + return self.getToken(CypherParser.DROP, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def oC_RelationshipPropertyExistenceConstraint(self): + return self.getTypedRuleContext( + CypherParser.OC_RelationshipPropertyExistenceConstraintContext, 0 + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_DropRelationshipPropertyExistenceConstraint + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_DropRelationshipPropertyExistenceConstraint"): + listener.enterOC_DropRelationshipPropertyExistenceConstraint(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_DropRelationshipPropertyExistenceConstraint"): + listener.exitOC_DropRelationshipPropertyExistenceConstraint(self) + + def oC_DropRelationshipPropertyExistenceConstraint(self): + + localctx = CypherParser.OC_DropRelationshipPropertyExistenceConstraintContext( + self, self._ctx, self.state + ) + self.enterRule( + localctx, 54, self.RULE_oC_DropRelationshipPropertyExistenceConstraint + ) + try: + self.enterOuterAlt(localctx, 1) + self.state = 520 + self.match(CypherParser.DROP) + self.state = 521 + self.match(CypherParser.SP) + self.state = 522 + self.oC_RelationshipPropertyExistenceConstraint() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_DropIndexContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def DROP(self): + return self.getToken(CypherParser.DROP, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def oC_Index(self): + return self.getTypedRuleContext(CypherParser.OC_IndexContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_DropIndex + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_DropIndex"): + listener.enterOC_DropIndex(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_DropIndex"): + listener.exitOC_DropIndex(self) + + def oC_DropIndex(self): + + localctx = CypherParser.OC_DropIndexContext(self, self._ctx, self.state) + self.enterRule(localctx, 56, self.RULE_oC_DropIndex) + try: + self.enterOuterAlt(localctx, 1) + self.state = 524 + self.match(CypherParser.DROP) + self.state = 525 + self.match(CypherParser.SP) + self.state = 526 + self.oC_Index() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_IndexContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def INDEX(self): + return self.getToken(CypherParser.INDEX, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def ON(self): + return self.getToken(CypherParser.ON, 0) + + def oC_NodeLabel(self): + return self.getTypedRuleContext(CypherParser.OC_NodeLabelContext, 0) + + def oC_PropertyKeyName(self): + return self.getTypedRuleContext(CypherParser.OC_PropertyKeyNameContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Index + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Index"): + listener.enterOC_Index(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Index"): + listener.exitOC_Index(self) + + def oC_Index(self): + + localctx = CypherParser.OC_IndexContext(self, self._ctx, self.state) + self.enterRule(localctx, 58, self.RULE_oC_Index) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 528 + self.match(CypherParser.INDEX) + self.state = 529 + self.match(CypherParser.SP) + self.state = 530 + self.match(CypherParser.ON) + self.state = 532 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 531 + self.match(CypherParser.SP) + + self.state = 534 + self.oC_NodeLabel() + self.state = 535 + self.match(CypherParser.T__2) + self.state = 536 + self.oC_PropertyKeyName() + self.state = 537 + self.match(CypherParser.T__3) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_UniqueConstraintContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def CONSTRAINT(self): + return self.getToken(CypherParser.CONSTRAINT, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def ON(self): + return self.getToken(CypherParser.ON, 0) + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def oC_NodeLabel(self): + return self.getTypedRuleContext(CypherParser.OC_NodeLabelContext, 0) + + def ASSERT(self): + return self.getToken(CypherParser.ASSERT, 0) + + def oC_PropertyExpression(self): + return self.getTypedRuleContext( + CypherParser.OC_PropertyExpressionContext, 0 + ) + + def IS(self): + return self.getToken(CypherParser.IS, 0) + + def UNIQUE(self): + return self.getToken(CypherParser.UNIQUE, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_UniqueConstraint + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_UniqueConstraint"): + listener.enterOC_UniqueConstraint(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_UniqueConstraint"): + listener.exitOC_UniqueConstraint(self) + + def oC_UniqueConstraint(self): + + localctx = CypherParser.OC_UniqueConstraintContext(self, self._ctx, self.state) + self.enterRule(localctx, 60, self.RULE_oC_UniqueConstraint) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 539 + self.match(CypherParser.CONSTRAINT) + self.state = 540 + self.match(CypherParser.SP) + self.state = 541 + self.match(CypherParser.ON) + self.state = 543 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 542 + self.match(CypherParser.SP) + + self.state = 545 + self.match(CypherParser.T__2) + self.state = 546 + self.oC_Variable() + self.state = 547 + self.oC_NodeLabel() + self.state = 548 + self.match(CypherParser.T__3) + self.state = 550 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 549 + self.match(CypherParser.SP) + + self.state = 552 + self.match(CypherParser.ASSERT) + self.state = 553 + self.match(CypherParser.SP) + self.state = 554 + self.oC_PropertyExpression() + self.state = 555 + self.match(CypherParser.SP) + self.state = 556 + self.match(CypherParser.IS) + self.state = 557 + self.match(CypherParser.SP) + self.state = 558 + self.match(CypherParser.UNIQUE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_NodePropertyExistenceConstraintContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def CONSTRAINT(self): + return self.getToken(CypherParser.CONSTRAINT, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def ON(self): + return self.getToken(CypherParser.ON, 0) + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def oC_NodeLabel(self): + return self.getTypedRuleContext(CypherParser.OC_NodeLabelContext, 0) + + def ASSERT(self): + return self.getToken(CypherParser.ASSERT, 0) + + def EXISTS(self): + return self.getToken(CypherParser.EXISTS, 0) + + def oC_PropertyExpression(self): + return self.getTypedRuleContext( + CypherParser.OC_PropertyExpressionContext, 0 + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_NodePropertyExistenceConstraint + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_NodePropertyExistenceConstraint"): + listener.enterOC_NodePropertyExistenceConstraint(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_NodePropertyExistenceConstraint"): + listener.exitOC_NodePropertyExistenceConstraint(self) + + def oC_NodePropertyExistenceConstraint(self): + + localctx = CypherParser.OC_NodePropertyExistenceConstraintContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 62, self.RULE_oC_NodePropertyExistenceConstraint) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 560 + self.match(CypherParser.CONSTRAINT) + self.state = 561 + self.match(CypherParser.SP) + self.state = 562 + self.match(CypherParser.ON) + self.state = 564 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 563 + self.match(CypherParser.SP) + + self.state = 566 + self.match(CypherParser.T__2) + self.state = 567 + self.oC_Variable() + self.state = 568 + self.oC_NodeLabel() + self.state = 569 + self.match(CypherParser.T__3) + self.state = 571 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 570 + self.match(CypherParser.SP) + + self.state = 573 + self.match(CypherParser.ASSERT) + self.state = 574 + self.match(CypherParser.SP) + self.state = 575 + self.match(CypherParser.EXISTS) + self.state = 577 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 576 + self.match(CypherParser.SP) + + self.state = 579 + self.match(CypherParser.T__2) + self.state = 580 + self.oC_PropertyExpression() + self.state = 581 + self.match(CypherParser.T__3) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_RelationshipPropertyExistenceConstraintContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def CONSTRAINT(self): + return self.getToken(CypherParser.CONSTRAINT, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def ON(self): + return self.getToken(CypherParser.ON, 0) + + def oC_RelationshipPatternSyntax(self): + return self.getTypedRuleContext( + CypherParser.OC_RelationshipPatternSyntaxContext, 0 + ) + + def ASSERT(self): + return self.getToken(CypherParser.ASSERT, 0) + + def EXISTS(self): + return self.getToken(CypherParser.EXISTS, 0) + + def oC_PropertyExpression(self): + return self.getTypedRuleContext( + CypherParser.OC_PropertyExpressionContext, 0 + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_RelationshipPropertyExistenceConstraint + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_RelationshipPropertyExistenceConstraint"): + listener.enterOC_RelationshipPropertyExistenceConstraint(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_RelationshipPropertyExistenceConstraint"): + listener.exitOC_RelationshipPropertyExistenceConstraint(self) + + def oC_RelationshipPropertyExistenceConstraint(self): + + localctx = CypherParser.OC_RelationshipPropertyExistenceConstraintContext( + self, self._ctx, self.state + ) + self.enterRule( + localctx, 64, self.RULE_oC_RelationshipPropertyExistenceConstraint + ) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 583 + self.match(CypherParser.CONSTRAINT) + self.state = 584 + self.match(CypherParser.SP) + self.state = 585 + self.match(CypherParser.ON) + self.state = 587 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 586 + self.match(CypherParser.SP) + + self.state = 589 + self.oC_RelationshipPatternSyntax() + self.state = 591 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 590 + self.match(CypherParser.SP) + + self.state = 593 + self.match(CypherParser.ASSERT) + self.state = 594 + self.match(CypherParser.SP) + self.state = 595 + self.match(CypherParser.EXISTS) + self.state = 597 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 596 + self.match(CypherParser.SP) + + self.state = 599 + self.match(CypherParser.T__2) + self.state = 600 + self.oC_PropertyExpression() + self.state = 601 + self.match(CypherParser.T__3) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_RelationshipPatternSyntaxContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Dash(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_DashContext) + else: + return self.getTypedRuleContext(CypherParser.OC_DashContext, i) + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def oC_RelType(self): + return self.getTypedRuleContext(CypherParser.OC_RelTypeContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_RightArrowHead(self): + return self.getTypedRuleContext(CypherParser.OC_RightArrowHeadContext, 0) + + def oC_LeftArrowHead(self): + return self.getTypedRuleContext(CypherParser.OC_LeftArrowHeadContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_RelationshipPatternSyntax + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_RelationshipPatternSyntax"): + listener.enterOC_RelationshipPatternSyntax(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_RelationshipPatternSyntax"): + listener.exitOC_RelationshipPatternSyntax(self) + + def oC_RelationshipPatternSyntax(self): + + localctx = CypherParser.OC_RelationshipPatternSyntaxContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 66, self.RULE_oC_RelationshipPatternSyntax) + self._la = 0 # Token type + try: + self.state = 656 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 54, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 603 + self.match(CypherParser.T__2) + self.state = 605 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 604 + self.match(CypherParser.SP) + + self.state = 607 + self.match(CypherParser.T__3) + self.state = 608 + self.oC_Dash() + self.state = 609 + self.match(CypherParser.T__4) + self.state = 610 + self.oC_Variable() + self.state = 611 + self.oC_RelType() + self.state = 612 + self.match(CypherParser.T__5) + self.state = 613 + self.oC_Dash() + self.state = 614 + self.match(CypherParser.T__2) + self.state = 616 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 615 + self.match(CypherParser.SP) + + self.state = 618 + self.match(CypherParser.T__3) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 620 + self.match(CypherParser.T__2) + self.state = 622 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 621 + self.match(CypherParser.SP) + + self.state = 624 + self.match(CypherParser.T__3) + self.state = 625 + self.oC_Dash() + self.state = 626 + self.match(CypherParser.T__4) + self.state = 627 + self.oC_Variable() + self.state = 628 + self.oC_RelType() + self.state = 629 + self.match(CypherParser.T__5) + self.state = 630 + self.oC_Dash() + self.state = 631 + self.oC_RightArrowHead() + self.state = 632 + self.match(CypherParser.T__2) + self.state = 634 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 633 + self.match(CypherParser.SP) + + self.state = 636 + self.match(CypherParser.T__3) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 638 + self.match(CypherParser.T__2) + self.state = 640 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 639 + self.match(CypherParser.SP) + + self.state = 642 + self.match(CypherParser.T__3) + self.state = 643 + self.oC_LeftArrowHead() + self.state = 644 + self.oC_Dash() + self.state = 645 + self.match(CypherParser.T__4) + self.state = 646 + self.oC_Variable() + self.state = 647 + self.oC_RelType() + self.state = 648 + self.match(CypherParser.T__5) + self.state = 649 + self.oC_Dash() + self.state = 650 + self.match(CypherParser.T__2) + self.state = 652 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 651 + self.match(CypherParser.SP) + + self.state = 654 + self.match(CypherParser.T__3) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_LoadCSVContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def LOAD(self): + return self.getToken(CypherParser.LOAD, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def CSV(self): + return self.getToken(CypherParser.CSV, 0) + + def FROM(self): + return self.getToken(CypherParser.FROM, 0) + + def oC_Expression(self): + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, 0) + + def AS(self): + return self.getToken(CypherParser.AS, 0) + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def WITH(self): + return self.getToken(CypherParser.WITH, 0) + + def HEADERS(self): + return self.getToken(CypherParser.HEADERS, 0) + + def FIELDTERMINATOR(self): + return self.getToken(CypherParser.FIELDTERMINATOR, 0) + + def StringLiteral(self): + return self.getToken(CypherParser.StringLiteral, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_LoadCSV + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_LoadCSV"): + listener.enterOC_LoadCSV(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_LoadCSV"): + listener.exitOC_LoadCSV(self) + + def oC_LoadCSV(self): + + localctx = CypherParser.OC_LoadCSVContext(self, self._ctx, self.state) + self.enterRule(localctx, 68, self.RULE_oC_LoadCSV) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 658 + self.match(CypherParser.LOAD) + self.state = 659 + self.match(CypherParser.SP) + self.state = 660 + self.match(CypherParser.CSV) + self.state = 661 + self.match(CypherParser.SP) + self.state = 666 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 66: + self.state = 662 + self.match(CypherParser.WITH) + self.state = 663 + self.match(CypherParser.SP) + self.state = 664 + self.match(CypherParser.HEADERS) + self.state = 665 + self.match(CypherParser.SP) + + self.state = 668 + self.match(CypherParser.FROM) + self.state = 669 + self.match(CypherParser.SP) + self.state = 670 + self.oC_Expression() + self.state = 671 + self.match(CypherParser.SP) + self.state = 672 + self.match(CypherParser.AS) + self.state = 673 + self.match(CypherParser.SP) + self.state = 674 + self.oC_Variable() + self.state = 675 + self.match(CypherParser.SP) + self.state = 679 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 70: + self.state = 676 + self.match(CypherParser.FIELDTERMINATOR) + self.state = 677 + self.match(CypherParser.SP) + self.state = 678 + self.match(CypherParser.StringLiteral) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_MatchContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def MATCH(self): + return self.getToken(CypherParser.MATCH, 0) + + def oC_Pattern(self): + return self.getTypedRuleContext(CypherParser.OC_PatternContext, 0) + + def OPTIONAL(self): + return self.getToken(CypherParser.OPTIONAL, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_Hint(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_HintContext) + else: + return self.getTypedRuleContext(CypherParser.OC_HintContext, i) + + def oC_Where(self): + return self.getTypedRuleContext(CypherParser.OC_WhereContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Match + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Match"): + listener.enterOC_Match(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Match"): + listener.exitOC_Match(self) + + def oC_Match(self): + + localctx = CypherParser.OC_MatchContext(self, self._ctx, self.state) + self.enterRule(localctx, 70, self.RULE_oC_Match) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 683 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 71: + self.state = 681 + self.match(CypherParser.OPTIONAL) + self.state = 682 + self.match(CypherParser.SP) + + self.state = 685 + self.match(CypherParser.MATCH) + self.state = 687 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 686 + self.match(CypherParser.SP) + + self.state = 689 + self.oC_Pattern() + self.state = 693 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 59, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 690 + self.oC_Hint() + self.state = 695 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 59, self._ctx) + + self.state = 700 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 61, self._ctx) + if la_ == 1: + self.state = 697 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 696 + self.match(CypherParser.SP) + + self.state = 699 + self.oC_Where() + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_UnwindContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def UNWIND(self): + return self.getToken(CypherParser.UNWIND, 0) + + def oC_Expression(self): + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def AS(self): + return self.getToken(CypherParser.AS, 0) + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Unwind + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Unwind"): + listener.enterOC_Unwind(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Unwind"): + listener.exitOC_Unwind(self) + + def oC_Unwind(self): + + localctx = CypherParser.OC_UnwindContext(self, self._ctx, self.state) + self.enterRule(localctx, 72, self.RULE_oC_Unwind) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 702 + self.match(CypherParser.UNWIND) + self.state = 704 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 703 + self.match(CypherParser.SP) + + self.state = 706 + self.oC_Expression() + self.state = 707 + self.match(CypherParser.SP) + self.state = 708 + self.match(CypherParser.AS) + self.state = 709 + self.match(CypherParser.SP) + self.state = 710 + self.oC_Variable() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_MergeContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def MERGE(self): + return self.getToken(CypherParser.MERGE, 0) + + def oC_PatternPart(self): + return self.getTypedRuleContext(CypherParser.OC_PatternPartContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_MergeAction(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_MergeActionContext) + else: + return self.getTypedRuleContext(CypherParser.OC_MergeActionContext, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Merge + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Merge"): + listener.enterOC_Merge(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Merge"): + listener.exitOC_Merge(self) + + def oC_Merge(self): + + localctx = CypherParser.OC_MergeContext(self, self._ctx, self.state) + self.enterRule(localctx, 74, self.RULE_oC_Merge) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 712 + self.match(CypherParser.MERGE) + self.state = 714 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 713 + self.match(CypherParser.SP) + + self.state = 716 + self.oC_PatternPart() + self.state = 721 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 64, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 717 + self.match(CypherParser.SP) + self.state = 718 + self.oC_MergeAction() + self.state = 723 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 64, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_MergeActionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def ON(self): + return self.getToken(CypherParser.ON, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def MATCH(self): + return self.getToken(CypherParser.MATCH, 0) + + def oC_Set(self): + return self.getTypedRuleContext(CypherParser.OC_SetContext, 0) + + def CREATE(self): + return self.getToken(CypherParser.CREATE, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_MergeAction + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_MergeAction"): + listener.enterOC_MergeAction(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_MergeAction"): + listener.exitOC_MergeAction(self) + + def oC_MergeAction(self): + + localctx = CypherParser.OC_MergeActionContext(self, self._ctx, self.state) + self.enterRule(localctx, 76, self.RULE_oC_MergeAction) + try: + self.state = 734 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 65, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 724 + self.match(CypherParser.ON) + self.state = 725 + self.match(CypherParser.SP) + self.state = 726 + self.match(CypherParser.MATCH) + self.state = 727 + self.match(CypherParser.SP) + self.state = 728 + self.oC_Set() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 729 + self.match(CypherParser.ON) + self.state = 730 + self.match(CypherParser.SP) + self.state = 731 + self.match(CypherParser.CREATE) + self.state = 732 + self.match(CypherParser.SP) + self.state = 733 + self.oC_Set() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_CreateContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def CREATE(self): + return self.getToken(CypherParser.CREATE, 0) + + def oC_Pattern(self): + return self.getTypedRuleContext(CypherParser.OC_PatternContext, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Create + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Create"): + listener.enterOC_Create(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Create"): + listener.exitOC_Create(self) + + def oC_Create(self): + + localctx = CypherParser.OC_CreateContext(self, self._ctx, self.state) + self.enterRule(localctx, 78, self.RULE_oC_Create) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 736 + self.match(CypherParser.CREATE) + self.state = 738 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 737 + self.match(CypherParser.SP) + + self.state = 740 + self.oC_Pattern() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_CreateUniqueContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def CREATE(self): + return self.getToken(CypherParser.CREATE, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def UNIQUE(self): + return self.getToken(CypherParser.UNIQUE, 0) + + def oC_Pattern(self): + return self.getTypedRuleContext(CypherParser.OC_PatternContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_CreateUnique + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_CreateUnique"): + listener.enterOC_CreateUnique(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_CreateUnique"): + listener.exitOC_CreateUnique(self) + + def oC_CreateUnique(self): + + localctx = CypherParser.OC_CreateUniqueContext(self, self._ctx, self.state) + self.enterRule(localctx, 80, self.RULE_oC_CreateUnique) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 742 + self.match(CypherParser.CREATE) + self.state = 743 + self.match(CypherParser.SP) + self.state = 744 + self.match(CypherParser.UNIQUE) + self.state = 746 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 745 + self.match(CypherParser.SP) + + self.state = 748 + self.oC_Pattern() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_SetContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def SET(self): + return self.getToken(CypherParser.SET, 0) + + def oC_SetItem(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_SetItemContext) + else: + return self.getTypedRuleContext(CypherParser.OC_SetItemContext, i) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Set + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Set"): + listener.enterOC_Set(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Set"): + listener.exitOC_Set(self) + + def oC_Set(self): + + localctx = CypherParser.OC_SetContext(self, self._ctx, self.state) + self.enterRule(localctx, 82, self.RULE_oC_Set) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 750 + self.match(CypherParser.SET) + self.state = 752 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 751 + self.match(CypherParser.SP) + + self.state = 754 + self.oC_SetItem() + self.state = 765 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 71, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 756 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 755 + self.match(CypherParser.SP) + + self.state = 758 + self.match(CypherParser.T__6) + self.state = 760 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 759 + self.match(CypherParser.SP) + + self.state = 762 + self.oC_SetItem() + self.state = 767 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 71, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_SetItemContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_PropertyExpression(self): + return self.getTypedRuleContext( + CypherParser.OC_PropertyExpressionContext, 0 + ) + + def oC_Expression(self): + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def oC_NodeLabels(self): + return self.getTypedRuleContext(CypherParser.OC_NodeLabelsContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_SetItem + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_SetItem"): + listener.enterOC_SetItem(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_SetItem"): + listener.exitOC_SetItem(self) + + def oC_SetItem(self): + + localctx = CypherParser.OC_SetItemContext(self, self._ctx, self.state) + self.enterRule(localctx, 84, self.RULE_oC_SetItem) + self._la = 0 # Token type + try: + self.state = 804 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 79, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 768 + self.oC_PropertyExpression() + self.state = 770 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 769 + self.match(CypherParser.SP) + + self.state = 772 + self.match(CypherParser.T__1) + self.state = 774 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 773 + self.match(CypherParser.SP) + + self.state = 776 + self.oC_Expression() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 778 + self.oC_Variable() + self.state = 780 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 779 + self.match(CypherParser.SP) + + self.state = 782 + self.match(CypherParser.T__1) + self.state = 784 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 783 + self.match(CypherParser.SP) + + self.state = 786 + self.oC_Expression() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 788 + self.oC_Variable() + self.state = 790 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 789 + self.match(CypherParser.SP) + + self.state = 792 + self.match(CypherParser.T__7) + self.state = 794 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 793 + self.match(CypherParser.SP) + + self.state = 796 + self.oC_Expression() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 798 + self.oC_Variable() + self.state = 800 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 799 + self.match(CypherParser.SP) + + self.state = 802 + self.oC_NodeLabels() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_DeleteContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def DELETE(self): + return self.getToken(CypherParser.DELETE, 0) + + def oC_Expression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_ExpressionContext) + else: + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, i) + + def DETACH(self): + return self.getToken(CypherParser.DETACH, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Delete + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Delete"): + listener.enterOC_Delete(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Delete"): + listener.exitOC_Delete(self) + + def oC_Delete(self): + + localctx = CypherParser.OC_DeleteContext(self, self._ctx, self.state) + self.enterRule(localctx, 86, self.RULE_oC_Delete) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 808 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 76: + self.state = 806 + self.match(CypherParser.DETACH) + self.state = 807 + self.match(CypherParser.SP) + + self.state = 810 + self.match(CypherParser.DELETE) + self.state = 812 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 811 + self.match(CypherParser.SP) + + self.state = 814 + self.oC_Expression() + self.state = 825 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 84, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 816 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 815 + self.match(CypherParser.SP) + + self.state = 818 + self.match(CypherParser.T__6) + self.state = 820 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 819 + self.match(CypherParser.SP) + + self.state = 822 + self.oC_Expression() + self.state = 827 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 84, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_RemoveContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def REMOVE(self): + return self.getToken(CypherParser.REMOVE, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_RemoveItem(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_RemoveItemContext) + else: + return self.getTypedRuleContext(CypherParser.OC_RemoveItemContext, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Remove + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Remove"): + listener.enterOC_Remove(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Remove"): + listener.exitOC_Remove(self) + + def oC_Remove(self): + + localctx = CypherParser.OC_RemoveContext(self, self._ctx, self.state) + self.enterRule(localctx, 88, self.RULE_oC_Remove) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 828 + self.match(CypherParser.REMOVE) + self.state = 829 + self.match(CypherParser.SP) + self.state = 830 + self.oC_RemoveItem() + self.state = 841 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 87, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 832 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 831 + self.match(CypherParser.SP) + + self.state = 834 + self.match(CypherParser.T__6) + self.state = 836 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 835 + self.match(CypherParser.SP) + + self.state = 838 + self.oC_RemoveItem() + self.state = 843 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 87, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_RemoveItemContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def oC_NodeLabels(self): + return self.getTypedRuleContext(CypherParser.OC_NodeLabelsContext, 0) + + def oC_PropertyExpression(self): + return self.getTypedRuleContext( + CypherParser.OC_PropertyExpressionContext, 0 + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_RemoveItem + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_RemoveItem"): + listener.enterOC_RemoveItem(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_RemoveItem"): + listener.exitOC_RemoveItem(self) + + def oC_RemoveItem(self): + + localctx = CypherParser.OC_RemoveItemContext(self, self._ctx, self.state) + self.enterRule(localctx, 90, self.RULE_oC_RemoveItem) + try: + self.state = 848 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 88, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 844 + self.oC_Variable() + self.state = 845 + self.oC_NodeLabels() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 847 + self.oC_PropertyExpression() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ForeachContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def FOREACH(self): + return self.getToken(CypherParser.FOREACH, 0) + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def IN(self): + return self.getToken(CypherParser.IN, 0) + + def oC_Expression(self): + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, 0) + + def oC_UpdatingClause(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_UpdatingClauseContext) + else: + return self.getTypedRuleContext( + CypherParser.OC_UpdatingClauseContext, i + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Foreach + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Foreach"): + listener.enterOC_Foreach(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Foreach"): + listener.exitOC_Foreach(self) + + def oC_Foreach(self): + + localctx = CypherParser.OC_ForeachContext(self, self._ctx, self.state) + self.enterRule(localctx, 92, self.RULE_oC_Foreach) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 850 + self.match(CypherParser.FOREACH) + self.state = 852 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 851 + self.match(CypherParser.SP) + + self.state = 854 + self.match(CypherParser.T__2) + self.state = 856 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 855 + self.match(CypherParser.SP) + + self.state = 858 + self.oC_Variable() + self.state = 859 + self.match(CypherParser.SP) + self.state = 860 + self.match(CypherParser.IN) + self.state = 861 + self.match(CypherParser.SP) + self.state = 862 + self.oC_Expression() + self.state = 864 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 863 + self.match(CypherParser.SP) + + self.state = 866 + self.match(CypherParser.T__8) + self.state = 869 + self._errHandler.sync(self) + _alt = 1 + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 867 + self.match(CypherParser.SP) + self.state = 868 + self.oC_UpdatingClause() + + else: + raise NoViableAltException(self) + self.state = 871 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 92, self._ctx) + + self.state = 874 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 873 + self.match(CypherParser.SP) + + self.state = 876 + self.match(CypherParser.T__3) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_InQueryCallContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def CALL(self): + return self.getToken(CypherParser.CALL, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_ExplicitProcedureInvocation(self): + return self.getTypedRuleContext( + CypherParser.OC_ExplicitProcedureInvocationContext, 0 + ) + + def YIELD(self): + return self.getToken(CypherParser.YIELD, 0) + + def oC_YieldItems(self): + return self.getTypedRuleContext(CypherParser.OC_YieldItemsContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_InQueryCall + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_InQueryCall"): + listener.enterOC_InQueryCall(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_InQueryCall"): + listener.exitOC_InQueryCall(self) + + def oC_InQueryCall(self): + + localctx = CypherParser.OC_InQueryCallContext(self, self._ctx, self.state) + self.enterRule(localctx, 94, self.RULE_oC_InQueryCall) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 878 + self.match(CypherParser.CALL) + self.state = 879 + self.match(CypherParser.SP) + self.state = 880 + self.oC_ExplicitProcedureInvocation() + self.state = 887 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 95, self._ctx) + if la_ == 1: + self.state = 882 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 881 + self.match(CypherParser.SP) + + self.state = 884 + self.match(CypherParser.YIELD) + self.state = 885 + self.match(CypherParser.SP) + self.state = 886 + self.oC_YieldItems() + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_StandaloneCallContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def CALL(self): + return self.getToken(CypherParser.CALL, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_ExplicitProcedureInvocation(self): + return self.getTypedRuleContext( + CypherParser.OC_ExplicitProcedureInvocationContext, 0 + ) + + def oC_ImplicitProcedureInvocation(self): + return self.getTypedRuleContext( + CypherParser.OC_ImplicitProcedureInvocationContext, 0 + ) + + def YIELD(self): + return self.getToken(CypherParser.YIELD, 0) + + def oC_YieldItems(self): + return self.getTypedRuleContext(CypherParser.OC_YieldItemsContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_StandaloneCall + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_StandaloneCall"): + listener.enterOC_StandaloneCall(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_StandaloneCall"): + listener.exitOC_StandaloneCall(self) + + def oC_StandaloneCall(self): + + localctx = CypherParser.OC_StandaloneCallContext(self, self._ctx, self.state) + self.enterRule(localctx, 96, self.RULE_oC_StandaloneCall) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 889 + self.match(CypherParser.CALL) + self.state = 890 + self.match(CypherParser.SP) + self.state = 893 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 96, self._ctx) + if la_ == 1: + self.state = 891 + self.oC_ExplicitProcedureInvocation() + pass + + elif la_ == 2: + self.state = 892 + self.oC_ImplicitProcedureInvocation() + pass + + self.state = 904 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 99, self._ctx) + if la_ == 1: + self.state = 896 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 895 + self.match(CypherParser.SP) + + self.state = 898 + self.match(CypherParser.YIELD) + self.state = 899 + self.match(CypherParser.SP) + self.state = 902 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [10]: + self.state = 900 + self.match(CypherParser.T__9) + pass + elif token in [110, 116, 117, 119, 120, 121, 127, 145, 148]: + self.state = 901 + self.oC_YieldItems() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_YieldItemsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_YieldItem(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_YieldItemContext) + else: + return self.getTypedRuleContext(CypherParser.OC_YieldItemContext, i) + + def oC_Where(self): + return self.getTypedRuleContext(CypherParser.OC_WhereContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_YieldItems + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_YieldItems"): + listener.enterOC_YieldItems(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_YieldItems"): + listener.exitOC_YieldItems(self) + + def oC_YieldItems(self): + + localctx = CypherParser.OC_YieldItemsContext(self, self._ctx, self.state) + self.enterRule(localctx, 98, self.RULE_oC_YieldItems) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 906 + self.oC_YieldItem() + self.state = 917 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 102, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 908 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 907 + self.match(CypherParser.SP) + + self.state = 910 + self.match(CypherParser.T__6) + self.state = 912 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 911 + self.match(CypherParser.SP) + + self.state = 914 + self.oC_YieldItem() + self.state = 919 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 102, self._ctx) + + self.state = 924 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 104, self._ctx) + if la_ == 1: + self.state = 921 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 920 + self.match(CypherParser.SP) + + self.state = 923 + self.oC_Where() + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_YieldItemContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def oC_ProcedureResultField(self): + return self.getTypedRuleContext( + CypherParser.OC_ProcedureResultFieldContext, 0 + ) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def AS(self): + return self.getToken(CypherParser.AS, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_YieldItem + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_YieldItem"): + listener.enterOC_YieldItem(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_YieldItem"): + listener.exitOC_YieldItem(self) + + def oC_YieldItem(self): + + localctx = CypherParser.OC_YieldItemContext(self, self._ctx, self.state) + self.enterRule(localctx, 100, self.RULE_oC_YieldItem) + try: + self.enterOuterAlt(localctx, 1) + self.state = 931 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 105, self._ctx) + if la_ == 1: + self.state = 926 + self.oC_ProcedureResultField() + self.state = 927 + self.match(CypherParser.SP) + self.state = 928 + self.match(CypherParser.AS) + self.state = 929 + self.match(CypherParser.SP) + + self.state = 933 + self.oC_Variable() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_WithContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def WITH(self): + return self.getToken(CypherParser.WITH, 0) + + def oC_ProjectionBody(self): + return self.getTypedRuleContext(CypherParser.OC_ProjectionBodyContext, 0) + + def oC_Where(self): + return self.getTypedRuleContext(CypherParser.OC_WhereContext, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_With + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_With"): + listener.enterOC_With(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_With"): + listener.exitOC_With(self) + + def oC_With(self): + + localctx = CypherParser.OC_WithContext(self, self._ctx, self.state) + self.enterRule(localctx, 102, self.RULE_oC_With) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 935 + self.match(CypherParser.WITH) + self.state = 936 + self.oC_ProjectionBody() + self.state = 941 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 107, self._ctx) + if la_ == 1: + self.state = 938 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 937 + self.match(CypherParser.SP) + + self.state = 940 + self.oC_Where() + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ReturnContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def RETURN(self): + return self.getToken(CypherParser.RETURN, 0) + + def oC_ProjectionBody(self): + return self.getTypedRuleContext(CypherParser.OC_ProjectionBodyContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Return + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Return"): + listener.enterOC_Return(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Return"): + listener.exitOC_Return(self) + + def oC_Return(self): + + localctx = CypherParser.OC_ReturnContext(self, self._ctx, self.state) + self.enterRule(localctx, 104, self.RULE_oC_Return) + try: + self.enterOuterAlt(localctx, 1) + self.state = 943 + self.match(CypherParser.RETURN) + self.state = 944 + self.oC_ProjectionBody() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ProjectionBodyContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_ProjectionItems(self): + return self.getTypedRuleContext(CypherParser.OC_ProjectionItemsContext, 0) + + def DISTINCT(self): + return self.getToken(CypherParser.DISTINCT, 0) + + def oC_Order(self): + return self.getTypedRuleContext(CypherParser.OC_OrderContext, 0) + + def oC_Skip(self): + return self.getTypedRuleContext(CypherParser.OC_SkipContext, 0) + + def oC_Limit(self): + return self.getTypedRuleContext(CypherParser.OC_LimitContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ProjectionBody + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ProjectionBody"): + listener.enterOC_ProjectionBody(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ProjectionBody"): + listener.exitOC_ProjectionBody(self) + + def oC_ProjectionBody(self): + + localctx = CypherParser.OC_ProjectionBodyContext(self, self._ctx, self.state) + self.enterRule(localctx, 106, self.RULE_oC_ProjectionBody) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 950 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 109, self._ctx) + if la_ == 1: + self.state = 947 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 946 + self.match(CypherParser.SP) + + self.state = 949 + self.match(CypherParser.DISTINCT) + + self.state = 952 + self.match(CypherParser.SP) + self.state = 953 + self.oC_ProjectionItems() + self.state = 956 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 110, self._ctx) + if la_ == 1: + self.state = 954 + self.match(CypherParser.SP) + self.state = 955 + self.oC_Order() + + self.state = 960 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 111, self._ctx) + if la_ == 1: + self.state = 958 + self.match(CypherParser.SP) + self.state = 959 + self.oC_Skip() + + self.state = 964 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 112, self._ctx) + if la_ == 1: + self.state = 962 + self.match(CypherParser.SP) + self.state = 963 + self.oC_Limit() + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ProjectionItemsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_ProjectionItem(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_ProjectionItemContext) + else: + return self.getTypedRuleContext( + CypherParser.OC_ProjectionItemContext, i + ) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ProjectionItems + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ProjectionItems"): + listener.enterOC_ProjectionItems(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ProjectionItems"): + listener.exitOC_ProjectionItems(self) + + def oC_ProjectionItems(self): + + localctx = CypherParser.OC_ProjectionItemsContext(self, self._ctx, self.state) + self.enterRule(localctx, 108, self.RULE_oC_ProjectionItems) + self._la = 0 # Token type + try: + self.state = 994 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [10]: + self.enterOuterAlt(localctx, 1) + self.state = 966 + self.match(CypherParser.T__9) + self.state = 977 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 115, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 968 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 967 + self.match(CypherParser.SP) + + self.state = 970 + self.match(CypherParser.T__6) + self.state = 972 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 971 + self.match(CypherParser.SP) + + self.state = 974 + self.oC_ProjectionItem() + self.state = 979 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 115, self._ctx) + + pass + elif token in [ + 3, + 5, + 19, + 20, + 25, + 27, + 54, + 63, + 100, + 101, + 105, + 109, + 110, + 111, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 134, + 135, + 136, + 145, + 148, + ]: + self.enterOuterAlt(localctx, 2) + self.state = 980 + self.oC_ProjectionItem() + self.state = 991 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 118, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 982 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 981 + self.match(CypherParser.SP) + + self.state = 984 + self.match(CypherParser.T__6) + self.state = 986 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 985 + self.match(CypherParser.SP) + + self.state = 988 + self.oC_ProjectionItem() + self.state = 993 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 118, self._ctx) + + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ProjectionItemContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Expression(self): + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def AS(self): + return self.getToken(CypherParser.AS, 0) + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ProjectionItem + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ProjectionItem"): + listener.enterOC_ProjectionItem(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ProjectionItem"): + listener.exitOC_ProjectionItem(self) + + def oC_ProjectionItem(self): + + localctx = CypherParser.OC_ProjectionItemContext(self, self._ctx, self.state) + self.enterRule(localctx, 110, self.RULE_oC_ProjectionItem) + try: + self.state = 1003 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 120, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 996 + self.oC_Expression() + self.state = 997 + self.match(CypherParser.SP) + self.state = 998 + self.match(CypherParser.AS) + self.state = 999 + self.match(CypherParser.SP) + self.state = 1000 + self.oC_Variable() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1002 + self.oC_Expression() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_OrderContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def ORDER(self): + return self.getToken(CypherParser.ORDER, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def BY(self): + return self.getToken(CypherParser.BY, 0) + + def oC_SortItem(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_SortItemContext) + else: + return self.getTypedRuleContext(CypherParser.OC_SortItemContext, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Order + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Order"): + listener.enterOC_Order(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Order"): + listener.exitOC_Order(self) + + def oC_Order(self): + + localctx = CypherParser.OC_OrderContext(self, self._ctx, self.state) + self.enterRule(localctx, 112, self.RULE_oC_Order) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1005 + self.match(CypherParser.ORDER) + self.state = 1006 + self.match(CypherParser.SP) + self.state = 1007 + self.match(CypherParser.BY) + self.state = 1008 + self.match(CypherParser.SP) + self.state = 1009 + self.oC_SortItem() + self.state = 1017 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 7: + self.state = 1010 + self.match(CypherParser.T__6) + self.state = 1012 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1011 + self.match(CypherParser.SP) + + self.state = 1014 + self.oC_SortItem() + self.state = 1019 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_SkipContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def L_SKIP(self): + return self.getToken(CypherParser.L_SKIP, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def oC_Expression(self): + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Skip + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Skip"): + listener.enterOC_Skip(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Skip"): + listener.exitOC_Skip(self) + + def oC_Skip(self): + + localctx = CypherParser.OC_SkipContext(self, self._ctx, self.state) + self.enterRule(localctx, 114, self.RULE_oC_Skip) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1020 + self.match(CypherParser.L_SKIP) + self.state = 1021 + self.match(CypherParser.SP) + self.state = 1022 + self.oC_Expression() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_LimitContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def LIMIT(self): + return self.getToken(CypherParser.LIMIT, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def oC_Expression(self): + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Limit + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Limit"): + listener.enterOC_Limit(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Limit"): + listener.exitOC_Limit(self) + + def oC_Limit(self): + + localctx = CypherParser.OC_LimitContext(self, self._ctx, self.state) + self.enterRule(localctx, 116, self.RULE_oC_Limit) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1024 + self.match(CypherParser.LIMIT) + self.state = 1025 + self.match(CypherParser.SP) + self.state = 1026 + self.oC_Expression() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_SortItemContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Expression(self): + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, 0) + + def ASCENDING(self): + return self.getToken(CypherParser.ASCENDING, 0) + + def ASC(self): + return self.getToken(CypherParser.ASC, 0) + + def DESCENDING(self): + return self.getToken(CypherParser.DESCENDING, 0) + + def DESC(self): + return self.getToken(CypherParser.DESC, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_SortItem + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_SortItem"): + listener.enterOC_SortItem(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_SortItem"): + listener.exitOC_SortItem(self) + + def oC_SortItem(self): + + localctx = CypherParser.OC_SortItemContext(self, self._ctx, self.state) + self.enterRule(localctx, 118, self.RULE_oC_SortItem) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1028 + self.oC_Expression() + self.state = 1033 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 124, self._ctx) + if la_ == 1: + self.state = 1030 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1029 + self.match(CypherParser.SP) + + self.state = 1032 + _la = self._input.LA(1) + if not ( + ((((_la - 89)) & ~0x3F) == 0 and ((1 << (_la - 89)) & 15) != 0) + ): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_HintContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def USING(self): + return self.getToken(CypherParser.USING, 0) + + def INDEX(self): + return self.getToken(CypherParser.INDEX, 0) + + def oC_Variable(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_VariableContext) + else: + return self.getTypedRuleContext(CypherParser.OC_VariableContext, i) + + def oC_NodeLabel(self): + return self.getTypedRuleContext(CypherParser.OC_NodeLabelContext, 0) + + def oC_PropertyKeyName(self): + return self.getTypedRuleContext(CypherParser.OC_PropertyKeyNameContext, 0) + + def JOIN(self): + return self.getToken(CypherParser.JOIN, 0) + + def ON(self): + return self.getToken(CypherParser.ON, 0) + + def SCAN(self): + return self.getToken(CypherParser.SCAN, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Hint + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Hint"): + listener.enterOC_Hint(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Hint"): + listener.exitOC_Hint(self) + + def oC_Hint(self): + + localctx = CypherParser.OC_HintContext(self, self._ctx, self.state) + self.enterRule(localctx, 120, self.RULE_oC_Hint) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1036 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1035 + self.match(CypherParser.SP) + + self.state = 1075 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 129, self._ctx) + if la_ == 1: + self.state = 1038 + self.match(CypherParser.USING) + self.state = 1039 + self.match(CypherParser.SP) + self.state = 1040 + self.match(CypherParser.INDEX) + self.state = 1041 + self.match(CypherParser.SP) + self.state = 1042 + self.oC_Variable() + self.state = 1043 + self.oC_NodeLabel() + self.state = 1044 + self.match(CypherParser.T__2) + self.state = 1045 + self.oC_PropertyKeyName() + self.state = 1046 + self.match(CypherParser.T__3) + pass + + elif la_ == 2: + self.state = 1048 + self.match(CypherParser.USING) + self.state = 1049 + self.match(CypherParser.SP) + self.state = 1050 + self.match(CypherParser.JOIN) + self.state = 1051 + self.match(CypherParser.SP) + self.state = 1052 + self.match(CypherParser.ON) + self.state = 1053 + self.match(CypherParser.SP) + self.state = 1054 + self.oC_Variable() + self.state = 1065 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 128, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1056 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1055 + self.match(CypherParser.SP) + + self.state = 1058 + self.match(CypherParser.T__6) + self.state = 1060 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1059 + self.match(CypherParser.SP) + + self.state = 1062 + self.oC_Variable() + self.state = 1067 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 128, self._ctx) + + pass + + elif la_ == 3: + self.state = 1068 + self.match(CypherParser.USING) + self.state = 1069 + self.match(CypherParser.SP) + self.state = 1070 + self.match(CypherParser.SCAN) + self.state = 1071 + self.match(CypherParser.SP) + self.state = 1072 + self.oC_Variable() + self.state = 1073 + self.oC_NodeLabel() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_StartContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def START(self): + return self.getToken(CypherParser.START, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_StartPoint(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_StartPointContext) + else: + return self.getTypedRuleContext(CypherParser.OC_StartPointContext, i) + + def oC_Where(self): + return self.getTypedRuleContext(CypherParser.OC_WhereContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Start + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Start"): + listener.enterOC_Start(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Start"): + listener.exitOC_Start(self) + + def oC_Start(self): + + localctx = CypherParser.OC_StartContext(self, self._ctx, self.state) + self.enterRule(localctx, 122, self.RULE_oC_Start) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1077 + self.match(CypherParser.START) + self.state = 1078 + self.match(CypherParser.SP) + self.state = 1079 + self.oC_StartPoint() + self.state = 1090 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 132, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1081 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1080 + self.match(CypherParser.SP) + + self.state = 1083 + self.match(CypherParser.T__6) + self.state = 1085 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1084 + self.match(CypherParser.SP) + + self.state = 1087 + self.oC_StartPoint() + self.state = 1092 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 132, self._ctx) + + self.state = 1094 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 99: + self.state = 1093 + self.oC_Where() + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_StartPointContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def oC_Lookup(self): + return self.getTypedRuleContext(CypherParser.OC_LookupContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_StartPoint + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_StartPoint"): + listener.enterOC_StartPoint(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_StartPoint"): + listener.exitOC_StartPoint(self) + + def oC_StartPoint(self): + + localctx = CypherParser.OC_StartPointContext(self, self._ctx, self.state) + self.enterRule(localctx, 124, self.RULE_oC_StartPoint) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1096 + self.oC_Variable() + self.state = 1098 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1097 + self.match(CypherParser.SP) + + self.state = 1100 + self.match(CypherParser.T__1) + self.state = 1102 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1101 + self.match(CypherParser.SP) + + self.state = 1104 + self.oC_Lookup() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_LookupContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_NodeLookup(self): + return self.getTypedRuleContext(CypherParser.OC_NodeLookupContext, 0) + + def oC_RelationshipLookup(self): + return self.getTypedRuleContext( + CypherParser.OC_RelationshipLookupContext, 0 + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Lookup + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Lookup"): + listener.enterOC_Lookup(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Lookup"): + listener.exitOC_Lookup(self) + + def oC_Lookup(self): + + localctx = CypherParser.OC_LookupContext(self, self._ctx, self.state) + self.enterRule(localctx, 126, self.RULE_oC_Lookup) + try: + self.state = 1108 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [96]: + self.enterOuterAlt(localctx, 1) + self.state = 1106 + self.oC_NodeLookup() + pass + elif token in [97, 98]: + self.enterOuterAlt(localctx, 2) + self.state = 1107 + self.oC_RelationshipLookup() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_NodeLookupContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def NODE(self): + return self.getToken(CypherParser.NODE, 0) + + def oC_IdentifiedIndexLookup(self): + return self.getTypedRuleContext( + CypherParser.OC_IdentifiedIndexLookupContext, 0 + ) + + def oC_IndexQuery(self): + return self.getTypedRuleContext(CypherParser.OC_IndexQueryContext, 0) + + def oC_IdLookup(self): + return self.getTypedRuleContext(CypherParser.OC_IdLookupContext, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_NodeLookup + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_NodeLookup"): + listener.enterOC_NodeLookup(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_NodeLookup"): + listener.exitOC_NodeLookup(self) + + def oC_NodeLookup(self): + + localctx = CypherParser.OC_NodeLookupContext(self, self._ctx, self.state) + self.enterRule(localctx, 128, self.RULE_oC_NodeLookup) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1110 + self.match(CypherParser.NODE) + self.state = 1112 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1111 + self.match(CypherParser.SP) + + self.state = 1117 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 138, self._ctx) + if la_ == 1: + self.state = 1114 + self.oC_IdentifiedIndexLookup() + pass + + elif la_ == 2: + self.state = 1115 + self.oC_IndexQuery() + pass + + elif la_ == 3: + self.state = 1116 + self.oC_IdLookup() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_RelationshipLookupContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def RELATIONSHIP(self): + return self.getToken(CypherParser.RELATIONSHIP, 0) + + def REL(self): + return self.getToken(CypherParser.REL, 0) + + def oC_IdentifiedIndexLookup(self): + return self.getTypedRuleContext( + CypherParser.OC_IdentifiedIndexLookupContext, 0 + ) + + def oC_IndexQuery(self): + return self.getTypedRuleContext(CypherParser.OC_IndexQueryContext, 0) + + def oC_IdLookup(self): + return self.getTypedRuleContext(CypherParser.OC_IdLookupContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_RelationshipLookup + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_RelationshipLookup"): + listener.enterOC_RelationshipLookup(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_RelationshipLookup"): + listener.exitOC_RelationshipLookup(self) + + def oC_RelationshipLookup(self): + + localctx = CypherParser.OC_RelationshipLookupContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 130, self.RULE_oC_RelationshipLookup) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1119 + _la = self._input.LA(1) + if not (_la == 97 or _la == 98): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1123 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 139, self._ctx) + if la_ == 1: + self.state = 1120 + self.oC_IdentifiedIndexLookup() + pass + + elif la_ == 2: + self.state = 1121 + self.oC_IndexQuery() + pass + + elif la_ == 3: + self.state = 1122 + self.oC_IdLookup() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_IdentifiedIndexLookupContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_SymbolicName(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_SymbolicNameContext) + else: + return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext, i) + + def StringLiteral(self): + return self.getToken(CypherParser.StringLiteral, 0) + + def oC_LegacyParameter(self): + return self.getTypedRuleContext(CypherParser.OC_LegacyParameterContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_IdentifiedIndexLookup + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_IdentifiedIndexLookup"): + listener.enterOC_IdentifiedIndexLookup(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_IdentifiedIndexLookup"): + listener.exitOC_IdentifiedIndexLookup(self) + + def oC_IdentifiedIndexLookup(self): + + localctx = CypherParser.OC_IdentifiedIndexLookupContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 132, self.RULE_oC_IdentifiedIndexLookup) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1125 + self.match(CypherParser.T__10) + self.state = 1126 + self.oC_SymbolicName() + self.state = 1127 + self.match(CypherParser.T__2) + self.state = 1128 + self.oC_SymbolicName() + self.state = 1129 + self.match(CypherParser.T__1) + self.state = 1132 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [136]: + self.state = 1130 + self.match(CypherParser.StringLiteral) + pass + elif token in [25]: + self.state = 1131 + self.oC_LegacyParameter() + pass + else: + raise NoViableAltException(self) + + self.state = 1134 + self.match(CypherParser.T__3) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_IndexQueryContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_SymbolicName(self): + return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext, 0) + + def StringLiteral(self): + return self.getToken(CypherParser.StringLiteral, 0) + + def oC_LegacyParameter(self): + return self.getTypedRuleContext(CypherParser.OC_LegacyParameterContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_IndexQuery + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_IndexQuery"): + listener.enterOC_IndexQuery(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_IndexQuery"): + listener.exitOC_IndexQuery(self) + + def oC_IndexQuery(self): + + localctx = CypherParser.OC_IndexQueryContext(self, self._ctx, self.state) + self.enterRule(localctx, 134, self.RULE_oC_IndexQuery) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1136 + self.match(CypherParser.T__10) + self.state = 1137 + self.oC_SymbolicName() + self.state = 1138 + self.match(CypherParser.T__2) + self.state = 1141 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [136]: + self.state = 1139 + self.match(CypherParser.StringLiteral) + pass + elif token in [25]: + self.state = 1140 + self.oC_LegacyParameter() + pass + else: + raise NoViableAltException(self) + + self.state = 1143 + self.match(CypherParser.T__3) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_IdLookupContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_LiteralIds(self): + return self.getTypedRuleContext(CypherParser.OC_LiteralIdsContext, 0) + + def oC_LegacyParameter(self): + return self.getTypedRuleContext(CypherParser.OC_LegacyParameterContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_IdLookup + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_IdLookup"): + listener.enterOC_IdLookup(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_IdLookup"): + listener.exitOC_IdLookup(self) + + def oC_IdLookup(self): + + localctx = CypherParser.OC_IdLookupContext(self, self._ctx, self.state) + self.enterRule(localctx, 136, self.RULE_oC_IdLookup) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1145 + self.match(CypherParser.T__2) + self.state = 1149 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [124, 125, 126]: + self.state = 1146 + self.oC_LiteralIds() + pass + elif token in [25]: + self.state = 1147 + self.oC_LegacyParameter() + pass + elif token in [10]: + self.state = 1148 + self.match(CypherParser.T__9) + pass + else: + raise NoViableAltException(self) + + self.state = 1151 + self.match(CypherParser.T__3) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_LiteralIdsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_IntegerLiteral(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_IntegerLiteralContext) + else: + return self.getTypedRuleContext( + CypherParser.OC_IntegerLiteralContext, i + ) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_LiteralIds + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_LiteralIds"): + listener.enterOC_LiteralIds(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_LiteralIds"): + listener.exitOC_LiteralIds(self) + + def oC_LiteralIds(self): + + localctx = CypherParser.OC_LiteralIdsContext(self, self._ctx, self.state) + self.enterRule(localctx, 138, self.RULE_oC_LiteralIds) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1153 + self.oC_IntegerLiteral() + self.state = 1164 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 7 or _la == 149: + self.state = 1155 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1154 + self.match(CypherParser.SP) + + self.state = 1157 + self.match(CypherParser.T__6) + self.state = 1159 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1158 + self.match(CypherParser.SP) + + self.state = 1161 + self.oC_IntegerLiteral() + self.state = 1166 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_WhereContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def WHERE(self): + return self.getToken(CypherParser.WHERE, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def oC_Expression(self): + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Where + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Where"): + listener.enterOC_Where(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Where"): + listener.exitOC_Where(self) + + def oC_Where(self): + + localctx = CypherParser.OC_WhereContext(self, self._ctx, self.state) + self.enterRule(localctx, 140, self.RULE_oC_Where) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1167 + self.match(CypherParser.WHERE) + self.state = 1168 + self.match(CypherParser.SP) + self.state = 1169 + self.oC_Expression() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_PatternContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_PatternPart(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_PatternPartContext) + else: + return self.getTypedRuleContext(CypherParser.OC_PatternPartContext, i) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Pattern + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Pattern"): + listener.enterOC_Pattern(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Pattern"): + listener.exitOC_Pattern(self) + + def oC_Pattern(self): + + localctx = CypherParser.OC_PatternContext(self, self._ctx, self.state) + self.enterRule(localctx, 142, self.RULE_oC_Pattern) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1171 + self.oC_PatternPart() + self.state = 1182 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 148, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1173 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1172 + self.match(CypherParser.SP) + + self.state = 1175 + self.match(CypherParser.T__6) + self.state = 1177 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1176 + self.match(CypherParser.SP) + + self.state = 1179 + self.oC_PatternPart() + self.state = 1184 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 148, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_PatternPartContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def oC_AnonymousPatternPart(self): + return self.getTypedRuleContext( + CypherParser.OC_AnonymousPatternPartContext, 0 + ) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_PatternPart + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_PatternPart"): + listener.enterOC_PatternPart(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_PatternPart"): + listener.exitOC_PatternPart(self) + + def oC_PatternPart(self): + + localctx = CypherParser.OC_PatternPartContext(self, self._ctx, self.state) + self.enterRule(localctx, 144, self.RULE_oC_PatternPart) + self._la = 0 # Token type + try: + self.state = 1196 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [110, 116, 117, 119, 120, 121, 127, 145, 148]: + self.enterOuterAlt(localctx, 1) + self.state = 1185 + self.oC_Variable() + self.state = 1187 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1186 + self.match(CypherParser.SP) + + self.state = 1189 + self.match(CypherParser.T__1) + self.state = 1191 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1190 + self.match(CypherParser.SP) + + self.state = 1193 + self.oC_AnonymousPatternPart() + pass + elif token in [3, 100, 101]: + self.enterOuterAlt(localctx, 2) + self.state = 1195 + self.oC_AnonymousPatternPart() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_AnonymousPatternPartContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_ShortestPathPattern(self): + return self.getTypedRuleContext( + CypherParser.OC_ShortestPathPatternContext, 0 + ) + + def oC_PatternElement(self): + return self.getTypedRuleContext(CypherParser.OC_PatternElementContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_AnonymousPatternPart + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_AnonymousPatternPart"): + listener.enterOC_AnonymousPatternPart(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_AnonymousPatternPart"): + listener.exitOC_AnonymousPatternPart(self) + + def oC_AnonymousPatternPart(self): + + localctx = CypherParser.OC_AnonymousPatternPartContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 146, self.RULE_oC_AnonymousPatternPart) + try: + self.state = 1200 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [100, 101]: + self.enterOuterAlt(localctx, 1) + self.state = 1198 + self.oC_ShortestPathPattern() + pass + elif token in [3]: + self.enterOuterAlt(localctx, 2) + self.state = 1199 + self.oC_PatternElement() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ShortestPathPatternContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def SHORTESTPATH(self): + return self.getToken(CypherParser.SHORTESTPATH, 0) + + def oC_PatternElement(self): + return self.getTypedRuleContext(CypherParser.OC_PatternElementContext, 0) + + def ALLSHORTESTPATHS(self): + return self.getToken(CypherParser.ALLSHORTESTPATHS, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ShortestPathPattern + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ShortestPathPattern"): + listener.enterOC_ShortestPathPattern(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ShortestPathPattern"): + listener.exitOC_ShortestPathPattern(self) + + def oC_ShortestPathPattern(self): + + localctx = CypherParser.OC_ShortestPathPatternContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 148, self.RULE_oC_ShortestPathPattern) + try: + self.state = 1212 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [100]: + self.enterOuterAlt(localctx, 1) + self.state = 1202 + self.match(CypherParser.SHORTESTPATH) + self.state = 1203 + self.match(CypherParser.T__2) + self.state = 1204 + self.oC_PatternElement() + self.state = 1205 + self.match(CypherParser.T__3) + pass + elif token in [101]: + self.enterOuterAlt(localctx, 2) + self.state = 1207 + self.match(CypherParser.ALLSHORTESTPATHS) + self.state = 1208 + self.match(CypherParser.T__2) + self.state = 1209 + self.oC_PatternElement() + self.state = 1210 + self.match(CypherParser.T__3) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_PatternElementContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_NodePattern(self): + return self.getTypedRuleContext(CypherParser.OC_NodePatternContext, 0) + + def oC_PatternElementChain(self, i: int = None): + if i is None: + return self.getTypedRuleContexts( + CypherParser.OC_PatternElementChainContext + ) + else: + return self.getTypedRuleContext( + CypherParser.OC_PatternElementChainContext, i + ) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_PatternElement(self): + return self.getTypedRuleContext(CypherParser.OC_PatternElementContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_PatternElement + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_PatternElement"): + listener.enterOC_PatternElement(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_PatternElement"): + listener.exitOC_PatternElement(self) + + def oC_PatternElement(self): + + localctx = CypherParser.OC_PatternElementContext(self, self._ctx, self.state) + self.enterRule(localctx, 150, self.RULE_oC_PatternElement) + self._la = 0 # Token type + try: + self.state = 1228 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 156, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1214 + self.oC_NodePattern() + self.state = 1221 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 155, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1216 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1215 + self.match(CypherParser.SP) + + self.state = 1218 + self.oC_PatternElementChain() + self.state = 1223 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 155, self._ctx) + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1224 + self.match(CypherParser.T__2) + self.state = 1225 + self.oC_PatternElement() + self.state = 1226 + self.match(CypherParser.T__3) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_RelationshipsPatternContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_NodePattern(self): + return self.getTypedRuleContext(CypherParser.OC_NodePatternContext, 0) + + def oC_PatternElementChain(self, i: int = None): + if i is None: + return self.getTypedRuleContexts( + CypherParser.OC_PatternElementChainContext + ) + else: + return self.getTypedRuleContext( + CypherParser.OC_PatternElementChainContext, i + ) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_RelationshipsPattern + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_RelationshipsPattern"): + listener.enterOC_RelationshipsPattern(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_RelationshipsPattern"): + listener.exitOC_RelationshipsPattern(self) + + def oC_RelationshipsPattern(self): + + localctx = CypherParser.OC_RelationshipsPatternContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 152, self.RULE_oC_RelationshipsPattern) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1230 + self.oC_NodePattern() + self.state = 1235 + self._errHandler.sync(self) + _alt = 1 + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1232 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1231 + self.match(CypherParser.SP) + + self.state = 1234 + self.oC_PatternElementChain() + + else: + raise NoViableAltException(self) + self.state = 1237 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 158, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_NodePatternContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def oC_NodeLabels(self): + return self.getTypedRuleContext(CypherParser.OC_NodeLabelsContext, 0) + + def oC_Properties(self): + return self.getTypedRuleContext(CypherParser.OC_PropertiesContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_NodePattern + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_NodePattern"): + listener.enterOC_NodePattern(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_NodePattern"): + listener.exitOC_NodePattern(self) + + def oC_NodePattern(self): + + localctx = CypherParser.OC_NodePatternContext(self, self._ctx, self.state) + self.enterRule(localctx, 154, self.RULE_oC_NodePattern) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1239 + self.match(CypherParser.T__2) + self.state = 1241 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1240 + self.match(CypherParser.SP) + + self.state = 1247 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la - 110)) & ~0x3F) == 0 and ( + (1 << (_la - 110)) & 309237780161 + ) != 0: + self.state = 1243 + self.oC_Variable() + self.state = 1245 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1244 + self.match(CypherParser.SP) + + self.state = 1253 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 11: + self.state = 1249 + self.oC_NodeLabels() + self.state = 1251 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1250 + self.match(CypherParser.SP) + + self.state = 1259 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 25 or _la == 27: + self.state = 1255 + self.oC_Properties() + self.state = 1257 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1256 + self.match(CypherParser.SP) + + self.state = 1261 + self.match(CypherParser.T__3) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_PatternElementChainContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_RelationshipPattern(self): + return self.getTypedRuleContext( + CypherParser.OC_RelationshipPatternContext, 0 + ) + + def oC_NodePattern(self): + return self.getTypedRuleContext(CypherParser.OC_NodePatternContext, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_PatternElementChain + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_PatternElementChain"): + listener.enterOC_PatternElementChain(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_PatternElementChain"): + listener.exitOC_PatternElementChain(self) + + def oC_PatternElementChain(self): + + localctx = CypherParser.OC_PatternElementChainContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 156, self.RULE_oC_PatternElementChain) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1263 + self.oC_RelationshipPattern() + self.state = 1265 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1264 + self.match(CypherParser.SP) + + self.state = 1267 + self.oC_NodePattern() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_RelationshipPatternContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_LeftArrowHead(self): + return self.getTypedRuleContext(CypherParser.OC_LeftArrowHeadContext, 0) + + def oC_Dash(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_DashContext) + else: + return self.getTypedRuleContext(CypherParser.OC_DashContext, i) + + def oC_RightArrowHead(self): + return self.getTypedRuleContext(CypherParser.OC_RightArrowHeadContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_RelationshipDetail(self): + return self.getTypedRuleContext( + CypherParser.OC_RelationshipDetailContext, 0 + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_RelationshipPattern + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_RelationshipPattern"): + listener.enterOC_RelationshipPattern(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_RelationshipPattern"): + listener.exitOC_RelationshipPattern(self) + + def oC_RelationshipPattern(self): + + localctx = CypherParser.OC_RelationshipPatternContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 158, self.RULE_oC_RelationshipPattern) + self._la = 0 # Token type + try: + self.state = 1333 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 183, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1269 + self.oC_LeftArrowHead() + self.state = 1271 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1270 + self.match(CypherParser.SP) + + self.state = 1273 + self.oC_Dash() + self.state = 1275 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 168, self._ctx) + if la_ == 1: + self.state = 1274 + self.match(CypherParser.SP) + + self.state = 1278 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 5: + self.state = 1277 + self.oC_RelationshipDetail() + + self.state = 1281 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1280 + self.match(CypherParser.SP) + + self.state = 1283 + self.oC_Dash() + self.state = 1285 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1284 + self.match(CypherParser.SP) + + self.state = 1287 + self.oC_RightArrowHead() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1289 + self.oC_LeftArrowHead() + self.state = 1291 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1290 + self.match(CypherParser.SP) + + self.state = 1293 + self.oC_Dash() + self.state = 1295 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 173, self._ctx) + if la_ == 1: + self.state = 1294 + self.match(CypherParser.SP) + + self.state = 1298 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 5: + self.state = 1297 + self.oC_RelationshipDetail() + + self.state = 1301 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1300 + self.match(CypherParser.SP) + + self.state = 1303 + self.oC_Dash() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 1305 + self.oC_Dash() + self.state = 1307 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 176, self._ctx) + if la_ == 1: + self.state = 1306 + self.match(CypherParser.SP) + + self.state = 1310 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 5: + self.state = 1309 + self.oC_RelationshipDetail() + + self.state = 1313 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1312 + self.match(CypherParser.SP) + + self.state = 1315 + self.oC_Dash() + self.state = 1317 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1316 + self.match(CypherParser.SP) + + self.state = 1319 + self.oC_RightArrowHead() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 1321 + self.oC_Dash() + self.state = 1323 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 180, self._ctx) + if la_ == 1: + self.state = 1322 + self.match(CypherParser.SP) + + self.state = 1326 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 5: + self.state = 1325 + self.oC_RelationshipDetail() + + self.state = 1329 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1328 + self.match(CypherParser.SP) + + self.state = 1331 + self.oC_Dash() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_RelationshipDetailContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def oC_RelationshipTypes(self): + return self.getTypedRuleContext(CypherParser.OC_RelationshipTypesContext, 0) + + def oC_RangeLiteral(self): + return self.getTypedRuleContext(CypherParser.OC_RangeLiteralContext, 0) + + def oC_Properties(self): + return self.getTypedRuleContext(CypherParser.OC_PropertiesContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_RelationshipDetail + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_RelationshipDetail"): + listener.enterOC_RelationshipDetail(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_RelationshipDetail"): + listener.exitOC_RelationshipDetail(self) + + def oC_RelationshipDetail(self): + + localctx = CypherParser.OC_RelationshipDetailContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 160, self.RULE_oC_RelationshipDetail) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1335 + self.match(CypherParser.T__4) + self.state = 1337 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1336 + self.match(CypherParser.SP) + + self.state = 1343 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la - 110)) & ~0x3F) == 0 and ( + (1 << (_la - 110)) & 309237780161 + ) != 0: + self.state = 1339 + self.oC_Variable() + self.state = 1341 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1340 + self.match(CypherParser.SP) + + self.state = 1349 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 11: + self.state = 1345 + self.oC_RelationshipTypes() + self.state = 1347 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1346 + self.match(CypherParser.SP) + + self.state = 1352 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 10: + self.state = 1351 + self.oC_RangeLiteral() + + self.state = 1358 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 25 or _la == 27: + self.state = 1354 + self.oC_Properties() + self.state = 1356 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1355 + self.match(CypherParser.SP) + + self.state = 1360 + self.match(CypherParser.T__5) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_PropertiesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_MapLiteral(self): + return self.getTypedRuleContext(CypherParser.OC_MapLiteralContext, 0) + + def oC_Parameter(self): + return self.getTypedRuleContext(CypherParser.OC_ParameterContext, 0) + + def oC_LegacyParameter(self): + return self.getTypedRuleContext(CypherParser.OC_LegacyParameterContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Properties + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Properties"): + listener.enterOC_Properties(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Properties"): + listener.exitOC_Properties(self) + + def oC_Properties(self): + + localctx = CypherParser.OC_PropertiesContext(self, self._ctx, self.state) + self.enterRule(localctx, 162, self.RULE_oC_Properties) + try: + self.state = 1365 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 192, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1362 + self.oC_MapLiteral() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1363 + self.oC_Parameter() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 1364 + self.oC_LegacyParameter() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_RelTypeContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_RelTypeName(self): + return self.getTypedRuleContext(CypherParser.OC_RelTypeNameContext, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_RelType + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_RelType"): + listener.enterOC_RelType(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_RelType"): + listener.exitOC_RelType(self) + + def oC_RelType(self): + + localctx = CypherParser.OC_RelTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 164, self.RULE_oC_RelType) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1367 + self.match(CypherParser.T__10) + self.state = 1369 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1368 + self.match(CypherParser.SP) + + self.state = 1371 + self.oC_RelTypeName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_RelationshipTypesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_RelTypeName(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_RelTypeNameContext) + else: + return self.getTypedRuleContext(CypherParser.OC_RelTypeNameContext, i) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_RelationshipTypes + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_RelationshipTypes"): + listener.enterOC_RelationshipTypes(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_RelationshipTypes"): + listener.exitOC_RelationshipTypes(self) + + def oC_RelationshipTypes(self): + + localctx = CypherParser.OC_RelationshipTypesContext(self, self._ctx, self.state) + self.enterRule(localctx, 166, self.RULE_oC_RelationshipTypes) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1373 + self.match(CypherParser.T__10) + self.state = 1375 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1374 + self.match(CypherParser.SP) + + self.state = 1377 + self.oC_RelTypeName() + self.state = 1391 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 198, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1379 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1378 + self.match(CypherParser.SP) + + self.state = 1381 + self.match(CypherParser.T__8) + self.state = 1383 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 11: + self.state = 1382 + self.match(CypherParser.T__10) + + self.state = 1386 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1385 + self.match(CypherParser.SP) + + self.state = 1388 + self.oC_RelTypeName() + self.state = 1393 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 198, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_NodeLabelsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_NodeLabel(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_NodeLabelContext) + else: + return self.getTypedRuleContext(CypherParser.OC_NodeLabelContext, i) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_NodeLabels + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_NodeLabels"): + listener.enterOC_NodeLabels(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_NodeLabels"): + listener.exitOC_NodeLabels(self) + + def oC_NodeLabels(self): + + localctx = CypherParser.OC_NodeLabelsContext(self, self._ctx, self.state) + self.enterRule(localctx, 168, self.RULE_oC_NodeLabels) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1394 + self.oC_NodeLabel() + self.state = 1401 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 200, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1396 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1395 + self.match(CypherParser.SP) + + self.state = 1398 + self.oC_NodeLabel() + self.state = 1403 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 200, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_NodeLabelContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_LabelName(self): + return self.getTypedRuleContext(CypherParser.OC_LabelNameContext, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_NodeLabel + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_NodeLabel"): + listener.enterOC_NodeLabel(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_NodeLabel"): + listener.exitOC_NodeLabel(self) + + def oC_NodeLabel(self): + + localctx = CypherParser.OC_NodeLabelContext(self, self._ctx, self.state) + self.enterRule(localctx, 170, self.RULE_oC_NodeLabel) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1404 + self.match(CypherParser.T__10) + self.state = 1406 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1405 + self.match(CypherParser.SP) + + self.state = 1408 + self.oC_LabelName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_RangeLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_IntegerLiteral(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_IntegerLiteralContext) + else: + return self.getTypedRuleContext( + CypherParser.OC_IntegerLiteralContext, i + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_RangeLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_RangeLiteral"): + listener.enterOC_RangeLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_RangeLiteral"): + listener.exitOC_RangeLiteral(self) + + def oC_RangeLiteral(self): + + localctx = CypherParser.OC_RangeLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 172, self.RULE_oC_RangeLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1410 + self.match(CypherParser.T__9) + self.state = 1412 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1411 + self.match(CypherParser.SP) + + self.state = 1418 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la - 124)) & ~0x3F) == 0 and ((1 << (_la - 124)) & 7) != 0: + self.state = 1414 + self.oC_IntegerLiteral() + self.state = 1416 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1415 + self.match(CypherParser.SP) + + self.state = 1430 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 12: + self.state = 1420 + self.match(CypherParser.T__11) + self.state = 1422 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1421 + self.match(CypherParser.SP) + + self.state = 1428 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la - 124)) & ~0x3F) == 0 and ((1 << (_la - 124)) & 7) != 0: + self.state = 1424 + self.oC_IntegerLiteral() + self.state = 1426 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1425 + self.match(CypherParser.SP) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_LabelNameContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_SchemaName(self): + return self.getTypedRuleContext(CypherParser.OC_SchemaNameContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_LabelName + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_LabelName"): + listener.enterOC_LabelName(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_LabelName"): + listener.exitOC_LabelName(self) + + def oC_LabelName(self): + + localctx = CypherParser.OC_LabelNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 174, self.RULE_oC_LabelName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1432 + self.oC_SchemaName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_RelTypeNameContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_SchemaName(self): + return self.getTypedRuleContext(CypherParser.OC_SchemaNameContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_RelTypeName + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_RelTypeName"): + listener.enterOC_RelTypeName(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_RelTypeName"): + listener.exitOC_RelTypeName(self) + + def oC_RelTypeName(self): + + localctx = CypherParser.OC_RelTypeNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 176, self.RULE_oC_RelTypeName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1434 + self.oC_SchemaName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_PropertyExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Atom(self): + return self.getTypedRuleContext(CypherParser.OC_AtomContext, 0) + + def oC_PropertyLookup(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_PropertyLookupContext) + else: + return self.getTypedRuleContext( + CypherParser.OC_PropertyLookupContext, i + ) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_PropertyExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_PropertyExpression"): + listener.enterOC_PropertyExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_PropertyExpression"): + listener.exitOC_PropertyExpression(self) + + def oC_PropertyExpression(self): + + localctx = CypherParser.OC_PropertyExpressionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 178, self.RULE_oC_PropertyExpression) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1436 + self.oC_Atom() + self.state = 1441 + self._errHandler.sync(self) + _alt = 1 + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1438 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1437 + self.match(CypherParser.SP) + + self.state = 1440 + self.oC_PropertyLookup() + + else: + raise NoViableAltException(self) + self.state = 1443 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 210, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_OrExpression(self): + return self.getTypedRuleContext(CypherParser.OC_OrExpressionContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Expression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Expression"): + listener.enterOC_Expression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Expression"): + listener.exitOC_Expression(self) + + def oC_Expression(self): + + localctx = CypherParser.OC_ExpressionContext(self, self._ctx, self.state) + self.enterRule(localctx, 180, self.RULE_oC_Expression) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1445 + self.oC_OrExpression() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_OrExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_XorExpression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_XorExpressionContext) + else: + return self.getTypedRuleContext(CypherParser.OC_XorExpressionContext, i) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def OR(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.OR) + else: + return self.getToken(CypherParser.OR, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_OrExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_OrExpression"): + listener.enterOC_OrExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_OrExpression"): + listener.exitOC_OrExpression(self) + + def oC_OrExpression(self): + + localctx = CypherParser.OC_OrExpressionContext(self, self._ctx, self.state) + self.enterRule(localctx, 182, self.RULE_oC_OrExpression) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1447 + self.oC_XorExpression() + self.state = 1454 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 211, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1448 + self.match(CypherParser.SP) + self.state = 1449 + self.match(CypherParser.OR) + self.state = 1450 + self.match(CypherParser.SP) + self.state = 1451 + self.oC_XorExpression() + self.state = 1456 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 211, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_XorExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_AndExpression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_AndExpressionContext) + else: + return self.getTypedRuleContext(CypherParser.OC_AndExpressionContext, i) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def XOR(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.XOR) + else: + return self.getToken(CypherParser.XOR, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_XorExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_XorExpression"): + listener.enterOC_XorExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_XorExpression"): + listener.exitOC_XorExpression(self) + + def oC_XorExpression(self): + + localctx = CypherParser.OC_XorExpressionContext(self, self._ctx, self.state) + self.enterRule(localctx, 184, self.RULE_oC_XorExpression) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1457 + self.oC_AndExpression() + self.state = 1464 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 212, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1458 + self.match(CypherParser.SP) + self.state = 1459 + self.match(CypherParser.XOR) + self.state = 1460 + self.match(CypherParser.SP) + self.state = 1461 + self.oC_AndExpression() + self.state = 1466 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 212, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_AndExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_NotExpression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_NotExpressionContext) + else: + return self.getTypedRuleContext(CypherParser.OC_NotExpressionContext, i) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def AND(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.AND) + else: + return self.getToken(CypherParser.AND, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_AndExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_AndExpression"): + listener.enterOC_AndExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_AndExpression"): + listener.exitOC_AndExpression(self) + + def oC_AndExpression(self): + + localctx = CypherParser.OC_AndExpressionContext(self, self._ctx, self.state) + self.enterRule(localctx, 186, self.RULE_oC_AndExpression) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1467 + self.oC_NotExpression() + self.state = 1474 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 213, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1468 + self.match(CypherParser.SP) + self.state = 1469 + self.match(CypherParser.AND) + self.state = 1470 + self.match(CypherParser.SP) + self.state = 1471 + self.oC_NotExpression() + self.state = 1476 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 213, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_NotExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_ComparisonExpression(self): + return self.getTypedRuleContext( + CypherParser.OC_ComparisonExpressionContext, 0 + ) + + def NOT(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.NOT) + else: + return self.getToken(CypherParser.NOT, i) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_NotExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_NotExpression"): + listener.enterOC_NotExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_NotExpression"): + listener.exitOC_NotExpression(self) + + def oC_NotExpression(self): + + localctx = CypherParser.OC_NotExpressionContext(self, self._ctx, self.state) + self.enterRule(localctx, 188, self.RULE_oC_NotExpression) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1483 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 105: + self.state = 1477 + self.match(CypherParser.NOT) + self.state = 1479 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1478 + self.match(CypherParser.SP) + + self.state = 1485 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 1486 + self.oC_ComparisonExpression() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ComparisonExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_StringListNullPredicateExpression(self): + return self.getTypedRuleContext( + CypherParser.OC_StringListNullPredicateExpressionContext, 0 + ) + + def oC_PartialComparisonExpression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts( + CypherParser.OC_PartialComparisonExpressionContext + ) + else: + return self.getTypedRuleContext( + CypherParser.OC_PartialComparisonExpressionContext, i + ) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ComparisonExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ComparisonExpression"): + listener.enterOC_ComparisonExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ComparisonExpression"): + listener.exitOC_ComparisonExpression(self) + + def oC_ComparisonExpression(self): + + localctx = CypherParser.OC_ComparisonExpressionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 190, self.RULE_oC_ComparisonExpression) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1488 + self.oC_StringListNullPredicateExpression() + self.state = 1495 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 217, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1490 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1489 + self.match(CypherParser.SP) + + self.state = 1492 + self.oC_PartialComparisonExpression() + self.state = 1497 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 217, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_PartialComparisonExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_StringListNullPredicateExpression(self): + return self.getTypedRuleContext( + CypherParser.OC_StringListNullPredicateExpressionContext, 0 + ) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_PartialComparisonExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_PartialComparisonExpression"): + listener.enterOC_PartialComparisonExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_PartialComparisonExpression"): + listener.exitOC_PartialComparisonExpression(self) + + def oC_PartialComparisonExpression(self): + + localctx = CypherParser.OC_PartialComparisonExpressionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 192, self.RULE_oC_PartialComparisonExpression) + self._la = 0 # Token type + try: + self.state = 1528 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [2]: + self.enterOuterAlt(localctx, 1) + self.state = 1498 + self.match(CypherParser.T__1) + self.state = 1500 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1499 + self.match(CypherParser.SP) + + self.state = 1502 + self.oC_StringListNullPredicateExpression() + pass + elif token in [13]: + self.enterOuterAlt(localctx, 2) + self.state = 1503 + self.match(CypherParser.T__12) + self.state = 1505 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1504 + self.match(CypherParser.SP) + + self.state = 1507 + self.oC_StringListNullPredicateExpression() + pass + elif token in [14]: + self.enterOuterAlt(localctx, 3) + self.state = 1508 + self.match(CypherParser.T__13) + self.state = 1510 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1509 + self.match(CypherParser.SP) + + self.state = 1512 + self.oC_StringListNullPredicateExpression() + pass + elif token in [15]: + self.enterOuterAlt(localctx, 4) + self.state = 1513 + self.match(CypherParser.T__14) + self.state = 1515 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1514 + self.match(CypherParser.SP) + + self.state = 1517 + self.oC_StringListNullPredicateExpression() + pass + elif token in [16]: + self.enterOuterAlt(localctx, 5) + self.state = 1518 + self.match(CypherParser.T__15) + self.state = 1520 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1519 + self.match(CypherParser.SP) + + self.state = 1522 + self.oC_StringListNullPredicateExpression() + pass + elif token in [17]: + self.enterOuterAlt(localctx, 6) + self.state = 1523 + self.match(CypherParser.T__16) + self.state = 1525 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1524 + self.match(CypherParser.SP) + + self.state = 1527 + self.oC_StringListNullPredicateExpression() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_StringListNullPredicateExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_AddOrSubtractExpression(self): + return self.getTypedRuleContext( + CypherParser.OC_AddOrSubtractExpressionContext, 0 + ) + + def oC_StringPredicateExpression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts( + CypherParser.OC_StringPredicateExpressionContext + ) + else: + return self.getTypedRuleContext( + CypherParser.OC_StringPredicateExpressionContext, i + ) + + def oC_ListPredicateExpression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts( + CypherParser.OC_ListPredicateExpressionContext + ) + else: + return self.getTypedRuleContext( + CypherParser.OC_ListPredicateExpressionContext, i + ) + + def oC_NullPredicateExpression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts( + CypherParser.OC_NullPredicateExpressionContext + ) + else: + return self.getTypedRuleContext( + CypherParser.OC_NullPredicateExpressionContext, i + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_StringListNullPredicateExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_StringListNullPredicateExpression"): + listener.enterOC_StringListNullPredicateExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_StringListNullPredicateExpression"): + listener.exitOC_StringListNullPredicateExpression(self) + + def oC_StringListNullPredicateExpression(self): + + localctx = CypherParser.OC_StringListNullPredicateExpressionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 194, self.RULE_oC_StringListNullPredicateExpression) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1530 + self.oC_AddOrSubtractExpression() + self.state = 1536 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 226, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1534 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 225, self._ctx) + if la_ == 1: + self.state = 1531 + self.oC_StringPredicateExpression() + pass + + elif la_ == 2: + self.state = 1532 + self.oC_ListPredicateExpression() + pass + + elif la_ == 3: + self.state = 1533 + self.oC_NullPredicateExpression() + pass + + self.state = 1538 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 226, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_StringPredicateExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_AddOrSubtractExpression(self): + return self.getTypedRuleContext( + CypherParser.OC_AddOrSubtractExpressionContext, 0 + ) + + def oC_RegularExpression(self): + return self.getTypedRuleContext(CypherParser.OC_RegularExpressionContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def STARTS(self): + return self.getToken(CypherParser.STARTS, 0) + + def WITH(self): + return self.getToken(CypherParser.WITH, 0) + + def ENDS(self): + return self.getToken(CypherParser.ENDS, 0) + + def CONTAINS(self): + return self.getToken(CypherParser.CONTAINS, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_StringPredicateExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_StringPredicateExpression"): + listener.enterOC_StringPredicateExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_StringPredicateExpression"): + listener.exitOC_StringPredicateExpression(self) + + def oC_StringPredicateExpression(self): + + localctx = CypherParser.OC_StringPredicateExpressionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 196, self.RULE_oC_StringPredicateExpression) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1550 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 227, self._ctx) + if la_ == 1: + self.state = 1539 + self.oC_RegularExpression() + pass + + elif la_ == 2: + self.state = 1540 + self.match(CypherParser.SP) + self.state = 1541 + self.match(CypherParser.STARTS) + self.state = 1542 + self.match(CypherParser.SP) + self.state = 1543 + self.match(CypherParser.WITH) + pass + + elif la_ == 3: + self.state = 1544 + self.match(CypherParser.SP) + self.state = 1545 + self.match(CypherParser.ENDS) + self.state = 1546 + self.match(CypherParser.SP) + self.state = 1547 + self.match(CypherParser.WITH) + pass + + elif la_ == 4: + self.state = 1548 + self.match(CypherParser.SP) + self.state = 1549 + self.match(CypherParser.CONTAINS) + pass + + self.state = 1553 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1552 + self.match(CypherParser.SP) + + self.state = 1555 + self.oC_AddOrSubtractExpression() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ListPredicateExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def IN(self): + return self.getToken(CypherParser.IN, 0) + + def oC_AddOrSubtractExpression(self): + return self.getTypedRuleContext( + CypherParser.OC_AddOrSubtractExpressionContext, 0 + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ListPredicateExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ListPredicateExpression"): + listener.enterOC_ListPredicateExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ListPredicateExpression"): + listener.exitOC_ListPredicateExpression(self) + + def oC_ListPredicateExpression(self): + + localctx = CypherParser.OC_ListPredicateExpressionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 198, self.RULE_oC_ListPredicateExpression) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1557 + self.match(CypherParser.SP) + self.state = 1558 + self.match(CypherParser.IN) + self.state = 1560 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1559 + self.match(CypherParser.SP) + + self.state = 1562 + self.oC_AddOrSubtractExpression() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_NullPredicateExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def IS(self): + return self.getToken(CypherParser.IS, 0) + + def NULL(self): + return self.getToken(CypherParser.NULL, 0) + + def NOT(self): + return self.getToken(CypherParser.NOT, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_NullPredicateExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_NullPredicateExpression"): + listener.enterOC_NullPredicateExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_NullPredicateExpression"): + listener.exitOC_NullPredicateExpression(self) + + def oC_NullPredicateExpression(self): + + localctx = CypherParser.OC_NullPredicateExpressionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 200, self.RULE_oC_NullPredicateExpression) + try: + self.state = 1574 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 230, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1564 + self.match(CypherParser.SP) + self.state = 1565 + self.match(CypherParser.IS) + self.state = 1566 + self.match(CypherParser.SP) + self.state = 1567 + self.match(CypherParser.NULL) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1568 + self.match(CypherParser.SP) + self.state = 1569 + self.match(CypherParser.IS) + self.state = 1570 + self.match(CypherParser.SP) + self.state = 1571 + self.match(CypherParser.NOT) + self.state = 1572 + self.match(CypherParser.SP) + self.state = 1573 + self.match(CypherParser.NULL) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_RegularExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_RegularExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_RegularExpression"): + listener.enterOC_RegularExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_RegularExpression"): + listener.exitOC_RegularExpression(self) + + def oC_RegularExpression(self): + + localctx = CypherParser.OC_RegularExpressionContext(self, self._ctx, self.state) + self.enterRule(localctx, 202, self.RULE_oC_RegularExpression) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1577 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1576 + self.match(CypherParser.SP) + + self.state = 1579 + self.match(CypherParser.T__17) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_AddOrSubtractExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_MultiplyDivideModuloExpression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts( + CypherParser.OC_MultiplyDivideModuloExpressionContext + ) + else: + return self.getTypedRuleContext( + CypherParser.OC_MultiplyDivideModuloExpressionContext, i + ) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_AddOrSubtractExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_AddOrSubtractExpression"): + listener.enterOC_AddOrSubtractExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_AddOrSubtractExpression"): + listener.exitOC_AddOrSubtractExpression(self) + + def oC_AddOrSubtractExpression(self): + + localctx = CypherParser.OC_AddOrSubtractExpressionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 204, self.RULE_oC_AddOrSubtractExpression) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1581 + self.oC_MultiplyDivideModuloExpression() + self.state = 1600 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 237, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1598 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 236, self._ctx) + if la_ == 1: + self.state = 1583 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1582 + self.match(CypherParser.SP) + + self.state = 1585 + self.match(CypherParser.T__18) + self.state = 1587 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1586 + self.match(CypherParser.SP) + + self.state = 1589 + self.oC_MultiplyDivideModuloExpression() + pass + + elif la_ == 2: + self.state = 1591 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1590 + self.match(CypherParser.SP) + + self.state = 1593 + self.match(CypherParser.T__19) + self.state = 1595 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1594 + self.match(CypherParser.SP) + + self.state = 1597 + self.oC_MultiplyDivideModuloExpression() + pass + + self.state = 1602 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 237, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_MultiplyDivideModuloExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_PowerOfExpression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts( + CypherParser.OC_PowerOfExpressionContext + ) + else: + return self.getTypedRuleContext( + CypherParser.OC_PowerOfExpressionContext, i + ) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_MultiplyDivideModuloExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_MultiplyDivideModuloExpression"): + listener.enterOC_MultiplyDivideModuloExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_MultiplyDivideModuloExpression"): + listener.exitOC_MultiplyDivideModuloExpression(self) + + def oC_MultiplyDivideModuloExpression(self): + + localctx = CypherParser.OC_MultiplyDivideModuloExpressionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 206, self.RULE_oC_MultiplyDivideModuloExpression) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1603 + self.oC_PowerOfExpression() + self.state = 1630 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 245, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1628 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 244, self._ctx) + if la_ == 1: + self.state = 1605 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1604 + self.match(CypherParser.SP) + + self.state = 1607 + self.match(CypherParser.T__9) + self.state = 1609 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1608 + self.match(CypherParser.SP) + + self.state = 1611 + self.oC_PowerOfExpression() + pass + + elif la_ == 2: + self.state = 1613 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1612 + self.match(CypherParser.SP) + + self.state = 1615 + self.match(CypherParser.T__20) + self.state = 1617 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1616 + self.match(CypherParser.SP) + + self.state = 1619 + self.oC_PowerOfExpression() + pass + + elif la_ == 3: + self.state = 1621 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1620 + self.match(CypherParser.SP) + + self.state = 1623 + self.match(CypherParser.T__21) + self.state = 1625 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1624 + self.match(CypherParser.SP) + + self.state = 1627 + self.oC_PowerOfExpression() + pass + + self.state = 1632 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 245, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_PowerOfExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_UnaryAddOrSubtractExpression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts( + CypherParser.OC_UnaryAddOrSubtractExpressionContext + ) + else: + return self.getTypedRuleContext( + CypherParser.OC_UnaryAddOrSubtractExpressionContext, i + ) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_PowerOfExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_PowerOfExpression"): + listener.enterOC_PowerOfExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_PowerOfExpression"): + listener.exitOC_PowerOfExpression(self) + + def oC_PowerOfExpression(self): + + localctx = CypherParser.OC_PowerOfExpressionContext(self, self._ctx, self.state) + self.enterRule(localctx, 208, self.RULE_oC_PowerOfExpression) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1633 + self.oC_UnaryAddOrSubtractExpression() + self.state = 1644 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 248, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1635 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1634 + self.match(CypherParser.SP) + + self.state = 1637 + self.match(CypherParser.T__22) + self.state = 1639 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1638 + self.match(CypherParser.SP) + + self.state = 1641 + self.oC_UnaryAddOrSubtractExpression() + self.state = 1646 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 248, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_UnaryAddOrSubtractExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_NonArithmeticOperatorExpression(self): + return self.getTypedRuleContext( + CypherParser.OC_NonArithmeticOperatorExpressionContext, 0 + ) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_UnaryAddOrSubtractExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_UnaryAddOrSubtractExpression"): + listener.enterOC_UnaryAddOrSubtractExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_UnaryAddOrSubtractExpression"): + listener.exitOC_UnaryAddOrSubtractExpression(self) + + def oC_UnaryAddOrSubtractExpression(self): + + localctx = CypherParser.OC_UnaryAddOrSubtractExpressionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 210, self.RULE_oC_UnaryAddOrSubtractExpression) + self._la = 0 # Token type + try: + self.state = 1653 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [ + 3, + 5, + 25, + 27, + 54, + 63, + 100, + 101, + 109, + 110, + 111, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 134, + 135, + 136, + 145, + 148, + ]: + self.enterOuterAlt(localctx, 1) + self.state = 1647 + self.oC_NonArithmeticOperatorExpression() + pass + elif token in [19, 20]: + self.enterOuterAlt(localctx, 2) + self.state = 1648 + _la = self._input.LA(1) + if not (_la == 19 or _la == 20): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1650 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1649 + self.match(CypherParser.SP) + + self.state = 1652 + self.oC_NonArithmeticOperatorExpression() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_NonArithmeticOperatorExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Atom(self): + return self.getTypedRuleContext(CypherParser.OC_AtomContext, 0) + + def oC_NodeLabels(self): + return self.getTypedRuleContext(CypherParser.OC_NodeLabelsContext, 0) + + def oC_ListOperatorExpression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts( + CypherParser.OC_ListOperatorExpressionContext + ) + else: + return self.getTypedRuleContext( + CypherParser.OC_ListOperatorExpressionContext, i + ) + + def oC_PropertyLookup(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_PropertyLookupContext) + else: + return self.getTypedRuleContext( + CypherParser.OC_PropertyLookupContext, i + ) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_NonArithmeticOperatorExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_NonArithmeticOperatorExpression"): + listener.enterOC_NonArithmeticOperatorExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_NonArithmeticOperatorExpression"): + listener.exitOC_NonArithmeticOperatorExpression(self) + + def oC_NonArithmeticOperatorExpression(self): + + localctx = CypherParser.OC_NonArithmeticOperatorExpressionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 212, self.RULE_oC_NonArithmeticOperatorExpression) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1655 + self.oC_Atom() + self.state = 1666 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 254, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1664 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 253, self._ctx) + if la_ == 1: + self.state = 1657 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1656 + self.match(CypherParser.SP) + + self.state = 1659 + self.oC_ListOperatorExpression() + pass + + elif la_ == 2: + self.state = 1661 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1660 + self.match(CypherParser.SP) + + self.state = 1663 + self.oC_PropertyLookup() + pass + + self.state = 1668 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 254, self._ctx) + + self.state = 1673 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 256, self._ctx) + if la_ == 1: + self.state = 1670 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1669 + self.match(CypherParser.SP) + + self.state = 1672 + self.oC_NodeLabels() + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ListOperatorExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Expression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_ExpressionContext) + else: + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ListOperatorExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ListOperatorExpression"): + listener.enterOC_ListOperatorExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ListOperatorExpression"): + listener.exitOC_ListOperatorExpression(self) + + def oC_ListOperatorExpression(self): + + localctx = CypherParser.OC_ListOperatorExpressionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 214, self.RULE_oC_ListOperatorExpression) + self._la = 0 # Token type + try: + self.state = 1688 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 259, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1675 + self.match(CypherParser.T__4) + self.state = 1676 + self.oC_Expression() + self.state = 1677 + self.match(CypherParser.T__5) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1679 + self.match(CypherParser.T__4) + self.state = 1681 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ( + ((_la) & ~0x3F) == 0 and ((1 << _la) & -9205357638175948760) != 0 + ) or ( + (((_la - 100)) & ~0x3F) == 0 + and ((1 << (_la - 100)) & 316779876257315) != 0 + ): + self.state = 1680 + self.oC_Expression() + + self.state = 1683 + self.match(CypherParser.T__11) + self.state = 1685 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ( + ((_la) & ~0x3F) == 0 and ((1 << _la) & -9205357638175948760) != 0 + ) or ( + (((_la - 100)) & ~0x3F) == 0 + and ((1 << (_la - 100)) & 316779876257315) != 0 + ): + self.state = 1684 + self.oC_Expression() + + self.state = 1687 + self.match(CypherParser.T__5) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_PropertyLookupContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_PropertyKeyName(self): + return self.getTypedRuleContext(CypherParser.OC_PropertyKeyNameContext, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_PropertyLookup + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_PropertyLookup"): + listener.enterOC_PropertyLookup(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_PropertyLookup"): + listener.exitOC_PropertyLookup(self) + + def oC_PropertyLookup(self): + + localctx = CypherParser.OC_PropertyLookupContext(self, self._ctx, self.state) + self.enterRule(localctx, 216, self.RULE_oC_PropertyLookup) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1690 + self.match(CypherParser.T__23) + self.state = 1692 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1691 + self.match(CypherParser.SP) + + self.state = 1694 + self.oC_PropertyKeyName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_AtomContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Literal(self): + return self.getTypedRuleContext(CypherParser.OC_LiteralContext, 0) + + def oC_Parameter(self): + return self.getTypedRuleContext(CypherParser.OC_ParameterContext, 0) + + def oC_LegacyParameter(self): + return self.getTypedRuleContext(CypherParser.OC_LegacyParameterContext, 0) + + def oC_CaseExpression(self): + return self.getTypedRuleContext(CypherParser.OC_CaseExpressionContext, 0) + + def COUNT(self): + return self.getToken(CypherParser.COUNT, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_ListComprehension(self): + return self.getTypedRuleContext(CypherParser.OC_ListComprehensionContext, 0) + + def oC_PatternComprehension(self): + return self.getTypedRuleContext( + CypherParser.OC_PatternComprehensionContext, 0 + ) + + def oC_LegacyListExpression(self): + return self.getTypedRuleContext( + CypherParser.OC_LegacyListExpressionContext, 0 + ) + + def oC_Reduce(self): + return self.getTypedRuleContext(CypherParser.OC_ReduceContext, 0) + + def oC_Quantifier(self): + return self.getTypedRuleContext(CypherParser.OC_QuantifierContext, 0) + + def oC_ShortestPathPattern(self): + return self.getTypedRuleContext( + CypherParser.OC_ShortestPathPatternContext, 0 + ) + + def oC_PatternPredicate(self): + return self.getTypedRuleContext(CypherParser.OC_PatternPredicateContext, 0) + + def oC_ParenthesizedExpression(self): + return self.getTypedRuleContext( + CypherParser.OC_ParenthesizedExpressionContext, 0 + ) + + def oC_FunctionInvocation(self): + return self.getTypedRuleContext( + CypherParser.OC_FunctionInvocationContext, 0 + ) + + def oC_ExistentialSubquery(self): + return self.getTypedRuleContext( + CypherParser.OC_ExistentialSubqueryContext, 0 + ) + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Atom + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Atom"): + listener.enterOC_Atom(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Atom"): + listener.exitOC_Atom(self) + + def oC_Atom(self): + + localctx = CypherParser.OC_AtomContext(self, self._ctx, self.state) + self.enterRule(localctx, 218, self.RULE_oC_Atom) + self._la = 0 # Token type + try: + self.state = 1724 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 264, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1696 + self.oC_Literal() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1697 + self.oC_Parameter() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 1698 + self.oC_LegacyParameter() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 1699 + self.oC_CaseExpression() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 1700 + self.match(CypherParser.COUNT) + self.state = 1702 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1701 + self.match(CypherParser.SP) + + self.state = 1704 + self.match(CypherParser.T__2) + self.state = 1706 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1705 + self.match(CypherParser.SP) + + self.state = 1708 + self.match(CypherParser.T__9) + self.state = 1710 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1709 + self.match(CypherParser.SP) + + self.state = 1712 + self.match(CypherParser.T__3) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 1713 + self.oC_ListComprehension() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 1714 + self.oC_PatternComprehension() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 1715 + self.oC_LegacyListExpression() + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 1716 + self.oC_Reduce() + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 1717 + self.oC_Quantifier() + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 1718 + self.oC_ShortestPathPattern() + pass + + elif la_ == 12: + self.enterOuterAlt(localctx, 12) + self.state = 1719 + self.oC_PatternPredicate() + pass + + elif la_ == 13: + self.enterOuterAlt(localctx, 13) + self.state = 1720 + self.oC_ParenthesizedExpression() + pass + + elif la_ == 14: + self.enterOuterAlt(localctx, 14) + self.state = 1721 + self.oC_FunctionInvocation() + pass + + elif la_ == 15: + self.enterOuterAlt(localctx, 15) + self.state = 1722 + self.oC_ExistentialSubquery() + pass + + elif la_ == 16: + self.enterOuterAlt(localctx, 16) + self.state = 1723 + self.oC_Variable() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_CaseExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def END(self): + return self.getToken(CypherParser.END, 0) + + def ELSE(self): + return self.getToken(CypherParser.ELSE, 0) + + def oC_Expression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_ExpressionContext) + else: + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, i) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def CASE(self): + return self.getToken(CypherParser.CASE, 0) + + def oC_CaseAlternative(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_CaseAlternativeContext) + else: + return self.getTypedRuleContext( + CypherParser.OC_CaseAlternativeContext, i + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_CaseExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_CaseExpression"): + listener.enterOC_CaseExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_CaseExpression"): + listener.exitOC_CaseExpression(self) + + def oC_CaseExpression(self): + + localctx = CypherParser.OC_CaseExpressionContext(self, self._ctx, self.state) + self.enterRule(localctx, 220, self.RULE_oC_CaseExpression) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1748 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 270, self._ctx) + if la_ == 1: + self.state = 1726 + self.match(CypherParser.CASE) + self.state = 1731 + self._errHandler.sync(self) + _alt = 1 + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1728 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1727 + self.match(CypherParser.SP) + + self.state = 1730 + self.oC_CaseAlternative() + + else: + raise NoViableAltException(self) + self.state = 1733 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 266, self._ctx) + + pass + + elif la_ == 2: + self.state = 1735 + self.match(CypherParser.CASE) + self.state = 1737 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1736 + self.match(CypherParser.SP) + + self.state = 1739 + self.oC_Expression() + self.state = 1744 + self._errHandler.sync(self) + _alt = 1 + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1741 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1740 + self.match(CypherParser.SP) + + self.state = 1743 + self.oC_CaseAlternative() + + else: + raise NoViableAltException(self) + self.state = 1746 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 269, self._ctx) + + pass + + self.state = 1758 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 273, self._ctx) + if la_ == 1: + self.state = 1751 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1750 + self.match(CypherParser.SP) + + self.state = 1753 + self.match(CypherParser.ELSE) + self.state = 1755 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1754 + self.match(CypherParser.SP) + + self.state = 1757 + self.oC_Expression() + + self.state = 1761 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1760 + self.match(CypherParser.SP) + + self.state = 1763 + self.match(CypherParser.END) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_CaseAlternativeContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def WHEN(self): + return self.getToken(CypherParser.WHEN, 0) + + def oC_Expression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_ExpressionContext) + else: + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, i) + + def THEN(self): + return self.getToken(CypherParser.THEN, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_CaseAlternative + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_CaseAlternative"): + listener.enterOC_CaseAlternative(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_CaseAlternative"): + listener.exitOC_CaseAlternative(self) + + def oC_CaseAlternative(self): + + localctx = CypherParser.OC_CaseAlternativeContext(self, self._ctx, self.state) + self.enterRule(localctx, 222, self.RULE_oC_CaseAlternative) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1765 + self.match(CypherParser.WHEN) + self.state = 1767 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1766 + self.match(CypherParser.SP) + + self.state = 1769 + self.oC_Expression() + self.state = 1771 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1770 + self.match(CypherParser.SP) + + self.state = 1773 + self.match(CypherParser.THEN) + self.state = 1775 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1774 + self.match(CypherParser.SP) + + self.state = 1777 + self.oC_Expression() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ListComprehensionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_FilterExpression(self): + return self.getTypedRuleContext(CypherParser.OC_FilterExpressionContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_Expression(self): + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ListComprehension + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ListComprehension"): + listener.enterOC_ListComprehension(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ListComprehension"): + listener.exitOC_ListComprehension(self) + + def oC_ListComprehension(self): + + localctx = CypherParser.OC_ListComprehensionContext(self, self._ctx, self.state) + self.enterRule(localctx, 224, self.RULE_oC_ListComprehension) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1779 + self.match(CypherParser.T__4) + self.state = 1781 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1780 + self.match(CypherParser.SP) + + self.state = 1783 + self.oC_FilterExpression() + self.state = 1792 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 281, self._ctx) + if la_ == 1: + self.state = 1785 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1784 + self.match(CypherParser.SP) + + self.state = 1787 + self.match(CypherParser.T__8) + self.state = 1789 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1788 + self.match(CypherParser.SP) + + self.state = 1791 + self.oC_Expression() + + self.state = 1795 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1794 + self.match(CypherParser.SP) + + self.state = 1797 + self.match(CypherParser.T__5) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_PatternComprehensionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_RelationshipsPattern(self): + return self.getTypedRuleContext( + CypherParser.OC_RelationshipsPatternContext, 0 + ) + + def oC_Expression(self): + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def oC_Where(self): + return self.getTypedRuleContext(CypherParser.OC_WhereContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_PatternComprehension + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_PatternComprehension"): + listener.enterOC_PatternComprehension(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_PatternComprehension"): + listener.exitOC_PatternComprehension(self) + + def oC_PatternComprehension(self): + + localctx = CypherParser.OC_PatternComprehensionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 226, self.RULE_oC_PatternComprehension) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1799 + self.match(CypherParser.T__4) + self.state = 1801 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1800 + self.match(CypherParser.SP) + + self.state = 1811 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la - 110)) & ~0x3F) == 0 and ( + (1 << (_la - 110)) & 309237780161 + ) != 0: + self.state = 1803 + self.oC_Variable() + self.state = 1805 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1804 + self.match(CypherParser.SP) + + self.state = 1807 + self.match(CypherParser.T__1) + self.state = 1809 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1808 + self.match(CypherParser.SP) + + self.state = 1813 + self.oC_RelationshipsPattern() + self.state = 1815 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1814 + self.match(CypherParser.SP) + + self.state = 1821 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 99: + self.state = 1817 + self.oC_Where() + self.state = 1819 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1818 + self.match(CypherParser.SP) + + self.state = 1823 + self.match(CypherParser.T__8) + self.state = 1825 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1824 + self.match(CypherParser.SP) + + self.state = 1827 + self.oC_Expression() + self.state = 1829 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1828 + self.match(CypherParser.SP) + + self.state = 1831 + self.match(CypherParser.T__5) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_LegacyListExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def FILTER(self): + return self.getToken(CypherParser.FILTER, 0) + + def oC_FilterExpression(self): + return self.getTypedRuleContext(CypherParser.OC_FilterExpressionContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def EXTRACT(self): + return self.getToken(CypherParser.EXTRACT, 0) + + def oC_Expression(self): + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_LegacyListExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_LegacyListExpression"): + listener.enterOC_LegacyListExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_LegacyListExpression"): + listener.exitOC_LegacyListExpression(self) + + def oC_LegacyListExpression(self): + + localctx = CypherParser.OC_LegacyListExpressionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 228, self.RULE_oC_LegacyListExpression) + self._la = 0 # Token type + try: + self.state = 1868 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [116]: + self.enterOuterAlt(localctx, 1) + self.state = 1833 + self.match(CypherParser.FILTER) + self.state = 1835 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1834 + self.match(CypherParser.SP) + + self.state = 1837 + self.match(CypherParser.T__2) + self.state = 1839 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1838 + self.match(CypherParser.SP) + + self.state = 1841 + self.oC_FilterExpression() + self.state = 1843 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1842 + self.match(CypherParser.SP) + + self.state = 1845 + self.match(CypherParser.T__3) + pass + elif token in [117]: + self.enterOuterAlt(localctx, 2) + self.state = 1847 + self.match(CypherParser.EXTRACT) + self.state = 1849 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1848 + self.match(CypherParser.SP) + + self.state = 1851 + self.match(CypherParser.T__2) + self.state = 1853 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1852 + self.match(CypherParser.SP) + + self.state = 1855 + self.oC_FilterExpression() + self.state = 1857 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 297, self._ctx) + if la_ == 1: + self.state = 1856 + self.match(CypherParser.SP) + + self.state = 1864 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 9 or _la == 149: + self.state = 1860 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1859 + self.match(CypherParser.SP) + + self.state = 1862 + self.match(CypherParser.T__8) + self.state = 1863 + self.oC_Expression() + + self.state = 1866 + self.match(CypherParser.T__3) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ReduceContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def REDUCE(self): + return self.getToken(CypherParser.REDUCE, 0) + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def oC_Expression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_ExpressionContext) + else: + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, i) + + def oC_IdInColl(self): + return self.getTypedRuleContext(CypherParser.OC_IdInCollContext, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Reduce + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Reduce"): + listener.enterOC_Reduce(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Reduce"): + listener.exitOC_Reduce(self) + + def oC_Reduce(self): + + localctx = CypherParser.OC_ReduceContext(self, self._ctx, self.state) + self.enterRule(localctx, 230, self.RULE_oC_Reduce) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1870 + self.match(CypherParser.REDUCE) + self.state = 1872 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1871 + self.match(CypherParser.SP) + + self.state = 1874 + self.match(CypherParser.T__2) + self.state = 1875 + self.oC_Variable() + self.state = 1876 + self.match(CypherParser.T__1) + self.state = 1877 + self.oC_Expression() + self.state = 1878 + self.match(CypherParser.T__6) + self.state = 1879 + self.oC_IdInColl() + self.state = 1880 + self.match(CypherParser.T__8) + self.state = 1881 + self.oC_Expression() + self.state = 1882 + self.match(CypherParser.T__3) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_QuantifierContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def ALL(self): + return self.getToken(CypherParser.ALL, 0) + + def oC_FilterExpression(self): + return self.getTypedRuleContext(CypherParser.OC_FilterExpressionContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def ANY(self): + return self.getToken(CypherParser.ANY, 0) + + def NONE(self): + return self.getToken(CypherParser.NONE, 0) + + def SINGLE(self): + return self.getToken(CypherParser.SINGLE, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Quantifier + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Quantifier"): + listener.enterOC_Quantifier(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Quantifier"): + listener.exitOC_Quantifier(self) + + def oC_Quantifier(self): + + localctx = CypherParser.OC_QuantifierContext(self, self._ctx, self.state) + self.enterRule(localctx, 232, self.RULE_oC_Quantifier) + self._la = 0 # Token type + try: + self.state = 1940 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [54]: + self.enterOuterAlt(localctx, 1) + self.state = 1884 + self.match(CypherParser.ALL) + self.state = 1886 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1885 + self.match(CypherParser.SP) + + self.state = 1888 + self.match(CypherParser.T__2) + self.state = 1890 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1889 + self.match(CypherParser.SP) + + self.state = 1892 + self.oC_FilterExpression() + self.state = 1894 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1893 + self.match(CypherParser.SP) + + self.state = 1896 + self.match(CypherParser.T__3) + pass + elif token in [119]: + self.enterOuterAlt(localctx, 2) + self.state = 1898 + self.match(CypherParser.ANY) + self.state = 1900 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1899 + self.match(CypherParser.SP) + + self.state = 1902 + self.match(CypherParser.T__2) + self.state = 1904 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1903 + self.match(CypherParser.SP) + + self.state = 1906 + self.oC_FilterExpression() + self.state = 1908 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1907 + self.match(CypherParser.SP) + + self.state = 1910 + self.match(CypherParser.T__3) + pass + elif token in [120]: + self.enterOuterAlt(localctx, 3) + self.state = 1912 + self.match(CypherParser.NONE) + self.state = 1914 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1913 + self.match(CypherParser.SP) + + self.state = 1916 + self.match(CypherParser.T__2) + self.state = 1918 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1917 + self.match(CypherParser.SP) + + self.state = 1920 + self.oC_FilterExpression() + self.state = 1922 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1921 + self.match(CypherParser.SP) + + self.state = 1924 + self.match(CypherParser.T__3) + pass + elif token in [121]: + self.enterOuterAlt(localctx, 4) + self.state = 1926 + self.match(CypherParser.SINGLE) + self.state = 1928 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1927 + self.match(CypherParser.SP) + + self.state = 1930 + self.match(CypherParser.T__2) + self.state = 1932 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1931 + self.match(CypherParser.SP) + + self.state = 1934 + self.oC_FilterExpression() + self.state = 1936 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1935 + self.match(CypherParser.SP) + + self.state = 1938 + self.match(CypherParser.T__3) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_FilterExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_IdInColl(self): + return self.getTypedRuleContext(CypherParser.OC_IdInCollContext, 0) + + def oC_Where(self): + return self.getTypedRuleContext(CypherParser.OC_WhereContext, 0) + + def SP(self): + return self.getToken(CypherParser.SP, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_FilterExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_FilterExpression"): + listener.enterOC_FilterExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_FilterExpression"): + listener.exitOC_FilterExpression(self) + + def oC_FilterExpression(self): + + localctx = CypherParser.OC_FilterExpressionContext(self, self._ctx, self.state) + self.enterRule(localctx, 234, self.RULE_oC_FilterExpression) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1942 + self.oC_IdInColl() + self.state = 1947 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 316, self._ctx) + if la_ == 1: + self.state = 1944 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1943 + self.match(CypherParser.SP) + + self.state = 1946 + self.oC_Where() + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_PatternPredicateContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_RelationshipsPattern(self): + return self.getTypedRuleContext( + CypherParser.OC_RelationshipsPatternContext, 0 + ) + + def getRuleIndex(self): + return CypherParser.RULE_oC_PatternPredicate + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_PatternPredicate"): + listener.enterOC_PatternPredicate(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_PatternPredicate"): + listener.exitOC_PatternPredicate(self) + + def oC_PatternPredicate(self): + + localctx = CypherParser.OC_PatternPredicateContext(self, self._ctx, self.state) + self.enterRule(localctx, 236, self.RULE_oC_PatternPredicate) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1949 + self.oC_RelationshipsPattern() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ParenthesizedExpressionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Expression(self): + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ParenthesizedExpression + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ParenthesizedExpression"): + listener.enterOC_ParenthesizedExpression(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ParenthesizedExpression"): + listener.exitOC_ParenthesizedExpression(self) + + def oC_ParenthesizedExpression(self): + + localctx = CypherParser.OC_ParenthesizedExpressionContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 238, self.RULE_oC_ParenthesizedExpression) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1951 + self.match(CypherParser.T__2) + self.state = 1953 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1952 + self.match(CypherParser.SP) + + self.state = 1955 + self.oC_Expression() + self.state = 1957 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1956 + self.match(CypherParser.SP) + + self.state = 1959 + self.match(CypherParser.T__3) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_IdInCollContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Variable(self): + return self.getTypedRuleContext(CypherParser.OC_VariableContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def IN(self): + return self.getToken(CypherParser.IN, 0) + + def oC_Expression(self): + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_IdInColl + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_IdInColl"): + listener.enterOC_IdInColl(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_IdInColl"): + listener.exitOC_IdInColl(self) + + def oC_IdInColl(self): + + localctx = CypherParser.OC_IdInCollContext(self, self._ctx, self.state) + self.enterRule(localctx, 240, self.RULE_oC_IdInColl) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1961 + self.oC_Variable() + self.state = 1962 + self.match(CypherParser.SP) + self.state = 1963 + self.match(CypherParser.IN) + self.state = 1964 + self.match(CypherParser.SP) + self.state = 1965 + self.oC_Expression() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_FunctionInvocationContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_FunctionName(self): + return self.getTypedRuleContext(CypherParser.OC_FunctionNameContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def DISTINCT(self): + return self.getToken(CypherParser.DISTINCT, 0) + + def oC_Expression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_ExpressionContext) + else: + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_FunctionInvocation + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_FunctionInvocation"): + listener.enterOC_FunctionInvocation(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_FunctionInvocation"): + listener.exitOC_FunctionInvocation(self) + + def oC_FunctionInvocation(self): + + localctx = CypherParser.OC_FunctionInvocationContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 242, self.RULE_oC_FunctionInvocation) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1967 + self.oC_FunctionName() + self.state = 1969 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1968 + self.match(CypherParser.SP) + + self.state = 1971 + self.match(CypherParser.T__2) + self.state = 1973 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1972 + self.match(CypherParser.SP) + + self.state = 1979 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 84: + self.state = 1975 + self.match(CypherParser.DISTINCT) + self.state = 1977 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1976 + self.match(CypherParser.SP) + + self.state = 1998 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3F) == 0 and ((1 << _la) & -9205357638175948760) != 0) or ( + (((_la - 100)) & ~0x3F) == 0 + and ((1 << (_la - 100)) & 316779876257315) != 0 + ): + self.state = 1981 + self.oC_Expression() + self.state = 1983 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1982 + self.match(CypherParser.SP) + + self.state = 1995 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 7: + self.state = 1985 + self.match(CypherParser.T__6) + self.state = 1987 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1986 + self.match(CypherParser.SP) + + self.state = 1989 + self.oC_Expression() + self.state = 1991 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 1990 + self.match(CypherParser.SP) + + self.state = 1997 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2000 + self.match(CypherParser.T__3) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_FunctionNameContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Namespace(self): + return self.getTypedRuleContext(CypherParser.OC_NamespaceContext, 0) + + def oC_SymbolicName(self): + return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_FunctionName + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_FunctionName"): + listener.enterOC_FunctionName(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_FunctionName"): + listener.exitOC_FunctionName(self) + + def oC_FunctionName(self): + + localctx = CypherParser.OC_FunctionNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 244, self.RULE_oC_FunctionName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2002 + self.oC_Namespace() + self.state = 2003 + self.oC_SymbolicName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ExistentialSubqueryContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def EXISTS(self): + return self.getToken(CypherParser.EXISTS, 0) + + def oC_RegularQuery(self): + return self.getTypedRuleContext(CypherParser.OC_RegularQueryContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_Pattern(self): + return self.getTypedRuleContext(CypherParser.OC_PatternContext, 0) + + def oC_Where(self): + return self.getTypedRuleContext(CypherParser.OC_WhereContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ExistentialSubquery + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ExistentialSubquery"): + listener.enterOC_ExistentialSubquery(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ExistentialSubquery"): + listener.exitOC_ExistentialSubquery(self) + + def oC_ExistentialSubquery(self): + + localctx = CypherParser.OC_ExistentialSubqueryContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 246, self.RULE_oC_ExistentialSubquery) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2005 + self.match(CypherParser.EXISTS) + self.state = 2007 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2006 + self.match(CypherParser.SP) + + self.state = 2009 + self.match(CypherParser.T__24) + self.state = 2011 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2010 + self.match(CypherParser.SP) + + self.state = 2021 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [55, 64, 66, 71, 72, 73, 74, 75, 76, 77, 78, 79, 81, 83, 95]: + self.state = 2013 + self.oC_RegularQuery() + pass + elif token in [3, 100, 101, 110, 116, 117, 119, 120, 121, 127, 145, 148]: + self.state = 2014 + self.oC_Pattern() + self.state = 2019 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 331, self._ctx) + if la_ == 1: + self.state = 2016 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2015 + self.match(CypherParser.SP) + + self.state = 2018 + self.oC_Where() + + pass + else: + raise NoViableAltException(self) + + self.state = 2024 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2023 + self.match(CypherParser.SP) + + self.state = 2026 + self.match(CypherParser.T__25) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ExplicitProcedureInvocationContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_ProcedureName(self): + return self.getTypedRuleContext(CypherParser.OC_ProcedureNameContext, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_Expression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_ExpressionContext) + else: + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ExplicitProcedureInvocation + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ExplicitProcedureInvocation"): + listener.enterOC_ExplicitProcedureInvocation(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ExplicitProcedureInvocation"): + listener.exitOC_ExplicitProcedureInvocation(self) + + def oC_ExplicitProcedureInvocation(self): + + localctx = CypherParser.OC_ExplicitProcedureInvocationContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 248, self.RULE_oC_ExplicitProcedureInvocation) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2028 + self.oC_ProcedureName() + self.state = 2030 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2029 + self.match(CypherParser.SP) + + self.state = 2032 + self.match(CypherParser.T__2) + self.state = 2034 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2033 + self.match(CypherParser.SP) + + self.state = 2053 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3F) == 0 and ((1 << _la) & -9205357638175948760) != 0) or ( + (((_la - 100)) & ~0x3F) == 0 + and ((1 << (_la - 100)) & 316779876257315) != 0 + ): + self.state = 2036 + self.oC_Expression() + self.state = 2038 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2037 + self.match(CypherParser.SP) + + self.state = 2050 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 7: + self.state = 2040 + self.match(CypherParser.T__6) + self.state = 2042 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2041 + self.match(CypherParser.SP) + + self.state = 2044 + self.oC_Expression() + self.state = 2046 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2045 + self.match(CypherParser.SP) + + self.state = 2052 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2055 + self.match(CypherParser.T__3) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ImplicitProcedureInvocationContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_ProcedureName(self): + return self.getTypedRuleContext(CypherParser.OC_ProcedureNameContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ImplicitProcedureInvocation + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ImplicitProcedureInvocation"): + listener.enterOC_ImplicitProcedureInvocation(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ImplicitProcedureInvocation"): + listener.exitOC_ImplicitProcedureInvocation(self) + + def oC_ImplicitProcedureInvocation(self): + + localctx = CypherParser.OC_ImplicitProcedureInvocationContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 250, self.RULE_oC_ImplicitProcedureInvocation) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2057 + self.oC_ProcedureName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ProcedureResultFieldContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_SymbolicName(self): + return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ProcedureResultField + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ProcedureResultField"): + listener.enterOC_ProcedureResultField(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ProcedureResultField"): + listener.exitOC_ProcedureResultField(self) + + def oC_ProcedureResultField(self): + + localctx = CypherParser.OC_ProcedureResultFieldContext( + self, self._ctx, self.state + ) + self.enterRule(localctx, 252, self.RULE_oC_ProcedureResultField) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2059 + self.oC_SymbolicName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ProcedureNameContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_Namespace(self): + return self.getTypedRuleContext(CypherParser.OC_NamespaceContext, 0) + + def oC_SymbolicName(self): + return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ProcedureName + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ProcedureName"): + listener.enterOC_ProcedureName(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ProcedureName"): + listener.exitOC_ProcedureName(self) + + def oC_ProcedureName(self): + + localctx = CypherParser.OC_ProcedureNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 254, self.RULE_oC_ProcedureName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2061 + self.oC_Namespace() + self.state = 2062 + self.oC_SymbolicName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_NamespaceContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_SymbolicName(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_SymbolicNameContext) + else: + return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Namespace + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Namespace"): + listener.enterOC_Namespace(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Namespace"): + listener.exitOC_Namespace(self) + + def oC_Namespace(self): + + localctx = CypherParser.OC_NamespaceContext(self, self._ctx, self.state) + self.enterRule(localctx, 256, self.RULE_oC_Namespace) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2069 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 341, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 2064 + self.oC_SymbolicName() + self.state = 2065 + self.match(CypherParser.T__23) + self.state = 2071 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 341, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_VariableContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_SymbolicName(self): + return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Variable + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Variable"): + listener.enterOC_Variable(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Variable"): + listener.exitOC_Variable(self) + + def oC_Variable(self): + + localctx = CypherParser.OC_VariableContext(self, self._ctx, self.state) + self.enterRule(localctx, 258, self.RULE_oC_Variable) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2072 + self.oC_SymbolicName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_LiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_BooleanLiteral(self): + return self.getTypedRuleContext(CypherParser.OC_BooleanLiteralContext, 0) + + def NULL(self): + return self.getToken(CypherParser.NULL, 0) + + def oC_NumberLiteral(self): + return self.getTypedRuleContext(CypherParser.OC_NumberLiteralContext, 0) + + def StringLiteral(self): + return self.getToken(CypherParser.StringLiteral, 0) + + def oC_ListLiteral(self): + return self.getTypedRuleContext(CypherParser.OC_ListLiteralContext, 0) + + def oC_MapLiteral(self): + return self.getTypedRuleContext(CypherParser.OC_MapLiteralContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Literal + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Literal"): + listener.enterOC_Literal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Literal"): + listener.exitOC_Literal(self) + + def oC_Literal(self): + + localctx = CypherParser.OC_LiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 260, self.RULE_oC_Literal) + try: + self.state = 2080 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [122, 123]: + self.enterOuterAlt(localctx, 1) + self.state = 2074 + self.oC_BooleanLiteral() + pass + elif token in [109]: + self.enterOuterAlt(localctx, 2) + self.state = 2075 + self.match(CypherParser.NULL) + pass + elif token in [124, 125, 126, 134, 135]: + self.enterOuterAlt(localctx, 3) + self.state = 2076 + self.oC_NumberLiteral() + pass + elif token in [136]: + self.enterOuterAlt(localctx, 4) + self.state = 2077 + self.match(CypherParser.StringLiteral) + pass + elif token in [5]: + self.enterOuterAlt(localctx, 5) + self.state = 2078 + self.oC_ListLiteral() + pass + elif token in [25]: + self.enterOuterAlt(localctx, 6) + self.state = 2079 + self.oC_MapLiteral() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_BooleanLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def TRUE(self): + return self.getToken(CypherParser.TRUE, 0) + + def FALSE(self): + return self.getToken(CypherParser.FALSE, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_BooleanLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_BooleanLiteral"): + listener.enterOC_BooleanLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_BooleanLiteral"): + listener.exitOC_BooleanLiteral(self) + + def oC_BooleanLiteral(self): + + localctx = CypherParser.OC_BooleanLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 262, self.RULE_oC_BooleanLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2082 + _la = self._input.LA(1) + if not (_la == 122 or _la == 123): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_NumberLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_DoubleLiteral(self): + return self.getTypedRuleContext(CypherParser.OC_DoubleLiteralContext, 0) + + def oC_IntegerLiteral(self): + return self.getTypedRuleContext(CypherParser.OC_IntegerLiteralContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_NumberLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_NumberLiteral"): + listener.enterOC_NumberLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_NumberLiteral"): + listener.exitOC_NumberLiteral(self) + + def oC_NumberLiteral(self): + + localctx = CypherParser.OC_NumberLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 264, self.RULE_oC_NumberLiteral) + try: + self.state = 2086 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [134, 135]: + self.enterOuterAlt(localctx, 1) + self.state = 2084 + self.oC_DoubleLiteral() + pass + elif token in [124, 125, 126]: + self.enterOuterAlt(localctx, 2) + self.state = 2085 + self.oC_IntegerLiteral() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_IntegerLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def HexInteger(self): + return self.getToken(CypherParser.HexInteger, 0) + + def OctalInteger(self): + return self.getToken(CypherParser.OctalInteger, 0) + + def DecimalInteger(self): + return self.getToken(CypherParser.DecimalInteger, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_IntegerLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_IntegerLiteral"): + listener.enterOC_IntegerLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_IntegerLiteral"): + listener.exitOC_IntegerLiteral(self) + + def oC_IntegerLiteral(self): + + localctx = CypherParser.OC_IntegerLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 266, self.RULE_oC_IntegerLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2088 + _la = self._input.LA(1) + if not (((((_la - 124)) & ~0x3F) == 0 and ((1 << (_la - 124)) & 7) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_DoubleLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def ExponentDecimalReal(self): + return self.getToken(CypherParser.ExponentDecimalReal, 0) + + def RegularDecimalReal(self): + return self.getToken(CypherParser.RegularDecimalReal, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_DoubleLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_DoubleLiteral"): + listener.enterOC_DoubleLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_DoubleLiteral"): + listener.exitOC_DoubleLiteral(self) + + def oC_DoubleLiteral(self): + + localctx = CypherParser.OC_DoubleLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 268, self.RULE_oC_DoubleLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2090 + _la = self._input.LA(1) + if not (_la == 134 or _la == 135): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ListLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_Expression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_ExpressionContext) + else: + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ListLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ListLiteral"): + listener.enterOC_ListLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ListLiteral"): + listener.exitOC_ListLiteral(self) + + def oC_ListLiteral(self): + + localctx = CypherParser.OC_ListLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 270, self.RULE_oC_ListLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2092 + self.match(CypherParser.T__4) + self.state = 2094 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2093 + self.match(CypherParser.SP) + + self.state = 2113 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3F) == 0 and ((1 << _la) & -9205357638175948760) != 0) or ( + (((_la - 100)) & ~0x3F) == 0 + and ((1 << (_la - 100)) & 316779876257315) != 0 + ): + self.state = 2096 + self.oC_Expression() + self.state = 2098 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2097 + self.match(CypherParser.SP) + + self.state = 2110 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 7: + self.state = 2100 + self.match(CypherParser.T__6) + self.state = 2102 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2101 + self.match(CypherParser.SP) + + self.state = 2104 + self.oC_Expression() + self.state = 2106 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2105 + self.match(CypherParser.SP) + + self.state = 2112 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2115 + self.match(CypherParser.T__5) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_MapLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def oC_PropertyKeyName(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_PropertyKeyNameContext) + else: + return self.getTypedRuleContext( + CypherParser.OC_PropertyKeyNameContext, i + ) + + def oC_Expression(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(CypherParser.OC_ExpressionContext) + else: + return self.getTypedRuleContext(CypherParser.OC_ExpressionContext, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_MapLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_MapLiteral"): + listener.enterOC_MapLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_MapLiteral"): + listener.exitOC_MapLiteral(self) + + def oC_MapLiteral(self): + + localctx = CypherParser.OC_MapLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 272, self.RULE_oC_MapLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2117 + self.match(CypherParser.T__24) + self.state = 2119 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2118 + self.match(CypherParser.SP) + + self.state = 2154 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ( + (((_la - 53)) & ~0x3F) == 0 + and ((1 << (_la - 53)) & -491482570217617) != 0 + ) or ( + (((_la - 117)) & ~0x3F) == 0 and ((1 << (_la - 117)) & 2682258557) != 0 + ): + self.state = 2121 + self.oC_PropertyKeyName() + self.state = 2123 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2122 + self.match(CypherParser.SP) + + self.state = 2125 + self.match(CypherParser.T__10) + self.state = 2127 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2126 + self.match(CypherParser.SP) + + self.state = 2129 + self.oC_Expression() + self.state = 2131 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2130 + self.match(CypherParser.SP) + + self.state = 2151 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 7: + self.state = 2133 + self.match(CypherParser.T__6) + self.state = 2135 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2134 + self.match(CypherParser.SP) + + self.state = 2137 + self.oC_PropertyKeyName() + self.state = 2139 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2138 + self.match(CypherParser.SP) + + self.state = 2141 + self.match(CypherParser.T__10) + self.state = 2143 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2142 + self.match(CypherParser.SP) + + self.state = 2145 + self.oC_Expression() + self.state = 2147 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2146 + self.match(CypherParser.SP) + + self.state = 2153 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2156 + self.match(CypherParser.T__25) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_PropertyKeyNameContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_SchemaName(self): + return self.getTypedRuleContext(CypherParser.OC_SchemaNameContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_PropertyKeyName + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_PropertyKeyName"): + listener.enterOC_PropertyKeyName(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_PropertyKeyName"): + listener.exitOC_PropertyKeyName(self) + + def oC_PropertyKeyName(self): + + localctx = CypherParser.OC_PropertyKeyNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 274, self.RULE_oC_PropertyKeyName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2158 + self.oC_SchemaName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_LegacyParameterContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_SymbolicName(self): + return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext, 0) + + def DecimalInteger(self): + return self.getToken(CypherParser.DecimalInteger, 0) + + def SP(self, i: int = None): + if i is None: + return self.getTokens(CypherParser.SP) + else: + return self.getToken(CypherParser.SP, i) + + def getRuleIndex(self): + return CypherParser.RULE_oC_LegacyParameter + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_LegacyParameter"): + listener.enterOC_LegacyParameter(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_LegacyParameter"): + listener.exitOC_LegacyParameter(self) + + def oC_LegacyParameter(self): + + localctx = CypherParser.OC_LegacyParameterContext(self, self._ctx, self.state) + self.enterRule(localctx, 276, self.RULE_oC_LegacyParameter) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2160 + self.match(CypherParser.T__24) + self.state = 2162 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2161 + self.match(CypherParser.SP) + + self.state = 2166 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [110, 116, 117, 119, 120, 121, 127, 145, 148]: + self.state = 2164 + self.oC_SymbolicName() + pass + elif token in [125]: + self.state = 2165 + self.match(CypherParser.DecimalInteger) + pass + else: + raise NoViableAltException(self) + + self.state = 2169 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 149: + self.state = 2168 + self.match(CypherParser.SP) + + self.state = 2171 + self.match(CypherParser.T__25) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ParameterContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_SymbolicName(self): + return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext, 0) + + def DecimalInteger(self): + return self.getToken(CypherParser.DecimalInteger, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_Parameter + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Parameter"): + listener.enterOC_Parameter(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Parameter"): + listener.exitOC_Parameter(self) + + def oC_Parameter(self): + + localctx = CypherParser.OC_ParameterContext(self, self._ctx, self.state) + self.enterRule(localctx, 278, self.RULE_oC_Parameter) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2173 + self.match(CypherParser.T__26) + self.state = 2176 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [110, 116, 117, 119, 120, 121, 127, 145, 148]: + self.state = 2174 + self.oC_SymbolicName() + pass + elif token in [125]: + self.state = 2175 + self.match(CypherParser.DecimalInteger) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_SchemaNameContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def oC_SymbolicName(self): + return self.getTypedRuleContext(CypherParser.OC_SymbolicNameContext, 0) + + def oC_ReservedWord(self): + return self.getTypedRuleContext(CypherParser.OC_ReservedWordContext, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_SchemaName + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_SchemaName"): + listener.enterOC_SchemaName(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_SchemaName"): + listener.exitOC_SchemaName(self) + + def oC_SchemaName(self): + + localctx = CypherParser.OC_SchemaNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 280, self.RULE_oC_SchemaName) + try: + self.state = 2180 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [110, 116, 117, 119, 120, 121, 127, 145, 148]: + self.enterOuterAlt(localctx, 1) + self.state = 2178 + self.oC_SymbolicName() + pass + elif token in [ + 53, + 54, + 55, + 56, + 58, + 59, + 61, + 62, + 63, + 66, + 69, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 80, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 99, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 111, + 112, + 113, + 114, + 115, + 122, + 123, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + ]: + self.enterOuterAlt(localctx, 2) + self.state = 2179 + self.oC_ReservedWord() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_ReservedWordContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def ALL(self): + return self.getToken(CypherParser.ALL, 0) + + def ASC(self): + return self.getToken(CypherParser.ASC, 0) + + def ASCENDING(self): + return self.getToken(CypherParser.ASCENDING, 0) + + def BY(self): + return self.getToken(CypherParser.BY, 0) + + def CREATE(self): + return self.getToken(CypherParser.CREATE, 0) + + def DELETE(self): + return self.getToken(CypherParser.DELETE, 0) + + def DESC(self): + return self.getToken(CypherParser.DESC, 0) + + def DESCENDING(self): + return self.getToken(CypherParser.DESCENDING, 0) + + def DETACH(self): + return self.getToken(CypherParser.DETACH, 0) + + def EXISTS(self): + return self.getToken(CypherParser.EXISTS, 0) + + def LIMIT(self): + return self.getToken(CypherParser.LIMIT, 0) + + def MATCH(self): + return self.getToken(CypherParser.MATCH, 0) + + def MERGE(self): + return self.getToken(CypherParser.MERGE, 0) + + def ON(self): + return self.getToken(CypherParser.ON, 0) + + def OPTIONAL(self): + return self.getToken(CypherParser.OPTIONAL, 0) + + def ORDER(self): + return self.getToken(CypherParser.ORDER, 0) + + def REMOVE(self): + return self.getToken(CypherParser.REMOVE, 0) + + def RETURN(self): + return self.getToken(CypherParser.RETURN, 0) + + def SET(self): + return self.getToken(CypherParser.SET, 0) + + def L_SKIP(self): + return self.getToken(CypherParser.L_SKIP, 0) + + def WHERE(self): + return self.getToken(CypherParser.WHERE, 0) + + def WITH(self): + return self.getToken(CypherParser.WITH, 0) + + def UNION(self): + return self.getToken(CypherParser.UNION, 0) + + def UNWIND(self): + return self.getToken(CypherParser.UNWIND, 0) + + def AND(self): + return self.getToken(CypherParser.AND, 0) + + def AS(self): + return self.getToken(CypherParser.AS, 0) + + def CONTAINS(self): + return self.getToken(CypherParser.CONTAINS, 0) + + def DISTINCT(self): + return self.getToken(CypherParser.DISTINCT, 0) + + def ENDS(self): + return self.getToken(CypherParser.ENDS, 0) + + def IN(self): + return self.getToken(CypherParser.IN, 0) + + def IS(self): + return self.getToken(CypherParser.IS, 0) + + def NOT(self): + return self.getToken(CypherParser.NOT, 0) + + def OR(self): + return self.getToken(CypherParser.OR, 0) + + def STARTS(self): + return self.getToken(CypherParser.STARTS, 0) + + def XOR(self): + return self.getToken(CypherParser.XOR, 0) + + def FALSE(self): + return self.getToken(CypherParser.FALSE, 0) + + def TRUE(self): + return self.getToken(CypherParser.TRUE, 0) + + def NULL(self): + return self.getToken(CypherParser.NULL, 0) + + def CONSTRAINT(self): + return self.getToken(CypherParser.CONSTRAINT, 0) + + def DO(self): + return self.getToken(CypherParser.DO, 0) + + def FOR(self): + return self.getToken(CypherParser.FOR, 0) + + def REQUIRE(self): + return self.getToken(CypherParser.REQUIRE, 0) + + def UNIQUE(self): + return self.getToken(CypherParser.UNIQUE, 0) + + def CASE(self): + return self.getToken(CypherParser.CASE, 0) + + def WHEN(self): + return self.getToken(CypherParser.WHEN, 0) + + def THEN(self): + return self.getToken(CypherParser.THEN, 0) + + def ELSE(self): + return self.getToken(CypherParser.ELSE, 0) + + def END(self): + return self.getToken(CypherParser.END, 0) + + def MANDATORY(self): + return self.getToken(CypherParser.MANDATORY, 0) + + def SCALAR(self): + return self.getToken(CypherParser.SCALAR, 0) + + def OF(self): + return self.getToken(CypherParser.OF, 0) + + def ADD(self): + return self.getToken(CypherParser.ADD, 0) + + def DROP(self): + return self.getToken(CypherParser.DROP, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_ReservedWord + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_ReservedWord"): + listener.enterOC_ReservedWord(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_ReservedWord"): + listener.exitOC_ReservedWord(self) + + def oC_ReservedWord(self): + + localctx = CypherParser.OC_ReservedWordContext(self, self._ctx, self.state) + self.enterRule(localctx, 282, self.RULE_oC_ReservedWord) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2182 + _la = self._input.LA(1) + if not ( + ( + (((_la - 53)) & ~0x3F) == 0 + and ((1 << (_la - 53)) & 9078765366208702319) != 0 + ) + or ( + (((_la - 122)) & ~0x3F) == 0 and ((1 << (_la - 122)) & 8323075) != 0 + ) + ): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_SymbolicNameContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def UnescapedSymbolicName(self): + return self.getToken(CypherParser.UnescapedSymbolicName, 0) + + def EscapedSymbolicName(self): + return self.getToken(CypherParser.EscapedSymbolicName, 0) + + def HexLetter(self): + return self.getToken(CypherParser.HexLetter, 0) + + def COUNT(self): + return self.getToken(CypherParser.COUNT, 0) + + def FILTER(self): + return self.getToken(CypherParser.FILTER, 0) + + def EXTRACT(self): + return self.getToken(CypherParser.EXTRACT, 0) + + def ANY(self): + return self.getToken(CypherParser.ANY, 0) + + def NONE(self): + return self.getToken(CypherParser.NONE, 0) + + def SINGLE(self): + return self.getToken(CypherParser.SINGLE, 0) + + def getRuleIndex(self): + return CypherParser.RULE_oC_SymbolicName + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_SymbolicName"): + listener.enterOC_SymbolicName(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_SymbolicName"): + listener.exitOC_SymbolicName(self) + + def oC_SymbolicName(self): + + localctx = CypherParser.OC_SymbolicNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 284, self.RULE_oC_SymbolicName) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2184 + _la = self._input.LA(1) + if not ( + ( + (((_la - 110)) & ~0x3F) == 0 + and ((1 << (_la - 110)) & 309237780161) != 0 + ) + ): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_LeftArrowHeadContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return CypherParser.RULE_oC_LeftArrowHead + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_LeftArrowHead"): + listener.enterOC_LeftArrowHead(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_LeftArrowHead"): + listener.exitOC_LeftArrowHead(self) + + def oC_LeftArrowHead(self): + + localctx = CypherParser.OC_LeftArrowHeadContext(self, self._ctx, self.state) + self.enterRule(localctx, 286, self.RULE_oC_LeftArrowHead) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2186 + _la = self._input.LA(1) + if not ((((_la) & ~0x3F) == 0 and ((1 << _la) & 4026548224) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_RightArrowHeadContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return CypherParser.RULE_oC_RightArrowHead + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_RightArrowHead"): + listener.enterOC_RightArrowHead(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_RightArrowHead"): + listener.exitOC_RightArrowHead(self) + + def oC_RightArrowHead(self): + + localctx = CypherParser.OC_RightArrowHeadContext(self, self._ctx, self.state) + self.enterRule(localctx, 288, self.RULE_oC_RightArrowHead) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2188 + _la = self._input.LA(1) + if not ((((_la) & ~0x3F) == 0 and ((1 << _la) & 64424542208) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class OC_DashContext(ParserRuleContext): + __slots__ = "parser" + + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return CypherParser.RULE_oC_Dash + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOC_Dash"): + listener.enterOC_Dash(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOC_Dash"): + listener.exitOC_Dash(self) + + def oC_Dash(self): + + localctx = CypherParser.OC_DashContext(self, self._ctx, self.state) + self.enterRule(localctx, 290, self.RULE_oC_Dash) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2190 + _la = self._input.LA(1) + if not ((((_la) & ~0x3F) == 0 and ((1 << _la) & 140668769927168) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx diff --git a/tests/grammar/__init__.py b/tests/grammar/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/grammar/cypher/Cypher.g4 b/tests/grammar/cypher/Cypher.g4 new file mode 100644 index 0000000..2db68c7 --- /dev/null +++ b/tests/grammar/cypher/Cypher.g4 @@ -0,0 +1,1013 @@ +/** + * Copyright (c) 2015-2023 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Attribution Notice under the terms of the Apache License 2.0 + * + * This work was created by the collective efforts of the openCypher community. + * Without limiting the terms of Section 6, any Derivative Work that is not + * approved by the public consensus process of the openCypher Implementers Group + * should not be described as “Cypher” (and Cypher® is a registered trademark of + * Neo4j Inc.) or as "openCypher". Extensions by implementers or prototypes or + * proposals for change that have been documented or implemented should only be + * described as "implementation extensions to Cypher" or as "proposed changes to + * Cypher that are not yet approved by the openCypher community". + */ +grammar Cypher; + +oC_Cypher + : SP? oC_QueryOptions oC_Statement ( SP? ';' )? SP? EOF ; + +oC_QueryOptions + : ( oC_AnyCypherOption SP? )* ; + +oC_AnyCypherOption + : oC_CypherOption + | oC_Explain + | oC_Profile + ; + +oC_CypherOption + : CYPHER ( SP oC_VersionNumber )? ( SP oC_ConfigurationOption )* ; + +CYPHER : ( 'C' | 'c' ) ( 'Y' | 'y' ) ( 'P' | 'p' ) ( 'H' | 'h' ) ( 'E' | 'e' ) ( 'R' | 'r' ) ; + +oC_VersionNumber + : RegularDecimalReal ; + +oC_Explain + : EXPLAIN ; + +EXPLAIN : ( 'E' | 'e' ) ( 'X' | 'x' ) ( 'P' | 'p' ) ( 'L' | 'l' ) ( 'A' | 'a' ) ( 'I' | 'i' ) ( 'N' | 'n' ) ; + +oC_Profile + : PROFILE ; + +PROFILE : ( 'P' | 'p' ) ( 'R' | 'r' ) ( 'O' | 'o' ) ( 'F' | 'f' ) ( 'I' | 'i' ) ( 'L' | 'l' ) ( 'E' | 'e' ) ; + +oC_ConfigurationOption + : oC_SymbolicName SP? '=' SP? oC_SymbolicName ; + +oC_Statement + : oC_Command + | oC_Query + ; + +oC_Query + : oC_RegularQuery + | oC_StandaloneCall + | oC_BulkImportQuery + ; + +oC_RegularQuery + : oC_SingleQuery ( SP? oC_Union )* ; + +oC_BulkImportQuery + : oC_PeriodicCommitHint SP? oC_LoadCSVQuery ; + +oC_PeriodicCommitHint + : USING SP PERIODIC SP COMMIT ( SP oC_IntegerLiteral )? ; + +USING : ( 'U' | 'u' ) ( 'S' | 's' ) ( 'I' | 'i' ) ( 'N' | 'n' ) ( 'G' | 'g' ) ; + +PERIODIC : ( 'P' | 'p' ) ( 'E' | 'e' ) ( 'R' | 'r' ) ( 'I' | 'i' ) ( 'O' | 'o' ) ( 'D' | 'd' ) ( 'I' | 'i' ) ( 'C' | 'c' ) ; + +COMMIT : ( 'C' | 'c' ) ( 'O' | 'o' ) ( 'M' | 'm' ) ( 'M' | 'm' ) ( 'I' | 'i' ) ( 'T' | 't' ) ; + +oC_LoadCSVQuery + : oC_LoadCSV oC_SingleQuery ; + +oC_Union + : ( UNION SP ALL SP? oC_SingleQuery ) + | ( UNION SP? oC_SingleQuery ) + ; + +UNION : ( 'U' | 'u' ) ( 'N' | 'n' ) ( 'I' | 'i' ) ( 'O' | 'o' ) ( 'N' | 'n' ) ; + +ALL : ( 'A' | 'a' ) ( 'L' | 'l' ) ( 'L' | 'l' ) ; + +oC_SingleQuery + : oC_SinglePartQuery + | oC_MultiPartQuery + ; + +oC_SinglePartQuery + : ( ( oC_ReadingClause SP? )* oC_Return ) + | ( ( oC_ReadingClause SP? )* oC_UpdatingClause ( SP? oC_UpdatingClause )* ( SP? oC_Return )? ) + ; + +oC_MultiPartQuery + : ( ( oC_ReadingClause SP? )* ( oC_UpdatingClause SP? )* oC_With SP? )+ oC_SinglePartQuery ; + +oC_UpdatingClause + : oC_Create + | oC_Merge + | oC_CreateUnique + | oC_Foreach + | oC_Delete + | oC_Set + | oC_Remove + ; + +oC_ReadingClause + : oC_LoadCSV + | oC_Start + | oC_Match + | oC_Unwind + | oC_InQueryCall + ; + +oC_Command + : oC_CreateIndex + | oC_DropIndex + | oC_CreateUniqueConstraint + | oC_DropUniqueConstraint + | oC_CreateNodePropertyExistenceConstraint + | oC_DropNodePropertyExistenceConstraint + | oC_CreateRelationshipPropertyExistenceConstraint + | oC_DropRelationshipPropertyExistenceConstraint + ; + +oC_CreateUniqueConstraint + : CREATE SP oC_UniqueConstraint ; + +CREATE : ( 'C' | 'c' ) ( 'R' | 'r' ) ( 'E' | 'e' ) ( 'A' | 'a' ) ( 'T' | 't' ) ( 'E' | 'e' ) ; + +oC_CreateNodePropertyExistenceConstraint + : CREATE SP oC_NodePropertyExistenceConstraint ; + +oC_CreateRelationshipPropertyExistenceConstraint + : CREATE SP oC_RelationshipPropertyExistenceConstraint ; + +oC_CreateIndex + : CREATE SP oC_Index ; + +oC_DropUniqueConstraint + : DROP SP oC_UniqueConstraint ; + +DROP : ( 'D' | 'd' ) ( 'R' | 'r' ) ( 'O' | 'o' ) ( 'P' | 'p' ) ; + +oC_DropNodePropertyExistenceConstraint + : DROP SP oC_NodePropertyExistenceConstraint ; + +oC_DropRelationshipPropertyExistenceConstraint + : DROP SP oC_RelationshipPropertyExistenceConstraint ; + +oC_DropIndex + : DROP SP oC_Index ; + +oC_Index + : INDEX SP ON SP? oC_NodeLabel '(' oC_PropertyKeyName ')' ; + +INDEX : ( 'I' | 'i' ) ( 'N' | 'n' ) ( 'D' | 'd' ) ( 'E' | 'e' ) ( 'X' | 'x' ) ; + +ON : ( 'O' | 'o' ) ( 'N' | 'n' ) ; + +oC_UniqueConstraint + : CONSTRAINT SP ON SP? '(' oC_Variable oC_NodeLabel ')' SP? ASSERT SP oC_PropertyExpression SP IS SP UNIQUE ; + +CONSTRAINT : ( 'C' | 'c' ) ( 'O' | 'o' ) ( 'N' | 'n' ) ( 'S' | 's' ) ( 'T' | 't' ) ( 'R' | 'r' ) ( 'A' | 'a' ) ( 'I' | 'i' ) ( 'N' | 'n' ) ( 'T' | 't' ) ; + +ASSERT : ( 'A' | 'a' ) ( 'S' | 's' ) ( 'S' | 's' ) ( 'E' | 'e' ) ( 'R' | 'r' ) ( 'T' | 't' ) ; + +IS : ( 'I' | 'i' ) ( 'S' | 's' ) ; + +UNIQUE : ( 'U' | 'u' ) ( 'N' | 'n' ) ( 'I' | 'i' ) ( 'Q' | 'q' ) ( 'U' | 'u' ) ( 'E' | 'e' ) ; + +oC_NodePropertyExistenceConstraint + : CONSTRAINT SP ON SP? '(' oC_Variable oC_NodeLabel ')' SP? ASSERT SP EXISTS SP? '(' oC_PropertyExpression ')' ; + +EXISTS : ( 'E' | 'e' ) ( 'X' | 'x' ) ( 'I' | 'i' ) ( 'S' | 's' ) ( 'T' | 't' ) ( 'S' | 's' ) ; + +oC_RelationshipPropertyExistenceConstraint + : CONSTRAINT SP ON SP? oC_RelationshipPatternSyntax SP? ASSERT SP EXISTS SP? '(' oC_PropertyExpression ')' ; + +oC_RelationshipPatternSyntax + : ( '(' SP? ')' oC_Dash '[' oC_Variable oC_RelType ']' oC_Dash '(' SP? ')' ) + | ( '(' SP? ')' oC_Dash '[' oC_Variable oC_RelType ']' oC_Dash oC_RightArrowHead '(' SP? ')' ) + | ( '(' SP? ')' oC_LeftArrowHead oC_Dash '[' oC_Variable oC_RelType ']' oC_Dash '(' SP? ')' ) + ; + +oC_LoadCSV + : LOAD SP CSV SP ( WITH SP HEADERS SP )? FROM SP oC_Expression SP AS SP oC_Variable SP ( FIELDTERMINATOR SP StringLiteral )? ; + +LOAD : ( 'L' | 'l' ) ( 'O' | 'o' ) ( 'A' | 'a' ) ( 'D' | 'd' ) ; + +CSV : ( 'C' | 'c' ) ( 'S' | 's' ) ( 'V' | 'v' ) ; + +WITH : ( 'W' | 'w' ) ( 'I' | 'i' ) ( 'T' | 't' ) ( 'H' | 'h' ) ; + +HEADERS : ( 'H' | 'h' ) ( 'E' | 'e' ) ( 'A' | 'a' ) ( 'D' | 'd' ) ( 'E' | 'e' ) ( 'R' | 'r' ) ( 'S' | 's' ) ; + +FROM : ( 'F' | 'f' ) ( 'R' | 'r' ) ( 'O' | 'o' ) ( 'M' | 'm' ) ; + +AS : ( 'A' | 'a' ) ( 'S' | 's' ) ; + +FIELDTERMINATOR : ( 'F' | 'f' ) ( 'I' | 'i' ) ( 'E' | 'e' ) ( 'L' | 'l' ) ( 'D' | 'd' ) ( 'T' | 't' ) ( 'E' | 'e' ) ( 'R' | 'r' ) ( 'M' | 'm' ) ( 'I' | 'i' ) ( 'N' | 'n' ) ( 'A' | 'a' ) ( 'T' | 't' ) ( 'O' | 'o' ) ( 'R' | 'r' ) ; + +oC_Match + : ( OPTIONAL SP )? MATCH SP? oC_Pattern ( oC_Hint )* ( SP? oC_Where )? ; + +OPTIONAL : ( 'O' | 'o' ) ( 'P' | 'p' ) ( 'T' | 't' ) ( 'I' | 'i' ) ( 'O' | 'o' ) ( 'N' | 'n' ) ( 'A' | 'a' ) ( 'L' | 'l' ) ; + +MATCH : ( 'M' | 'm' ) ( 'A' | 'a' ) ( 'T' | 't' ) ( 'C' | 'c' ) ( 'H' | 'h' ) ; + +oC_Unwind + : UNWIND SP? oC_Expression SP AS SP oC_Variable ; + +UNWIND : ( 'U' | 'u' ) ( 'N' | 'n' ) ( 'W' | 'w' ) ( 'I' | 'i' ) ( 'N' | 'n' ) ( 'D' | 'd' ) ; + +oC_Merge + : MERGE SP? oC_PatternPart ( SP oC_MergeAction )* ; + +MERGE : ( 'M' | 'm' ) ( 'E' | 'e' ) ( 'R' | 'r' ) ( 'G' | 'g' ) ( 'E' | 'e' ) ; + +oC_MergeAction + : ( ON SP MATCH SP oC_Set ) + | ( ON SP CREATE SP oC_Set ) + ; + +oC_Create + : CREATE SP? oC_Pattern ; + +oC_CreateUnique + : CREATE SP UNIQUE SP? oC_Pattern ; + +oC_Set + : SET SP? oC_SetItem ( SP? ',' SP? oC_SetItem )* ; + +SET : ( 'S' | 's' ) ( 'E' | 'e' ) ( 'T' | 't' ) ; + +oC_SetItem + : ( oC_PropertyExpression SP? '=' SP? oC_Expression ) + | ( oC_Variable SP? '=' SP? oC_Expression ) + | ( oC_Variable SP? '+=' SP? oC_Expression ) + | ( oC_Variable SP? oC_NodeLabels ) + ; + +oC_Delete + : ( DETACH SP )? DELETE SP? oC_Expression ( SP? ',' SP? oC_Expression )* ; + +DETACH : ( 'D' | 'd' ) ( 'E' | 'e' ) ( 'T' | 't' ) ( 'A' | 'a' ) ( 'C' | 'c' ) ( 'H' | 'h' ) ; + +DELETE : ( 'D' | 'd' ) ( 'E' | 'e' ) ( 'L' | 'l' ) ( 'E' | 'e' ) ( 'T' | 't' ) ( 'E' | 'e' ) ; + +oC_Remove + : REMOVE SP oC_RemoveItem ( SP? ',' SP? oC_RemoveItem )* ; + +REMOVE : ( 'R' | 'r' ) ( 'E' | 'e' ) ( 'M' | 'm' ) ( 'O' | 'o' ) ( 'V' | 'v' ) ( 'E' | 'e' ) ; + +oC_RemoveItem + : ( oC_Variable oC_NodeLabels ) + | oC_PropertyExpression + ; + +oC_Foreach + : FOREACH SP? '(' SP? oC_Variable SP IN SP oC_Expression SP? '|' ( SP oC_UpdatingClause )+ SP? ')' ; + +FOREACH : ( 'F' | 'f' ) ( 'O' | 'o' ) ( 'R' | 'r' ) ( 'E' | 'e' ) ( 'A' | 'a' ) ( 'C' | 'c' ) ( 'H' | 'h' ) ; + +IN : ( 'I' | 'i' ) ( 'N' | 'n' ) ; + +oC_InQueryCall + : CALL SP oC_ExplicitProcedureInvocation ( SP? YIELD SP oC_YieldItems )? ; + +CALL : ( 'C' | 'c' ) ( 'A' | 'a' ) ( 'L' | 'l' ) ( 'L' | 'l' ) ; + +YIELD : ( 'Y' | 'y' ) ( 'I' | 'i' ) ( 'E' | 'e' ) ( 'L' | 'l' ) ( 'D' | 'd' ) ; + +oC_StandaloneCall + : CALL SP ( oC_ExplicitProcedureInvocation | oC_ImplicitProcedureInvocation ) ( SP? YIELD SP ( '*' | oC_YieldItems ) )? ; + +oC_YieldItems + : oC_YieldItem ( SP? ',' SP? oC_YieldItem )* ( SP? oC_Where )? ; + +oC_YieldItem + : ( oC_ProcedureResultField SP AS SP )? oC_Variable ; + +oC_With + : WITH oC_ProjectionBody ( SP? oC_Where )? ; + +oC_Return + : RETURN oC_ProjectionBody ; + +RETURN : ( 'R' | 'r' ) ( 'E' | 'e' ) ( 'T' | 't' ) ( 'U' | 'u' ) ( 'R' | 'r' ) ( 'N' | 'n' ) ; + +oC_ProjectionBody + : ( SP? DISTINCT )? SP oC_ProjectionItems ( SP oC_Order )? ( SP oC_Skip )? ( SP oC_Limit )? ; + +DISTINCT : ( 'D' | 'd' ) ( 'I' | 'i' ) ( 'S' | 's' ) ( 'T' | 't' ) ( 'I' | 'i' ) ( 'N' | 'n' ) ( 'C' | 'c' ) ( 'T' | 't' ) ; + +oC_ProjectionItems + : ( '*' ( SP? ',' SP? oC_ProjectionItem )* ) + | ( oC_ProjectionItem ( SP? ',' SP? oC_ProjectionItem )* ) + ; + +oC_ProjectionItem + : ( oC_Expression SP AS SP oC_Variable ) + | oC_Expression + ; + +oC_Order + : ORDER SP BY SP oC_SortItem ( ',' SP? oC_SortItem )* ; + +ORDER : ( 'O' | 'o' ) ( 'R' | 'r' ) ( 'D' | 'd' ) ( 'E' | 'e' ) ( 'R' | 'r' ) ; + +BY : ( 'B' | 'b' ) ( 'Y' | 'y' ) ; + +oC_Skip + : L_SKIP SP oC_Expression ; + +L_SKIP : ( 'S' | 's' ) ( 'K' | 'k' ) ( 'I' | 'i' ) ( 'P' | 'p' ) ; + +oC_Limit + : LIMIT SP oC_Expression ; + +LIMIT : ( 'L' | 'l' ) ( 'I' | 'i' ) ( 'M' | 'm' ) ( 'I' | 'i' ) ( 'T' | 't' ) ; + +oC_SortItem + : oC_Expression ( SP? ( ASCENDING | ASC | DESCENDING | DESC ) )? ; + +ASCENDING : ( 'A' | 'a' ) ( 'S' | 's' ) ( 'C' | 'c' ) ( 'E' | 'e' ) ( 'N' | 'n' ) ( 'D' | 'd' ) ( 'I' | 'i' ) ( 'N' | 'n' ) ( 'G' | 'g' ) ; + +ASC : ( 'A' | 'a' ) ( 'S' | 's' ) ( 'C' | 'c' ) ; + +DESCENDING : ( 'D' | 'd' ) ( 'E' | 'e' ) ( 'S' | 's' ) ( 'C' | 'c' ) ( 'E' | 'e' ) ( 'N' | 'n' ) ( 'D' | 'd' ) ( 'I' | 'i' ) ( 'N' | 'n' ) ( 'G' | 'g' ) ; + +DESC : ( 'D' | 'd' ) ( 'E' | 'e' ) ( 'S' | 's' ) ( 'C' | 'c' ) ; + +oC_Hint + : SP? ( ( USING SP INDEX SP oC_Variable oC_NodeLabel '(' oC_PropertyKeyName ')' ) | ( USING SP JOIN SP ON SP oC_Variable ( SP? ',' SP? oC_Variable )* ) | ( USING SP SCAN SP oC_Variable oC_NodeLabel ) ) ; + +JOIN : ( 'J' | 'j' ) ( 'O' | 'o' ) ( 'I' | 'i' ) ( 'N' | 'n' ) ; + +SCAN : ( 'S' | 's' ) ( 'C' | 'c' ) ( 'A' | 'a' ) ( 'N' | 'n' ) ; + +oC_Start + : START SP oC_StartPoint ( SP? ',' SP? oC_StartPoint )* oC_Where? ; + +START : ( 'S' | 's' ) ( 'T' | 't' ) ( 'A' | 'a' ) ( 'R' | 'r' ) ( 'T' | 't' ) ; + +oC_StartPoint + : oC_Variable SP? '=' SP? oC_Lookup ; + +oC_Lookup + : oC_NodeLookup + | oC_RelationshipLookup + ; + +oC_NodeLookup + : NODE SP? ( oC_IdentifiedIndexLookup | oC_IndexQuery | oC_IdLookup ) ; + +NODE : ( 'N' | 'n' ) ( 'O' | 'o' ) ( 'D' | 'd' ) ( 'E' | 'e' ) ; + +oC_RelationshipLookup + : ( RELATIONSHIP | REL ) ( oC_IdentifiedIndexLookup | oC_IndexQuery | oC_IdLookup ) ; + +RELATIONSHIP : ( 'R' | 'r' ) ( 'E' | 'e' ) ( 'L' | 'l' ) ( 'A' | 'a' ) ( 'T' | 't' ) ( 'I' | 'i' ) ( 'O' | 'o' ) ( 'N' | 'n' ) ( 'S' | 's' ) ( 'H' | 'h' ) ( 'I' | 'i' ) ( 'P' | 'p' ) ; + +REL : ( 'R' | 'r' ) ( 'E' | 'e' ) ( 'L' | 'l' ) ; + +oC_IdentifiedIndexLookup + : ':' oC_SymbolicName '(' oC_SymbolicName '=' ( StringLiteral | oC_LegacyParameter ) ')' ; + +oC_IndexQuery + : ':' oC_SymbolicName '(' ( StringLiteral | oC_LegacyParameter ) ')' ; + +oC_IdLookup + : '(' ( oC_LiteralIds | oC_LegacyParameter | '*' ) ')' ; + +oC_LiteralIds + : oC_IntegerLiteral ( SP? ',' SP? oC_IntegerLiteral )* ; + +oC_Where + : WHERE SP oC_Expression ; + +WHERE : ( 'W' | 'w' ) ( 'H' | 'h' ) ( 'E' | 'e' ) ( 'R' | 'r' ) ( 'E' | 'e' ) ; + +oC_Pattern + : oC_PatternPart ( SP? ',' SP? oC_PatternPart )* ; + +oC_PatternPart + : ( oC_Variable SP? '=' SP? oC_AnonymousPatternPart ) + | oC_AnonymousPatternPart + ; + +oC_AnonymousPatternPart + : oC_ShortestPathPattern + | oC_PatternElement + ; + +oC_ShortestPathPattern + : ( SHORTESTPATH '(' oC_PatternElement ')' ) + | ( ALLSHORTESTPATHS '(' oC_PatternElement ')' ) + ; + +SHORTESTPATH : ( 'S' | 's' ) ( 'H' | 'h' ) ( 'O' | 'o' ) ( 'R' | 'r' ) ( 'T' | 't' ) ( 'E' | 'e' ) ( 'S' | 's' ) ( 'T' | 't' ) ( 'P' | 'p' ) ( 'A' | 'a' ) ( 'T' | 't' ) ( 'H' | 'h' ) ; + +ALLSHORTESTPATHS : ( 'A' | 'a' ) ( 'L' | 'l' ) ( 'L' | 'l' ) ( 'S' | 's' ) ( 'H' | 'h' ) ( 'O' | 'o' ) ( 'R' | 'r' ) ( 'T' | 't' ) ( 'E' | 'e' ) ( 'S' | 's' ) ( 'T' | 't' ) ( 'P' | 'p' ) ( 'A' | 'a' ) ( 'T' | 't' ) ( 'H' | 'h' ) ( 'S' | 's' ) ; + +oC_PatternElement + : ( oC_NodePattern ( SP? oC_PatternElementChain )* ) + | ( '(' oC_PatternElement ')' ) + ; + +oC_RelationshipsPattern + : oC_NodePattern ( SP? oC_PatternElementChain )+ ; + +oC_NodePattern + : '(' SP? ( oC_Variable SP? )? ( oC_NodeLabels SP? )? ( oC_Properties SP? )? ')' ; + +oC_PatternElementChain + : oC_RelationshipPattern SP? oC_NodePattern ; + +oC_RelationshipPattern + : ( oC_LeftArrowHead SP? oC_Dash SP? oC_RelationshipDetail? SP? oC_Dash SP? oC_RightArrowHead ) + | ( oC_LeftArrowHead SP? oC_Dash SP? oC_RelationshipDetail? SP? oC_Dash ) + | ( oC_Dash SP? oC_RelationshipDetail? SP? oC_Dash SP? oC_RightArrowHead ) + | ( oC_Dash SP? oC_RelationshipDetail? SP? oC_Dash ) + ; + +oC_RelationshipDetail + : '[' SP? ( oC_Variable SP? )? ( oC_RelationshipTypes SP? )? oC_RangeLiteral? ( oC_Properties SP? )? ']' ; + +oC_Properties + : oC_MapLiteral + | oC_Parameter + | oC_LegacyParameter + ; + +oC_RelType + : ':' SP? oC_RelTypeName ; + +oC_RelationshipTypes + : ':' SP? oC_RelTypeName ( SP? '|' ':'? SP? oC_RelTypeName )* ; + +oC_NodeLabels + : oC_NodeLabel ( SP? oC_NodeLabel )* ; + +oC_NodeLabel + : ':' SP? oC_LabelName ; + +oC_RangeLiteral + : '*' SP? ( oC_IntegerLiteral SP? )? ( '..' SP? ( oC_IntegerLiteral SP? )? )? ; + +oC_LabelName + : oC_SchemaName ; + +oC_RelTypeName + : oC_SchemaName ; + +oC_PropertyExpression + : oC_Atom ( SP? oC_PropertyLookup )+ ; + +oC_Expression + : oC_OrExpression ; + +oC_OrExpression + : oC_XorExpression ( SP OR SP oC_XorExpression )* ; + +OR : ( 'O' | 'o' ) ( 'R' | 'r' ) ; + +oC_XorExpression + : oC_AndExpression ( SP XOR SP oC_AndExpression )* ; + +XOR : ( 'X' | 'x' ) ( 'O' | 'o' ) ( 'R' | 'r' ) ; + +oC_AndExpression + : oC_NotExpression ( SP AND SP oC_NotExpression )* ; + +AND : ( 'A' | 'a' ) ( 'N' | 'n' ) ( 'D' | 'd' ) ; + +oC_NotExpression + : ( NOT SP? )* oC_ComparisonExpression ; + +NOT : ( 'N' | 'n' ) ( 'O' | 'o' ) ( 'T' | 't' ) ; + +oC_ComparisonExpression + : oC_StringListNullPredicateExpression ( SP? oC_PartialComparisonExpression )* ; + +oC_PartialComparisonExpression + : ( '=' SP? oC_StringListNullPredicateExpression ) + | ( '<>' SP? oC_StringListNullPredicateExpression ) + | ( '<' SP? oC_StringListNullPredicateExpression ) + | ( '>' SP? oC_StringListNullPredicateExpression ) + | ( '<=' SP? oC_StringListNullPredicateExpression ) + | ( '>=' SP? oC_StringListNullPredicateExpression ) + ; + +oC_StringListNullPredicateExpression + : oC_AddOrSubtractExpression ( oC_StringPredicateExpression | oC_ListPredicateExpression | oC_NullPredicateExpression )* ; + +oC_StringPredicateExpression + : ( oC_RegularExpression | ( SP STARTS SP WITH ) | ( SP ENDS SP WITH ) | ( SP CONTAINS ) ) SP? oC_AddOrSubtractExpression ; + +STARTS : ( 'S' | 's' ) ( 'T' | 't' ) ( 'A' | 'a' ) ( 'R' | 'r' ) ( 'T' | 't' ) ( 'S' | 's' ) ; + +ENDS : ( 'E' | 'e' ) ( 'N' | 'n' ) ( 'D' | 'd' ) ( 'S' | 's' ) ; + +CONTAINS : ( 'C' | 'c' ) ( 'O' | 'o' ) ( 'N' | 'n' ) ( 'T' | 't' ) ( 'A' | 'a' ) ( 'I' | 'i' ) ( 'N' | 'n' ) ( 'S' | 's' ) ; + +oC_ListPredicateExpression + : SP IN SP? oC_AddOrSubtractExpression ; + +oC_NullPredicateExpression + : ( SP IS SP NULL ) + | ( SP IS SP NOT SP NULL ) + ; + +NULL : ( 'N' | 'n' ) ( 'U' | 'u' ) ( 'L' | 'l' ) ( 'L' | 'l' ) ; + +oC_RegularExpression + : SP? '=~' ; + +oC_AddOrSubtractExpression + : oC_MultiplyDivideModuloExpression ( ( SP? '+' SP? oC_MultiplyDivideModuloExpression ) | ( SP? '-' SP? oC_MultiplyDivideModuloExpression ) )* ; + +oC_MultiplyDivideModuloExpression + : oC_PowerOfExpression ( ( SP? '*' SP? oC_PowerOfExpression ) | ( SP? '/' SP? oC_PowerOfExpression ) | ( SP? '%' SP? oC_PowerOfExpression ) )* ; + +oC_PowerOfExpression + : oC_UnaryAddOrSubtractExpression ( SP? '^' SP? oC_UnaryAddOrSubtractExpression )* ; + +oC_UnaryAddOrSubtractExpression + : oC_NonArithmeticOperatorExpression + | ( ( '+' | '-' ) SP? oC_NonArithmeticOperatorExpression ) + ; + +oC_NonArithmeticOperatorExpression + : oC_Atom ( ( SP? oC_ListOperatorExpression ) | ( SP? oC_PropertyLookup ) )* ( SP? oC_NodeLabels )? ; + +oC_ListOperatorExpression + : ( '[' oC_Expression ']' ) + | ( '[' oC_Expression? '..' oC_Expression? ']' ) + ; + +oC_PropertyLookup + : '.' SP? ( oC_PropertyKeyName ) ; + +oC_Atom + : oC_Literal + | oC_Parameter + | oC_LegacyParameter + | oC_CaseExpression + | ( COUNT SP? '(' SP? '*' SP? ')' ) + | oC_ListComprehension + | oC_PatternComprehension + | oC_LegacyListExpression + | oC_Reduce + | oC_Quantifier + | oC_ShortestPathPattern + | oC_PatternPredicate + | oC_ParenthesizedExpression + | oC_FunctionInvocation + | oC_ExistentialSubquery + | oC_Variable + ; + +COUNT : ( 'C' | 'c' ) ( 'O' | 'o' ) ( 'U' | 'u' ) ( 'N' | 'n' ) ( 'T' | 't' ) ; + +oC_CaseExpression + : ( ( CASE ( SP? oC_CaseAlternative )+ ) | ( CASE SP? oC_Expression ( SP? oC_CaseAlternative )+ ) ) ( SP? ELSE SP? oC_Expression )? SP? END ; + +CASE : ( 'C' | 'c' ) ( 'A' | 'a' ) ( 'S' | 's' ) ( 'E' | 'e' ) ; + +ELSE : ( 'E' | 'e' ) ( 'L' | 'l' ) ( 'S' | 's' ) ( 'E' | 'e' ) ; + +END : ( 'E' | 'e' ) ( 'N' | 'n' ) ( 'D' | 'd' ) ; + +oC_CaseAlternative + : WHEN SP? oC_Expression SP? THEN SP? oC_Expression ; + +WHEN : ( 'W' | 'w' ) ( 'H' | 'h' ) ( 'E' | 'e' ) ( 'N' | 'n' ) ; + +THEN : ( 'T' | 't' ) ( 'H' | 'h' ) ( 'E' | 'e' ) ( 'N' | 'n' ) ; + +oC_ListComprehension + : '[' SP? oC_FilterExpression ( SP? '|' SP? oC_Expression )? SP? ']' ; + +oC_PatternComprehension + : '[' SP? ( oC_Variable SP? '=' SP? )? oC_RelationshipsPattern SP? ( oC_Where SP? )? '|' SP? oC_Expression SP? ']' ; + +oC_LegacyListExpression + : ( FILTER SP? '(' SP? oC_FilterExpression SP? ')' ) + | ( EXTRACT SP? '(' SP? oC_FilterExpression SP? ( SP? '|' oC_Expression )? ')' ) + ; + +FILTER : ( 'F' | 'f' ) ( 'I' | 'i' ) ( 'L' | 'l' ) ( 'T' | 't' ) ( 'E' | 'e' ) ( 'R' | 'r' ) ; + +EXTRACT : ( 'E' | 'e' ) ( 'X' | 'x' ) ( 'T' | 't' ) ( 'R' | 'r' ) ( 'A' | 'a' ) ( 'C' | 'c' ) ( 'T' | 't' ) ; + +oC_Reduce + : REDUCE SP? '(' oC_Variable '=' oC_Expression ',' oC_IdInColl '|' oC_Expression ')' ; + +REDUCE : ( 'R' | 'r' ) ( 'E' | 'e' ) ( 'D' | 'd' ) ( 'U' | 'u' ) ( 'C' | 'c' ) ( 'E' | 'e' ) ; + +oC_Quantifier + : ( ALL SP? '(' SP? oC_FilterExpression SP? ')' ) + | ( ANY SP? '(' SP? oC_FilterExpression SP? ')' ) + | ( NONE SP? '(' SP? oC_FilterExpression SP? ')' ) + | ( SINGLE SP? '(' SP? oC_FilterExpression SP? ')' ) + ; + +ANY : ( 'A' | 'a' ) ( 'N' | 'n' ) ( 'Y' | 'y' ) ; + +NONE : ( 'N' | 'n' ) ( 'O' | 'o' ) ( 'N' | 'n' ) ( 'E' | 'e' ) ; + +SINGLE : ( 'S' | 's' ) ( 'I' | 'i' ) ( 'N' | 'n' ) ( 'G' | 'g' ) ( 'L' | 'l' ) ( 'E' | 'e' ) ; + +oC_FilterExpression + : oC_IdInColl ( SP? oC_Where )? ; + +oC_PatternPredicate + : oC_RelationshipsPattern ; + +oC_ParenthesizedExpression + : '(' SP? oC_Expression SP? ')' ; + +oC_IdInColl + : oC_Variable SP IN SP oC_Expression ; + +oC_FunctionInvocation + : oC_FunctionName SP? '(' SP? ( DISTINCT SP? )? ( oC_Expression SP? ( ',' SP? oC_Expression SP? )* )? ')' ; + +oC_FunctionName + : oC_Namespace oC_SymbolicName ; + +oC_ExistentialSubquery + : EXISTS SP? '{' SP? ( oC_RegularQuery | ( oC_Pattern ( SP? oC_Where )? ) ) SP? '}' ; + +oC_ExplicitProcedureInvocation + : oC_ProcedureName SP? '(' SP? ( oC_Expression SP? ( ',' SP? oC_Expression SP? )* )? ')' ; + +oC_ImplicitProcedureInvocation + : oC_ProcedureName ; + +oC_ProcedureResultField + : oC_SymbolicName ; + +oC_ProcedureName + : oC_Namespace oC_SymbolicName ; + +oC_Namespace + : ( oC_SymbolicName '.' )* ; + +oC_Variable + : oC_SymbolicName ; + +oC_Literal + : oC_BooleanLiteral + | NULL + | oC_NumberLiteral + | StringLiteral + | oC_ListLiteral + | oC_MapLiteral + ; + +oC_BooleanLiteral + : TRUE + | FALSE + ; + +TRUE : ( 'T' | 't' ) ( 'R' | 'r' ) ( 'U' | 'u' ) ( 'E' | 'e' ) ; + +FALSE : ( 'F' | 'f' ) ( 'A' | 'a' ) ( 'L' | 'l' ) ( 'S' | 's' ) ( 'E' | 'e' ) ; + +oC_NumberLiteral + : oC_DoubleLiteral + | oC_IntegerLiteral + ; + +oC_IntegerLiteral + : HexInteger + | OctalInteger + | DecimalInteger + ; + +HexInteger + : '0x' ( HexDigit )+ ; + +DecimalInteger + : ZeroDigit + | ( NonZeroDigit ( Digit )* ) + ; + +OctalInteger + : '0o' ( OctDigit )+ ; + +HexLetter + : ( ( 'A' | 'a' ) ) + | ( ( 'B' | 'b' ) ) + | ( ( 'C' | 'c' ) ) + | ( ( 'D' | 'd' ) ) + | ( ( 'E' | 'e' ) ) + | ( ( 'F' | 'f' ) ) + ; + +HexDigit + : Digit + | HexLetter + ; + +Digit + : ZeroDigit + | NonZeroDigit + ; + +NonZeroDigit + : NonZeroOctDigit + | '8' + | '9' + ; + +NonZeroOctDigit + : '1' + | '2' + | '3' + | '4' + | '5' + | '6' + | '7' + ; + +OctDigit + : ZeroDigit + | NonZeroOctDigit + ; + +ZeroDigit + : '0' ; + +oC_DoubleLiteral + : ExponentDecimalReal + | RegularDecimalReal + ; + +ExponentDecimalReal + : ( ( Digit )+ | ( ( Digit )+ '.' ( Digit )+ ) | ( '.' ( Digit )+ ) ) ( ( 'E' | 'e' ) ) '-'? ( Digit )+ ; + +RegularDecimalReal + : ( Digit )* '.' ( Digit )+ ; + +StringLiteral + : ( '"' ( StringLiteral_0 | EscapedChar )* '"' ) + | ( '\'' ( StringLiteral_1 | EscapedChar )* '\'' ) + ; + +EscapedChar + : '\\' ( '\\' | '\'' | '"' | ( ( 'B' | 'b' ) ) | ( ( 'F' | 'f' ) ) | ( ( 'N' | 'n' ) ) | ( ( 'R' | 'r' ) ) | ( ( 'T' | 't' ) ) | ( ( ( 'U' | 'u' ) ) ( HexDigit HexDigit HexDigit HexDigit ) ) | ( ( ( 'U' | 'u' ) ) ( HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit HexDigit ) ) ) ; + +oC_ListLiteral + : '[' SP? ( oC_Expression SP? ( ',' SP? oC_Expression SP? )* )? ']' ; + +oC_MapLiteral + : '{' SP? ( oC_PropertyKeyName SP? ':' SP? oC_Expression SP? ( ',' SP? oC_PropertyKeyName SP? ':' SP? oC_Expression SP? )* )? '}' ; + +oC_PropertyKeyName + : oC_SchemaName ; + +oC_LegacyParameter + : '{' SP? ( oC_SymbolicName | DecimalInteger ) SP? '}' ; + +oC_Parameter + : '$' ( oC_SymbolicName | DecimalInteger ) ; + +oC_SchemaName + : oC_SymbolicName + | oC_ReservedWord + ; + +oC_ReservedWord + : ALL + | ASC + | ASCENDING + | BY + | CREATE + | DELETE + | DESC + | DESCENDING + | DETACH + | EXISTS + | LIMIT + | MATCH + | MERGE + | ON + | OPTIONAL + | ORDER + | REMOVE + | RETURN + | SET + | L_SKIP + | WHERE + | WITH + | UNION + | UNWIND + | AND + | AS + | CONTAINS + | DISTINCT + | ENDS + | IN + | IS + | NOT + | OR + | STARTS + | XOR + | FALSE + | TRUE + | NULL + | CONSTRAINT + | DO + | FOR + | REQUIRE + | UNIQUE + | CASE + | WHEN + | THEN + | ELSE + | END + | MANDATORY + | SCALAR + | OF + | ADD + | DROP + ; + +DO : ( 'D' | 'd' ) ( 'O' | 'o' ) ; + +FOR : ( 'F' | 'f' ) ( 'O' | 'o' ) ( 'R' | 'r' ) ; + +REQUIRE : ( 'R' | 'r' ) ( 'E' | 'e' ) ( 'Q' | 'q' ) ( 'U' | 'u' ) ( 'I' | 'i' ) ( 'R' | 'r' ) ( 'E' | 'e' ) ; + +MANDATORY : ( 'M' | 'm' ) ( 'A' | 'a' ) ( 'N' | 'n' ) ( 'D' | 'd' ) ( 'A' | 'a' ) ( 'T' | 't' ) ( 'O' | 'o' ) ( 'R' | 'r' ) ( 'Y' | 'y' ) ; + +SCALAR : ( 'S' | 's' ) ( 'C' | 'c' ) ( 'A' | 'a' ) ( 'L' | 'l' ) ( 'A' | 'a' ) ( 'R' | 'r' ) ; + +OF : ( 'O' | 'o' ) ( 'F' | 'f' ) ; + +ADD : ( 'A' | 'a' ) ( 'D' | 'd' ) ( 'D' | 'd' ) ; + +oC_SymbolicName + : UnescapedSymbolicName + | EscapedSymbolicName + | HexLetter + | COUNT + | FILTER + | EXTRACT + | ANY + | NONE + | SINGLE + ; + +UnescapedSymbolicName + : IdentifierStart ( IdentifierPart )* ; + +/** + * Based on the unicode identifier and pattern syntax + * (http://www.unicode.org/reports/tr31/) + * And extended with a few characters. + */ +IdentifierStart + : ID_Start + | Pc + ; + +/** + * Based on the unicode identifier and pattern syntax + * (http://www.unicode.org/reports/tr31/) + * And extended with a few characters. + */ +IdentifierPart + : ID_Continue + | Sc + ; + +/** + * Any character except "`", enclosed within `backticks`. Backticks are escaped with double backticks. + */ +EscapedSymbolicName + : ( '`' ( EscapedSymbolicName_0 )* '`' )+ ; + +SP + : ( WHITESPACE )+ ; + +WHITESPACE + : SPACE + | TAB + | LF + | VT + | FF + | CR + | FS + | GS + | RS + | US + | '\u1680' + | '\u180e' + | '\u2000' + | '\u2001' + | '\u2002' + | '\u2003' + | '\u2004' + | '\u2005' + | '\u2006' + | '\u2008' + | '\u2009' + | '\u200a' + | '\u2028' + | '\u2029' + | '\u205f' + | '\u3000' + | '\u00a0' + | '\u2007' + | '\u202f' + | Comment + ; + +Comment + : ( '/*' ( Comment_1 | ( '*' Comment_2 ) )* '*/' ) + | ( '//' ( Comment_3 )* CR? ( LF | EOF ) ) + ; + +oC_LeftArrowHead + : '<' + | '\u27e8' + | '\u3008' + | '\ufe64' + | '\uff1c' + ; + +oC_RightArrowHead + : '>' + | '\u27e9' + | '\u3009' + | '\ufe65' + | '\uff1e' + ; + +oC_Dash + : '-' + | '\u00ad' + | '\u2010' + | '\u2011' + | '\u2012' + | '\u2013' + | '\u2014' + | '\u2015' + | '\u2212' + | '\ufe58' + | '\ufe63' + | '\uff0d' + ; + +fragment FF : [\f] ; + +fragment EscapedSymbolicName_0 : ~[`] ; + +fragment RS : [\u001E] ; + +fragment ID_Continue : [\p{ID_Continue}] ; + +fragment Comment_1 : ~[*] ; + +fragment StringLiteral_1 : ~['\\] ; + +fragment Comment_3 : ~[\n\r] ; + +fragment Comment_2 : ~[/] ; + +fragment GS : [\u001D] ; + +fragment FS : [\u001C] ; + +fragment CR : [\r] ; + +fragment Sc : [\p{Sc}] ; + +fragment SPACE : [ ] ; + +fragment Pc : [\p{Pc}] ; + +fragment TAB : [\t] ; + +fragment StringLiteral_0 : ~["\\] ; + +fragment LF : [\n] ; + +fragment VT : [\u000B] ; + +fragment US : [\u001F] ; + +fragment ID_Start : [\p{ID_Start}] ; diff --git a/tests/grammar/cypher/Cypher.interp b/tests/grammar/cypher/Cypher.interp new file mode 100644 index 0000000..1b99456 --- /dev/null +++ b/tests/grammar/cypher/Cypher.interp @@ -0,0 +1,459 @@ +token literal names: +null +';' +'=' +'(' +')' +'[' +']' +',' +'+=' +'|' +'*' +':' +'..' +'<>' +'<' +'>' +'<=' +'>=' +'=~' +'+' +'-' +'/' +'%' +'^' +'.' +'{' +'}' +'$' +'\u27e8' +'\u3008' +'\ufe64' +'\uff1c' +'\u27e9' +'\u3009' +'\ufe65' +'\uff1e' +'\u00ad' +'\u2010' +'\u2011' +'\u2012' +'\u2013' +'\u2014' +'\u2015' +'\u2212' +'\ufe58' +'\ufe63' +'\uff0d' +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 +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 +'0' +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +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 +null +null +null +CYPHER +EXPLAIN +PROFILE +USING +PERIODIC +COMMIT +UNION +ALL +CREATE +DROP +INDEX +ON +CONSTRAINT +ASSERT +IS +UNIQUE +EXISTS +LOAD +CSV +WITH +HEADERS +FROM +AS +FIELDTERMINATOR +OPTIONAL +MATCH +UNWIND +MERGE +SET +DETACH +DELETE +REMOVE +FOREACH +IN +CALL +YIELD +RETURN +DISTINCT +ORDER +BY +L_SKIP +LIMIT +ASCENDING +ASC +DESCENDING +DESC +JOIN +SCAN +START +NODE +RELATIONSHIP +REL +WHERE +SHORTESTPATH +ALLSHORTESTPATHS +OR +XOR +AND +NOT +STARTS +ENDS +CONTAINS +NULL +COUNT +CASE +ELSE +END +WHEN +THEN +FILTER +EXTRACT +REDUCE +ANY +NONE +SINGLE +TRUE +FALSE +HexInteger +DecimalInteger +OctalInteger +HexLetter +HexDigit +Digit +NonZeroDigit +NonZeroOctDigit +OctDigit +ZeroDigit +ExponentDecimalReal +RegularDecimalReal +StringLiteral +EscapedChar +DO +FOR +REQUIRE +MANDATORY +SCALAR +OF +ADD +UnescapedSymbolicName +IdentifierStart +IdentifierPart +EscapedSymbolicName +SP +WHITESPACE +Comment + +rule names: +oC_Cypher +oC_QueryOptions +oC_AnyCypherOption +oC_CypherOption +oC_VersionNumber +oC_Explain +oC_Profile +oC_ConfigurationOption +oC_Statement +oC_Query +oC_RegularQuery +oC_BulkImportQuery +oC_PeriodicCommitHint +oC_LoadCSVQuery +oC_Union +oC_SingleQuery +oC_SinglePartQuery +oC_MultiPartQuery +oC_UpdatingClause +oC_ReadingClause +oC_Command +oC_CreateUniqueConstraint +oC_CreateNodePropertyExistenceConstraint +oC_CreateRelationshipPropertyExistenceConstraint +oC_CreateIndex +oC_DropUniqueConstraint +oC_DropNodePropertyExistenceConstraint +oC_DropRelationshipPropertyExistenceConstraint +oC_DropIndex +oC_Index +oC_UniqueConstraint +oC_NodePropertyExistenceConstraint +oC_RelationshipPropertyExistenceConstraint +oC_RelationshipPatternSyntax +oC_LoadCSV +oC_Match +oC_Unwind +oC_Merge +oC_MergeAction +oC_Create +oC_CreateUnique +oC_Set +oC_SetItem +oC_Delete +oC_Remove +oC_RemoveItem +oC_Foreach +oC_InQueryCall +oC_StandaloneCall +oC_YieldItems +oC_YieldItem +oC_With +oC_Return +oC_ProjectionBody +oC_ProjectionItems +oC_ProjectionItem +oC_Order +oC_Skip +oC_Limit +oC_SortItem +oC_Hint +oC_Start +oC_StartPoint +oC_Lookup +oC_NodeLookup +oC_RelationshipLookup +oC_IdentifiedIndexLookup +oC_IndexQuery +oC_IdLookup +oC_LiteralIds +oC_Where +oC_Pattern +oC_PatternPart +oC_AnonymousPatternPart +oC_ShortestPathPattern +oC_PatternElement +oC_RelationshipsPattern +oC_NodePattern +oC_PatternElementChain +oC_RelationshipPattern +oC_RelationshipDetail +oC_Properties +oC_RelType +oC_RelationshipTypes +oC_NodeLabels +oC_NodeLabel +oC_RangeLiteral +oC_LabelName +oC_RelTypeName +oC_PropertyExpression +oC_Expression +oC_OrExpression +oC_XorExpression +oC_AndExpression +oC_NotExpression +oC_ComparisonExpression +oC_PartialComparisonExpression +oC_StringListNullPredicateExpression +oC_StringPredicateExpression +oC_ListPredicateExpression +oC_NullPredicateExpression +oC_RegularExpression +oC_AddOrSubtractExpression +oC_MultiplyDivideModuloExpression +oC_PowerOfExpression +oC_UnaryAddOrSubtractExpression +oC_NonArithmeticOperatorExpression +oC_ListOperatorExpression +oC_PropertyLookup +oC_Atom +oC_CaseExpression +oC_CaseAlternative +oC_ListComprehension +oC_PatternComprehension +oC_LegacyListExpression +oC_Reduce +oC_Quantifier +oC_FilterExpression +oC_PatternPredicate +oC_ParenthesizedExpression +oC_IdInColl +oC_FunctionInvocation +oC_FunctionName +oC_ExistentialSubquery +oC_ExplicitProcedureInvocation +oC_ImplicitProcedureInvocation +oC_ProcedureResultField +oC_ProcedureName +oC_Namespace +oC_Variable +oC_Literal +oC_BooleanLiteral +oC_NumberLiteral +oC_IntegerLiteral +oC_DoubleLiteral +oC_ListLiteral +oC_MapLiteral +oC_PropertyKeyName +oC_LegacyParameter +oC_Parameter +oC_SchemaName +oC_ReservedWord +oC_SymbolicName +oC_LeftArrowHead +oC_RightArrowHead +oC_Dash + + +atn: +[4, 1, 151, 2193, 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, 1, 0, 3, 0, 294, 8, 0, 1, 0, 1, 0, 1, 0, 3, 0, 299, 8, 0, 1, 0, 3, 0, 302, 8, 0, 1, 0, 3, 0, 305, 8, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 311, 8, 1, 5, 1, 313, 8, 1, 10, 1, 12, 1, 316, 9, 1, 1, 2, 1, 2, 1, 2, 3, 2, 321, 8, 2, 1, 3, 1, 3, 1, 3, 3, 3, 326, 8, 3, 1, 3, 1, 3, 5, 3, 330, 8, 3, 10, 3, 12, 3, 333, 9, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 3, 7, 343, 8, 7, 1, 7, 1, 7, 3, 7, 347, 8, 7, 1, 7, 1, 7, 1, 8, 1, 8, 3, 8, 353, 8, 8, 1, 9, 1, 9, 1, 9, 3, 9, 358, 8, 9, 1, 10, 1, 10, 3, 10, 362, 8, 10, 1, 10, 5, 10, 365, 8, 10, 10, 10, 12, 10, 368, 9, 10, 1, 11, 1, 11, 3, 11, 372, 8, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 383, 8, 12, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 392, 8, 14, 1, 14, 1, 14, 1, 14, 3, 14, 397, 8, 14, 1, 14, 3, 14, 400, 8, 14, 1, 15, 1, 15, 3, 15, 404, 8, 15, 1, 16, 1, 16, 3, 16, 408, 8, 16, 5, 16, 410, 8, 16, 10, 16, 12, 16, 413, 9, 16, 1, 16, 1, 16, 1, 16, 3, 16, 418, 8, 16, 5, 16, 420, 8, 16, 10, 16, 12, 16, 423, 9, 16, 1, 16, 1, 16, 3, 16, 427, 8, 16, 1, 16, 5, 16, 430, 8, 16, 10, 16, 12, 16, 433, 9, 16, 1, 16, 3, 16, 436, 8, 16, 1, 16, 3, 16, 439, 8, 16, 3, 16, 441, 8, 16, 1, 17, 1, 17, 3, 17, 445, 8, 17, 5, 17, 447, 8, 17, 10, 17, 12, 17, 450, 9, 17, 1, 17, 1, 17, 3, 17, 454, 8, 17, 5, 17, 456, 8, 17, 10, 17, 12, 17, 459, 9, 17, 1, 17, 1, 17, 3, 17, 463, 8, 17, 4, 17, 465, 8, 17, 11, 17, 12, 17, 466, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 478, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 485, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 495, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 3, 29, 533, 8, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 3, 30, 544, 8, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 3, 30, 551, 8, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 565, 8, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 572, 8, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 578, 8, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 588, 8, 32, 1, 32, 1, 32, 3, 32, 592, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 598, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 3, 33, 606, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 617, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 623, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 635, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 641, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 653, 8, 33, 1, 33, 1, 33, 3, 33, 657, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 667, 8, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 680, 8, 34, 1, 35, 1, 35, 3, 35, 684, 8, 35, 1, 35, 1, 35, 3, 35, 688, 8, 35, 1, 35, 1, 35, 5, 35, 692, 8, 35, 10, 35, 12, 35, 695, 9, 35, 1, 35, 3, 35, 698, 8, 35, 1, 35, 3, 35, 701, 8, 35, 1, 36, 1, 36, 3, 36, 705, 8, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 3, 37, 715, 8, 37, 1, 37, 1, 37, 1, 37, 5, 37, 720, 8, 37, 10, 37, 12, 37, 723, 9, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 735, 8, 38, 1, 39, 1, 39, 3, 39, 739, 8, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 747, 8, 40, 1, 40, 1, 40, 1, 41, 1, 41, 3, 41, 753, 8, 41, 1, 41, 1, 41, 3, 41, 757, 8, 41, 1, 41, 1, 41, 3, 41, 761, 8, 41, 1, 41, 5, 41, 764, 8, 41, 10, 41, 12, 41, 767, 9, 41, 1, 42, 1, 42, 3, 42, 771, 8, 42, 1, 42, 1, 42, 3, 42, 775, 8, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 781, 8, 42, 1, 42, 1, 42, 3, 42, 785, 8, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 791, 8, 42, 1, 42, 1, 42, 3, 42, 795, 8, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 801, 8, 42, 1, 42, 1, 42, 3, 42, 805, 8, 42, 1, 43, 1, 43, 3, 43, 809, 8, 43, 1, 43, 1, 43, 3, 43, 813, 8, 43, 1, 43, 1, 43, 3, 43, 817, 8, 43, 1, 43, 1, 43, 3, 43, 821, 8, 43, 1, 43, 5, 43, 824, 8, 43, 10, 43, 12, 43, 827, 9, 43, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 833, 8, 44, 1, 44, 1, 44, 3, 44, 837, 8, 44, 1, 44, 5, 44, 840, 8, 44, 10, 44, 12, 44, 843, 9, 44, 1, 45, 1, 45, 1, 45, 1, 45, 3, 45, 849, 8, 45, 1, 46, 1, 46, 3, 46, 853, 8, 46, 1, 46, 1, 46, 3, 46, 857, 8, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 865, 8, 46, 1, 46, 1, 46, 1, 46, 4, 46, 870, 8, 46, 11, 46, 12, 46, 871, 1, 46, 3, 46, 875, 8, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 883, 8, 47, 1, 47, 1, 47, 1, 47, 3, 47, 888, 8, 47, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 894, 8, 48, 1, 48, 3, 48, 897, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 903, 8, 48, 3, 48, 905, 8, 48, 1, 49, 1, 49, 3, 49, 909, 8, 49, 1, 49, 1, 49, 3, 49, 913, 8, 49, 1, 49, 5, 49, 916, 8, 49, 10, 49, 12, 49, 919, 9, 49, 1, 49, 3, 49, 922, 8, 49, 1, 49, 3, 49, 925, 8, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 932, 8, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 3, 51, 939, 8, 51, 1, 51, 3, 51, 942, 8, 51, 1, 52, 1, 52, 1, 52, 1, 53, 3, 53, 948, 8, 53, 1, 53, 3, 53, 951, 8, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 957, 8, 53, 1, 53, 1, 53, 3, 53, 961, 8, 53, 1, 53, 1, 53, 3, 53, 965, 8, 53, 1, 54, 1, 54, 3, 54, 969, 8, 54, 1, 54, 1, 54, 3, 54, 973, 8, 54, 1, 54, 5, 54, 976, 8, 54, 10, 54, 12, 54, 979, 9, 54, 1, 54, 1, 54, 3, 54, 983, 8, 54, 1, 54, 1, 54, 3, 54, 987, 8, 54, 1, 54, 5, 54, 990, 8, 54, 10, 54, 12, 54, 993, 9, 54, 3, 54, 995, 8, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 1004, 8, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1013, 8, 56, 1, 56, 5, 56, 1016, 8, 56, 10, 56, 12, 56, 1019, 9, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 3, 59, 1031, 8, 59, 1, 59, 3, 59, 1034, 8, 59, 1, 60, 3, 60, 1037, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 1057, 8, 60, 1, 60, 1, 60, 3, 60, 1061, 8, 60, 1, 60, 5, 60, 1064, 8, 60, 10, 60, 12, 60, 1067, 9, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 1076, 8, 60, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1082, 8, 61, 1, 61, 1, 61, 3, 61, 1086, 8, 61, 1, 61, 5, 61, 1089, 8, 61, 10, 61, 12, 61, 1092, 9, 61, 1, 61, 3, 61, 1095, 8, 61, 1, 62, 1, 62, 3, 62, 1099, 8, 62, 1, 62, 1, 62, 3, 62, 1103, 8, 62, 1, 62, 1, 62, 1, 63, 1, 63, 3, 63, 1109, 8, 63, 1, 64, 1, 64, 3, 64, 1113, 8, 64, 1, 64, 1, 64, 1, 64, 3, 64, 1118, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 1124, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1133, 8, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 3, 67, 1142, 8, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1150, 8, 68, 1, 68, 1, 68, 1, 69, 1, 69, 3, 69, 1156, 8, 69, 1, 69, 1, 69, 3, 69, 1160, 8, 69, 1, 69, 5, 69, 1163, 8, 69, 10, 69, 12, 69, 1166, 9, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 3, 71, 1174, 8, 71, 1, 71, 1, 71, 3, 71, 1178, 8, 71, 1, 71, 5, 71, 1181, 8, 71, 10, 71, 12, 71, 1184, 9, 71, 1, 72, 1, 72, 3, 72, 1188, 8, 72, 1, 72, 1, 72, 3, 72, 1192, 8, 72, 1, 72, 1, 72, 1, 72, 3, 72, 1197, 8, 72, 1, 73, 1, 73, 3, 73, 1201, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 1213, 8, 74, 1, 75, 1, 75, 3, 75, 1217, 8, 75, 1, 75, 5, 75, 1220, 8, 75, 10, 75, 12, 75, 1223, 9, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1229, 8, 75, 1, 76, 1, 76, 3, 76, 1233, 8, 76, 1, 76, 4, 76, 1236, 8, 76, 11, 76, 12, 76, 1237, 1, 77, 1, 77, 3, 77, 1242, 8, 77, 1, 77, 1, 77, 3, 77, 1246, 8, 77, 3, 77, 1248, 8, 77, 1, 77, 1, 77, 3, 77, 1252, 8, 77, 3, 77, 1254, 8, 77, 1, 77, 1, 77, 3, 77, 1258, 8, 77, 3, 77, 1260, 8, 77, 1, 77, 1, 77, 1, 78, 1, 78, 3, 78, 1266, 8, 78, 1, 78, 1, 78, 1, 79, 1, 79, 3, 79, 1272, 8, 79, 1, 79, 1, 79, 3, 79, 1276, 8, 79, 1, 79, 3, 79, 1279, 8, 79, 1, 79, 3, 79, 1282, 8, 79, 1, 79, 1, 79, 3, 79, 1286, 8, 79, 1, 79, 1, 79, 1, 79, 1, 79, 3, 79, 1292, 8, 79, 1, 79, 1, 79, 3, 79, 1296, 8, 79, 1, 79, 3, 79, 1299, 8, 79, 1, 79, 3, 79, 1302, 8, 79, 1, 79, 1, 79, 1, 79, 1, 79, 3, 79, 1308, 8, 79, 1, 79, 3, 79, 1311, 8, 79, 1, 79, 3, 79, 1314, 8, 79, 1, 79, 1, 79, 3, 79, 1318, 8, 79, 1, 79, 1, 79, 1, 79, 1, 79, 3, 79, 1324, 8, 79, 1, 79, 3, 79, 1327, 8, 79, 1, 79, 3, 79, 1330, 8, 79, 1, 79, 1, 79, 3, 79, 1334, 8, 79, 1, 80, 1, 80, 3, 80, 1338, 8, 80, 1, 80, 1, 80, 3, 80, 1342, 8, 80, 3, 80, 1344, 8, 80, 1, 80, 1, 80, 3, 80, 1348, 8, 80, 3, 80, 1350, 8, 80, 1, 80, 3, 80, 1353, 8, 80, 1, 80, 1, 80, 3, 80, 1357, 8, 80, 3, 80, 1359, 8, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 3, 81, 1366, 8, 81, 1, 82, 1, 82, 3, 82, 1370, 8, 82, 1, 82, 1, 82, 1, 83, 1, 83, 3, 83, 1376, 8, 83, 1, 83, 1, 83, 3, 83, 1380, 8, 83, 1, 83, 1, 83, 3, 83, 1384, 8, 83, 1, 83, 3, 83, 1387, 8, 83, 1, 83, 5, 83, 1390, 8, 83, 10, 83, 12, 83, 1393, 9, 83, 1, 84, 1, 84, 3, 84, 1397, 8, 84, 1, 84, 5, 84, 1400, 8, 84, 10, 84, 12, 84, 1403, 9, 84, 1, 85, 1, 85, 3, 85, 1407, 8, 85, 1, 85, 1, 85, 1, 86, 1, 86, 3, 86, 1413, 8, 86, 1, 86, 1, 86, 3, 86, 1417, 8, 86, 3, 86, 1419, 8, 86, 1, 86, 1, 86, 3, 86, 1423, 8, 86, 1, 86, 1, 86, 3, 86, 1427, 8, 86, 3, 86, 1429, 8, 86, 3, 86, 1431, 8, 86, 1, 87, 1, 87, 1, 88, 1, 88, 1, 89, 1, 89, 3, 89, 1439, 8, 89, 1, 89, 4, 89, 1442, 8, 89, 11, 89, 12, 89, 1443, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 5, 91, 1453, 8, 91, 10, 91, 12, 91, 1456, 9, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 5, 92, 1463, 8, 92, 10, 92, 12, 92, 1466, 9, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 5, 93, 1473, 8, 93, 10, 93, 12, 93, 1476, 9, 93, 1, 94, 1, 94, 3, 94, 1480, 8, 94, 5, 94, 1482, 8, 94, 10, 94, 12, 94, 1485, 9, 94, 1, 94, 1, 94, 1, 95, 1, 95, 3, 95, 1491, 8, 95, 1, 95, 5, 95, 1494, 8, 95, 10, 95, 12, 95, 1497, 9, 95, 1, 96, 1, 96, 3, 96, 1501, 8, 96, 1, 96, 1, 96, 1, 96, 3, 96, 1506, 8, 96, 1, 96, 1, 96, 1, 96, 3, 96, 1511, 8, 96, 1, 96, 1, 96, 1, 96, 3, 96, 1516, 8, 96, 1, 96, 1, 96, 1, 96, 3, 96, 1521, 8, 96, 1, 96, 1, 96, 1, 96, 3, 96, 1526, 8, 96, 1, 96, 3, 96, 1529, 8, 96, 1, 97, 1, 97, 1, 97, 1, 97, 5, 97, 1535, 8, 97, 10, 97, 12, 97, 1538, 9, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 1551, 8, 98, 1, 98, 3, 98, 1554, 8, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 3, 99, 1561, 8, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 1575, 8, 100, 1, 101, 3, 101, 1578, 8, 101, 1, 101, 1, 101, 1, 102, 1, 102, 3, 102, 1584, 8, 102, 1, 102, 1, 102, 3, 102, 1588, 8, 102, 1, 102, 1, 102, 3, 102, 1592, 8, 102, 1, 102, 1, 102, 3, 102, 1596, 8, 102, 1, 102, 5, 102, 1599, 8, 102, 10, 102, 12, 102, 1602, 9, 102, 1, 103, 1, 103, 3, 103, 1606, 8, 103, 1, 103, 1, 103, 3, 103, 1610, 8, 103, 1, 103, 1, 103, 3, 103, 1614, 8, 103, 1, 103, 1, 103, 3, 103, 1618, 8, 103, 1, 103, 1, 103, 3, 103, 1622, 8, 103, 1, 103, 1, 103, 3, 103, 1626, 8, 103, 1, 103, 5, 103, 1629, 8, 103, 10, 103, 12, 103, 1632, 9, 103, 1, 104, 1, 104, 3, 104, 1636, 8, 104, 1, 104, 1, 104, 3, 104, 1640, 8, 104, 1, 104, 5, 104, 1643, 8, 104, 10, 104, 12, 104, 1646, 9, 104, 1, 105, 1, 105, 1, 105, 3, 105, 1651, 8, 105, 1, 105, 3, 105, 1654, 8, 105, 1, 106, 1, 106, 3, 106, 1658, 8, 106, 1, 106, 1, 106, 3, 106, 1662, 8, 106, 1, 106, 5, 106, 1665, 8, 106, 10, 106, 12, 106, 1668, 9, 106, 1, 106, 3, 106, 1671, 8, 106, 1, 106, 3, 106, 1674, 8, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 3, 107, 1682, 8, 107, 1, 107, 1, 107, 3, 107, 1686, 8, 107, 1, 107, 3, 107, 1689, 8, 107, 1, 108, 1, 108, 3, 108, 1693, 8, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 3, 109, 1703, 8, 109, 1, 109, 1, 109, 3, 109, 1707, 8, 109, 1, 109, 1, 109, 3, 109, 1711, 8, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 3, 109, 1725, 8, 109, 1, 110, 1, 110, 3, 110, 1729, 8, 110, 1, 110, 4, 110, 1732, 8, 110, 11, 110, 12, 110, 1733, 1, 110, 1, 110, 3, 110, 1738, 8, 110, 1, 110, 1, 110, 3, 110, 1742, 8, 110, 1, 110, 4, 110, 1745, 8, 110, 11, 110, 12, 110, 1746, 3, 110, 1749, 8, 110, 1, 110, 3, 110, 1752, 8, 110, 1, 110, 1, 110, 3, 110, 1756, 8, 110, 1, 110, 3, 110, 1759, 8, 110, 1, 110, 3, 110, 1762, 8, 110, 1, 110, 1, 110, 1, 111, 1, 111, 3, 111, 1768, 8, 111, 1, 111, 1, 111, 3, 111, 1772, 8, 111, 1, 111, 1, 111, 3, 111, 1776, 8, 111, 1, 111, 1, 111, 1, 112, 1, 112, 3, 112, 1782, 8, 112, 1, 112, 1, 112, 3, 112, 1786, 8, 112, 1, 112, 1, 112, 3, 112, 1790, 8, 112, 1, 112, 3, 112, 1793, 8, 112, 1, 112, 3, 112, 1796, 8, 112, 1, 112, 1, 112, 1, 113, 1, 113, 3, 113, 1802, 8, 113, 1, 113, 1, 113, 3, 113, 1806, 8, 113, 1, 113, 1, 113, 3, 113, 1810, 8, 113, 3, 113, 1812, 8, 113, 1, 113, 1, 113, 3, 113, 1816, 8, 113, 1, 113, 1, 113, 3, 113, 1820, 8, 113, 3, 113, 1822, 8, 113, 1, 113, 1, 113, 3, 113, 1826, 8, 113, 1, 113, 1, 113, 3, 113, 1830, 8, 113, 1, 113, 1, 113, 1, 114, 1, 114, 3, 114, 1836, 8, 114, 1, 114, 1, 114, 3, 114, 1840, 8, 114, 1, 114, 1, 114, 3, 114, 1844, 8, 114, 1, 114, 1, 114, 1, 114, 1, 114, 3, 114, 1850, 8, 114, 1, 114, 1, 114, 3, 114, 1854, 8, 114, 1, 114, 1, 114, 3, 114, 1858, 8, 114, 1, 114, 3, 114, 1861, 8, 114, 1, 114, 1, 114, 3, 114, 1865, 8, 114, 1, 114, 1, 114, 3, 114, 1869, 8, 114, 1, 115, 1, 115, 3, 115, 1873, 8, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 3, 116, 1887, 8, 116, 1, 116, 1, 116, 3, 116, 1891, 8, 116, 1, 116, 1, 116, 3, 116, 1895, 8, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 1901, 8, 116, 1, 116, 1, 116, 3, 116, 1905, 8, 116, 1, 116, 1, 116, 3, 116, 1909, 8, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 1915, 8, 116, 1, 116, 1, 116, 3, 116, 1919, 8, 116, 1, 116, 1, 116, 3, 116, 1923, 8, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 1929, 8, 116, 1, 116, 1, 116, 3, 116, 1933, 8, 116, 1, 116, 1, 116, 3, 116, 1937, 8, 116, 1, 116, 1, 116, 3, 116, 1941, 8, 116, 1, 117, 1, 117, 3, 117, 1945, 8, 117, 1, 117, 3, 117, 1948, 8, 117, 1, 118, 1, 118, 1, 119, 1, 119, 3, 119, 1954, 8, 119, 1, 119, 1, 119, 3, 119, 1958, 8, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 3, 121, 1970, 8, 121, 1, 121, 1, 121, 3, 121, 1974, 8, 121, 1, 121, 1, 121, 3, 121, 1978, 8, 121, 3, 121, 1980, 8, 121, 1, 121, 1, 121, 3, 121, 1984, 8, 121, 1, 121, 1, 121, 3, 121, 1988, 8, 121, 1, 121, 1, 121, 3, 121, 1992, 8, 121, 5, 121, 1994, 8, 121, 10, 121, 12, 121, 1997, 9, 121, 3, 121, 1999, 8, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 3, 123, 2008, 8, 123, 1, 123, 1, 123, 3, 123, 2012, 8, 123, 1, 123, 1, 123, 1, 123, 3, 123, 2017, 8, 123, 1, 123, 3, 123, 2020, 8, 123, 3, 123, 2022, 8, 123, 1, 123, 3, 123, 2025, 8, 123, 1, 123, 1, 123, 1, 124, 1, 124, 3, 124, 2031, 8, 124, 1, 124, 1, 124, 3, 124, 2035, 8, 124, 1, 124, 1, 124, 3, 124, 2039, 8, 124, 1, 124, 1, 124, 3, 124, 2043, 8, 124, 1, 124, 1, 124, 3, 124, 2047, 8, 124, 5, 124, 2049, 8, 124, 10, 124, 12, 124, 2052, 9, 124, 3, 124, 2054, 8, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 5, 128, 2068, 8, 128, 10, 128, 12, 128, 2071, 9, 128, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 3, 130, 2081, 8, 130, 1, 131, 1, 131, 1, 132, 1, 132, 3, 132, 2087, 8, 132, 1, 133, 1, 133, 1, 134, 1, 134, 1, 135, 1, 135, 3, 135, 2095, 8, 135, 1, 135, 1, 135, 3, 135, 2099, 8, 135, 1, 135, 1, 135, 3, 135, 2103, 8, 135, 1, 135, 1, 135, 3, 135, 2107, 8, 135, 5, 135, 2109, 8, 135, 10, 135, 12, 135, 2112, 9, 135, 3, 135, 2114, 8, 135, 1, 135, 1, 135, 1, 136, 1, 136, 3, 136, 2120, 8, 136, 1, 136, 1, 136, 3, 136, 2124, 8, 136, 1, 136, 1, 136, 3, 136, 2128, 8, 136, 1, 136, 1, 136, 3, 136, 2132, 8, 136, 1, 136, 1, 136, 3, 136, 2136, 8, 136, 1, 136, 1, 136, 3, 136, 2140, 8, 136, 1, 136, 1, 136, 3, 136, 2144, 8, 136, 1, 136, 1, 136, 3, 136, 2148, 8, 136, 5, 136, 2150, 8, 136, 10, 136, 12, 136, 2153, 9, 136, 3, 136, 2155, 8, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 138, 1, 138, 3, 138, 2163, 8, 138, 1, 138, 1, 138, 3, 138, 2167, 8, 138, 1, 138, 3, 138, 2170, 8, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 3, 139, 2177, 8, 139, 1, 140, 1, 140, 3, 140, 2181, 8, 140, 1, 141, 1, 141, 1, 142, 1, 142, 1, 143, 1, 143, 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 0, 0, 146, 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, 0, 11, 1, 0, 89, 92, 1, 0, 97, 98, 1, 0, 19, 20, 1, 0, 122, 123, 1, 0, 124, 126, 1, 0, 134, 135, 13, 0, 53, 56, 58, 59, 61, 63, 66, 66, 69, 69, 71, 78, 80, 80, 83, 92, 99, 99, 102, 109, 111, 115, 122, 123, 138, 144, 6, 0, 110, 110, 116, 117, 119, 121, 127, 127, 145, 145, 148, 148, 2, 0, 14, 14, 28, 31, 2, 0, 15, 15, 32, 35, 2, 0, 20, 20, 36, 46, 2465, 0, 293, 1, 0, 0, 0, 2, 314, 1, 0, 0, 0, 4, 320, 1, 0, 0, 0, 6, 322, 1, 0, 0, 0, 8, 334, 1, 0, 0, 0, 10, 336, 1, 0, 0, 0, 12, 338, 1, 0, 0, 0, 14, 340, 1, 0, 0, 0, 16, 352, 1, 0, 0, 0, 18, 357, 1, 0, 0, 0, 20, 359, 1, 0, 0, 0, 22, 369, 1, 0, 0, 0, 24, 375, 1, 0, 0, 0, 26, 384, 1, 0, 0, 0, 28, 399, 1, 0, 0, 0, 30, 403, 1, 0, 0, 0, 32, 440, 1, 0, 0, 0, 34, 464, 1, 0, 0, 0, 36, 477, 1, 0, 0, 0, 38, 484, 1, 0, 0, 0, 40, 494, 1, 0, 0, 0, 42, 496, 1, 0, 0, 0, 44, 500, 1, 0, 0, 0, 46, 504, 1, 0, 0, 0, 48, 508, 1, 0, 0, 0, 50, 512, 1, 0, 0, 0, 52, 516, 1, 0, 0, 0, 54, 520, 1, 0, 0, 0, 56, 524, 1, 0, 0, 0, 58, 528, 1, 0, 0, 0, 60, 539, 1, 0, 0, 0, 62, 560, 1, 0, 0, 0, 64, 583, 1, 0, 0, 0, 66, 656, 1, 0, 0, 0, 68, 658, 1, 0, 0, 0, 70, 683, 1, 0, 0, 0, 72, 702, 1, 0, 0, 0, 74, 712, 1, 0, 0, 0, 76, 734, 1, 0, 0, 0, 78, 736, 1, 0, 0, 0, 80, 742, 1, 0, 0, 0, 82, 750, 1, 0, 0, 0, 84, 804, 1, 0, 0, 0, 86, 808, 1, 0, 0, 0, 88, 828, 1, 0, 0, 0, 90, 848, 1, 0, 0, 0, 92, 850, 1, 0, 0, 0, 94, 878, 1, 0, 0, 0, 96, 889, 1, 0, 0, 0, 98, 906, 1, 0, 0, 0, 100, 931, 1, 0, 0, 0, 102, 935, 1, 0, 0, 0, 104, 943, 1, 0, 0, 0, 106, 950, 1, 0, 0, 0, 108, 994, 1, 0, 0, 0, 110, 1003, 1, 0, 0, 0, 112, 1005, 1, 0, 0, 0, 114, 1020, 1, 0, 0, 0, 116, 1024, 1, 0, 0, 0, 118, 1028, 1, 0, 0, 0, 120, 1036, 1, 0, 0, 0, 122, 1077, 1, 0, 0, 0, 124, 1096, 1, 0, 0, 0, 126, 1108, 1, 0, 0, 0, 128, 1110, 1, 0, 0, 0, 130, 1119, 1, 0, 0, 0, 132, 1125, 1, 0, 0, 0, 134, 1136, 1, 0, 0, 0, 136, 1145, 1, 0, 0, 0, 138, 1153, 1, 0, 0, 0, 140, 1167, 1, 0, 0, 0, 142, 1171, 1, 0, 0, 0, 144, 1196, 1, 0, 0, 0, 146, 1200, 1, 0, 0, 0, 148, 1212, 1, 0, 0, 0, 150, 1228, 1, 0, 0, 0, 152, 1230, 1, 0, 0, 0, 154, 1239, 1, 0, 0, 0, 156, 1263, 1, 0, 0, 0, 158, 1333, 1, 0, 0, 0, 160, 1335, 1, 0, 0, 0, 162, 1365, 1, 0, 0, 0, 164, 1367, 1, 0, 0, 0, 166, 1373, 1, 0, 0, 0, 168, 1394, 1, 0, 0, 0, 170, 1404, 1, 0, 0, 0, 172, 1410, 1, 0, 0, 0, 174, 1432, 1, 0, 0, 0, 176, 1434, 1, 0, 0, 0, 178, 1436, 1, 0, 0, 0, 180, 1445, 1, 0, 0, 0, 182, 1447, 1, 0, 0, 0, 184, 1457, 1, 0, 0, 0, 186, 1467, 1, 0, 0, 0, 188, 1483, 1, 0, 0, 0, 190, 1488, 1, 0, 0, 0, 192, 1528, 1, 0, 0, 0, 194, 1530, 1, 0, 0, 0, 196, 1550, 1, 0, 0, 0, 198, 1557, 1, 0, 0, 0, 200, 1574, 1, 0, 0, 0, 202, 1577, 1, 0, 0, 0, 204, 1581, 1, 0, 0, 0, 206, 1603, 1, 0, 0, 0, 208, 1633, 1, 0, 0, 0, 210, 1653, 1, 0, 0, 0, 212, 1655, 1, 0, 0, 0, 214, 1688, 1, 0, 0, 0, 216, 1690, 1, 0, 0, 0, 218, 1724, 1, 0, 0, 0, 220, 1748, 1, 0, 0, 0, 222, 1765, 1, 0, 0, 0, 224, 1779, 1, 0, 0, 0, 226, 1799, 1, 0, 0, 0, 228, 1868, 1, 0, 0, 0, 230, 1870, 1, 0, 0, 0, 232, 1940, 1, 0, 0, 0, 234, 1942, 1, 0, 0, 0, 236, 1949, 1, 0, 0, 0, 238, 1951, 1, 0, 0, 0, 240, 1961, 1, 0, 0, 0, 242, 1967, 1, 0, 0, 0, 244, 2002, 1, 0, 0, 0, 246, 2005, 1, 0, 0, 0, 248, 2028, 1, 0, 0, 0, 250, 2057, 1, 0, 0, 0, 252, 2059, 1, 0, 0, 0, 254, 2061, 1, 0, 0, 0, 256, 2069, 1, 0, 0, 0, 258, 2072, 1, 0, 0, 0, 260, 2080, 1, 0, 0, 0, 262, 2082, 1, 0, 0, 0, 264, 2086, 1, 0, 0, 0, 266, 2088, 1, 0, 0, 0, 268, 2090, 1, 0, 0, 0, 270, 2092, 1, 0, 0, 0, 272, 2117, 1, 0, 0, 0, 274, 2158, 1, 0, 0, 0, 276, 2160, 1, 0, 0, 0, 278, 2173, 1, 0, 0, 0, 280, 2180, 1, 0, 0, 0, 282, 2182, 1, 0, 0, 0, 284, 2184, 1, 0, 0, 0, 286, 2186, 1, 0, 0, 0, 288, 2188, 1, 0, 0, 0, 290, 2190, 1, 0, 0, 0, 292, 294, 5, 149, 0, 0, 293, 292, 1, 0, 0, 0, 293, 294, 1, 0, 0, 0, 294, 295, 1, 0, 0, 0, 295, 296, 3, 2, 1, 0, 296, 301, 3, 16, 8, 0, 297, 299, 5, 149, 0, 0, 298, 297, 1, 0, 0, 0, 298, 299, 1, 0, 0, 0, 299, 300, 1, 0, 0, 0, 300, 302, 5, 1, 0, 0, 301, 298, 1, 0, 0, 0, 301, 302, 1, 0, 0, 0, 302, 304, 1, 0, 0, 0, 303, 305, 5, 149, 0, 0, 304, 303, 1, 0, 0, 0, 304, 305, 1, 0, 0, 0, 305, 306, 1, 0, 0, 0, 306, 307, 5, 0, 0, 1, 307, 1, 1, 0, 0, 0, 308, 310, 3, 4, 2, 0, 309, 311, 5, 149, 0, 0, 310, 309, 1, 0, 0, 0, 310, 311, 1, 0, 0, 0, 311, 313, 1, 0, 0, 0, 312, 308, 1, 0, 0, 0, 313, 316, 1, 0, 0, 0, 314, 312, 1, 0, 0, 0, 314, 315, 1, 0, 0, 0, 315, 3, 1, 0, 0, 0, 316, 314, 1, 0, 0, 0, 317, 321, 3, 6, 3, 0, 318, 321, 3, 10, 5, 0, 319, 321, 3, 12, 6, 0, 320, 317, 1, 0, 0, 0, 320, 318, 1, 0, 0, 0, 320, 319, 1, 0, 0, 0, 321, 5, 1, 0, 0, 0, 322, 325, 5, 47, 0, 0, 323, 324, 5, 149, 0, 0, 324, 326, 3, 8, 4, 0, 325, 323, 1, 0, 0, 0, 325, 326, 1, 0, 0, 0, 326, 331, 1, 0, 0, 0, 327, 328, 5, 149, 0, 0, 328, 330, 3, 14, 7, 0, 329, 327, 1, 0, 0, 0, 330, 333, 1, 0, 0, 0, 331, 329, 1, 0, 0, 0, 331, 332, 1, 0, 0, 0, 332, 7, 1, 0, 0, 0, 333, 331, 1, 0, 0, 0, 334, 335, 5, 135, 0, 0, 335, 9, 1, 0, 0, 0, 336, 337, 5, 48, 0, 0, 337, 11, 1, 0, 0, 0, 338, 339, 5, 49, 0, 0, 339, 13, 1, 0, 0, 0, 340, 342, 3, 284, 142, 0, 341, 343, 5, 149, 0, 0, 342, 341, 1, 0, 0, 0, 342, 343, 1, 0, 0, 0, 343, 344, 1, 0, 0, 0, 344, 346, 5, 2, 0, 0, 345, 347, 5, 149, 0, 0, 346, 345, 1, 0, 0, 0, 346, 347, 1, 0, 0, 0, 347, 348, 1, 0, 0, 0, 348, 349, 3, 284, 142, 0, 349, 15, 1, 0, 0, 0, 350, 353, 3, 40, 20, 0, 351, 353, 3, 18, 9, 0, 352, 350, 1, 0, 0, 0, 352, 351, 1, 0, 0, 0, 353, 17, 1, 0, 0, 0, 354, 358, 3, 20, 10, 0, 355, 358, 3, 96, 48, 0, 356, 358, 3, 22, 11, 0, 357, 354, 1, 0, 0, 0, 357, 355, 1, 0, 0, 0, 357, 356, 1, 0, 0, 0, 358, 19, 1, 0, 0, 0, 359, 366, 3, 30, 15, 0, 360, 362, 5, 149, 0, 0, 361, 360, 1, 0, 0, 0, 361, 362, 1, 0, 0, 0, 362, 363, 1, 0, 0, 0, 363, 365, 3, 28, 14, 0, 364, 361, 1, 0, 0, 0, 365, 368, 1, 0, 0, 0, 366, 364, 1, 0, 0, 0, 366, 367, 1, 0, 0, 0, 367, 21, 1, 0, 0, 0, 368, 366, 1, 0, 0, 0, 369, 371, 3, 24, 12, 0, 370, 372, 5, 149, 0, 0, 371, 370, 1, 0, 0, 0, 371, 372, 1, 0, 0, 0, 372, 373, 1, 0, 0, 0, 373, 374, 3, 26, 13, 0, 374, 23, 1, 0, 0, 0, 375, 376, 5, 50, 0, 0, 376, 377, 5, 149, 0, 0, 377, 378, 5, 51, 0, 0, 378, 379, 5, 149, 0, 0, 379, 382, 5, 52, 0, 0, 380, 381, 5, 149, 0, 0, 381, 383, 3, 266, 133, 0, 382, 380, 1, 0, 0, 0, 382, 383, 1, 0, 0, 0, 383, 25, 1, 0, 0, 0, 384, 385, 3, 68, 34, 0, 385, 386, 3, 30, 15, 0, 386, 27, 1, 0, 0, 0, 387, 388, 5, 53, 0, 0, 388, 389, 5, 149, 0, 0, 389, 391, 5, 54, 0, 0, 390, 392, 5, 149, 0, 0, 391, 390, 1, 0, 0, 0, 391, 392, 1, 0, 0, 0, 392, 393, 1, 0, 0, 0, 393, 400, 3, 30, 15, 0, 394, 396, 5, 53, 0, 0, 395, 397, 5, 149, 0, 0, 396, 395, 1, 0, 0, 0, 396, 397, 1, 0, 0, 0, 397, 398, 1, 0, 0, 0, 398, 400, 3, 30, 15, 0, 399, 387, 1, 0, 0, 0, 399, 394, 1, 0, 0, 0, 400, 29, 1, 0, 0, 0, 401, 404, 3, 32, 16, 0, 402, 404, 3, 34, 17, 0, 403, 401, 1, 0, 0, 0, 403, 402, 1, 0, 0, 0, 404, 31, 1, 0, 0, 0, 405, 407, 3, 38, 19, 0, 406, 408, 5, 149, 0, 0, 407, 406, 1, 0, 0, 0, 407, 408, 1, 0, 0, 0, 408, 410, 1, 0, 0, 0, 409, 405, 1, 0, 0, 0, 410, 413, 1, 0, 0, 0, 411, 409, 1, 0, 0, 0, 411, 412, 1, 0, 0, 0, 412, 414, 1, 0, 0, 0, 413, 411, 1, 0, 0, 0, 414, 441, 3, 104, 52, 0, 415, 417, 3, 38, 19, 0, 416, 418, 5, 149, 0, 0, 417, 416, 1, 0, 0, 0, 417, 418, 1, 0, 0, 0, 418, 420, 1, 0, 0, 0, 419, 415, 1, 0, 0, 0, 420, 423, 1, 0, 0, 0, 421, 419, 1, 0, 0, 0, 421, 422, 1, 0, 0, 0, 422, 424, 1, 0, 0, 0, 423, 421, 1, 0, 0, 0, 424, 431, 3, 36, 18, 0, 425, 427, 5, 149, 0, 0, 426, 425, 1, 0, 0, 0, 426, 427, 1, 0, 0, 0, 427, 428, 1, 0, 0, 0, 428, 430, 3, 36, 18, 0, 429, 426, 1, 0, 0, 0, 430, 433, 1, 0, 0, 0, 431, 429, 1, 0, 0, 0, 431, 432, 1, 0, 0, 0, 432, 438, 1, 0, 0, 0, 433, 431, 1, 0, 0, 0, 434, 436, 5, 149, 0, 0, 435, 434, 1, 0, 0, 0, 435, 436, 1, 0, 0, 0, 436, 437, 1, 0, 0, 0, 437, 439, 3, 104, 52, 0, 438, 435, 1, 0, 0, 0, 438, 439, 1, 0, 0, 0, 439, 441, 1, 0, 0, 0, 440, 411, 1, 0, 0, 0, 440, 421, 1, 0, 0, 0, 441, 33, 1, 0, 0, 0, 442, 444, 3, 38, 19, 0, 443, 445, 5, 149, 0, 0, 444, 443, 1, 0, 0, 0, 444, 445, 1, 0, 0, 0, 445, 447, 1, 0, 0, 0, 446, 442, 1, 0, 0, 0, 447, 450, 1, 0, 0, 0, 448, 446, 1, 0, 0, 0, 448, 449, 1, 0, 0, 0, 449, 457, 1, 0, 0, 0, 450, 448, 1, 0, 0, 0, 451, 453, 3, 36, 18, 0, 452, 454, 5, 149, 0, 0, 453, 452, 1, 0, 0, 0, 453, 454, 1, 0, 0, 0, 454, 456, 1, 0, 0, 0, 455, 451, 1, 0, 0, 0, 456, 459, 1, 0, 0, 0, 457, 455, 1, 0, 0, 0, 457, 458, 1, 0, 0, 0, 458, 460, 1, 0, 0, 0, 459, 457, 1, 0, 0, 0, 460, 462, 3, 102, 51, 0, 461, 463, 5, 149, 0, 0, 462, 461, 1, 0, 0, 0, 462, 463, 1, 0, 0, 0, 463, 465, 1, 0, 0, 0, 464, 448, 1, 0, 0, 0, 465, 466, 1, 0, 0, 0, 466, 464, 1, 0, 0, 0, 466, 467, 1, 0, 0, 0, 467, 468, 1, 0, 0, 0, 468, 469, 3, 32, 16, 0, 469, 35, 1, 0, 0, 0, 470, 478, 3, 78, 39, 0, 471, 478, 3, 74, 37, 0, 472, 478, 3, 80, 40, 0, 473, 478, 3, 92, 46, 0, 474, 478, 3, 86, 43, 0, 475, 478, 3, 82, 41, 0, 476, 478, 3, 88, 44, 0, 477, 470, 1, 0, 0, 0, 477, 471, 1, 0, 0, 0, 477, 472, 1, 0, 0, 0, 477, 473, 1, 0, 0, 0, 477, 474, 1, 0, 0, 0, 477, 475, 1, 0, 0, 0, 477, 476, 1, 0, 0, 0, 478, 37, 1, 0, 0, 0, 479, 485, 3, 68, 34, 0, 480, 485, 3, 122, 61, 0, 481, 485, 3, 70, 35, 0, 482, 485, 3, 72, 36, 0, 483, 485, 3, 94, 47, 0, 484, 479, 1, 0, 0, 0, 484, 480, 1, 0, 0, 0, 484, 481, 1, 0, 0, 0, 484, 482, 1, 0, 0, 0, 484, 483, 1, 0, 0, 0, 485, 39, 1, 0, 0, 0, 486, 495, 3, 48, 24, 0, 487, 495, 3, 56, 28, 0, 488, 495, 3, 42, 21, 0, 489, 495, 3, 50, 25, 0, 490, 495, 3, 44, 22, 0, 491, 495, 3, 52, 26, 0, 492, 495, 3, 46, 23, 0, 493, 495, 3, 54, 27, 0, 494, 486, 1, 0, 0, 0, 494, 487, 1, 0, 0, 0, 494, 488, 1, 0, 0, 0, 494, 489, 1, 0, 0, 0, 494, 490, 1, 0, 0, 0, 494, 491, 1, 0, 0, 0, 494, 492, 1, 0, 0, 0, 494, 493, 1, 0, 0, 0, 495, 41, 1, 0, 0, 0, 496, 497, 5, 55, 0, 0, 497, 498, 5, 149, 0, 0, 498, 499, 3, 60, 30, 0, 499, 43, 1, 0, 0, 0, 500, 501, 5, 55, 0, 0, 501, 502, 5, 149, 0, 0, 502, 503, 3, 62, 31, 0, 503, 45, 1, 0, 0, 0, 504, 505, 5, 55, 0, 0, 505, 506, 5, 149, 0, 0, 506, 507, 3, 64, 32, 0, 507, 47, 1, 0, 0, 0, 508, 509, 5, 55, 0, 0, 509, 510, 5, 149, 0, 0, 510, 511, 3, 58, 29, 0, 511, 49, 1, 0, 0, 0, 512, 513, 5, 56, 0, 0, 513, 514, 5, 149, 0, 0, 514, 515, 3, 60, 30, 0, 515, 51, 1, 0, 0, 0, 516, 517, 5, 56, 0, 0, 517, 518, 5, 149, 0, 0, 518, 519, 3, 62, 31, 0, 519, 53, 1, 0, 0, 0, 520, 521, 5, 56, 0, 0, 521, 522, 5, 149, 0, 0, 522, 523, 3, 64, 32, 0, 523, 55, 1, 0, 0, 0, 524, 525, 5, 56, 0, 0, 525, 526, 5, 149, 0, 0, 526, 527, 3, 58, 29, 0, 527, 57, 1, 0, 0, 0, 528, 529, 5, 57, 0, 0, 529, 530, 5, 149, 0, 0, 530, 532, 5, 58, 0, 0, 531, 533, 5, 149, 0, 0, 532, 531, 1, 0, 0, 0, 532, 533, 1, 0, 0, 0, 533, 534, 1, 0, 0, 0, 534, 535, 3, 170, 85, 0, 535, 536, 5, 3, 0, 0, 536, 537, 3, 274, 137, 0, 537, 538, 5, 4, 0, 0, 538, 59, 1, 0, 0, 0, 539, 540, 5, 59, 0, 0, 540, 541, 5, 149, 0, 0, 541, 543, 5, 58, 0, 0, 542, 544, 5, 149, 0, 0, 543, 542, 1, 0, 0, 0, 543, 544, 1, 0, 0, 0, 544, 545, 1, 0, 0, 0, 545, 546, 5, 3, 0, 0, 546, 547, 3, 258, 129, 0, 547, 548, 3, 170, 85, 0, 548, 550, 5, 4, 0, 0, 549, 551, 5, 149, 0, 0, 550, 549, 1, 0, 0, 0, 550, 551, 1, 0, 0, 0, 551, 552, 1, 0, 0, 0, 552, 553, 5, 60, 0, 0, 553, 554, 5, 149, 0, 0, 554, 555, 3, 178, 89, 0, 555, 556, 5, 149, 0, 0, 556, 557, 5, 61, 0, 0, 557, 558, 5, 149, 0, 0, 558, 559, 5, 62, 0, 0, 559, 61, 1, 0, 0, 0, 560, 561, 5, 59, 0, 0, 561, 562, 5, 149, 0, 0, 562, 564, 5, 58, 0, 0, 563, 565, 5, 149, 0, 0, 564, 563, 1, 0, 0, 0, 564, 565, 1, 0, 0, 0, 565, 566, 1, 0, 0, 0, 566, 567, 5, 3, 0, 0, 567, 568, 3, 258, 129, 0, 568, 569, 3, 170, 85, 0, 569, 571, 5, 4, 0, 0, 570, 572, 5, 149, 0, 0, 571, 570, 1, 0, 0, 0, 571, 572, 1, 0, 0, 0, 572, 573, 1, 0, 0, 0, 573, 574, 5, 60, 0, 0, 574, 575, 5, 149, 0, 0, 575, 577, 5, 63, 0, 0, 576, 578, 5, 149, 0, 0, 577, 576, 1, 0, 0, 0, 577, 578, 1, 0, 0, 0, 578, 579, 1, 0, 0, 0, 579, 580, 5, 3, 0, 0, 580, 581, 3, 178, 89, 0, 581, 582, 5, 4, 0, 0, 582, 63, 1, 0, 0, 0, 583, 584, 5, 59, 0, 0, 584, 585, 5, 149, 0, 0, 585, 587, 5, 58, 0, 0, 586, 588, 5, 149, 0, 0, 587, 586, 1, 0, 0, 0, 587, 588, 1, 0, 0, 0, 588, 589, 1, 0, 0, 0, 589, 591, 3, 66, 33, 0, 590, 592, 5, 149, 0, 0, 591, 590, 1, 0, 0, 0, 591, 592, 1, 0, 0, 0, 592, 593, 1, 0, 0, 0, 593, 594, 5, 60, 0, 0, 594, 595, 5, 149, 0, 0, 595, 597, 5, 63, 0, 0, 596, 598, 5, 149, 0, 0, 597, 596, 1, 0, 0, 0, 597, 598, 1, 0, 0, 0, 598, 599, 1, 0, 0, 0, 599, 600, 5, 3, 0, 0, 600, 601, 3, 178, 89, 0, 601, 602, 5, 4, 0, 0, 602, 65, 1, 0, 0, 0, 603, 605, 5, 3, 0, 0, 604, 606, 5, 149, 0, 0, 605, 604, 1, 0, 0, 0, 605, 606, 1, 0, 0, 0, 606, 607, 1, 0, 0, 0, 607, 608, 5, 4, 0, 0, 608, 609, 3, 290, 145, 0, 609, 610, 5, 5, 0, 0, 610, 611, 3, 258, 129, 0, 611, 612, 3, 164, 82, 0, 612, 613, 5, 6, 0, 0, 613, 614, 3, 290, 145, 0, 614, 616, 5, 3, 0, 0, 615, 617, 5, 149, 0, 0, 616, 615, 1, 0, 0, 0, 616, 617, 1, 0, 0, 0, 617, 618, 1, 0, 0, 0, 618, 619, 5, 4, 0, 0, 619, 657, 1, 0, 0, 0, 620, 622, 5, 3, 0, 0, 621, 623, 5, 149, 0, 0, 622, 621, 1, 0, 0, 0, 622, 623, 1, 0, 0, 0, 623, 624, 1, 0, 0, 0, 624, 625, 5, 4, 0, 0, 625, 626, 3, 290, 145, 0, 626, 627, 5, 5, 0, 0, 627, 628, 3, 258, 129, 0, 628, 629, 3, 164, 82, 0, 629, 630, 5, 6, 0, 0, 630, 631, 3, 290, 145, 0, 631, 632, 3, 288, 144, 0, 632, 634, 5, 3, 0, 0, 633, 635, 5, 149, 0, 0, 634, 633, 1, 0, 0, 0, 634, 635, 1, 0, 0, 0, 635, 636, 1, 0, 0, 0, 636, 637, 5, 4, 0, 0, 637, 657, 1, 0, 0, 0, 638, 640, 5, 3, 0, 0, 639, 641, 5, 149, 0, 0, 640, 639, 1, 0, 0, 0, 640, 641, 1, 0, 0, 0, 641, 642, 1, 0, 0, 0, 642, 643, 5, 4, 0, 0, 643, 644, 3, 286, 143, 0, 644, 645, 3, 290, 145, 0, 645, 646, 5, 5, 0, 0, 646, 647, 3, 258, 129, 0, 647, 648, 3, 164, 82, 0, 648, 649, 5, 6, 0, 0, 649, 650, 3, 290, 145, 0, 650, 652, 5, 3, 0, 0, 651, 653, 5, 149, 0, 0, 652, 651, 1, 0, 0, 0, 652, 653, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 655, 5, 4, 0, 0, 655, 657, 1, 0, 0, 0, 656, 603, 1, 0, 0, 0, 656, 620, 1, 0, 0, 0, 656, 638, 1, 0, 0, 0, 657, 67, 1, 0, 0, 0, 658, 659, 5, 64, 0, 0, 659, 660, 5, 149, 0, 0, 660, 661, 5, 65, 0, 0, 661, 666, 5, 149, 0, 0, 662, 663, 5, 66, 0, 0, 663, 664, 5, 149, 0, 0, 664, 665, 5, 67, 0, 0, 665, 667, 5, 149, 0, 0, 666, 662, 1, 0, 0, 0, 666, 667, 1, 0, 0, 0, 667, 668, 1, 0, 0, 0, 668, 669, 5, 68, 0, 0, 669, 670, 5, 149, 0, 0, 670, 671, 3, 180, 90, 0, 671, 672, 5, 149, 0, 0, 672, 673, 5, 69, 0, 0, 673, 674, 5, 149, 0, 0, 674, 675, 3, 258, 129, 0, 675, 679, 5, 149, 0, 0, 676, 677, 5, 70, 0, 0, 677, 678, 5, 149, 0, 0, 678, 680, 5, 136, 0, 0, 679, 676, 1, 0, 0, 0, 679, 680, 1, 0, 0, 0, 680, 69, 1, 0, 0, 0, 681, 682, 5, 71, 0, 0, 682, 684, 5, 149, 0, 0, 683, 681, 1, 0, 0, 0, 683, 684, 1, 0, 0, 0, 684, 685, 1, 0, 0, 0, 685, 687, 5, 72, 0, 0, 686, 688, 5, 149, 0, 0, 687, 686, 1, 0, 0, 0, 687, 688, 1, 0, 0, 0, 688, 689, 1, 0, 0, 0, 689, 693, 3, 142, 71, 0, 690, 692, 3, 120, 60, 0, 691, 690, 1, 0, 0, 0, 692, 695, 1, 0, 0, 0, 693, 691, 1, 0, 0, 0, 693, 694, 1, 0, 0, 0, 694, 700, 1, 0, 0, 0, 695, 693, 1, 0, 0, 0, 696, 698, 5, 149, 0, 0, 697, 696, 1, 0, 0, 0, 697, 698, 1, 0, 0, 0, 698, 699, 1, 0, 0, 0, 699, 701, 3, 140, 70, 0, 700, 697, 1, 0, 0, 0, 700, 701, 1, 0, 0, 0, 701, 71, 1, 0, 0, 0, 702, 704, 5, 73, 0, 0, 703, 705, 5, 149, 0, 0, 704, 703, 1, 0, 0, 0, 704, 705, 1, 0, 0, 0, 705, 706, 1, 0, 0, 0, 706, 707, 3, 180, 90, 0, 707, 708, 5, 149, 0, 0, 708, 709, 5, 69, 0, 0, 709, 710, 5, 149, 0, 0, 710, 711, 3, 258, 129, 0, 711, 73, 1, 0, 0, 0, 712, 714, 5, 74, 0, 0, 713, 715, 5, 149, 0, 0, 714, 713, 1, 0, 0, 0, 714, 715, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 721, 3, 144, 72, 0, 717, 718, 5, 149, 0, 0, 718, 720, 3, 76, 38, 0, 719, 717, 1, 0, 0, 0, 720, 723, 1, 0, 0, 0, 721, 719, 1, 0, 0, 0, 721, 722, 1, 0, 0, 0, 722, 75, 1, 0, 0, 0, 723, 721, 1, 0, 0, 0, 724, 725, 5, 58, 0, 0, 725, 726, 5, 149, 0, 0, 726, 727, 5, 72, 0, 0, 727, 728, 5, 149, 0, 0, 728, 735, 3, 82, 41, 0, 729, 730, 5, 58, 0, 0, 730, 731, 5, 149, 0, 0, 731, 732, 5, 55, 0, 0, 732, 733, 5, 149, 0, 0, 733, 735, 3, 82, 41, 0, 734, 724, 1, 0, 0, 0, 734, 729, 1, 0, 0, 0, 735, 77, 1, 0, 0, 0, 736, 738, 5, 55, 0, 0, 737, 739, 5, 149, 0, 0, 738, 737, 1, 0, 0, 0, 738, 739, 1, 0, 0, 0, 739, 740, 1, 0, 0, 0, 740, 741, 3, 142, 71, 0, 741, 79, 1, 0, 0, 0, 742, 743, 5, 55, 0, 0, 743, 744, 5, 149, 0, 0, 744, 746, 5, 62, 0, 0, 745, 747, 5, 149, 0, 0, 746, 745, 1, 0, 0, 0, 746, 747, 1, 0, 0, 0, 747, 748, 1, 0, 0, 0, 748, 749, 3, 142, 71, 0, 749, 81, 1, 0, 0, 0, 750, 752, 5, 75, 0, 0, 751, 753, 5, 149, 0, 0, 752, 751, 1, 0, 0, 0, 752, 753, 1, 0, 0, 0, 753, 754, 1, 0, 0, 0, 754, 765, 3, 84, 42, 0, 755, 757, 5, 149, 0, 0, 756, 755, 1, 0, 0, 0, 756, 757, 1, 0, 0, 0, 757, 758, 1, 0, 0, 0, 758, 760, 5, 7, 0, 0, 759, 761, 5, 149, 0, 0, 760, 759, 1, 0, 0, 0, 760, 761, 1, 0, 0, 0, 761, 762, 1, 0, 0, 0, 762, 764, 3, 84, 42, 0, 763, 756, 1, 0, 0, 0, 764, 767, 1, 0, 0, 0, 765, 763, 1, 0, 0, 0, 765, 766, 1, 0, 0, 0, 766, 83, 1, 0, 0, 0, 767, 765, 1, 0, 0, 0, 768, 770, 3, 178, 89, 0, 769, 771, 5, 149, 0, 0, 770, 769, 1, 0, 0, 0, 770, 771, 1, 0, 0, 0, 771, 772, 1, 0, 0, 0, 772, 774, 5, 2, 0, 0, 773, 775, 5, 149, 0, 0, 774, 773, 1, 0, 0, 0, 774, 775, 1, 0, 0, 0, 775, 776, 1, 0, 0, 0, 776, 777, 3, 180, 90, 0, 777, 805, 1, 0, 0, 0, 778, 780, 3, 258, 129, 0, 779, 781, 5, 149, 0, 0, 780, 779, 1, 0, 0, 0, 780, 781, 1, 0, 0, 0, 781, 782, 1, 0, 0, 0, 782, 784, 5, 2, 0, 0, 783, 785, 5, 149, 0, 0, 784, 783, 1, 0, 0, 0, 784, 785, 1, 0, 0, 0, 785, 786, 1, 0, 0, 0, 786, 787, 3, 180, 90, 0, 787, 805, 1, 0, 0, 0, 788, 790, 3, 258, 129, 0, 789, 791, 5, 149, 0, 0, 790, 789, 1, 0, 0, 0, 790, 791, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 794, 5, 8, 0, 0, 793, 795, 5, 149, 0, 0, 794, 793, 1, 0, 0, 0, 794, 795, 1, 0, 0, 0, 795, 796, 1, 0, 0, 0, 796, 797, 3, 180, 90, 0, 797, 805, 1, 0, 0, 0, 798, 800, 3, 258, 129, 0, 799, 801, 5, 149, 0, 0, 800, 799, 1, 0, 0, 0, 800, 801, 1, 0, 0, 0, 801, 802, 1, 0, 0, 0, 802, 803, 3, 168, 84, 0, 803, 805, 1, 0, 0, 0, 804, 768, 1, 0, 0, 0, 804, 778, 1, 0, 0, 0, 804, 788, 1, 0, 0, 0, 804, 798, 1, 0, 0, 0, 805, 85, 1, 0, 0, 0, 806, 807, 5, 76, 0, 0, 807, 809, 5, 149, 0, 0, 808, 806, 1, 0, 0, 0, 808, 809, 1, 0, 0, 0, 809, 810, 1, 0, 0, 0, 810, 812, 5, 77, 0, 0, 811, 813, 5, 149, 0, 0, 812, 811, 1, 0, 0, 0, 812, 813, 1, 0, 0, 0, 813, 814, 1, 0, 0, 0, 814, 825, 3, 180, 90, 0, 815, 817, 5, 149, 0, 0, 816, 815, 1, 0, 0, 0, 816, 817, 1, 0, 0, 0, 817, 818, 1, 0, 0, 0, 818, 820, 5, 7, 0, 0, 819, 821, 5, 149, 0, 0, 820, 819, 1, 0, 0, 0, 820, 821, 1, 0, 0, 0, 821, 822, 1, 0, 0, 0, 822, 824, 3, 180, 90, 0, 823, 816, 1, 0, 0, 0, 824, 827, 1, 0, 0, 0, 825, 823, 1, 0, 0, 0, 825, 826, 1, 0, 0, 0, 826, 87, 1, 0, 0, 0, 827, 825, 1, 0, 0, 0, 828, 829, 5, 78, 0, 0, 829, 830, 5, 149, 0, 0, 830, 841, 3, 90, 45, 0, 831, 833, 5, 149, 0, 0, 832, 831, 1, 0, 0, 0, 832, 833, 1, 0, 0, 0, 833, 834, 1, 0, 0, 0, 834, 836, 5, 7, 0, 0, 835, 837, 5, 149, 0, 0, 836, 835, 1, 0, 0, 0, 836, 837, 1, 0, 0, 0, 837, 838, 1, 0, 0, 0, 838, 840, 3, 90, 45, 0, 839, 832, 1, 0, 0, 0, 840, 843, 1, 0, 0, 0, 841, 839, 1, 0, 0, 0, 841, 842, 1, 0, 0, 0, 842, 89, 1, 0, 0, 0, 843, 841, 1, 0, 0, 0, 844, 845, 3, 258, 129, 0, 845, 846, 3, 168, 84, 0, 846, 849, 1, 0, 0, 0, 847, 849, 3, 178, 89, 0, 848, 844, 1, 0, 0, 0, 848, 847, 1, 0, 0, 0, 849, 91, 1, 0, 0, 0, 850, 852, 5, 79, 0, 0, 851, 853, 5, 149, 0, 0, 852, 851, 1, 0, 0, 0, 852, 853, 1, 0, 0, 0, 853, 854, 1, 0, 0, 0, 854, 856, 5, 3, 0, 0, 855, 857, 5, 149, 0, 0, 856, 855, 1, 0, 0, 0, 856, 857, 1, 0, 0, 0, 857, 858, 1, 0, 0, 0, 858, 859, 3, 258, 129, 0, 859, 860, 5, 149, 0, 0, 860, 861, 5, 80, 0, 0, 861, 862, 5, 149, 0, 0, 862, 864, 3, 180, 90, 0, 863, 865, 5, 149, 0, 0, 864, 863, 1, 0, 0, 0, 864, 865, 1, 0, 0, 0, 865, 866, 1, 0, 0, 0, 866, 869, 5, 9, 0, 0, 867, 868, 5, 149, 0, 0, 868, 870, 3, 36, 18, 0, 869, 867, 1, 0, 0, 0, 870, 871, 1, 0, 0, 0, 871, 869, 1, 0, 0, 0, 871, 872, 1, 0, 0, 0, 872, 874, 1, 0, 0, 0, 873, 875, 5, 149, 0, 0, 874, 873, 1, 0, 0, 0, 874, 875, 1, 0, 0, 0, 875, 876, 1, 0, 0, 0, 876, 877, 5, 4, 0, 0, 877, 93, 1, 0, 0, 0, 878, 879, 5, 81, 0, 0, 879, 880, 5, 149, 0, 0, 880, 887, 3, 248, 124, 0, 881, 883, 5, 149, 0, 0, 882, 881, 1, 0, 0, 0, 882, 883, 1, 0, 0, 0, 883, 884, 1, 0, 0, 0, 884, 885, 5, 82, 0, 0, 885, 886, 5, 149, 0, 0, 886, 888, 3, 98, 49, 0, 887, 882, 1, 0, 0, 0, 887, 888, 1, 0, 0, 0, 888, 95, 1, 0, 0, 0, 889, 890, 5, 81, 0, 0, 890, 893, 5, 149, 0, 0, 891, 894, 3, 248, 124, 0, 892, 894, 3, 250, 125, 0, 893, 891, 1, 0, 0, 0, 893, 892, 1, 0, 0, 0, 894, 904, 1, 0, 0, 0, 895, 897, 5, 149, 0, 0, 896, 895, 1, 0, 0, 0, 896, 897, 1, 0, 0, 0, 897, 898, 1, 0, 0, 0, 898, 899, 5, 82, 0, 0, 899, 902, 5, 149, 0, 0, 900, 903, 5, 10, 0, 0, 901, 903, 3, 98, 49, 0, 902, 900, 1, 0, 0, 0, 902, 901, 1, 0, 0, 0, 903, 905, 1, 0, 0, 0, 904, 896, 1, 0, 0, 0, 904, 905, 1, 0, 0, 0, 905, 97, 1, 0, 0, 0, 906, 917, 3, 100, 50, 0, 907, 909, 5, 149, 0, 0, 908, 907, 1, 0, 0, 0, 908, 909, 1, 0, 0, 0, 909, 910, 1, 0, 0, 0, 910, 912, 5, 7, 0, 0, 911, 913, 5, 149, 0, 0, 912, 911, 1, 0, 0, 0, 912, 913, 1, 0, 0, 0, 913, 914, 1, 0, 0, 0, 914, 916, 3, 100, 50, 0, 915, 908, 1, 0, 0, 0, 916, 919, 1, 0, 0, 0, 917, 915, 1, 0, 0, 0, 917, 918, 1, 0, 0, 0, 918, 924, 1, 0, 0, 0, 919, 917, 1, 0, 0, 0, 920, 922, 5, 149, 0, 0, 921, 920, 1, 0, 0, 0, 921, 922, 1, 0, 0, 0, 922, 923, 1, 0, 0, 0, 923, 925, 3, 140, 70, 0, 924, 921, 1, 0, 0, 0, 924, 925, 1, 0, 0, 0, 925, 99, 1, 0, 0, 0, 926, 927, 3, 252, 126, 0, 927, 928, 5, 149, 0, 0, 928, 929, 5, 69, 0, 0, 929, 930, 5, 149, 0, 0, 930, 932, 1, 0, 0, 0, 931, 926, 1, 0, 0, 0, 931, 932, 1, 0, 0, 0, 932, 933, 1, 0, 0, 0, 933, 934, 3, 258, 129, 0, 934, 101, 1, 0, 0, 0, 935, 936, 5, 66, 0, 0, 936, 941, 3, 106, 53, 0, 937, 939, 5, 149, 0, 0, 938, 937, 1, 0, 0, 0, 938, 939, 1, 0, 0, 0, 939, 940, 1, 0, 0, 0, 940, 942, 3, 140, 70, 0, 941, 938, 1, 0, 0, 0, 941, 942, 1, 0, 0, 0, 942, 103, 1, 0, 0, 0, 943, 944, 5, 83, 0, 0, 944, 945, 3, 106, 53, 0, 945, 105, 1, 0, 0, 0, 946, 948, 5, 149, 0, 0, 947, 946, 1, 0, 0, 0, 947, 948, 1, 0, 0, 0, 948, 949, 1, 0, 0, 0, 949, 951, 5, 84, 0, 0, 950, 947, 1, 0, 0, 0, 950, 951, 1, 0, 0, 0, 951, 952, 1, 0, 0, 0, 952, 953, 5, 149, 0, 0, 953, 956, 3, 108, 54, 0, 954, 955, 5, 149, 0, 0, 955, 957, 3, 112, 56, 0, 956, 954, 1, 0, 0, 0, 956, 957, 1, 0, 0, 0, 957, 960, 1, 0, 0, 0, 958, 959, 5, 149, 0, 0, 959, 961, 3, 114, 57, 0, 960, 958, 1, 0, 0, 0, 960, 961, 1, 0, 0, 0, 961, 964, 1, 0, 0, 0, 962, 963, 5, 149, 0, 0, 963, 965, 3, 116, 58, 0, 964, 962, 1, 0, 0, 0, 964, 965, 1, 0, 0, 0, 965, 107, 1, 0, 0, 0, 966, 977, 5, 10, 0, 0, 967, 969, 5, 149, 0, 0, 968, 967, 1, 0, 0, 0, 968, 969, 1, 0, 0, 0, 969, 970, 1, 0, 0, 0, 970, 972, 5, 7, 0, 0, 971, 973, 5, 149, 0, 0, 972, 971, 1, 0, 0, 0, 972, 973, 1, 0, 0, 0, 973, 974, 1, 0, 0, 0, 974, 976, 3, 110, 55, 0, 975, 968, 1, 0, 0, 0, 976, 979, 1, 0, 0, 0, 977, 975, 1, 0, 0, 0, 977, 978, 1, 0, 0, 0, 978, 995, 1, 0, 0, 0, 979, 977, 1, 0, 0, 0, 980, 991, 3, 110, 55, 0, 981, 983, 5, 149, 0, 0, 982, 981, 1, 0, 0, 0, 982, 983, 1, 0, 0, 0, 983, 984, 1, 0, 0, 0, 984, 986, 5, 7, 0, 0, 985, 987, 5, 149, 0, 0, 986, 985, 1, 0, 0, 0, 986, 987, 1, 0, 0, 0, 987, 988, 1, 0, 0, 0, 988, 990, 3, 110, 55, 0, 989, 982, 1, 0, 0, 0, 990, 993, 1, 0, 0, 0, 991, 989, 1, 0, 0, 0, 991, 992, 1, 0, 0, 0, 992, 995, 1, 0, 0, 0, 993, 991, 1, 0, 0, 0, 994, 966, 1, 0, 0, 0, 994, 980, 1, 0, 0, 0, 995, 109, 1, 0, 0, 0, 996, 997, 3, 180, 90, 0, 997, 998, 5, 149, 0, 0, 998, 999, 5, 69, 0, 0, 999, 1000, 5, 149, 0, 0, 1000, 1001, 3, 258, 129, 0, 1001, 1004, 1, 0, 0, 0, 1002, 1004, 3, 180, 90, 0, 1003, 996, 1, 0, 0, 0, 1003, 1002, 1, 0, 0, 0, 1004, 111, 1, 0, 0, 0, 1005, 1006, 5, 85, 0, 0, 1006, 1007, 5, 149, 0, 0, 1007, 1008, 5, 86, 0, 0, 1008, 1009, 5, 149, 0, 0, 1009, 1017, 3, 118, 59, 0, 1010, 1012, 5, 7, 0, 0, 1011, 1013, 5, 149, 0, 0, 1012, 1011, 1, 0, 0, 0, 1012, 1013, 1, 0, 0, 0, 1013, 1014, 1, 0, 0, 0, 1014, 1016, 3, 118, 59, 0, 1015, 1010, 1, 0, 0, 0, 1016, 1019, 1, 0, 0, 0, 1017, 1015, 1, 0, 0, 0, 1017, 1018, 1, 0, 0, 0, 1018, 113, 1, 0, 0, 0, 1019, 1017, 1, 0, 0, 0, 1020, 1021, 5, 87, 0, 0, 1021, 1022, 5, 149, 0, 0, 1022, 1023, 3, 180, 90, 0, 1023, 115, 1, 0, 0, 0, 1024, 1025, 5, 88, 0, 0, 1025, 1026, 5, 149, 0, 0, 1026, 1027, 3, 180, 90, 0, 1027, 117, 1, 0, 0, 0, 1028, 1033, 3, 180, 90, 0, 1029, 1031, 5, 149, 0, 0, 1030, 1029, 1, 0, 0, 0, 1030, 1031, 1, 0, 0, 0, 1031, 1032, 1, 0, 0, 0, 1032, 1034, 7, 0, 0, 0, 1033, 1030, 1, 0, 0, 0, 1033, 1034, 1, 0, 0, 0, 1034, 119, 1, 0, 0, 0, 1035, 1037, 5, 149, 0, 0, 1036, 1035, 1, 0, 0, 0, 1036, 1037, 1, 0, 0, 0, 1037, 1075, 1, 0, 0, 0, 1038, 1039, 5, 50, 0, 0, 1039, 1040, 5, 149, 0, 0, 1040, 1041, 5, 57, 0, 0, 1041, 1042, 5, 149, 0, 0, 1042, 1043, 3, 258, 129, 0, 1043, 1044, 3, 170, 85, 0, 1044, 1045, 5, 3, 0, 0, 1045, 1046, 3, 274, 137, 0, 1046, 1047, 5, 4, 0, 0, 1047, 1076, 1, 0, 0, 0, 1048, 1049, 5, 50, 0, 0, 1049, 1050, 5, 149, 0, 0, 1050, 1051, 5, 93, 0, 0, 1051, 1052, 5, 149, 0, 0, 1052, 1053, 5, 58, 0, 0, 1053, 1054, 5, 149, 0, 0, 1054, 1065, 3, 258, 129, 0, 1055, 1057, 5, 149, 0, 0, 1056, 1055, 1, 0, 0, 0, 1056, 1057, 1, 0, 0, 0, 1057, 1058, 1, 0, 0, 0, 1058, 1060, 5, 7, 0, 0, 1059, 1061, 5, 149, 0, 0, 1060, 1059, 1, 0, 0, 0, 1060, 1061, 1, 0, 0, 0, 1061, 1062, 1, 0, 0, 0, 1062, 1064, 3, 258, 129, 0, 1063, 1056, 1, 0, 0, 0, 1064, 1067, 1, 0, 0, 0, 1065, 1063, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1066, 1076, 1, 0, 0, 0, 1067, 1065, 1, 0, 0, 0, 1068, 1069, 5, 50, 0, 0, 1069, 1070, 5, 149, 0, 0, 1070, 1071, 5, 94, 0, 0, 1071, 1072, 5, 149, 0, 0, 1072, 1073, 3, 258, 129, 0, 1073, 1074, 3, 170, 85, 0, 1074, 1076, 1, 0, 0, 0, 1075, 1038, 1, 0, 0, 0, 1075, 1048, 1, 0, 0, 0, 1075, 1068, 1, 0, 0, 0, 1076, 121, 1, 0, 0, 0, 1077, 1078, 5, 95, 0, 0, 1078, 1079, 5, 149, 0, 0, 1079, 1090, 3, 124, 62, 0, 1080, 1082, 5, 149, 0, 0, 1081, 1080, 1, 0, 0, 0, 1081, 1082, 1, 0, 0, 0, 1082, 1083, 1, 0, 0, 0, 1083, 1085, 5, 7, 0, 0, 1084, 1086, 5, 149, 0, 0, 1085, 1084, 1, 0, 0, 0, 1085, 1086, 1, 0, 0, 0, 1086, 1087, 1, 0, 0, 0, 1087, 1089, 3, 124, 62, 0, 1088, 1081, 1, 0, 0, 0, 1089, 1092, 1, 0, 0, 0, 1090, 1088, 1, 0, 0, 0, 1090, 1091, 1, 0, 0, 0, 1091, 1094, 1, 0, 0, 0, 1092, 1090, 1, 0, 0, 0, 1093, 1095, 3, 140, 70, 0, 1094, 1093, 1, 0, 0, 0, 1094, 1095, 1, 0, 0, 0, 1095, 123, 1, 0, 0, 0, 1096, 1098, 3, 258, 129, 0, 1097, 1099, 5, 149, 0, 0, 1098, 1097, 1, 0, 0, 0, 1098, 1099, 1, 0, 0, 0, 1099, 1100, 1, 0, 0, 0, 1100, 1102, 5, 2, 0, 0, 1101, 1103, 5, 149, 0, 0, 1102, 1101, 1, 0, 0, 0, 1102, 1103, 1, 0, 0, 0, 1103, 1104, 1, 0, 0, 0, 1104, 1105, 3, 126, 63, 0, 1105, 125, 1, 0, 0, 0, 1106, 1109, 3, 128, 64, 0, 1107, 1109, 3, 130, 65, 0, 1108, 1106, 1, 0, 0, 0, 1108, 1107, 1, 0, 0, 0, 1109, 127, 1, 0, 0, 0, 1110, 1112, 5, 96, 0, 0, 1111, 1113, 5, 149, 0, 0, 1112, 1111, 1, 0, 0, 0, 1112, 1113, 1, 0, 0, 0, 1113, 1117, 1, 0, 0, 0, 1114, 1118, 3, 132, 66, 0, 1115, 1118, 3, 134, 67, 0, 1116, 1118, 3, 136, 68, 0, 1117, 1114, 1, 0, 0, 0, 1117, 1115, 1, 0, 0, 0, 1117, 1116, 1, 0, 0, 0, 1118, 129, 1, 0, 0, 0, 1119, 1123, 7, 1, 0, 0, 1120, 1124, 3, 132, 66, 0, 1121, 1124, 3, 134, 67, 0, 1122, 1124, 3, 136, 68, 0, 1123, 1120, 1, 0, 0, 0, 1123, 1121, 1, 0, 0, 0, 1123, 1122, 1, 0, 0, 0, 1124, 131, 1, 0, 0, 0, 1125, 1126, 5, 11, 0, 0, 1126, 1127, 3, 284, 142, 0, 1127, 1128, 5, 3, 0, 0, 1128, 1129, 3, 284, 142, 0, 1129, 1132, 5, 2, 0, 0, 1130, 1133, 5, 136, 0, 0, 1131, 1133, 3, 276, 138, 0, 1132, 1130, 1, 0, 0, 0, 1132, 1131, 1, 0, 0, 0, 1133, 1134, 1, 0, 0, 0, 1134, 1135, 5, 4, 0, 0, 1135, 133, 1, 0, 0, 0, 1136, 1137, 5, 11, 0, 0, 1137, 1138, 3, 284, 142, 0, 1138, 1141, 5, 3, 0, 0, 1139, 1142, 5, 136, 0, 0, 1140, 1142, 3, 276, 138, 0, 1141, 1139, 1, 0, 0, 0, 1141, 1140, 1, 0, 0, 0, 1142, 1143, 1, 0, 0, 0, 1143, 1144, 5, 4, 0, 0, 1144, 135, 1, 0, 0, 0, 1145, 1149, 5, 3, 0, 0, 1146, 1150, 3, 138, 69, 0, 1147, 1150, 3, 276, 138, 0, 1148, 1150, 5, 10, 0, 0, 1149, 1146, 1, 0, 0, 0, 1149, 1147, 1, 0, 0, 0, 1149, 1148, 1, 0, 0, 0, 1150, 1151, 1, 0, 0, 0, 1151, 1152, 5, 4, 0, 0, 1152, 137, 1, 0, 0, 0, 1153, 1164, 3, 266, 133, 0, 1154, 1156, 5, 149, 0, 0, 1155, 1154, 1, 0, 0, 0, 1155, 1156, 1, 0, 0, 0, 1156, 1157, 1, 0, 0, 0, 1157, 1159, 5, 7, 0, 0, 1158, 1160, 5, 149, 0, 0, 1159, 1158, 1, 0, 0, 0, 1159, 1160, 1, 0, 0, 0, 1160, 1161, 1, 0, 0, 0, 1161, 1163, 3, 266, 133, 0, 1162, 1155, 1, 0, 0, 0, 1163, 1166, 1, 0, 0, 0, 1164, 1162, 1, 0, 0, 0, 1164, 1165, 1, 0, 0, 0, 1165, 139, 1, 0, 0, 0, 1166, 1164, 1, 0, 0, 0, 1167, 1168, 5, 99, 0, 0, 1168, 1169, 5, 149, 0, 0, 1169, 1170, 3, 180, 90, 0, 1170, 141, 1, 0, 0, 0, 1171, 1182, 3, 144, 72, 0, 1172, 1174, 5, 149, 0, 0, 1173, 1172, 1, 0, 0, 0, 1173, 1174, 1, 0, 0, 0, 1174, 1175, 1, 0, 0, 0, 1175, 1177, 5, 7, 0, 0, 1176, 1178, 5, 149, 0, 0, 1177, 1176, 1, 0, 0, 0, 1177, 1178, 1, 0, 0, 0, 1178, 1179, 1, 0, 0, 0, 1179, 1181, 3, 144, 72, 0, 1180, 1173, 1, 0, 0, 0, 1181, 1184, 1, 0, 0, 0, 1182, 1180, 1, 0, 0, 0, 1182, 1183, 1, 0, 0, 0, 1183, 143, 1, 0, 0, 0, 1184, 1182, 1, 0, 0, 0, 1185, 1187, 3, 258, 129, 0, 1186, 1188, 5, 149, 0, 0, 1187, 1186, 1, 0, 0, 0, 1187, 1188, 1, 0, 0, 0, 1188, 1189, 1, 0, 0, 0, 1189, 1191, 5, 2, 0, 0, 1190, 1192, 5, 149, 0, 0, 1191, 1190, 1, 0, 0, 0, 1191, 1192, 1, 0, 0, 0, 1192, 1193, 1, 0, 0, 0, 1193, 1194, 3, 146, 73, 0, 1194, 1197, 1, 0, 0, 0, 1195, 1197, 3, 146, 73, 0, 1196, 1185, 1, 0, 0, 0, 1196, 1195, 1, 0, 0, 0, 1197, 145, 1, 0, 0, 0, 1198, 1201, 3, 148, 74, 0, 1199, 1201, 3, 150, 75, 0, 1200, 1198, 1, 0, 0, 0, 1200, 1199, 1, 0, 0, 0, 1201, 147, 1, 0, 0, 0, 1202, 1203, 5, 100, 0, 0, 1203, 1204, 5, 3, 0, 0, 1204, 1205, 3, 150, 75, 0, 1205, 1206, 5, 4, 0, 0, 1206, 1213, 1, 0, 0, 0, 1207, 1208, 5, 101, 0, 0, 1208, 1209, 5, 3, 0, 0, 1209, 1210, 3, 150, 75, 0, 1210, 1211, 5, 4, 0, 0, 1211, 1213, 1, 0, 0, 0, 1212, 1202, 1, 0, 0, 0, 1212, 1207, 1, 0, 0, 0, 1213, 149, 1, 0, 0, 0, 1214, 1221, 3, 154, 77, 0, 1215, 1217, 5, 149, 0, 0, 1216, 1215, 1, 0, 0, 0, 1216, 1217, 1, 0, 0, 0, 1217, 1218, 1, 0, 0, 0, 1218, 1220, 3, 156, 78, 0, 1219, 1216, 1, 0, 0, 0, 1220, 1223, 1, 0, 0, 0, 1221, 1219, 1, 0, 0, 0, 1221, 1222, 1, 0, 0, 0, 1222, 1229, 1, 0, 0, 0, 1223, 1221, 1, 0, 0, 0, 1224, 1225, 5, 3, 0, 0, 1225, 1226, 3, 150, 75, 0, 1226, 1227, 5, 4, 0, 0, 1227, 1229, 1, 0, 0, 0, 1228, 1214, 1, 0, 0, 0, 1228, 1224, 1, 0, 0, 0, 1229, 151, 1, 0, 0, 0, 1230, 1235, 3, 154, 77, 0, 1231, 1233, 5, 149, 0, 0, 1232, 1231, 1, 0, 0, 0, 1232, 1233, 1, 0, 0, 0, 1233, 1234, 1, 0, 0, 0, 1234, 1236, 3, 156, 78, 0, 1235, 1232, 1, 0, 0, 0, 1236, 1237, 1, 0, 0, 0, 1237, 1235, 1, 0, 0, 0, 1237, 1238, 1, 0, 0, 0, 1238, 153, 1, 0, 0, 0, 1239, 1241, 5, 3, 0, 0, 1240, 1242, 5, 149, 0, 0, 1241, 1240, 1, 0, 0, 0, 1241, 1242, 1, 0, 0, 0, 1242, 1247, 1, 0, 0, 0, 1243, 1245, 3, 258, 129, 0, 1244, 1246, 5, 149, 0, 0, 1245, 1244, 1, 0, 0, 0, 1245, 1246, 1, 0, 0, 0, 1246, 1248, 1, 0, 0, 0, 1247, 1243, 1, 0, 0, 0, 1247, 1248, 1, 0, 0, 0, 1248, 1253, 1, 0, 0, 0, 1249, 1251, 3, 168, 84, 0, 1250, 1252, 5, 149, 0, 0, 1251, 1250, 1, 0, 0, 0, 1251, 1252, 1, 0, 0, 0, 1252, 1254, 1, 0, 0, 0, 1253, 1249, 1, 0, 0, 0, 1253, 1254, 1, 0, 0, 0, 1254, 1259, 1, 0, 0, 0, 1255, 1257, 3, 162, 81, 0, 1256, 1258, 5, 149, 0, 0, 1257, 1256, 1, 0, 0, 0, 1257, 1258, 1, 0, 0, 0, 1258, 1260, 1, 0, 0, 0, 1259, 1255, 1, 0, 0, 0, 1259, 1260, 1, 0, 0, 0, 1260, 1261, 1, 0, 0, 0, 1261, 1262, 5, 4, 0, 0, 1262, 155, 1, 0, 0, 0, 1263, 1265, 3, 158, 79, 0, 1264, 1266, 5, 149, 0, 0, 1265, 1264, 1, 0, 0, 0, 1265, 1266, 1, 0, 0, 0, 1266, 1267, 1, 0, 0, 0, 1267, 1268, 3, 154, 77, 0, 1268, 157, 1, 0, 0, 0, 1269, 1271, 3, 286, 143, 0, 1270, 1272, 5, 149, 0, 0, 1271, 1270, 1, 0, 0, 0, 1271, 1272, 1, 0, 0, 0, 1272, 1273, 1, 0, 0, 0, 1273, 1275, 3, 290, 145, 0, 1274, 1276, 5, 149, 0, 0, 1275, 1274, 1, 0, 0, 0, 1275, 1276, 1, 0, 0, 0, 1276, 1278, 1, 0, 0, 0, 1277, 1279, 3, 160, 80, 0, 1278, 1277, 1, 0, 0, 0, 1278, 1279, 1, 0, 0, 0, 1279, 1281, 1, 0, 0, 0, 1280, 1282, 5, 149, 0, 0, 1281, 1280, 1, 0, 0, 0, 1281, 1282, 1, 0, 0, 0, 1282, 1283, 1, 0, 0, 0, 1283, 1285, 3, 290, 145, 0, 1284, 1286, 5, 149, 0, 0, 1285, 1284, 1, 0, 0, 0, 1285, 1286, 1, 0, 0, 0, 1286, 1287, 1, 0, 0, 0, 1287, 1288, 3, 288, 144, 0, 1288, 1334, 1, 0, 0, 0, 1289, 1291, 3, 286, 143, 0, 1290, 1292, 5, 149, 0, 0, 1291, 1290, 1, 0, 0, 0, 1291, 1292, 1, 0, 0, 0, 1292, 1293, 1, 0, 0, 0, 1293, 1295, 3, 290, 145, 0, 1294, 1296, 5, 149, 0, 0, 1295, 1294, 1, 0, 0, 0, 1295, 1296, 1, 0, 0, 0, 1296, 1298, 1, 0, 0, 0, 1297, 1299, 3, 160, 80, 0, 1298, 1297, 1, 0, 0, 0, 1298, 1299, 1, 0, 0, 0, 1299, 1301, 1, 0, 0, 0, 1300, 1302, 5, 149, 0, 0, 1301, 1300, 1, 0, 0, 0, 1301, 1302, 1, 0, 0, 0, 1302, 1303, 1, 0, 0, 0, 1303, 1304, 3, 290, 145, 0, 1304, 1334, 1, 0, 0, 0, 1305, 1307, 3, 290, 145, 0, 1306, 1308, 5, 149, 0, 0, 1307, 1306, 1, 0, 0, 0, 1307, 1308, 1, 0, 0, 0, 1308, 1310, 1, 0, 0, 0, 1309, 1311, 3, 160, 80, 0, 1310, 1309, 1, 0, 0, 0, 1310, 1311, 1, 0, 0, 0, 1311, 1313, 1, 0, 0, 0, 1312, 1314, 5, 149, 0, 0, 1313, 1312, 1, 0, 0, 0, 1313, 1314, 1, 0, 0, 0, 1314, 1315, 1, 0, 0, 0, 1315, 1317, 3, 290, 145, 0, 1316, 1318, 5, 149, 0, 0, 1317, 1316, 1, 0, 0, 0, 1317, 1318, 1, 0, 0, 0, 1318, 1319, 1, 0, 0, 0, 1319, 1320, 3, 288, 144, 0, 1320, 1334, 1, 0, 0, 0, 1321, 1323, 3, 290, 145, 0, 1322, 1324, 5, 149, 0, 0, 1323, 1322, 1, 0, 0, 0, 1323, 1324, 1, 0, 0, 0, 1324, 1326, 1, 0, 0, 0, 1325, 1327, 3, 160, 80, 0, 1326, 1325, 1, 0, 0, 0, 1326, 1327, 1, 0, 0, 0, 1327, 1329, 1, 0, 0, 0, 1328, 1330, 5, 149, 0, 0, 1329, 1328, 1, 0, 0, 0, 1329, 1330, 1, 0, 0, 0, 1330, 1331, 1, 0, 0, 0, 1331, 1332, 3, 290, 145, 0, 1332, 1334, 1, 0, 0, 0, 1333, 1269, 1, 0, 0, 0, 1333, 1289, 1, 0, 0, 0, 1333, 1305, 1, 0, 0, 0, 1333, 1321, 1, 0, 0, 0, 1334, 159, 1, 0, 0, 0, 1335, 1337, 5, 5, 0, 0, 1336, 1338, 5, 149, 0, 0, 1337, 1336, 1, 0, 0, 0, 1337, 1338, 1, 0, 0, 0, 1338, 1343, 1, 0, 0, 0, 1339, 1341, 3, 258, 129, 0, 1340, 1342, 5, 149, 0, 0, 1341, 1340, 1, 0, 0, 0, 1341, 1342, 1, 0, 0, 0, 1342, 1344, 1, 0, 0, 0, 1343, 1339, 1, 0, 0, 0, 1343, 1344, 1, 0, 0, 0, 1344, 1349, 1, 0, 0, 0, 1345, 1347, 3, 166, 83, 0, 1346, 1348, 5, 149, 0, 0, 1347, 1346, 1, 0, 0, 0, 1347, 1348, 1, 0, 0, 0, 1348, 1350, 1, 0, 0, 0, 1349, 1345, 1, 0, 0, 0, 1349, 1350, 1, 0, 0, 0, 1350, 1352, 1, 0, 0, 0, 1351, 1353, 3, 172, 86, 0, 1352, 1351, 1, 0, 0, 0, 1352, 1353, 1, 0, 0, 0, 1353, 1358, 1, 0, 0, 0, 1354, 1356, 3, 162, 81, 0, 1355, 1357, 5, 149, 0, 0, 1356, 1355, 1, 0, 0, 0, 1356, 1357, 1, 0, 0, 0, 1357, 1359, 1, 0, 0, 0, 1358, 1354, 1, 0, 0, 0, 1358, 1359, 1, 0, 0, 0, 1359, 1360, 1, 0, 0, 0, 1360, 1361, 5, 6, 0, 0, 1361, 161, 1, 0, 0, 0, 1362, 1366, 3, 272, 136, 0, 1363, 1366, 3, 278, 139, 0, 1364, 1366, 3, 276, 138, 0, 1365, 1362, 1, 0, 0, 0, 1365, 1363, 1, 0, 0, 0, 1365, 1364, 1, 0, 0, 0, 1366, 163, 1, 0, 0, 0, 1367, 1369, 5, 11, 0, 0, 1368, 1370, 5, 149, 0, 0, 1369, 1368, 1, 0, 0, 0, 1369, 1370, 1, 0, 0, 0, 1370, 1371, 1, 0, 0, 0, 1371, 1372, 3, 176, 88, 0, 1372, 165, 1, 0, 0, 0, 1373, 1375, 5, 11, 0, 0, 1374, 1376, 5, 149, 0, 0, 1375, 1374, 1, 0, 0, 0, 1375, 1376, 1, 0, 0, 0, 1376, 1377, 1, 0, 0, 0, 1377, 1391, 3, 176, 88, 0, 1378, 1380, 5, 149, 0, 0, 1379, 1378, 1, 0, 0, 0, 1379, 1380, 1, 0, 0, 0, 1380, 1381, 1, 0, 0, 0, 1381, 1383, 5, 9, 0, 0, 1382, 1384, 5, 11, 0, 0, 1383, 1382, 1, 0, 0, 0, 1383, 1384, 1, 0, 0, 0, 1384, 1386, 1, 0, 0, 0, 1385, 1387, 5, 149, 0, 0, 1386, 1385, 1, 0, 0, 0, 1386, 1387, 1, 0, 0, 0, 1387, 1388, 1, 0, 0, 0, 1388, 1390, 3, 176, 88, 0, 1389, 1379, 1, 0, 0, 0, 1390, 1393, 1, 0, 0, 0, 1391, 1389, 1, 0, 0, 0, 1391, 1392, 1, 0, 0, 0, 1392, 167, 1, 0, 0, 0, 1393, 1391, 1, 0, 0, 0, 1394, 1401, 3, 170, 85, 0, 1395, 1397, 5, 149, 0, 0, 1396, 1395, 1, 0, 0, 0, 1396, 1397, 1, 0, 0, 0, 1397, 1398, 1, 0, 0, 0, 1398, 1400, 3, 170, 85, 0, 1399, 1396, 1, 0, 0, 0, 1400, 1403, 1, 0, 0, 0, 1401, 1399, 1, 0, 0, 0, 1401, 1402, 1, 0, 0, 0, 1402, 169, 1, 0, 0, 0, 1403, 1401, 1, 0, 0, 0, 1404, 1406, 5, 11, 0, 0, 1405, 1407, 5, 149, 0, 0, 1406, 1405, 1, 0, 0, 0, 1406, 1407, 1, 0, 0, 0, 1407, 1408, 1, 0, 0, 0, 1408, 1409, 3, 174, 87, 0, 1409, 171, 1, 0, 0, 0, 1410, 1412, 5, 10, 0, 0, 1411, 1413, 5, 149, 0, 0, 1412, 1411, 1, 0, 0, 0, 1412, 1413, 1, 0, 0, 0, 1413, 1418, 1, 0, 0, 0, 1414, 1416, 3, 266, 133, 0, 1415, 1417, 5, 149, 0, 0, 1416, 1415, 1, 0, 0, 0, 1416, 1417, 1, 0, 0, 0, 1417, 1419, 1, 0, 0, 0, 1418, 1414, 1, 0, 0, 0, 1418, 1419, 1, 0, 0, 0, 1419, 1430, 1, 0, 0, 0, 1420, 1422, 5, 12, 0, 0, 1421, 1423, 5, 149, 0, 0, 1422, 1421, 1, 0, 0, 0, 1422, 1423, 1, 0, 0, 0, 1423, 1428, 1, 0, 0, 0, 1424, 1426, 3, 266, 133, 0, 1425, 1427, 5, 149, 0, 0, 1426, 1425, 1, 0, 0, 0, 1426, 1427, 1, 0, 0, 0, 1427, 1429, 1, 0, 0, 0, 1428, 1424, 1, 0, 0, 0, 1428, 1429, 1, 0, 0, 0, 1429, 1431, 1, 0, 0, 0, 1430, 1420, 1, 0, 0, 0, 1430, 1431, 1, 0, 0, 0, 1431, 173, 1, 0, 0, 0, 1432, 1433, 3, 280, 140, 0, 1433, 175, 1, 0, 0, 0, 1434, 1435, 3, 280, 140, 0, 1435, 177, 1, 0, 0, 0, 1436, 1441, 3, 218, 109, 0, 1437, 1439, 5, 149, 0, 0, 1438, 1437, 1, 0, 0, 0, 1438, 1439, 1, 0, 0, 0, 1439, 1440, 1, 0, 0, 0, 1440, 1442, 3, 216, 108, 0, 1441, 1438, 1, 0, 0, 0, 1442, 1443, 1, 0, 0, 0, 1443, 1441, 1, 0, 0, 0, 1443, 1444, 1, 0, 0, 0, 1444, 179, 1, 0, 0, 0, 1445, 1446, 3, 182, 91, 0, 1446, 181, 1, 0, 0, 0, 1447, 1454, 3, 184, 92, 0, 1448, 1449, 5, 149, 0, 0, 1449, 1450, 5, 102, 0, 0, 1450, 1451, 5, 149, 0, 0, 1451, 1453, 3, 184, 92, 0, 1452, 1448, 1, 0, 0, 0, 1453, 1456, 1, 0, 0, 0, 1454, 1452, 1, 0, 0, 0, 1454, 1455, 1, 0, 0, 0, 1455, 183, 1, 0, 0, 0, 1456, 1454, 1, 0, 0, 0, 1457, 1464, 3, 186, 93, 0, 1458, 1459, 5, 149, 0, 0, 1459, 1460, 5, 103, 0, 0, 1460, 1461, 5, 149, 0, 0, 1461, 1463, 3, 186, 93, 0, 1462, 1458, 1, 0, 0, 0, 1463, 1466, 1, 0, 0, 0, 1464, 1462, 1, 0, 0, 0, 1464, 1465, 1, 0, 0, 0, 1465, 185, 1, 0, 0, 0, 1466, 1464, 1, 0, 0, 0, 1467, 1474, 3, 188, 94, 0, 1468, 1469, 5, 149, 0, 0, 1469, 1470, 5, 104, 0, 0, 1470, 1471, 5, 149, 0, 0, 1471, 1473, 3, 188, 94, 0, 1472, 1468, 1, 0, 0, 0, 1473, 1476, 1, 0, 0, 0, 1474, 1472, 1, 0, 0, 0, 1474, 1475, 1, 0, 0, 0, 1475, 187, 1, 0, 0, 0, 1476, 1474, 1, 0, 0, 0, 1477, 1479, 5, 105, 0, 0, 1478, 1480, 5, 149, 0, 0, 1479, 1478, 1, 0, 0, 0, 1479, 1480, 1, 0, 0, 0, 1480, 1482, 1, 0, 0, 0, 1481, 1477, 1, 0, 0, 0, 1482, 1485, 1, 0, 0, 0, 1483, 1481, 1, 0, 0, 0, 1483, 1484, 1, 0, 0, 0, 1484, 1486, 1, 0, 0, 0, 1485, 1483, 1, 0, 0, 0, 1486, 1487, 3, 190, 95, 0, 1487, 189, 1, 0, 0, 0, 1488, 1495, 3, 194, 97, 0, 1489, 1491, 5, 149, 0, 0, 1490, 1489, 1, 0, 0, 0, 1490, 1491, 1, 0, 0, 0, 1491, 1492, 1, 0, 0, 0, 1492, 1494, 3, 192, 96, 0, 1493, 1490, 1, 0, 0, 0, 1494, 1497, 1, 0, 0, 0, 1495, 1493, 1, 0, 0, 0, 1495, 1496, 1, 0, 0, 0, 1496, 191, 1, 0, 0, 0, 1497, 1495, 1, 0, 0, 0, 1498, 1500, 5, 2, 0, 0, 1499, 1501, 5, 149, 0, 0, 1500, 1499, 1, 0, 0, 0, 1500, 1501, 1, 0, 0, 0, 1501, 1502, 1, 0, 0, 0, 1502, 1529, 3, 194, 97, 0, 1503, 1505, 5, 13, 0, 0, 1504, 1506, 5, 149, 0, 0, 1505, 1504, 1, 0, 0, 0, 1505, 1506, 1, 0, 0, 0, 1506, 1507, 1, 0, 0, 0, 1507, 1529, 3, 194, 97, 0, 1508, 1510, 5, 14, 0, 0, 1509, 1511, 5, 149, 0, 0, 1510, 1509, 1, 0, 0, 0, 1510, 1511, 1, 0, 0, 0, 1511, 1512, 1, 0, 0, 0, 1512, 1529, 3, 194, 97, 0, 1513, 1515, 5, 15, 0, 0, 1514, 1516, 5, 149, 0, 0, 1515, 1514, 1, 0, 0, 0, 1515, 1516, 1, 0, 0, 0, 1516, 1517, 1, 0, 0, 0, 1517, 1529, 3, 194, 97, 0, 1518, 1520, 5, 16, 0, 0, 1519, 1521, 5, 149, 0, 0, 1520, 1519, 1, 0, 0, 0, 1520, 1521, 1, 0, 0, 0, 1521, 1522, 1, 0, 0, 0, 1522, 1529, 3, 194, 97, 0, 1523, 1525, 5, 17, 0, 0, 1524, 1526, 5, 149, 0, 0, 1525, 1524, 1, 0, 0, 0, 1525, 1526, 1, 0, 0, 0, 1526, 1527, 1, 0, 0, 0, 1527, 1529, 3, 194, 97, 0, 1528, 1498, 1, 0, 0, 0, 1528, 1503, 1, 0, 0, 0, 1528, 1508, 1, 0, 0, 0, 1528, 1513, 1, 0, 0, 0, 1528, 1518, 1, 0, 0, 0, 1528, 1523, 1, 0, 0, 0, 1529, 193, 1, 0, 0, 0, 1530, 1536, 3, 204, 102, 0, 1531, 1535, 3, 196, 98, 0, 1532, 1535, 3, 198, 99, 0, 1533, 1535, 3, 200, 100, 0, 1534, 1531, 1, 0, 0, 0, 1534, 1532, 1, 0, 0, 0, 1534, 1533, 1, 0, 0, 0, 1535, 1538, 1, 0, 0, 0, 1536, 1534, 1, 0, 0, 0, 1536, 1537, 1, 0, 0, 0, 1537, 195, 1, 0, 0, 0, 1538, 1536, 1, 0, 0, 0, 1539, 1551, 3, 202, 101, 0, 1540, 1541, 5, 149, 0, 0, 1541, 1542, 5, 106, 0, 0, 1542, 1543, 5, 149, 0, 0, 1543, 1551, 5, 66, 0, 0, 1544, 1545, 5, 149, 0, 0, 1545, 1546, 5, 107, 0, 0, 1546, 1547, 5, 149, 0, 0, 1547, 1551, 5, 66, 0, 0, 1548, 1549, 5, 149, 0, 0, 1549, 1551, 5, 108, 0, 0, 1550, 1539, 1, 0, 0, 0, 1550, 1540, 1, 0, 0, 0, 1550, 1544, 1, 0, 0, 0, 1550, 1548, 1, 0, 0, 0, 1551, 1553, 1, 0, 0, 0, 1552, 1554, 5, 149, 0, 0, 1553, 1552, 1, 0, 0, 0, 1553, 1554, 1, 0, 0, 0, 1554, 1555, 1, 0, 0, 0, 1555, 1556, 3, 204, 102, 0, 1556, 197, 1, 0, 0, 0, 1557, 1558, 5, 149, 0, 0, 1558, 1560, 5, 80, 0, 0, 1559, 1561, 5, 149, 0, 0, 1560, 1559, 1, 0, 0, 0, 1560, 1561, 1, 0, 0, 0, 1561, 1562, 1, 0, 0, 0, 1562, 1563, 3, 204, 102, 0, 1563, 199, 1, 0, 0, 0, 1564, 1565, 5, 149, 0, 0, 1565, 1566, 5, 61, 0, 0, 1566, 1567, 5, 149, 0, 0, 1567, 1575, 5, 109, 0, 0, 1568, 1569, 5, 149, 0, 0, 1569, 1570, 5, 61, 0, 0, 1570, 1571, 5, 149, 0, 0, 1571, 1572, 5, 105, 0, 0, 1572, 1573, 5, 149, 0, 0, 1573, 1575, 5, 109, 0, 0, 1574, 1564, 1, 0, 0, 0, 1574, 1568, 1, 0, 0, 0, 1575, 201, 1, 0, 0, 0, 1576, 1578, 5, 149, 0, 0, 1577, 1576, 1, 0, 0, 0, 1577, 1578, 1, 0, 0, 0, 1578, 1579, 1, 0, 0, 0, 1579, 1580, 5, 18, 0, 0, 1580, 203, 1, 0, 0, 0, 1581, 1600, 3, 206, 103, 0, 1582, 1584, 5, 149, 0, 0, 1583, 1582, 1, 0, 0, 0, 1583, 1584, 1, 0, 0, 0, 1584, 1585, 1, 0, 0, 0, 1585, 1587, 5, 19, 0, 0, 1586, 1588, 5, 149, 0, 0, 1587, 1586, 1, 0, 0, 0, 1587, 1588, 1, 0, 0, 0, 1588, 1589, 1, 0, 0, 0, 1589, 1599, 3, 206, 103, 0, 1590, 1592, 5, 149, 0, 0, 1591, 1590, 1, 0, 0, 0, 1591, 1592, 1, 0, 0, 0, 1592, 1593, 1, 0, 0, 0, 1593, 1595, 5, 20, 0, 0, 1594, 1596, 5, 149, 0, 0, 1595, 1594, 1, 0, 0, 0, 1595, 1596, 1, 0, 0, 0, 1596, 1597, 1, 0, 0, 0, 1597, 1599, 3, 206, 103, 0, 1598, 1583, 1, 0, 0, 0, 1598, 1591, 1, 0, 0, 0, 1599, 1602, 1, 0, 0, 0, 1600, 1598, 1, 0, 0, 0, 1600, 1601, 1, 0, 0, 0, 1601, 205, 1, 0, 0, 0, 1602, 1600, 1, 0, 0, 0, 1603, 1630, 3, 208, 104, 0, 1604, 1606, 5, 149, 0, 0, 1605, 1604, 1, 0, 0, 0, 1605, 1606, 1, 0, 0, 0, 1606, 1607, 1, 0, 0, 0, 1607, 1609, 5, 10, 0, 0, 1608, 1610, 5, 149, 0, 0, 1609, 1608, 1, 0, 0, 0, 1609, 1610, 1, 0, 0, 0, 1610, 1611, 1, 0, 0, 0, 1611, 1629, 3, 208, 104, 0, 1612, 1614, 5, 149, 0, 0, 1613, 1612, 1, 0, 0, 0, 1613, 1614, 1, 0, 0, 0, 1614, 1615, 1, 0, 0, 0, 1615, 1617, 5, 21, 0, 0, 1616, 1618, 5, 149, 0, 0, 1617, 1616, 1, 0, 0, 0, 1617, 1618, 1, 0, 0, 0, 1618, 1619, 1, 0, 0, 0, 1619, 1629, 3, 208, 104, 0, 1620, 1622, 5, 149, 0, 0, 1621, 1620, 1, 0, 0, 0, 1621, 1622, 1, 0, 0, 0, 1622, 1623, 1, 0, 0, 0, 1623, 1625, 5, 22, 0, 0, 1624, 1626, 5, 149, 0, 0, 1625, 1624, 1, 0, 0, 0, 1625, 1626, 1, 0, 0, 0, 1626, 1627, 1, 0, 0, 0, 1627, 1629, 3, 208, 104, 0, 1628, 1605, 1, 0, 0, 0, 1628, 1613, 1, 0, 0, 0, 1628, 1621, 1, 0, 0, 0, 1629, 1632, 1, 0, 0, 0, 1630, 1628, 1, 0, 0, 0, 1630, 1631, 1, 0, 0, 0, 1631, 207, 1, 0, 0, 0, 1632, 1630, 1, 0, 0, 0, 1633, 1644, 3, 210, 105, 0, 1634, 1636, 5, 149, 0, 0, 1635, 1634, 1, 0, 0, 0, 1635, 1636, 1, 0, 0, 0, 1636, 1637, 1, 0, 0, 0, 1637, 1639, 5, 23, 0, 0, 1638, 1640, 5, 149, 0, 0, 1639, 1638, 1, 0, 0, 0, 1639, 1640, 1, 0, 0, 0, 1640, 1641, 1, 0, 0, 0, 1641, 1643, 3, 210, 105, 0, 1642, 1635, 1, 0, 0, 0, 1643, 1646, 1, 0, 0, 0, 1644, 1642, 1, 0, 0, 0, 1644, 1645, 1, 0, 0, 0, 1645, 209, 1, 0, 0, 0, 1646, 1644, 1, 0, 0, 0, 1647, 1654, 3, 212, 106, 0, 1648, 1650, 7, 2, 0, 0, 1649, 1651, 5, 149, 0, 0, 1650, 1649, 1, 0, 0, 0, 1650, 1651, 1, 0, 0, 0, 1651, 1652, 1, 0, 0, 0, 1652, 1654, 3, 212, 106, 0, 1653, 1647, 1, 0, 0, 0, 1653, 1648, 1, 0, 0, 0, 1654, 211, 1, 0, 0, 0, 1655, 1666, 3, 218, 109, 0, 1656, 1658, 5, 149, 0, 0, 1657, 1656, 1, 0, 0, 0, 1657, 1658, 1, 0, 0, 0, 1658, 1659, 1, 0, 0, 0, 1659, 1665, 3, 214, 107, 0, 1660, 1662, 5, 149, 0, 0, 1661, 1660, 1, 0, 0, 0, 1661, 1662, 1, 0, 0, 0, 1662, 1663, 1, 0, 0, 0, 1663, 1665, 3, 216, 108, 0, 1664, 1657, 1, 0, 0, 0, 1664, 1661, 1, 0, 0, 0, 1665, 1668, 1, 0, 0, 0, 1666, 1664, 1, 0, 0, 0, 1666, 1667, 1, 0, 0, 0, 1667, 1673, 1, 0, 0, 0, 1668, 1666, 1, 0, 0, 0, 1669, 1671, 5, 149, 0, 0, 1670, 1669, 1, 0, 0, 0, 1670, 1671, 1, 0, 0, 0, 1671, 1672, 1, 0, 0, 0, 1672, 1674, 3, 168, 84, 0, 1673, 1670, 1, 0, 0, 0, 1673, 1674, 1, 0, 0, 0, 1674, 213, 1, 0, 0, 0, 1675, 1676, 5, 5, 0, 0, 1676, 1677, 3, 180, 90, 0, 1677, 1678, 5, 6, 0, 0, 1678, 1689, 1, 0, 0, 0, 1679, 1681, 5, 5, 0, 0, 1680, 1682, 3, 180, 90, 0, 1681, 1680, 1, 0, 0, 0, 1681, 1682, 1, 0, 0, 0, 1682, 1683, 1, 0, 0, 0, 1683, 1685, 5, 12, 0, 0, 1684, 1686, 3, 180, 90, 0, 1685, 1684, 1, 0, 0, 0, 1685, 1686, 1, 0, 0, 0, 1686, 1687, 1, 0, 0, 0, 1687, 1689, 5, 6, 0, 0, 1688, 1675, 1, 0, 0, 0, 1688, 1679, 1, 0, 0, 0, 1689, 215, 1, 0, 0, 0, 1690, 1692, 5, 24, 0, 0, 1691, 1693, 5, 149, 0, 0, 1692, 1691, 1, 0, 0, 0, 1692, 1693, 1, 0, 0, 0, 1693, 1694, 1, 0, 0, 0, 1694, 1695, 3, 274, 137, 0, 1695, 217, 1, 0, 0, 0, 1696, 1725, 3, 260, 130, 0, 1697, 1725, 3, 278, 139, 0, 1698, 1725, 3, 276, 138, 0, 1699, 1725, 3, 220, 110, 0, 1700, 1702, 5, 110, 0, 0, 1701, 1703, 5, 149, 0, 0, 1702, 1701, 1, 0, 0, 0, 1702, 1703, 1, 0, 0, 0, 1703, 1704, 1, 0, 0, 0, 1704, 1706, 5, 3, 0, 0, 1705, 1707, 5, 149, 0, 0, 1706, 1705, 1, 0, 0, 0, 1706, 1707, 1, 0, 0, 0, 1707, 1708, 1, 0, 0, 0, 1708, 1710, 5, 10, 0, 0, 1709, 1711, 5, 149, 0, 0, 1710, 1709, 1, 0, 0, 0, 1710, 1711, 1, 0, 0, 0, 1711, 1712, 1, 0, 0, 0, 1712, 1725, 5, 4, 0, 0, 1713, 1725, 3, 224, 112, 0, 1714, 1725, 3, 226, 113, 0, 1715, 1725, 3, 228, 114, 0, 1716, 1725, 3, 230, 115, 0, 1717, 1725, 3, 232, 116, 0, 1718, 1725, 3, 148, 74, 0, 1719, 1725, 3, 236, 118, 0, 1720, 1725, 3, 238, 119, 0, 1721, 1725, 3, 242, 121, 0, 1722, 1725, 3, 246, 123, 0, 1723, 1725, 3, 258, 129, 0, 1724, 1696, 1, 0, 0, 0, 1724, 1697, 1, 0, 0, 0, 1724, 1698, 1, 0, 0, 0, 1724, 1699, 1, 0, 0, 0, 1724, 1700, 1, 0, 0, 0, 1724, 1713, 1, 0, 0, 0, 1724, 1714, 1, 0, 0, 0, 1724, 1715, 1, 0, 0, 0, 1724, 1716, 1, 0, 0, 0, 1724, 1717, 1, 0, 0, 0, 1724, 1718, 1, 0, 0, 0, 1724, 1719, 1, 0, 0, 0, 1724, 1720, 1, 0, 0, 0, 1724, 1721, 1, 0, 0, 0, 1724, 1722, 1, 0, 0, 0, 1724, 1723, 1, 0, 0, 0, 1725, 219, 1, 0, 0, 0, 1726, 1731, 5, 111, 0, 0, 1727, 1729, 5, 149, 0, 0, 1728, 1727, 1, 0, 0, 0, 1728, 1729, 1, 0, 0, 0, 1729, 1730, 1, 0, 0, 0, 1730, 1732, 3, 222, 111, 0, 1731, 1728, 1, 0, 0, 0, 1732, 1733, 1, 0, 0, 0, 1733, 1731, 1, 0, 0, 0, 1733, 1734, 1, 0, 0, 0, 1734, 1749, 1, 0, 0, 0, 1735, 1737, 5, 111, 0, 0, 1736, 1738, 5, 149, 0, 0, 1737, 1736, 1, 0, 0, 0, 1737, 1738, 1, 0, 0, 0, 1738, 1739, 1, 0, 0, 0, 1739, 1744, 3, 180, 90, 0, 1740, 1742, 5, 149, 0, 0, 1741, 1740, 1, 0, 0, 0, 1741, 1742, 1, 0, 0, 0, 1742, 1743, 1, 0, 0, 0, 1743, 1745, 3, 222, 111, 0, 1744, 1741, 1, 0, 0, 0, 1745, 1746, 1, 0, 0, 0, 1746, 1744, 1, 0, 0, 0, 1746, 1747, 1, 0, 0, 0, 1747, 1749, 1, 0, 0, 0, 1748, 1726, 1, 0, 0, 0, 1748, 1735, 1, 0, 0, 0, 1749, 1758, 1, 0, 0, 0, 1750, 1752, 5, 149, 0, 0, 1751, 1750, 1, 0, 0, 0, 1751, 1752, 1, 0, 0, 0, 1752, 1753, 1, 0, 0, 0, 1753, 1755, 5, 112, 0, 0, 1754, 1756, 5, 149, 0, 0, 1755, 1754, 1, 0, 0, 0, 1755, 1756, 1, 0, 0, 0, 1756, 1757, 1, 0, 0, 0, 1757, 1759, 3, 180, 90, 0, 1758, 1751, 1, 0, 0, 0, 1758, 1759, 1, 0, 0, 0, 1759, 1761, 1, 0, 0, 0, 1760, 1762, 5, 149, 0, 0, 1761, 1760, 1, 0, 0, 0, 1761, 1762, 1, 0, 0, 0, 1762, 1763, 1, 0, 0, 0, 1763, 1764, 5, 113, 0, 0, 1764, 221, 1, 0, 0, 0, 1765, 1767, 5, 114, 0, 0, 1766, 1768, 5, 149, 0, 0, 1767, 1766, 1, 0, 0, 0, 1767, 1768, 1, 0, 0, 0, 1768, 1769, 1, 0, 0, 0, 1769, 1771, 3, 180, 90, 0, 1770, 1772, 5, 149, 0, 0, 1771, 1770, 1, 0, 0, 0, 1771, 1772, 1, 0, 0, 0, 1772, 1773, 1, 0, 0, 0, 1773, 1775, 5, 115, 0, 0, 1774, 1776, 5, 149, 0, 0, 1775, 1774, 1, 0, 0, 0, 1775, 1776, 1, 0, 0, 0, 1776, 1777, 1, 0, 0, 0, 1777, 1778, 3, 180, 90, 0, 1778, 223, 1, 0, 0, 0, 1779, 1781, 5, 5, 0, 0, 1780, 1782, 5, 149, 0, 0, 1781, 1780, 1, 0, 0, 0, 1781, 1782, 1, 0, 0, 0, 1782, 1783, 1, 0, 0, 0, 1783, 1792, 3, 234, 117, 0, 1784, 1786, 5, 149, 0, 0, 1785, 1784, 1, 0, 0, 0, 1785, 1786, 1, 0, 0, 0, 1786, 1787, 1, 0, 0, 0, 1787, 1789, 5, 9, 0, 0, 1788, 1790, 5, 149, 0, 0, 1789, 1788, 1, 0, 0, 0, 1789, 1790, 1, 0, 0, 0, 1790, 1791, 1, 0, 0, 0, 1791, 1793, 3, 180, 90, 0, 1792, 1785, 1, 0, 0, 0, 1792, 1793, 1, 0, 0, 0, 1793, 1795, 1, 0, 0, 0, 1794, 1796, 5, 149, 0, 0, 1795, 1794, 1, 0, 0, 0, 1795, 1796, 1, 0, 0, 0, 1796, 1797, 1, 0, 0, 0, 1797, 1798, 5, 6, 0, 0, 1798, 225, 1, 0, 0, 0, 1799, 1801, 5, 5, 0, 0, 1800, 1802, 5, 149, 0, 0, 1801, 1800, 1, 0, 0, 0, 1801, 1802, 1, 0, 0, 0, 1802, 1811, 1, 0, 0, 0, 1803, 1805, 3, 258, 129, 0, 1804, 1806, 5, 149, 0, 0, 1805, 1804, 1, 0, 0, 0, 1805, 1806, 1, 0, 0, 0, 1806, 1807, 1, 0, 0, 0, 1807, 1809, 5, 2, 0, 0, 1808, 1810, 5, 149, 0, 0, 1809, 1808, 1, 0, 0, 0, 1809, 1810, 1, 0, 0, 0, 1810, 1812, 1, 0, 0, 0, 1811, 1803, 1, 0, 0, 0, 1811, 1812, 1, 0, 0, 0, 1812, 1813, 1, 0, 0, 0, 1813, 1815, 3, 152, 76, 0, 1814, 1816, 5, 149, 0, 0, 1815, 1814, 1, 0, 0, 0, 1815, 1816, 1, 0, 0, 0, 1816, 1821, 1, 0, 0, 0, 1817, 1819, 3, 140, 70, 0, 1818, 1820, 5, 149, 0, 0, 1819, 1818, 1, 0, 0, 0, 1819, 1820, 1, 0, 0, 0, 1820, 1822, 1, 0, 0, 0, 1821, 1817, 1, 0, 0, 0, 1821, 1822, 1, 0, 0, 0, 1822, 1823, 1, 0, 0, 0, 1823, 1825, 5, 9, 0, 0, 1824, 1826, 5, 149, 0, 0, 1825, 1824, 1, 0, 0, 0, 1825, 1826, 1, 0, 0, 0, 1826, 1827, 1, 0, 0, 0, 1827, 1829, 3, 180, 90, 0, 1828, 1830, 5, 149, 0, 0, 1829, 1828, 1, 0, 0, 0, 1829, 1830, 1, 0, 0, 0, 1830, 1831, 1, 0, 0, 0, 1831, 1832, 5, 6, 0, 0, 1832, 227, 1, 0, 0, 0, 1833, 1835, 5, 116, 0, 0, 1834, 1836, 5, 149, 0, 0, 1835, 1834, 1, 0, 0, 0, 1835, 1836, 1, 0, 0, 0, 1836, 1837, 1, 0, 0, 0, 1837, 1839, 5, 3, 0, 0, 1838, 1840, 5, 149, 0, 0, 1839, 1838, 1, 0, 0, 0, 1839, 1840, 1, 0, 0, 0, 1840, 1841, 1, 0, 0, 0, 1841, 1843, 3, 234, 117, 0, 1842, 1844, 5, 149, 0, 0, 1843, 1842, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1845, 1, 0, 0, 0, 1845, 1846, 5, 4, 0, 0, 1846, 1869, 1, 0, 0, 0, 1847, 1849, 5, 117, 0, 0, 1848, 1850, 5, 149, 0, 0, 1849, 1848, 1, 0, 0, 0, 1849, 1850, 1, 0, 0, 0, 1850, 1851, 1, 0, 0, 0, 1851, 1853, 5, 3, 0, 0, 1852, 1854, 5, 149, 0, 0, 1853, 1852, 1, 0, 0, 0, 1853, 1854, 1, 0, 0, 0, 1854, 1855, 1, 0, 0, 0, 1855, 1857, 3, 234, 117, 0, 1856, 1858, 5, 149, 0, 0, 1857, 1856, 1, 0, 0, 0, 1857, 1858, 1, 0, 0, 0, 1858, 1864, 1, 0, 0, 0, 1859, 1861, 5, 149, 0, 0, 1860, 1859, 1, 0, 0, 0, 1860, 1861, 1, 0, 0, 0, 1861, 1862, 1, 0, 0, 0, 1862, 1863, 5, 9, 0, 0, 1863, 1865, 3, 180, 90, 0, 1864, 1860, 1, 0, 0, 0, 1864, 1865, 1, 0, 0, 0, 1865, 1866, 1, 0, 0, 0, 1866, 1867, 5, 4, 0, 0, 1867, 1869, 1, 0, 0, 0, 1868, 1833, 1, 0, 0, 0, 1868, 1847, 1, 0, 0, 0, 1869, 229, 1, 0, 0, 0, 1870, 1872, 5, 118, 0, 0, 1871, 1873, 5, 149, 0, 0, 1872, 1871, 1, 0, 0, 0, 1872, 1873, 1, 0, 0, 0, 1873, 1874, 1, 0, 0, 0, 1874, 1875, 5, 3, 0, 0, 1875, 1876, 3, 258, 129, 0, 1876, 1877, 5, 2, 0, 0, 1877, 1878, 3, 180, 90, 0, 1878, 1879, 5, 7, 0, 0, 1879, 1880, 3, 240, 120, 0, 1880, 1881, 5, 9, 0, 0, 1881, 1882, 3, 180, 90, 0, 1882, 1883, 5, 4, 0, 0, 1883, 231, 1, 0, 0, 0, 1884, 1886, 5, 54, 0, 0, 1885, 1887, 5, 149, 0, 0, 1886, 1885, 1, 0, 0, 0, 1886, 1887, 1, 0, 0, 0, 1887, 1888, 1, 0, 0, 0, 1888, 1890, 5, 3, 0, 0, 1889, 1891, 5, 149, 0, 0, 1890, 1889, 1, 0, 0, 0, 1890, 1891, 1, 0, 0, 0, 1891, 1892, 1, 0, 0, 0, 1892, 1894, 3, 234, 117, 0, 1893, 1895, 5, 149, 0, 0, 1894, 1893, 1, 0, 0, 0, 1894, 1895, 1, 0, 0, 0, 1895, 1896, 1, 0, 0, 0, 1896, 1897, 5, 4, 0, 0, 1897, 1941, 1, 0, 0, 0, 1898, 1900, 5, 119, 0, 0, 1899, 1901, 5, 149, 0, 0, 1900, 1899, 1, 0, 0, 0, 1900, 1901, 1, 0, 0, 0, 1901, 1902, 1, 0, 0, 0, 1902, 1904, 5, 3, 0, 0, 1903, 1905, 5, 149, 0, 0, 1904, 1903, 1, 0, 0, 0, 1904, 1905, 1, 0, 0, 0, 1905, 1906, 1, 0, 0, 0, 1906, 1908, 3, 234, 117, 0, 1907, 1909, 5, 149, 0, 0, 1908, 1907, 1, 0, 0, 0, 1908, 1909, 1, 0, 0, 0, 1909, 1910, 1, 0, 0, 0, 1910, 1911, 5, 4, 0, 0, 1911, 1941, 1, 0, 0, 0, 1912, 1914, 5, 120, 0, 0, 1913, 1915, 5, 149, 0, 0, 1914, 1913, 1, 0, 0, 0, 1914, 1915, 1, 0, 0, 0, 1915, 1916, 1, 0, 0, 0, 1916, 1918, 5, 3, 0, 0, 1917, 1919, 5, 149, 0, 0, 1918, 1917, 1, 0, 0, 0, 1918, 1919, 1, 0, 0, 0, 1919, 1920, 1, 0, 0, 0, 1920, 1922, 3, 234, 117, 0, 1921, 1923, 5, 149, 0, 0, 1922, 1921, 1, 0, 0, 0, 1922, 1923, 1, 0, 0, 0, 1923, 1924, 1, 0, 0, 0, 1924, 1925, 5, 4, 0, 0, 1925, 1941, 1, 0, 0, 0, 1926, 1928, 5, 121, 0, 0, 1927, 1929, 5, 149, 0, 0, 1928, 1927, 1, 0, 0, 0, 1928, 1929, 1, 0, 0, 0, 1929, 1930, 1, 0, 0, 0, 1930, 1932, 5, 3, 0, 0, 1931, 1933, 5, 149, 0, 0, 1932, 1931, 1, 0, 0, 0, 1932, 1933, 1, 0, 0, 0, 1933, 1934, 1, 0, 0, 0, 1934, 1936, 3, 234, 117, 0, 1935, 1937, 5, 149, 0, 0, 1936, 1935, 1, 0, 0, 0, 1936, 1937, 1, 0, 0, 0, 1937, 1938, 1, 0, 0, 0, 1938, 1939, 5, 4, 0, 0, 1939, 1941, 1, 0, 0, 0, 1940, 1884, 1, 0, 0, 0, 1940, 1898, 1, 0, 0, 0, 1940, 1912, 1, 0, 0, 0, 1940, 1926, 1, 0, 0, 0, 1941, 233, 1, 0, 0, 0, 1942, 1947, 3, 240, 120, 0, 1943, 1945, 5, 149, 0, 0, 1944, 1943, 1, 0, 0, 0, 1944, 1945, 1, 0, 0, 0, 1945, 1946, 1, 0, 0, 0, 1946, 1948, 3, 140, 70, 0, 1947, 1944, 1, 0, 0, 0, 1947, 1948, 1, 0, 0, 0, 1948, 235, 1, 0, 0, 0, 1949, 1950, 3, 152, 76, 0, 1950, 237, 1, 0, 0, 0, 1951, 1953, 5, 3, 0, 0, 1952, 1954, 5, 149, 0, 0, 1953, 1952, 1, 0, 0, 0, 1953, 1954, 1, 0, 0, 0, 1954, 1955, 1, 0, 0, 0, 1955, 1957, 3, 180, 90, 0, 1956, 1958, 5, 149, 0, 0, 1957, 1956, 1, 0, 0, 0, 1957, 1958, 1, 0, 0, 0, 1958, 1959, 1, 0, 0, 0, 1959, 1960, 5, 4, 0, 0, 1960, 239, 1, 0, 0, 0, 1961, 1962, 3, 258, 129, 0, 1962, 1963, 5, 149, 0, 0, 1963, 1964, 5, 80, 0, 0, 1964, 1965, 5, 149, 0, 0, 1965, 1966, 3, 180, 90, 0, 1966, 241, 1, 0, 0, 0, 1967, 1969, 3, 244, 122, 0, 1968, 1970, 5, 149, 0, 0, 1969, 1968, 1, 0, 0, 0, 1969, 1970, 1, 0, 0, 0, 1970, 1971, 1, 0, 0, 0, 1971, 1973, 5, 3, 0, 0, 1972, 1974, 5, 149, 0, 0, 1973, 1972, 1, 0, 0, 0, 1973, 1974, 1, 0, 0, 0, 1974, 1979, 1, 0, 0, 0, 1975, 1977, 5, 84, 0, 0, 1976, 1978, 5, 149, 0, 0, 1977, 1976, 1, 0, 0, 0, 1977, 1978, 1, 0, 0, 0, 1978, 1980, 1, 0, 0, 0, 1979, 1975, 1, 0, 0, 0, 1979, 1980, 1, 0, 0, 0, 1980, 1998, 1, 0, 0, 0, 1981, 1983, 3, 180, 90, 0, 1982, 1984, 5, 149, 0, 0, 1983, 1982, 1, 0, 0, 0, 1983, 1984, 1, 0, 0, 0, 1984, 1995, 1, 0, 0, 0, 1985, 1987, 5, 7, 0, 0, 1986, 1988, 5, 149, 0, 0, 1987, 1986, 1, 0, 0, 0, 1987, 1988, 1, 0, 0, 0, 1988, 1989, 1, 0, 0, 0, 1989, 1991, 3, 180, 90, 0, 1990, 1992, 5, 149, 0, 0, 1991, 1990, 1, 0, 0, 0, 1991, 1992, 1, 0, 0, 0, 1992, 1994, 1, 0, 0, 0, 1993, 1985, 1, 0, 0, 0, 1994, 1997, 1, 0, 0, 0, 1995, 1993, 1, 0, 0, 0, 1995, 1996, 1, 0, 0, 0, 1996, 1999, 1, 0, 0, 0, 1997, 1995, 1, 0, 0, 0, 1998, 1981, 1, 0, 0, 0, 1998, 1999, 1, 0, 0, 0, 1999, 2000, 1, 0, 0, 0, 2000, 2001, 5, 4, 0, 0, 2001, 243, 1, 0, 0, 0, 2002, 2003, 3, 256, 128, 0, 2003, 2004, 3, 284, 142, 0, 2004, 245, 1, 0, 0, 0, 2005, 2007, 5, 63, 0, 0, 2006, 2008, 5, 149, 0, 0, 2007, 2006, 1, 0, 0, 0, 2007, 2008, 1, 0, 0, 0, 2008, 2009, 1, 0, 0, 0, 2009, 2011, 5, 25, 0, 0, 2010, 2012, 5, 149, 0, 0, 2011, 2010, 1, 0, 0, 0, 2011, 2012, 1, 0, 0, 0, 2012, 2021, 1, 0, 0, 0, 2013, 2022, 3, 20, 10, 0, 2014, 2019, 3, 142, 71, 0, 2015, 2017, 5, 149, 0, 0, 2016, 2015, 1, 0, 0, 0, 2016, 2017, 1, 0, 0, 0, 2017, 2018, 1, 0, 0, 0, 2018, 2020, 3, 140, 70, 0, 2019, 2016, 1, 0, 0, 0, 2019, 2020, 1, 0, 0, 0, 2020, 2022, 1, 0, 0, 0, 2021, 2013, 1, 0, 0, 0, 2021, 2014, 1, 0, 0, 0, 2022, 2024, 1, 0, 0, 0, 2023, 2025, 5, 149, 0, 0, 2024, 2023, 1, 0, 0, 0, 2024, 2025, 1, 0, 0, 0, 2025, 2026, 1, 0, 0, 0, 2026, 2027, 5, 26, 0, 0, 2027, 247, 1, 0, 0, 0, 2028, 2030, 3, 254, 127, 0, 2029, 2031, 5, 149, 0, 0, 2030, 2029, 1, 0, 0, 0, 2030, 2031, 1, 0, 0, 0, 2031, 2032, 1, 0, 0, 0, 2032, 2034, 5, 3, 0, 0, 2033, 2035, 5, 149, 0, 0, 2034, 2033, 1, 0, 0, 0, 2034, 2035, 1, 0, 0, 0, 2035, 2053, 1, 0, 0, 0, 2036, 2038, 3, 180, 90, 0, 2037, 2039, 5, 149, 0, 0, 2038, 2037, 1, 0, 0, 0, 2038, 2039, 1, 0, 0, 0, 2039, 2050, 1, 0, 0, 0, 2040, 2042, 5, 7, 0, 0, 2041, 2043, 5, 149, 0, 0, 2042, 2041, 1, 0, 0, 0, 2042, 2043, 1, 0, 0, 0, 2043, 2044, 1, 0, 0, 0, 2044, 2046, 3, 180, 90, 0, 2045, 2047, 5, 149, 0, 0, 2046, 2045, 1, 0, 0, 0, 2046, 2047, 1, 0, 0, 0, 2047, 2049, 1, 0, 0, 0, 2048, 2040, 1, 0, 0, 0, 2049, 2052, 1, 0, 0, 0, 2050, 2048, 1, 0, 0, 0, 2050, 2051, 1, 0, 0, 0, 2051, 2054, 1, 0, 0, 0, 2052, 2050, 1, 0, 0, 0, 2053, 2036, 1, 0, 0, 0, 2053, 2054, 1, 0, 0, 0, 2054, 2055, 1, 0, 0, 0, 2055, 2056, 5, 4, 0, 0, 2056, 249, 1, 0, 0, 0, 2057, 2058, 3, 254, 127, 0, 2058, 251, 1, 0, 0, 0, 2059, 2060, 3, 284, 142, 0, 2060, 253, 1, 0, 0, 0, 2061, 2062, 3, 256, 128, 0, 2062, 2063, 3, 284, 142, 0, 2063, 255, 1, 0, 0, 0, 2064, 2065, 3, 284, 142, 0, 2065, 2066, 5, 24, 0, 0, 2066, 2068, 1, 0, 0, 0, 2067, 2064, 1, 0, 0, 0, 2068, 2071, 1, 0, 0, 0, 2069, 2067, 1, 0, 0, 0, 2069, 2070, 1, 0, 0, 0, 2070, 257, 1, 0, 0, 0, 2071, 2069, 1, 0, 0, 0, 2072, 2073, 3, 284, 142, 0, 2073, 259, 1, 0, 0, 0, 2074, 2081, 3, 262, 131, 0, 2075, 2081, 5, 109, 0, 0, 2076, 2081, 3, 264, 132, 0, 2077, 2081, 5, 136, 0, 0, 2078, 2081, 3, 270, 135, 0, 2079, 2081, 3, 272, 136, 0, 2080, 2074, 1, 0, 0, 0, 2080, 2075, 1, 0, 0, 0, 2080, 2076, 1, 0, 0, 0, 2080, 2077, 1, 0, 0, 0, 2080, 2078, 1, 0, 0, 0, 2080, 2079, 1, 0, 0, 0, 2081, 261, 1, 0, 0, 0, 2082, 2083, 7, 3, 0, 0, 2083, 263, 1, 0, 0, 0, 2084, 2087, 3, 268, 134, 0, 2085, 2087, 3, 266, 133, 0, 2086, 2084, 1, 0, 0, 0, 2086, 2085, 1, 0, 0, 0, 2087, 265, 1, 0, 0, 0, 2088, 2089, 7, 4, 0, 0, 2089, 267, 1, 0, 0, 0, 2090, 2091, 7, 5, 0, 0, 2091, 269, 1, 0, 0, 0, 2092, 2094, 5, 5, 0, 0, 2093, 2095, 5, 149, 0, 0, 2094, 2093, 1, 0, 0, 0, 2094, 2095, 1, 0, 0, 0, 2095, 2113, 1, 0, 0, 0, 2096, 2098, 3, 180, 90, 0, 2097, 2099, 5, 149, 0, 0, 2098, 2097, 1, 0, 0, 0, 2098, 2099, 1, 0, 0, 0, 2099, 2110, 1, 0, 0, 0, 2100, 2102, 5, 7, 0, 0, 2101, 2103, 5, 149, 0, 0, 2102, 2101, 1, 0, 0, 0, 2102, 2103, 1, 0, 0, 0, 2103, 2104, 1, 0, 0, 0, 2104, 2106, 3, 180, 90, 0, 2105, 2107, 5, 149, 0, 0, 2106, 2105, 1, 0, 0, 0, 2106, 2107, 1, 0, 0, 0, 2107, 2109, 1, 0, 0, 0, 2108, 2100, 1, 0, 0, 0, 2109, 2112, 1, 0, 0, 0, 2110, 2108, 1, 0, 0, 0, 2110, 2111, 1, 0, 0, 0, 2111, 2114, 1, 0, 0, 0, 2112, 2110, 1, 0, 0, 0, 2113, 2096, 1, 0, 0, 0, 2113, 2114, 1, 0, 0, 0, 2114, 2115, 1, 0, 0, 0, 2115, 2116, 5, 6, 0, 0, 2116, 271, 1, 0, 0, 0, 2117, 2119, 5, 25, 0, 0, 2118, 2120, 5, 149, 0, 0, 2119, 2118, 1, 0, 0, 0, 2119, 2120, 1, 0, 0, 0, 2120, 2154, 1, 0, 0, 0, 2121, 2123, 3, 274, 137, 0, 2122, 2124, 5, 149, 0, 0, 2123, 2122, 1, 0, 0, 0, 2123, 2124, 1, 0, 0, 0, 2124, 2125, 1, 0, 0, 0, 2125, 2127, 5, 11, 0, 0, 2126, 2128, 5, 149, 0, 0, 2127, 2126, 1, 0, 0, 0, 2127, 2128, 1, 0, 0, 0, 2128, 2129, 1, 0, 0, 0, 2129, 2131, 3, 180, 90, 0, 2130, 2132, 5, 149, 0, 0, 2131, 2130, 1, 0, 0, 0, 2131, 2132, 1, 0, 0, 0, 2132, 2151, 1, 0, 0, 0, 2133, 2135, 5, 7, 0, 0, 2134, 2136, 5, 149, 0, 0, 2135, 2134, 1, 0, 0, 0, 2135, 2136, 1, 0, 0, 0, 2136, 2137, 1, 0, 0, 0, 2137, 2139, 3, 274, 137, 0, 2138, 2140, 5, 149, 0, 0, 2139, 2138, 1, 0, 0, 0, 2139, 2140, 1, 0, 0, 0, 2140, 2141, 1, 0, 0, 0, 2141, 2143, 5, 11, 0, 0, 2142, 2144, 5, 149, 0, 0, 2143, 2142, 1, 0, 0, 0, 2143, 2144, 1, 0, 0, 0, 2144, 2145, 1, 0, 0, 0, 2145, 2147, 3, 180, 90, 0, 2146, 2148, 5, 149, 0, 0, 2147, 2146, 1, 0, 0, 0, 2147, 2148, 1, 0, 0, 0, 2148, 2150, 1, 0, 0, 0, 2149, 2133, 1, 0, 0, 0, 2150, 2153, 1, 0, 0, 0, 2151, 2149, 1, 0, 0, 0, 2151, 2152, 1, 0, 0, 0, 2152, 2155, 1, 0, 0, 0, 2153, 2151, 1, 0, 0, 0, 2154, 2121, 1, 0, 0, 0, 2154, 2155, 1, 0, 0, 0, 2155, 2156, 1, 0, 0, 0, 2156, 2157, 5, 26, 0, 0, 2157, 273, 1, 0, 0, 0, 2158, 2159, 3, 280, 140, 0, 2159, 275, 1, 0, 0, 0, 2160, 2162, 5, 25, 0, 0, 2161, 2163, 5, 149, 0, 0, 2162, 2161, 1, 0, 0, 0, 2162, 2163, 1, 0, 0, 0, 2163, 2166, 1, 0, 0, 0, 2164, 2167, 3, 284, 142, 0, 2165, 2167, 5, 125, 0, 0, 2166, 2164, 1, 0, 0, 0, 2166, 2165, 1, 0, 0, 0, 2167, 2169, 1, 0, 0, 0, 2168, 2170, 5, 149, 0, 0, 2169, 2168, 1, 0, 0, 0, 2169, 2170, 1, 0, 0, 0, 2170, 2171, 1, 0, 0, 0, 2171, 2172, 5, 26, 0, 0, 2172, 277, 1, 0, 0, 0, 2173, 2176, 5, 27, 0, 0, 2174, 2177, 3, 284, 142, 0, 2175, 2177, 5, 125, 0, 0, 2176, 2174, 1, 0, 0, 0, 2176, 2175, 1, 0, 0, 0, 2177, 279, 1, 0, 0, 0, 2178, 2181, 3, 284, 142, 0, 2179, 2181, 3, 282, 141, 0, 2180, 2178, 1, 0, 0, 0, 2180, 2179, 1, 0, 0, 0, 2181, 281, 1, 0, 0, 0, 2182, 2183, 7, 6, 0, 0, 2183, 283, 1, 0, 0, 0, 2184, 2185, 7, 7, 0, 0, 2185, 285, 1, 0, 0, 0, 2186, 2187, 7, 8, 0, 0, 2187, 287, 1, 0, 0, 0, 2188, 2189, 7, 9, 0, 0, 2189, 289, 1, 0, 0, 0, 2190, 2191, 7, 10, 0, 0, 2191, 291, 1, 0, 0, 0, 365, 293, 298, 301, 304, 310, 314, 320, 325, 331, 342, 346, 352, 357, 361, 366, 371, 382, 391, 396, 399, 403, 407, 411, 417, 421, 426, 431, 435, 438, 440, 444, 448, 453, 457, 462, 466, 477, 484, 494, 532, 543, 550, 564, 571, 577, 587, 591, 597, 605, 616, 622, 634, 640, 652, 656, 666, 679, 683, 687, 693, 697, 700, 704, 714, 721, 734, 738, 746, 752, 756, 760, 765, 770, 774, 780, 784, 790, 794, 800, 804, 808, 812, 816, 820, 825, 832, 836, 841, 848, 852, 856, 864, 871, 874, 882, 887, 893, 896, 902, 904, 908, 912, 917, 921, 924, 931, 938, 941, 947, 950, 956, 960, 964, 968, 972, 977, 982, 986, 991, 994, 1003, 1012, 1017, 1030, 1033, 1036, 1056, 1060, 1065, 1075, 1081, 1085, 1090, 1094, 1098, 1102, 1108, 1112, 1117, 1123, 1132, 1141, 1149, 1155, 1159, 1164, 1173, 1177, 1182, 1187, 1191, 1196, 1200, 1212, 1216, 1221, 1228, 1232, 1237, 1241, 1245, 1247, 1251, 1253, 1257, 1259, 1265, 1271, 1275, 1278, 1281, 1285, 1291, 1295, 1298, 1301, 1307, 1310, 1313, 1317, 1323, 1326, 1329, 1333, 1337, 1341, 1343, 1347, 1349, 1352, 1356, 1358, 1365, 1369, 1375, 1379, 1383, 1386, 1391, 1396, 1401, 1406, 1412, 1416, 1418, 1422, 1426, 1428, 1430, 1438, 1443, 1454, 1464, 1474, 1479, 1483, 1490, 1495, 1500, 1505, 1510, 1515, 1520, 1525, 1528, 1534, 1536, 1550, 1553, 1560, 1574, 1577, 1583, 1587, 1591, 1595, 1598, 1600, 1605, 1609, 1613, 1617, 1621, 1625, 1628, 1630, 1635, 1639, 1644, 1650, 1653, 1657, 1661, 1664, 1666, 1670, 1673, 1681, 1685, 1688, 1692, 1702, 1706, 1710, 1724, 1728, 1733, 1737, 1741, 1746, 1748, 1751, 1755, 1758, 1761, 1767, 1771, 1775, 1781, 1785, 1789, 1792, 1795, 1801, 1805, 1809, 1811, 1815, 1819, 1821, 1825, 1829, 1835, 1839, 1843, 1849, 1853, 1857, 1860, 1864, 1868, 1872, 1886, 1890, 1894, 1900, 1904, 1908, 1914, 1918, 1922, 1928, 1932, 1936, 1940, 1944, 1947, 1953, 1957, 1969, 1973, 1977, 1979, 1983, 1987, 1991, 1995, 1998, 2007, 2011, 2016, 2019, 2021, 2024, 2030, 2034, 2038, 2042, 2046, 2050, 2053, 2069, 2080, 2086, 2094, 2098, 2102, 2106, 2110, 2113, 2119, 2123, 2127, 2131, 2135, 2139, 2143, 2147, 2151, 2154, 2162, 2166, 2169, 2176, 2180] \ No newline at end of file diff --git a/tests/grammar/cypher/Cypher.tokens b/tests/grammar/cypher/Cypher.tokens new file mode 100644 index 0000000..fd86f11 --- /dev/null +++ b/tests/grammar/cypher/Cypher.tokens @@ -0,0 +1,198 @@ +T__0=1 +T__1=2 +T__2=3 +T__3=4 +T__4=5 +T__5=6 +T__6=7 +T__7=8 +T__8=9 +T__9=10 +T__10=11 +T__11=12 +T__12=13 +T__13=14 +T__14=15 +T__15=16 +T__16=17 +T__17=18 +T__18=19 +T__19=20 +T__20=21 +T__21=22 +T__22=23 +T__23=24 +T__24=25 +T__25=26 +T__26=27 +T__27=28 +T__28=29 +T__29=30 +T__30=31 +T__31=32 +T__32=33 +T__33=34 +T__34=35 +T__35=36 +T__36=37 +T__37=38 +T__38=39 +T__39=40 +T__40=41 +T__41=42 +T__42=43 +T__43=44 +T__44=45 +T__45=46 +CYPHER=47 +EXPLAIN=48 +PROFILE=49 +USING=50 +PERIODIC=51 +COMMIT=52 +UNION=53 +ALL=54 +CREATE=55 +DROP=56 +INDEX=57 +ON=58 +CONSTRAINT=59 +ASSERT=60 +IS=61 +UNIQUE=62 +EXISTS=63 +LOAD=64 +CSV=65 +WITH=66 +HEADERS=67 +FROM=68 +AS=69 +FIELDTERMINATOR=70 +OPTIONAL=71 +MATCH=72 +UNWIND=73 +MERGE=74 +SET=75 +DETACH=76 +DELETE=77 +REMOVE=78 +FOREACH=79 +IN=80 +CALL=81 +YIELD=82 +RETURN=83 +DISTINCT=84 +ORDER=85 +BY=86 +L_SKIP=87 +LIMIT=88 +ASCENDING=89 +ASC=90 +DESCENDING=91 +DESC=92 +JOIN=93 +SCAN=94 +START=95 +NODE=96 +RELATIONSHIP=97 +REL=98 +WHERE=99 +SHORTESTPATH=100 +ALLSHORTESTPATHS=101 +OR=102 +XOR=103 +AND=104 +NOT=105 +STARTS=106 +ENDS=107 +CONTAINS=108 +NULL=109 +COUNT=110 +CASE=111 +ELSE=112 +END=113 +WHEN=114 +THEN=115 +FILTER=116 +EXTRACT=117 +REDUCE=118 +ANY=119 +NONE=120 +SINGLE=121 +TRUE=122 +FALSE=123 +HexInteger=124 +DecimalInteger=125 +OctalInteger=126 +HexLetter=127 +HexDigit=128 +Digit=129 +NonZeroDigit=130 +NonZeroOctDigit=131 +OctDigit=132 +ZeroDigit=133 +ExponentDecimalReal=134 +RegularDecimalReal=135 +StringLiteral=136 +EscapedChar=137 +DO=138 +FOR=139 +REQUIRE=140 +MANDATORY=141 +SCALAR=142 +OF=143 +ADD=144 +UnescapedSymbolicName=145 +IdentifierStart=146 +IdentifierPart=147 +EscapedSymbolicName=148 +SP=149 +WHITESPACE=150 +Comment=151 +';'=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 +'\u27e8'=28 +'\u3008'=29 +'\ufe64'=30 +'\uff1c'=31 +'\u27e9'=32 +'\u3009'=33 +'\ufe65'=34 +'\uff1e'=35 +'\u00ad'=36 +'\u2010'=37 +'\u2011'=38 +'\u2012'=39 +'\u2013'=40 +'\u2014'=41 +'\u2015'=42 +'\u2212'=43 +'\ufe58'=44 +'\ufe63'=45 +'\uff0d'=46 +'0'=133 diff --git a/tests/grammar/cypher/CypherLexer.interp b/tests/grammar/cypher/CypherLexer.interp new file mode 100644 index 0000000..35fde4c --- /dev/null +++ b/tests/grammar/cypher/CypherLexer.interp @@ -0,0 +1,490 @@ +token literal names: +null +';' +'=' +'(' +')' +'[' +']' +',' +'+=' +'|' +'*' +':' +'..' +'<>' +'<' +'>' +'<=' +'>=' +'=~' +'+' +'-' +'/' +'%' +'^' +'.' +'{' +'}' +'$' +'\u27e8' +'\u3008' +'\ufe64' +'\uff1c' +'\u27e9' +'\u3009' +'\ufe65' +'\uff1e' +'\u00ad' +'\u2010' +'\u2011' +'\u2012' +'\u2013' +'\u2014' +'\u2015' +'\u2212' +'\ufe58' +'\ufe63' +'\uff0d' +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 +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 +'0' +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +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 +null +null +null +CYPHER +EXPLAIN +PROFILE +USING +PERIODIC +COMMIT +UNION +ALL +CREATE +DROP +INDEX +ON +CONSTRAINT +ASSERT +IS +UNIQUE +EXISTS +LOAD +CSV +WITH +HEADERS +FROM +AS +FIELDTERMINATOR +OPTIONAL +MATCH +UNWIND +MERGE +SET +DETACH +DELETE +REMOVE +FOREACH +IN +CALL +YIELD +RETURN +DISTINCT +ORDER +BY +L_SKIP +LIMIT +ASCENDING +ASC +DESCENDING +DESC +JOIN +SCAN +START +NODE +RELATIONSHIP +REL +WHERE +SHORTESTPATH +ALLSHORTESTPATHS +OR +XOR +AND +NOT +STARTS +ENDS +CONTAINS +NULL +COUNT +CASE +ELSE +END +WHEN +THEN +FILTER +EXTRACT +REDUCE +ANY +NONE +SINGLE +TRUE +FALSE +HexInteger +DecimalInteger +OctalInteger +HexLetter +HexDigit +Digit +NonZeroDigit +NonZeroOctDigit +OctDigit +ZeroDigit +ExponentDecimalReal +RegularDecimalReal +StringLiteral +EscapedChar +DO +FOR +REQUIRE +MANDATORY +SCALAR +OF +ADD +UnescapedSymbolicName +IdentifierStart +IdentifierPart +EscapedSymbolicName +SP +WHITESPACE +Comment + +rule names: +T__0 +T__1 +T__2 +T__3 +T__4 +T__5 +T__6 +T__7 +T__8 +T__9 +T__10 +T__11 +T__12 +T__13 +T__14 +T__15 +T__16 +T__17 +T__18 +T__19 +T__20 +T__21 +T__22 +T__23 +T__24 +T__25 +T__26 +T__27 +T__28 +T__29 +T__30 +T__31 +T__32 +T__33 +T__34 +T__35 +T__36 +T__37 +T__38 +T__39 +T__40 +T__41 +T__42 +T__43 +T__44 +T__45 +CYPHER +EXPLAIN +PROFILE +USING +PERIODIC +COMMIT +UNION +ALL +CREATE +DROP +INDEX +ON +CONSTRAINT +ASSERT +IS +UNIQUE +EXISTS +LOAD +CSV +WITH +HEADERS +FROM +AS +FIELDTERMINATOR +OPTIONAL +MATCH +UNWIND +MERGE +SET +DETACH +DELETE +REMOVE +FOREACH +IN +CALL +YIELD +RETURN +DISTINCT +ORDER +BY +L_SKIP +LIMIT +ASCENDING +ASC +DESCENDING +DESC +JOIN +SCAN +START +NODE +RELATIONSHIP +REL +WHERE +SHORTESTPATH +ALLSHORTESTPATHS +OR +XOR +AND +NOT +STARTS +ENDS +CONTAINS +NULL +COUNT +CASE +ELSE +END +WHEN +THEN +FILTER +EXTRACT +REDUCE +ANY +NONE +SINGLE +TRUE +FALSE +HexInteger +DecimalInteger +OctalInteger +HexLetter +HexDigit +Digit +NonZeroDigit +NonZeroOctDigit +OctDigit +ZeroDigit +ExponentDecimalReal +RegularDecimalReal +StringLiteral +EscapedChar +DO +FOR +REQUIRE +MANDATORY +SCALAR +OF +ADD +UnescapedSymbolicName +IdentifierStart +IdentifierPart +EscapedSymbolicName +SP +WHITESPACE +Comment +FF +EscapedSymbolicName_0 +RS +ID_Continue +Comment_1 +StringLiteral_1 +Comment_3 +Comment_2 +GS +FS +CR +Sc +SPACE +Pc +TAB +StringLiteral_0 +LF +VT +US +ID_Start + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 151, 1223, 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, 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, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, 1, 32, 1, 32, 1, 33, 1, 33, 1, 34, 1, 34, 1, 35, 1, 35, 1, 36, 1, 36, 1, 37, 1, 37, 1, 38, 1, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 41, 1, 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 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, 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, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 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, 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, 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, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 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, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 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, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 4, 123, 938, 8, 123, 11, 123, 12, 123, 939, 1, 124, 1, 124, 1, 124, 5, 124, 945, 8, 124, 10, 124, 12, 124, 948, 9, 124, 3, 124, 950, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 4, 125, 956, 8, 125, 11, 125, 12, 125, 957, 1, 126, 3, 126, 961, 8, 126, 1, 127, 1, 127, 3, 127, 965, 8, 127, 1, 128, 1, 128, 3, 128, 969, 8, 128, 1, 129, 1, 129, 3, 129, 973, 8, 129, 1, 130, 1, 130, 1, 131, 1, 131, 3, 131, 979, 8, 131, 1, 132, 1, 132, 1, 133, 4, 133, 984, 8, 133, 11, 133, 12, 133, 985, 1, 133, 4, 133, 989, 8, 133, 11, 133, 12, 133, 990, 1, 133, 1, 133, 4, 133, 995, 8, 133, 11, 133, 12, 133, 996, 1, 133, 1, 133, 4, 133, 1001, 8, 133, 11, 133, 12, 133, 1002, 3, 133, 1005, 8, 133, 1, 133, 1, 133, 3, 133, 1009, 8, 133, 1, 133, 4, 133, 1012, 8, 133, 11, 133, 12, 133, 1013, 1, 134, 5, 134, 1017, 8, 134, 10, 134, 12, 134, 1020, 9, 134, 1, 134, 1, 134, 4, 134, 1024, 8, 134, 11, 134, 12, 134, 1025, 1, 135, 1, 135, 1, 135, 5, 135, 1031, 8, 135, 10, 135, 12, 135, 1034, 9, 135, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 1040, 8, 135, 10, 135, 12, 135, 1043, 9, 135, 1, 135, 3, 135, 1046, 8, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 1066, 8, 136, 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, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 144, 1, 144, 5, 144, 1109, 8, 144, 10, 144, 12, 144, 1112, 9, 144, 1, 145, 1, 145, 3, 145, 1116, 8, 145, 1, 146, 1, 146, 3, 146, 1120, 8, 146, 1, 147, 1, 147, 5, 147, 1124, 8, 147, 10, 147, 12, 147, 1127, 9, 147, 1, 147, 4, 147, 1130, 8, 147, 11, 147, 12, 147, 1131, 1, 148, 4, 148, 1135, 8, 148, 11, 148, 12, 148, 1136, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 1151, 8, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 5, 150, 1159, 8, 150, 10, 150, 12, 150, 1162, 9, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 5, 150, 1170, 8, 150, 10, 150, 12, 150, 1173, 9, 150, 1, 150, 3, 150, 1176, 8, 150, 1, 150, 1, 150, 3, 150, 1180, 8, 150, 3, 150, 1182, 8, 150, 1, 151, 1, 151, 1, 152, 1, 152, 1, 153, 1, 153, 1, 154, 1, 154, 1, 155, 1, 155, 1, 156, 1, 156, 1, 157, 1, 157, 1, 158, 1, 158, 1, 159, 1, 159, 1, 160, 1, 160, 1, 161, 1, 161, 1, 162, 1, 162, 1, 163, 1, 163, 1, 164, 1, 164, 1, 165, 1, 165, 1, 166, 1, 166, 1, 167, 1, 167, 1, 168, 1, 168, 1, 169, 1, 169, 1, 170, 1, 170, 0, 0, 171, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, 57, 115, 58, 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, 65, 131, 66, 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72, 145, 73, 147, 74, 149, 75, 151, 76, 153, 77, 155, 78, 157, 79, 159, 80, 161, 81, 163, 82, 165, 83, 167, 84, 169, 85, 171, 86, 173, 87, 175, 88, 177, 89, 179, 90, 181, 91, 183, 92, 185, 93, 187, 94, 189, 95, 191, 96, 193, 97, 195, 98, 197, 99, 199, 100, 201, 101, 203, 102, 205, 103, 207, 104, 209, 105, 211, 106, 213, 107, 215, 108, 217, 109, 219, 110, 221, 111, 223, 112, 225, 113, 227, 114, 229, 115, 231, 116, 233, 117, 235, 118, 237, 119, 239, 120, 241, 121, 243, 122, 245, 123, 247, 124, 249, 125, 251, 126, 253, 127, 255, 128, 257, 129, 259, 130, 261, 131, 263, 132, 265, 133, 267, 134, 269, 135, 271, 136, 273, 137, 275, 138, 277, 139, 279, 140, 281, 141, 283, 142, 285, 143, 287, 144, 289, 145, 291, 146, 293, 147, 295, 148, 297, 149, 299, 150, 301, 151, 303, 0, 305, 0, 307, 0, 309, 0, 311, 0, 313, 0, 315, 0, 317, 0, 319, 0, 321, 0, 323, 0, 325, 0, 327, 0, 329, 0, 331, 0, 333, 0, 335, 0, 337, 0, 339, 0, 341, 0, 1, 0, 48, 2, 0, 67, 67, 99, 99, 2, 0, 89, 89, 121, 121, 2, 0, 80, 80, 112, 112, 2, 0, 72, 72, 104, 104, 2, 0, 69, 69, 101, 101, 2, 0, 82, 82, 114, 114, 2, 0, 88, 88, 120, 120, 2, 0, 76, 76, 108, 108, 2, 0, 65, 65, 97, 97, 2, 0, 73, 73, 105, 105, 2, 0, 78, 78, 110, 110, 2, 0, 79, 79, 111, 111, 2, 0, 70, 70, 102, 102, 2, 0, 85, 85, 117, 117, 2, 0, 83, 83, 115, 115, 2, 0, 71, 71, 103, 103, 2, 0, 68, 68, 100, 100, 2, 0, 77, 77, 109, 109, 2, 0, 84, 84, 116, 116, 2, 0, 81, 81, 113, 113, 2, 0, 86, 86, 118, 118, 2, 0, 87, 87, 119, 119, 2, 0, 66, 66, 98, 98, 2, 0, 75, 75, 107, 107, 2, 0, 74, 74, 106, 106, 2, 0, 65, 70, 97, 102, 13, 0, 34, 34, 39, 39, 66, 66, 70, 70, 78, 78, 82, 82, 84, 84, 92, 92, 98, 98, 102, 102, 110, 110, 114, 114, 116, 116, 8, 0, 160, 160, 5760, 5760, 6158, 6158, 8192, 8202, 8232, 8233, 8239, 8239, 8287, 8287, 12288, 12288, 1, 0, 12, 12, 1, 0, 96, 96, 1, 0, 30, 30, 768, 0, 48, 57, 65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 183, 183, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 895, 895, 902, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1519, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2045, 2045, 2048, 2093, 2112, 2139, 2144, 2154, 2160, 2183, 2185, 2190, 2200, 2273, 2275, 2403, 2406, 2415, 2417, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2556, 2556, 2558, 2558, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2809, 2815, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2901, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3072, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3132, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3162, 3165, 3165, 3168, 3171, 3174, 3183, 3200, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3293, 3294, 3296, 3299, 3302, 3311, 3313, 3315, 3328, 3340, 3342, 3344, 3346, 3396, 3398, 3400, 3402, 3406, 3412, 3415, 3423, 3427, 3430, 3439, 3450, 3455, 3457, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3558, 3567, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3773, 3776, 3780, 3782, 3782, 3784, 3790, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4969, 4977, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5909, 5919, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6159, 6169, 6176, 6264, 6272, 6314, 6320, 6389, 6400, 6430, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6618, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6832, 6845, 6847, 6862, 6912, 6988, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7376, 7378, 7380, 7418, 7424, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12735, 12784, 12799, 13312, 19903, 19968, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42737, 42775, 42783, 42786, 42888, 42891, 42954, 42960, 42961, 42963, 42963, 42965, 42969, 42994, 43047, 43052, 43052, 43072, 43123, 43136, 43205, 43216, 43225, 43232, 43255, 43259, 43259, 43261, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43488, 43518, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43881, 43888, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65071, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66045, 66045, 66176, 66204, 66208, 66256, 66272, 66272, 66304, 66335, 66349, 66378, 66384, 66426, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66717, 66720, 66729, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 66928, 66938, 66940, 66954, 66956, 66962, 66964, 66965, 66967, 66977, 66979, 66993, 66995, 67001, 67003, 67004, 67072, 67382, 67392, 67413, 67424, 67431, 67456, 67461, 67463, 67504, 67506, 67514, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68099, 68101, 68102, 68108, 68115, 68117, 68119, 68121, 68149, 68152, 68154, 68159, 68159, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68326, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68903, 68912, 68921, 69248, 69289, 69291, 69292, 69296, 69297, 69373, 69404, 69415, 69415, 69424, 69456, 69488, 69509, 69552, 69572, 69600, 69622, 69632, 69702, 69734, 69749, 69759, 69818, 69826, 69826, 69840, 69864, 69872, 69881, 69888, 69940, 69942, 69951, 69956, 69959, 69968, 70003, 70006, 70006, 70016, 70084, 70089, 70092, 70094, 70106, 70108, 70108, 70144, 70161, 70163, 70199, 70206, 70209, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70378, 70384, 70393, 70400, 70403, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70459, 70468, 70471, 70472, 70475, 70477, 70480, 70480, 70487, 70487, 70493, 70499, 70502, 70508, 70512, 70516, 70656, 70730, 70736, 70745, 70750, 70753, 70784, 70853, 70855, 70855, 70864, 70873, 71040, 71093, 71096, 71104, 71128, 71133, 71168, 71232, 71236, 71236, 71248, 71257, 71296, 71352, 71360, 71369, 71424, 71450, 71453, 71467, 71472, 71481, 71488, 71494, 71680, 71738, 71840, 71913, 71935, 71942, 71945, 71945, 71948, 71955, 71957, 71958, 71960, 71989, 71991, 71992, 71995, 72003, 72016, 72025, 72096, 72103, 72106, 72151, 72154, 72161, 72163, 72164, 72192, 72254, 72263, 72263, 72272, 72345, 72349, 72349, 72368, 72440, 72704, 72712, 72714, 72758, 72760, 72768, 72784, 72793, 72818, 72847, 72850, 72871, 72873, 72886, 72960, 72966, 72968, 72969, 72971, 73014, 73018, 73018, 73020, 73021, 73023, 73031, 73040, 73049, 73056, 73061, 73063, 73064, 73066, 73102, 73104, 73105, 73107, 73112, 73120, 73129, 73440, 73462, 73472, 73488, 73490, 73530, 73534, 73538, 73552, 73561, 73648, 73648, 73728, 74649, 74752, 74862, 74880, 75075, 77712, 77808, 77824, 78895, 78912, 78933, 82944, 83526, 92160, 92728, 92736, 92766, 92768, 92777, 92784, 92862, 92864, 92873, 92880, 92909, 92912, 92916, 92928, 92982, 92992, 92995, 93008, 93017, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94031, 94087, 94095, 94111, 94176, 94177, 94179, 94180, 94192, 94193, 94208, 100343, 100352, 101589, 101632, 101640, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 113821, 113822, 118528, 118573, 118576, 118598, 119141, 119145, 119149, 119154, 119163, 119170, 119173, 119179, 119210, 119213, 119362, 119364, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 120782, 120831, 121344, 121398, 121403, 121452, 121461, 121461, 121476, 121476, 121499, 121503, 121505, 121519, 122624, 122654, 122661, 122666, 122880, 122886, 122888, 122904, 122907, 122913, 122915, 122916, 122918, 122922, 122928, 122989, 123023, 123023, 123136, 123180, 123184, 123197, 123200, 123209, 123214, 123214, 123536, 123566, 123584, 123641, 124112, 124153, 124896, 124902, 124904, 124907, 124909, 124910, 124912, 124926, 124928, 125124, 125136, 125142, 125184, 125259, 125264, 125273, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 130032, 130041, 131072, 173791, 173824, 177977, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101, 196608, 201546, 201552, 205743, 917760, 917999, 1, 0, 42, 42, 2, 0, 39, 39, 92, 92, 2, 0, 10, 10, 13, 13, 1, 0, 47, 47, 1, 0, 29, 29, 1, 0, 28, 28, 1, 0, 13, 13, 21, 0, 36, 36, 162, 165, 1423, 1423, 1547, 1547, 2046, 2047, 2546, 2547, 2555, 2555, 2801, 2801, 3065, 3065, 3647, 3647, 6107, 6107, 8352, 8384, 43064, 43064, 65020, 65020, 65129, 65129, 65284, 65284, 65504, 65505, 65509, 65510, 73693, 73696, 123647, 123647, 126128, 126128, 1, 0, 32, 32, 6, 0, 95, 95, 8255, 8256, 8276, 8276, 65075, 65076, 65101, 65103, 65343, 65343, 1, 0, 9, 9, 2, 0, 34, 34, 92, 92, 1, 0, 10, 10, 1, 0, 11, 11, 1, 0, 31, 31, 659, 0, 65, 90, 97, 122, 170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 895, 895, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1488, 1514, 1519, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2144, 2154, 2160, 2183, 2185, 2190, 2208, 2249, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2432, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2556, 2556, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2809, 2809, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3133, 3160, 3162, 3165, 3165, 3168, 3169, 3200, 3200, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3293, 3294, 3296, 3297, 3313, 3314, 3332, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3412, 3414, 3423, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5905, 5919, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6264, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6430, 6480, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6988, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7401, 7404, 7406, 7411, 7413, 7414, 7418, 7418, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12443, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12735, 12784, 12799, 13312, 19903, 19968, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42653, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42954, 42960, 42961, 42963, 42963, 42965, 42969, 42994, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43261, 43262, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43488, 43492, 43494, 43503, 43514, 43518, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43646, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43881, 43888, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66176, 66204, 66208, 66256, 66304, 66335, 66349, 66378, 66384, 66421, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66717, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 66928, 66938, 66940, 66954, 66956, 66962, 66964, 66965, 66967, 66977, 66979, 66993, 66995, 67001, 67003, 67004, 67072, 67382, 67392, 67413, 67424, 67431, 67456, 67461, 67463, 67504, 67506, 67514, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68096, 68112, 68115, 68117, 68119, 68121, 68149, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68324, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68899, 69248, 69289, 69296, 69297, 69376, 69404, 69415, 69415, 69424, 69445, 69488, 69505, 69552, 69572, 69600, 69622, 69635, 69687, 69745, 69746, 69749, 69749, 69763, 69807, 69840, 69864, 69891, 69926, 69956, 69956, 69959, 69959, 69968, 70002, 70006, 70006, 70019, 70066, 70081, 70084, 70106, 70106, 70108, 70108, 70144, 70161, 70163, 70187, 70207, 70208, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70366, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70461, 70461, 70480, 70480, 70493, 70497, 70656, 70708, 70727, 70730, 70751, 70753, 70784, 70831, 70852, 70853, 70855, 70855, 71040, 71086, 71128, 71131, 71168, 71215, 71236, 71236, 71296, 71338, 71352, 71352, 71424, 71450, 71488, 71494, 71680, 71723, 71840, 71903, 71935, 71942, 71945, 71945, 71948, 71955, 71957, 71958, 71960, 71983, 71999, 71999, 72001, 72001, 72096, 72103, 72106, 72144, 72161, 72161, 72163, 72163, 72192, 72192, 72203, 72242, 72250, 72250, 72272, 72272, 72284, 72329, 72349, 72349, 72368, 72440, 72704, 72712, 72714, 72750, 72768, 72768, 72818, 72847, 72960, 72966, 72968, 72969, 72971, 73008, 73030, 73030, 73056, 73061, 73063, 73064, 73066, 73097, 73112, 73112, 73440, 73458, 73474, 73474, 73476, 73488, 73490, 73523, 73648, 73648, 73728, 74649, 74752, 74862, 74880, 75075, 77712, 77808, 77824, 78895, 78913, 78918, 82944, 83526, 92160, 92728, 92736, 92766, 92784, 92862, 92880, 92909, 92928, 92975, 92992, 92995, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94032, 94032, 94099, 94111, 94176, 94177, 94179, 94179, 94208, 100343, 100352, 101589, 101632, 101640, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 122624, 122654, 122661, 122666, 122928, 122989, 123136, 123180, 123191, 123197, 123214, 123214, 123536, 123565, 123584, 123627, 124112, 124139, 124896, 124902, 124904, 124907, 124909, 124910, 124912, 124926, 124928, 125124, 125184, 125251, 125259, 125259, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173791, 173824, 177977, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101, 196608, 201546, 201552, 205743, 1250, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, 0, 0, 0, 0, 253, 1, 0, 0, 0, 0, 255, 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, 0, 259, 1, 0, 0, 0, 0, 261, 1, 0, 0, 0, 0, 263, 1, 0, 0, 0, 0, 265, 1, 0, 0, 0, 0, 267, 1, 0, 0, 0, 0, 269, 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 273, 1, 0, 0, 0, 0, 275, 1, 0, 0, 0, 0, 277, 1, 0, 0, 0, 0, 279, 1, 0, 0, 0, 0, 281, 1, 0, 0, 0, 0, 283, 1, 0, 0, 0, 0, 285, 1, 0, 0, 0, 0, 287, 1, 0, 0, 0, 0, 289, 1, 0, 0, 0, 0, 291, 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, 0, 295, 1, 0, 0, 0, 0, 297, 1, 0, 0, 0, 0, 299, 1, 0, 0, 0, 0, 301, 1, 0, 0, 0, 1, 343, 1, 0, 0, 0, 3, 345, 1, 0, 0, 0, 5, 347, 1, 0, 0, 0, 7, 349, 1, 0, 0, 0, 9, 351, 1, 0, 0, 0, 11, 353, 1, 0, 0, 0, 13, 355, 1, 0, 0, 0, 15, 357, 1, 0, 0, 0, 17, 360, 1, 0, 0, 0, 19, 362, 1, 0, 0, 0, 21, 364, 1, 0, 0, 0, 23, 366, 1, 0, 0, 0, 25, 369, 1, 0, 0, 0, 27, 372, 1, 0, 0, 0, 29, 374, 1, 0, 0, 0, 31, 376, 1, 0, 0, 0, 33, 379, 1, 0, 0, 0, 35, 382, 1, 0, 0, 0, 37, 385, 1, 0, 0, 0, 39, 387, 1, 0, 0, 0, 41, 389, 1, 0, 0, 0, 43, 391, 1, 0, 0, 0, 45, 393, 1, 0, 0, 0, 47, 395, 1, 0, 0, 0, 49, 397, 1, 0, 0, 0, 51, 399, 1, 0, 0, 0, 53, 401, 1, 0, 0, 0, 55, 403, 1, 0, 0, 0, 57, 405, 1, 0, 0, 0, 59, 407, 1, 0, 0, 0, 61, 409, 1, 0, 0, 0, 63, 411, 1, 0, 0, 0, 65, 413, 1, 0, 0, 0, 67, 415, 1, 0, 0, 0, 69, 417, 1, 0, 0, 0, 71, 419, 1, 0, 0, 0, 73, 421, 1, 0, 0, 0, 75, 423, 1, 0, 0, 0, 77, 425, 1, 0, 0, 0, 79, 427, 1, 0, 0, 0, 81, 429, 1, 0, 0, 0, 83, 431, 1, 0, 0, 0, 85, 433, 1, 0, 0, 0, 87, 435, 1, 0, 0, 0, 89, 437, 1, 0, 0, 0, 91, 439, 1, 0, 0, 0, 93, 441, 1, 0, 0, 0, 95, 448, 1, 0, 0, 0, 97, 456, 1, 0, 0, 0, 99, 464, 1, 0, 0, 0, 101, 470, 1, 0, 0, 0, 103, 479, 1, 0, 0, 0, 105, 486, 1, 0, 0, 0, 107, 492, 1, 0, 0, 0, 109, 496, 1, 0, 0, 0, 111, 503, 1, 0, 0, 0, 113, 508, 1, 0, 0, 0, 115, 514, 1, 0, 0, 0, 117, 517, 1, 0, 0, 0, 119, 528, 1, 0, 0, 0, 121, 535, 1, 0, 0, 0, 123, 538, 1, 0, 0, 0, 125, 545, 1, 0, 0, 0, 127, 552, 1, 0, 0, 0, 129, 557, 1, 0, 0, 0, 131, 561, 1, 0, 0, 0, 133, 566, 1, 0, 0, 0, 135, 574, 1, 0, 0, 0, 137, 579, 1, 0, 0, 0, 139, 582, 1, 0, 0, 0, 141, 598, 1, 0, 0, 0, 143, 607, 1, 0, 0, 0, 145, 613, 1, 0, 0, 0, 147, 620, 1, 0, 0, 0, 149, 626, 1, 0, 0, 0, 151, 630, 1, 0, 0, 0, 153, 637, 1, 0, 0, 0, 155, 644, 1, 0, 0, 0, 157, 651, 1, 0, 0, 0, 159, 659, 1, 0, 0, 0, 161, 662, 1, 0, 0, 0, 163, 667, 1, 0, 0, 0, 165, 673, 1, 0, 0, 0, 167, 680, 1, 0, 0, 0, 169, 689, 1, 0, 0, 0, 171, 695, 1, 0, 0, 0, 173, 698, 1, 0, 0, 0, 175, 703, 1, 0, 0, 0, 177, 709, 1, 0, 0, 0, 179, 719, 1, 0, 0, 0, 181, 723, 1, 0, 0, 0, 183, 734, 1, 0, 0, 0, 185, 739, 1, 0, 0, 0, 187, 744, 1, 0, 0, 0, 189, 749, 1, 0, 0, 0, 191, 755, 1, 0, 0, 0, 193, 760, 1, 0, 0, 0, 195, 773, 1, 0, 0, 0, 197, 777, 1, 0, 0, 0, 199, 783, 1, 0, 0, 0, 201, 796, 1, 0, 0, 0, 203, 813, 1, 0, 0, 0, 205, 816, 1, 0, 0, 0, 207, 820, 1, 0, 0, 0, 209, 824, 1, 0, 0, 0, 211, 828, 1, 0, 0, 0, 213, 835, 1, 0, 0, 0, 215, 840, 1, 0, 0, 0, 217, 849, 1, 0, 0, 0, 219, 854, 1, 0, 0, 0, 221, 860, 1, 0, 0, 0, 223, 865, 1, 0, 0, 0, 225, 870, 1, 0, 0, 0, 227, 874, 1, 0, 0, 0, 229, 879, 1, 0, 0, 0, 231, 884, 1, 0, 0, 0, 233, 891, 1, 0, 0, 0, 235, 899, 1, 0, 0, 0, 237, 906, 1, 0, 0, 0, 239, 910, 1, 0, 0, 0, 241, 915, 1, 0, 0, 0, 243, 922, 1, 0, 0, 0, 245, 927, 1, 0, 0, 0, 247, 933, 1, 0, 0, 0, 249, 949, 1, 0, 0, 0, 251, 951, 1, 0, 0, 0, 253, 960, 1, 0, 0, 0, 255, 964, 1, 0, 0, 0, 257, 968, 1, 0, 0, 0, 259, 972, 1, 0, 0, 0, 261, 974, 1, 0, 0, 0, 263, 978, 1, 0, 0, 0, 265, 980, 1, 0, 0, 0, 267, 1004, 1, 0, 0, 0, 269, 1018, 1, 0, 0, 0, 271, 1045, 1, 0, 0, 0, 273, 1047, 1, 0, 0, 0, 275, 1067, 1, 0, 0, 0, 277, 1070, 1, 0, 0, 0, 279, 1074, 1, 0, 0, 0, 281, 1082, 1, 0, 0, 0, 283, 1092, 1, 0, 0, 0, 285, 1099, 1, 0, 0, 0, 287, 1102, 1, 0, 0, 0, 289, 1106, 1, 0, 0, 0, 291, 1115, 1, 0, 0, 0, 293, 1119, 1, 0, 0, 0, 295, 1129, 1, 0, 0, 0, 297, 1134, 1, 0, 0, 0, 299, 1150, 1, 0, 0, 0, 301, 1181, 1, 0, 0, 0, 303, 1183, 1, 0, 0, 0, 305, 1185, 1, 0, 0, 0, 307, 1187, 1, 0, 0, 0, 309, 1189, 1, 0, 0, 0, 311, 1191, 1, 0, 0, 0, 313, 1193, 1, 0, 0, 0, 315, 1195, 1, 0, 0, 0, 317, 1197, 1, 0, 0, 0, 319, 1199, 1, 0, 0, 0, 321, 1201, 1, 0, 0, 0, 323, 1203, 1, 0, 0, 0, 325, 1205, 1, 0, 0, 0, 327, 1207, 1, 0, 0, 0, 329, 1209, 1, 0, 0, 0, 331, 1211, 1, 0, 0, 0, 333, 1213, 1, 0, 0, 0, 335, 1215, 1, 0, 0, 0, 337, 1217, 1, 0, 0, 0, 339, 1219, 1, 0, 0, 0, 341, 1221, 1, 0, 0, 0, 343, 344, 5, 59, 0, 0, 344, 2, 1, 0, 0, 0, 345, 346, 5, 61, 0, 0, 346, 4, 1, 0, 0, 0, 347, 348, 5, 40, 0, 0, 348, 6, 1, 0, 0, 0, 349, 350, 5, 41, 0, 0, 350, 8, 1, 0, 0, 0, 351, 352, 5, 91, 0, 0, 352, 10, 1, 0, 0, 0, 353, 354, 5, 93, 0, 0, 354, 12, 1, 0, 0, 0, 355, 356, 5, 44, 0, 0, 356, 14, 1, 0, 0, 0, 357, 358, 5, 43, 0, 0, 358, 359, 5, 61, 0, 0, 359, 16, 1, 0, 0, 0, 360, 361, 5, 124, 0, 0, 361, 18, 1, 0, 0, 0, 362, 363, 5, 42, 0, 0, 363, 20, 1, 0, 0, 0, 364, 365, 5, 58, 0, 0, 365, 22, 1, 0, 0, 0, 366, 367, 5, 46, 0, 0, 367, 368, 5, 46, 0, 0, 368, 24, 1, 0, 0, 0, 369, 370, 5, 60, 0, 0, 370, 371, 5, 62, 0, 0, 371, 26, 1, 0, 0, 0, 372, 373, 5, 60, 0, 0, 373, 28, 1, 0, 0, 0, 374, 375, 5, 62, 0, 0, 375, 30, 1, 0, 0, 0, 376, 377, 5, 60, 0, 0, 377, 378, 5, 61, 0, 0, 378, 32, 1, 0, 0, 0, 379, 380, 5, 62, 0, 0, 380, 381, 5, 61, 0, 0, 381, 34, 1, 0, 0, 0, 382, 383, 5, 61, 0, 0, 383, 384, 5, 126, 0, 0, 384, 36, 1, 0, 0, 0, 385, 386, 5, 43, 0, 0, 386, 38, 1, 0, 0, 0, 387, 388, 5, 45, 0, 0, 388, 40, 1, 0, 0, 0, 389, 390, 5, 47, 0, 0, 390, 42, 1, 0, 0, 0, 391, 392, 5, 37, 0, 0, 392, 44, 1, 0, 0, 0, 393, 394, 5, 94, 0, 0, 394, 46, 1, 0, 0, 0, 395, 396, 5, 46, 0, 0, 396, 48, 1, 0, 0, 0, 397, 398, 5, 123, 0, 0, 398, 50, 1, 0, 0, 0, 399, 400, 5, 125, 0, 0, 400, 52, 1, 0, 0, 0, 401, 402, 5, 36, 0, 0, 402, 54, 1, 0, 0, 0, 403, 404, 5, 10216, 0, 0, 404, 56, 1, 0, 0, 0, 405, 406, 5, 12296, 0, 0, 406, 58, 1, 0, 0, 0, 407, 408, 5, 65124, 0, 0, 408, 60, 1, 0, 0, 0, 409, 410, 5, 65308, 0, 0, 410, 62, 1, 0, 0, 0, 411, 412, 5, 10217, 0, 0, 412, 64, 1, 0, 0, 0, 413, 414, 5, 12297, 0, 0, 414, 66, 1, 0, 0, 0, 415, 416, 5, 65125, 0, 0, 416, 68, 1, 0, 0, 0, 417, 418, 5, 65310, 0, 0, 418, 70, 1, 0, 0, 0, 419, 420, 5, 173, 0, 0, 420, 72, 1, 0, 0, 0, 421, 422, 5, 8208, 0, 0, 422, 74, 1, 0, 0, 0, 423, 424, 5, 8209, 0, 0, 424, 76, 1, 0, 0, 0, 425, 426, 5, 8210, 0, 0, 426, 78, 1, 0, 0, 0, 427, 428, 5, 8211, 0, 0, 428, 80, 1, 0, 0, 0, 429, 430, 5, 8212, 0, 0, 430, 82, 1, 0, 0, 0, 431, 432, 5, 8213, 0, 0, 432, 84, 1, 0, 0, 0, 433, 434, 5, 8722, 0, 0, 434, 86, 1, 0, 0, 0, 435, 436, 5, 65112, 0, 0, 436, 88, 1, 0, 0, 0, 437, 438, 5, 65123, 0, 0, 438, 90, 1, 0, 0, 0, 439, 440, 5, 65293, 0, 0, 440, 92, 1, 0, 0, 0, 441, 442, 7, 0, 0, 0, 442, 443, 7, 1, 0, 0, 443, 444, 7, 2, 0, 0, 444, 445, 7, 3, 0, 0, 445, 446, 7, 4, 0, 0, 446, 447, 7, 5, 0, 0, 447, 94, 1, 0, 0, 0, 448, 449, 7, 4, 0, 0, 449, 450, 7, 6, 0, 0, 450, 451, 7, 2, 0, 0, 451, 452, 7, 7, 0, 0, 452, 453, 7, 8, 0, 0, 453, 454, 7, 9, 0, 0, 454, 455, 7, 10, 0, 0, 455, 96, 1, 0, 0, 0, 456, 457, 7, 2, 0, 0, 457, 458, 7, 5, 0, 0, 458, 459, 7, 11, 0, 0, 459, 460, 7, 12, 0, 0, 460, 461, 7, 9, 0, 0, 461, 462, 7, 7, 0, 0, 462, 463, 7, 4, 0, 0, 463, 98, 1, 0, 0, 0, 464, 465, 7, 13, 0, 0, 465, 466, 7, 14, 0, 0, 466, 467, 7, 9, 0, 0, 467, 468, 7, 10, 0, 0, 468, 469, 7, 15, 0, 0, 469, 100, 1, 0, 0, 0, 470, 471, 7, 2, 0, 0, 471, 472, 7, 4, 0, 0, 472, 473, 7, 5, 0, 0, 473, 474, 7, 9, 0, 0, 474, 475, 7, 11, 0, 0, 475, 476, 7, 16, 0, 0, 476, 477, 7, 9, 0, 0, 477, 478, 7, 0, 0, 0, 478, 102, 1, 0, 0, 0, 479, 480, 7, 0, 0, 0, 480, 481, 7, 11, 0, 0, 481, 482, 7, 17, 0, 0, 482, 483, 7, 17, 0, 0, 483, 484, 7, 9, 0, 0, 484, 485, 7, 18, 0, 0, 485, 104, 1, 0, 0, 0, 486, 487, 7, 13, 0, 0, 487, 488, 7, 10, 0, 0, 488, 489, 7, 9, 0, 0, 489, 490, 7, 11, 0, 0, 490, 491, 7, 10, 0, 0, 491, 106, 1, 0, 0, 0, 492, 493, 7, 8, 0, 0, 493, 494, 7, 7, 0, 0, 494, 495, 7, 7, 0, 0, 495, 108, 1, 0, 0, 0, 496, 497, 7, 0, 0, 0, 497, 498, 7, 5, 0, 0, 498, 499, 7, 4, 0, 0, 499, 500, 7, 8, 0, 0, 500, 501, 7, 18, 0, 0, 501, 502, 7, 4, 0, 0, 502, 110, 1, 0, 0, 0, 503, 504, 7, 16, 0, 0, 504, 505, 7, 5, 0, 0, 505, 506, 7, 11, 0, 0, 506, 507, 7, 2, 0, 0, 507, 112, 1, 0, 0, 0, 508, 509, 7, 9, 0, 0, 509, 510, 7, 10, 0, 0, 510, 511, 7, 16, 0, 0, 511, 512, 7, 4, 0, 0, 512, 513, 7, 6, 0, 0, 513, 114, 1, 0, 0, 0, 514, 515, 7, 11, 0, 0, 515, 516, 7, 10, 0, 0, 516, 116, 1, 0, 0, 0, 517, 518, 7, 0, 0, 0, 518, 519, 7, 11, 0, 0, 519, 520, 7, 10, 0, 0, 520, 521, 7, 14, 0, 0, 521, 522, 7, 18, 0, 0, 522, 523, 7, 5, 0, 0, 523, 524, 7, 8, 0, 0, 524, 525, 7, 9, 0, 0, 525, 526, 7, 10, 0, 0, 526, 527, 7, 18, 0, 0, 527, 118, 1, 0, 0, 0, 528, 529, 7, 8, 0, 0, 529, 530, 7, 14, 0, 0, 530, 531, 7, 14, 0, 0, 531, 532, 7, 4, 0, 0, 532, 533, 7, 5, 0, 0, 533, 534, 7, 18, 0, 0, 534, 120, 1, 0, 0, 0, 535, 536, 7, 9, 0, 0, 536, 537, 7, 14, 0, 0, 537, 122, 1, 0, 0, 0, 538, 539, 7, 13, 0, 0, 539, 540, 7, 10, 0, 0, 540, 541, 7, 9, 0, 0, 541, 542, 7, 19, 0, 0, 542, 543, 7, 13, 0, 0, 543, 544, 7, 4, 0, 0, 544, 124, 1, 0, 0, 0, 545, 546, 7, 4, 0, 0, 546, 547, 7, 6, 0, 0, 547, 548, 7, 9, 0, 0, 548, 549, 7, 14, 0, 0, 549, 550, 7, 18, 0, 0, 550, 551, 7, 14, 0, 0, 551, 126, 1, 0, 0, 0, 552, 553, 7, 7, 0, 0, 553, 554, 7, 11, 0, 0, 554, 555, 7, 8, 0, 0, 555, 556, 7, 16, 0, 0, 556, 128, 1, 0, 0, 0, 557, 558, 7, 0, 0, 0, 558, 559, 7, 14, 0, 0, 559, 560, 7, 20, 0, 0, 560, 130, 1, 0, 0, 0, 561, 562, 7, 21, 0, 0, 562, 563, 7, 9, 0, 0, 563, 564, 7, 18, 0, 0, 564, 565, 7, 3, 0, 0, 565, 132, 1, 0, 0, 0, 566, 567, 7, 3, 0, 0, 567, 568, 7, 4, 0, 0, 568, 569, 7, 8, 0, 0, 569, 570, 7, 16, 0, 0, 570, 571, 7, 4, 0, 0, 571, 572, 7, 5, 0, 0, 572, 573, 7, 14, 0, 0, 573, 134, 1, 0, 0, 0, 574, 575, 7, 12, 0, 0, 575, 576, 7, 5, 0, 0, 576, 577, 7, 11, 0, 0, 577, 578, 7, 17, 0, 0, 578, 136, 1, 0, 0, 0, 579, 580, 7, 8, 0, 0, 580, 581, 7, 14, 0, 0, 581, 138, 1, 0, 0, 0, 582, 583, 7, 12, 0, 0, 583, 584, 7, 9, 0, 0, 584, 585, 7, 4, 0, 0, 585, 586, 7, 7, 0, 0, 586, 587, 7, 16, 0, 0, 587, 588, 7, 18, 0, 0, 588, 589, 7, 4, 0, 0, 589, 590, 7, 5, 0, 0, 590, 591, 7, 17, 0, 0, 591, 592, 7, 9, 0, 0, 592, 593, 7, 10, 0, 0, 593, 594, 7, 8, 0, 0, 594, 595, 7, 18, 0, 0, 595, 596, 7, 11, 0, 0, 596, 597, 7, 5, 0, 0, 597, 140, 1, 0, 0, 0, 598, 599, 7, 11, 0, 0, 599, 600, 7, 2, 0, 0, 600, 601, 7, 18, 0, 0, 601, 602, 7, 9, 0, 0, 602, 603, 7, 11, 0, 0, 603, 604, 7, 10, 0, 0, 604, 605, 7, 8, 0, 0, 605, 606, 7, 7, 0, 0, 606, 142, 1, 0, 0, 0, 607, 608, 7, 17, 0, 0, 608, 609, 7, 8, 0, 0, 609, 610, 7, 18, 0, 0, 610, 611, 7, 0, 0, 0, 611, 612, 7, 3, 0, 0, 612, 144, 1, 0, 0, 0, 613, 614, 7, 13, 0, 0, 614, 615, 7, 10, 0, 0, 615, 616, 7, 21, 0, 0, 616, 617, 7, 9, 0, 0, 617, 618, 7, 10, 0, 0, 618, 619, 7, 16, 0, 0, 619, 146, 1, 0, 0, 0, 620, 621, 7, 17, 0, 0, 621, 622, 7, 4, 0, 0, 622, 623, 7, 5, 0, 0, 623, 624, 7, 15, 0, 0, 624, 625, 7, 4, 0, 0, 625, 148, 1, 0, 0, 0, 626, 627, 7, 14, 0, 0, 627, 628, 7, 4, 0, 0, 628, 629, 7, 18, 0, 0, 629, 150, 1, 0, 0, 0, 630, 631, 7, 16, 0, 0, 631, 632, 7, 4, 0, 0, 632, 633, 7, 18, 0, 0, 633, 634, 7, 8, 0, 0, 634, 635, 7, 0, 0, 0, 635, 636, 7, 3, 0, 0, 636, 152, 1, 0, 0, 0, 637, 638, 7, 16, 0, 0, 638, 639, 7, 4, 0, 0, 639, 640, 7, 7, 0, 0, 640, 641, 7, 4, 0, 0, 641, 642, 7, 18, 0, 0, 642, 643, 7, 4, 0, 0, 643, 154, 1, 0, 0, 0, 644, 645, 7, 5, 0, 0, 645, 646, 7, 4, 0, 0, 646, 647, 7, 17, 0, 0, 647, 648, 7, 11, 0, 0, 648, 649, 7, 20, 0, 0, 649, 650, 7, 4, 0, 0, 650, 156, 1, 0, 0, 0, 651, 652, 7, 12, 0, 0, 652, 653, 7, 11, 0, 0, 653, 654, 7, 5, 0, 0, 654, 655, 7, 4, 0, 0, 655, 656, 7, 8, 0, 0, 656, 657, 7, 0, 0, 0, 657, 658, 7, 3, 0, 0, 658, 158, 1, 0, 0, 0, 659, 660, 7, 9, 0, 0, 660, 661, 7, 10, 0, 0, 661, 160, 1, 0, 0, 0, 662, 663, 7, 0, 0, 0, 663, 664, 7, 8, 0, 0, 664, 665, 7, 7, 0, 0, 665, 666, 7, 7, 0, 0, 666, 162, 1, 0, 0, 0, 667, 668, 7, 1, 0, 0, 668, 669, 7, 9, 0, 0, 669, 670, 7, 4, 0, 0, 670, 671, 7, 7, 0, 0, 671, 672, 7, 16, 0, 0, 672, 164, 1, 0, 0, 0, 673, 674, 7, 5, 0, 0, 674, 675, 7, 4, 0, 0, 675, 676, 7, 18, 0, 0, 676, 677, 7, 13, 0, 0, 677, 678, 7, 5, 0, 0, 678, 679, 7, 10, 0, 0, 679, 166, 1, 0, 0, 0, 680, 681, 7, 16, 0, 0, 681, 682, 7, 9, 0, 0, 682, 683, 7, 14, 0, 0, 683, 684, 7, 18, 0, 0, 684, 685, 7, 9, 0, 0, 685, 686, 7, 10, 0, 0, 686, 687, 7, 0, 0, 0, 687, 688, 7, 18, 0, 0, 688, 168, 1, 0, 0, 0, 689, 690, 7, 11, 0, 0, 690, 691, 7, 5, 0, 0, 691, 692, 7, 16, 0, 0, 692, 693, 7, 4, 0, 0, 693, 694, 7, 5, 0, 0, 694, 170, 1, 0, 0, 0, 695, 696, 7, 22, 0, 0, 696, 697, 7, 1, 0, 0, 697, 172, 1, 0, 0, 0, 698, 699, 7, 14, 0, 0, 699, 700, 7, 23, 0, 0, 700, 701, 7, 9, 0, 0, 701, 702, 7, 2, 0, 0, 702, 174, 1, 0, 0, 0, 703, 704, 7, 7, 0, 0, 704, 705, 7, 9, 0, 0, 705, 706, 7, 17, 0, 0, 706, 707, 7, 9, 0, 0, 707, 708, 7, 18, 0, 0, 708, 176, 1, 0, 0, 0, 709, 710, 7, 8, 0, 0, 710, 711, 7, 14, 0, 0, 711, 712, 7, 0, 0, 0, 712, 713, 7, 4, 0, 0, 713, 714, 7, 10, 0, 0, 714, 715, 7, 16, 0, 0, 715, 716, 7, 9, 0, 0, 716, 717, 7, 10, 0, 0, 717, 718, 7, 15, 0, 0, 718, 178, 1, 0, 0, 0, 719, 720, 7, 8, 0, 0, 720, 721, 7, 14, 0, 0, 721, 722, 7, 0, 0, 0, 722, 180, 1, 0, 0, 0, 723, 724, 7, 16, 0, 0, 724, 725, 7, 4, 0, 0, 725, 726, 7, 14, 0, 0, 726, 727, 7, 0, 0, 0, 727, 728, 7, 4, 0, 0, 728, 729, 7, 10, 0, 0, 729, 730, 7, 16, 0, 0, 730, 731, 7, 9, 0, 0, 731, 732, 7, 10, 0, 0, 732, 733, 7, 15, 0, 0, 733, 182, 1, 0, 0, 0, 734, 735, 7, 16, 0, 0, 735, 736, 7, 4, 0, 0, 736, 737, 7, 14, 0, 0, 737, 738, 7, 0, 0, 0, 738, 184, 1, 0, 0, 0, 739, 740, 7, 24, 0, 0, 740, 741, 7, 11, 0, 0, 741, 742, 7, 9, 0, 0, 742, 743, 7, 10, 0, 0, 743, 186, 1, 0, 0, 0, 744, 745, 7, 14, 0, 0, 745, 746, 7, 0, 0, 0, 746, 747, 7, 8, 0, 0, 747, 748, 7, 10, 0, 0, 748, 188, 1, 0, 0, 0, 749, 750, 7, 14, 0, 0, 750, 751, 7, 18, 0, 0, 751, 752, 7, 8, 0, 0, 752, 753, 7, 5, 0, 0, 753, 754, 7, 18, 0, 0, 754, 190, 1, 0, 0, 0, 755, 756, 7, 10, 0, 0, 756, 757, 7, 11, 0, 0, 757, 758, 7, 16, 0, 0, 758, 759, 7, 4, 0, 0, 759, 192, 1, 0, 0, 0, 760, 761, 7, 5, 0, 0, 761, 762, 7, 4, 0, 0, 762, 763, 7, 7, 0, 0, 763, 764, 7, 8, 0, 0, 764, 765, 7, 18, 0, 0, 765, 766, 7, 9, 0, 0, 766, 767, 7, 11, 0, 0, 767, 768, 7, 10, 0, 0, 768, 769, 7, 14, 0, 0, 769, 770, 7, 3, 0, 0, 770, 771, 7, 9, 0, 0, 771, 772, 7, 2, 0, 0, 772, 194, 1, 0, 0, 0, 773, 774, 7, 5, 0, 0, 774, 775, 7, 4, 0, 0, 775, 776, 7, 7, 0, 0, 776, 196, 1, 0, 0, 0, 777, 778, 7, 21, 0, 0, 778, 779, 7, 3, 0, 0, 779, 780, 7, 4, 0, 0, 780, 781, 7, 5, 0, 0, 781, 782, 7, 4, 0, 0, 782, 198, 1, 0, 0, 0, 783, 784, 7, 14, 0, 0, 784, 785, 7, 3, 0, 0, 785, 786, 7, 11, 0, 0, 786, 787, 7, 5, 0, 0, 787, 788, 7, 18, 0, 0, 788, 789, 7, 4, 0, 0, 789, 790, 7, 14, 0, 0, 790, 791, 7, 18, 0, 0, 791, 792, 7, 2, 0, 0, 792, 793, 7, 8, 0, 0, 793, 794, 7, 18, 0, 0, 794, 795, 7, 3, 0, 0, 795, 200, 1, 0, 0, 0, 796, 797, 7, 8, 0, 0, 797, 798, 7, 7, 0, 0, 798, 799, 7, 7, 0, 0, 799, 800, 7, 14, 0, 0, 800, 801, 7, 3, 0, 0, 801, 802, 7, 11, 0, 0, 802, 803, 7, 5, 0, 0, 803, 804, 7, 18, 0, 0, 804, 805, 7, 4, 0, 0, 805, 806, 7, 14, 0, 0, 806, 807, 7, 18, 0, 0, 807, 808, 7, 2, 0, 0, 808, 809, 7, 8, 0, 0, 809, 810, 7, 18, 0, 0, 810, 811, 7, 3, 0, 0, 811, 812, 7, 14, 0, 0, 812, 202, 1, 0, 0, 0, 813, 814, 7, 11, 0, 0, 814, 815, 7, 5, 0, 0, 815, 204, 1, 0, 0, 0, 816, 817, 7, 6, 0, 0, 817, 818, 7, 11, 0, 0, 818, 819, 7, 5, 0, 0, 819, 206, 1, 0, 0, 0, 820, 821, 7, 8, 0, 0, 821, 822, 7, 10, 0, 0, 822, 823, 7, 16, 0, 0, 823, 208, 1, 0, 0, 0, 824, 825, 7, 10, 0, 0, 825, 826, 7, 11, 0, 0, 826, 827, 7, 18, 0, 0, 827, 210, 1, 0, 0, 0, 828, 829, 7, 14, 0, 0, 829, 830, 7, 18, 0, 0, 830, 831, 7, 8, 0, 0, 831, 832, 7, 5, 0, 0, 832, 833, 7, 18, 0, 0, 833, 834, 7, 14, 0, 0, 834, 212, 1, 0, 0, 0, 835, 836, 7, 4, 0, 0, 836, 837, 7, 10, 0, 0, 837, 838, 7, 16, 0, 0, 838, 839, 7, 14, 0, 0, 839, 214, 1, 0, 0, 0, 840, 841, 7, 0, 0, 0, 841, 842, 7, 11, 0, 0, 842, 843, 7, 10, 0, 0, 843, 844, 7, 18, 0, 0, 844, 845, 7, 8, 0, 0, 845, 846, 7, 9, 0, 0, 846, 847, 7, 10, 0, 0, 847, 848, 7, 14, 0, 0, 848, 216, 1, 0, 0, 0, 849, 850, 7, 10, 0, 0, 850, 851, 7, 13, 0, 0, 851, 852, 7, 7, 0, 0, 852, 853, 7, 7, 0, 0, 853, 218, 1, 0, 0, 0, 854, 855, 7, 0, 0, 0, 855, 856, 7, 11, 0, 0, 856, 857, 7, 13, 0, 0, 857, 858, 7, 10, 0, 0, 858, 859, 7, 18, 0, 0, 859, 220, 1, 0, 0, 0, 860, 861, 7, 0, 0, 0, 861, 862, 7, 8, 0, 0, 862, 863, 7, 14, 0, 0, 863, 864, 7, 4, 0, 0, 864, 222, 1, 0, 0, 0, 865, 866, 7, 4, 0, 0, 866, 867, 7, 7, 0, 0, 867, 868, 7, 14, 0, 0, 868, 869, 7, 4, 0, 0, 869, 224, 1, 0, 0, 0, 870, 871, 7, 4, 0, 0, 871, 872, 7, 10, 0, 0, 872, 873, 7, 16, 0, 0, 873, 226, 1, 0, 0, 0, 874, 875, 7, 21, 0, 0, 875, 876, 7, 3, 0, 0, 876, 877, 7, 4, 0, 0, 877, 878, 7, 10, 0, 0, 878, 228, 1, 0, 0, 0, 879, 880, 7, 18, 0, 0, 880, 881, 7, 3, 0, 0, 881, 882, 7, 4, 0, 0, 882, 883, 7, 10, 0, 0, 883, 230, 1, 0, 0, 0, 884, 885, 7, 12, 0, 0, 885, 886, 7, 9, 0, 0, 886, 887, 7, 7, 0, 0, 887, 888, 7, 18, 0, 0, 888, 889, 7, 4, 0, 0, 889, 890, 7, 5, 0, 0, 890, 232, 1, 0, 0, 0, 891, 892, 7, 4, 0, 0, 892, 893, 7, 6, 0, 0, 893, 894, 7, 18, 0, 0, 894, 895, 7, 5, 0, 0, 895, 896, 7, 8, 0, 0, 896, 897, 7, 0, 0, 0, 897, 898, 7, 18, 0, 0, 898, 234, 1, 0, 0, 0, 899, 900, 7, 5, 0, 0, 900, 901, 7, 4, 0, 0, 901, 902, 7, 16, 0, 0, 902, 903, 7, 13, 0, 0, 903, 904, 7, 0, 0, 0, 904, 905, 7, 4, 0, 0, 905, 236, 1, 0, 0, 0, 906, 907, 7, 8, 0, 0, 907, 908, 7, 10, 0, 0, 908, 909, 7, 1, 0, 0, 909, 238, 1, 0, 0, 0, 910, 911, 7, 10, 0, 0, 911, 912, 7, 11, 0, 0, 912, 913, 7, 10, 0, 0, 913, 914, 7, 4, 0, 0, 914, 240, 1, 0, 0, 0, 915, 916, 7, 14, 0, 0, 916, 917, 7, 9, 0, 0, 917, 918, 7, 10, 0, 0, 918, 919, 7, 15, 0, 0, 919, 920, 7, 7, 0, 0, 920, 921, 7, 4, 0, 0, 921, 242, 1, 0, 0, 0, 922, 923, 7, 18, 0, 0, 923, 924, 7, 5, 0, 0, 924, 925, 7, 13, 0, 0, 925, 926, 7, 4, 0, 0, 926, 244, 1, 0, 0, 0, 927, 928, 7, 12, 0, 0, 928, 929, 7, 8, 0, 0, 929, 930, 7, 7, 0, 0, 930, 931, 7, 14, 0, 0, 931, 932, 7, 4, 0, 0, 932, 246, 1, 0, 0, 0, 933, 934, 5, 48, 0, 0, 934, 935, 5, 120, 0, 0, 935, 937, 1, 0, 0, 0, 936, 938, 3, 255, 127, 0, 937, 936, 1, 0, 0, 0, 938, 939, 1, 0, 0, 0, 939, 937, 1, 0, 0, 0, 939, 940, 1, 0, 0, 0, 940, 248, 1, 0, 0, 0, 941, 950, 3, 265, 132, 0, 942, 946, 3, 259, 129, 0, 943, 945, 3, 257, 128, 0, 944, 943, 1, 0, 0, 0, 945, 948, 1, 0, 0, 0, 946, 944, 1, 0, 0, 0, 946, 947, 1, 0, 0, 0, 947, 950, 1, 0, 0, 0, 948, 946, 1, 0, 0, 0, 949, 941, 1, 0, 0, 0, 949, 942, 1, 0, 0, 0, 950, 250, 1, 0, 0, 0, 951, 952, 5, 48, 0, 0, 952, 953, 5, 111, 0, 0, 953, 955, 1, 0, 0, 0, 954, 956, 3, 263, 131, 0, 955, 954, 1, 0, 0, 0, 956, 957, 1, 0, 0, 0, 957, 955, 1, 0, 0, 0, 957, 958, 1, 0, 0, 0, 958, 252, 1, 0, 0, 0, 959, 961, 7, 25, 0, 0, 960, 959, 1, 0, 0, 0, 961, 254, 1, 0, 0, 0, 962, 965, 3, 257, 128, 0, 963, 965, 3, 253, 126, 0, 964, 962, 1, 0, 0, 0, 964, 963, 1, 0, 0, 0, 965, 256, 1, 0, 0, 0, 966, 969, 3, 265, 132, 0, 967, 969, 3, 259, 129, 0, 968, 966, 1, 0, 0, 0, 968, 967, 1, 0, 0, 0, 969, 258, 1, 0, 0, 0, 970, 973, 3, 261, 130, 0, 971, 973, 2, 56, 57, 0, 972, 970, 1, 0, 0, 0, 972, 971, 1, 0, 0, 0, 973, 260, 1, 0, 0, 0, 974, 975, 2, 49, 55, 0, 975, 262, 1, 0, 0, 0, 976, 979, 3, 265, 132, 0, 977, 979, 3, 261, 130, 0, 978, 976, 1, 0, 0, 0, 978, 977, 1, 0, 0, 0, 979, 264, 1, 0, 0, 0, 980, 981, 5, 48, 0, 0, 981, 266, 1, 0, 0, 0, 982, 984, 3, 257, 128, 0, 983, 982, 1, 0, 0, 0, 984, 985, 1, 0, 0, 0, 985, 983, 1, 0, 0, 0, 985, 986, 1, 0, 0, 0, 986, 1005, 1, 0, 0, 0, 987, 989, 3, 257, 128, 0, 988, 987, 1, 0, 0, 0, 989, 990, 1, 0, 0, 0, 990, 988, 1, 0, 0, 0, 990, 991, 1, 0, 0, 0, 991, 992, 1, 0, 0, 0, 992, 994, 5, 46, 0, 0, 993, 995, 3, 257, 128, 0, 994, 993, 1, 0, 0, 0, 995, 996, 1, 0, 0, 0, 996, 994, 1, 0, 0, 0, 996, 997, 1, 0, 0, 0, 997, 1005, 1, 0, 0, 0, 998, 1000, 5, 46, 0, 0, 999, 1001, 3, 257, 128, 0, 1000, 999, 1, 0, 0, 0, 1001, 1002, 1, 0, 0, 0, 1002, 1000, 1, 0, 0, 0, 1002, 1003, 1, 0, 0, 0, 1003, 1005, 1, 0, 0, 0, 1004, 983, 1, 0, 0, 0, 1004, 988, 1, 0, 0, 0, 1004, 998, 1, 0, 0, 0, 1005, 1006, 1, 0, 0, 0, 1006, 1008, 7, 4, 0, 0, 1007, 1009, 5, 45, 0, 0, 1008, 1007, 1, 0, 0, 0, 1008, 1009, 1, 0, 0, 0, 1009, 1011, 1, 0, 0, 0, 1010, 1012, 3, 257, 128, 0, 1011, 1010, 1, 0, 0, 0, 1012, 1013, 1, 0, 0, 0, 1013, 1011, 1, 0, 0, 0, 1013, 1014, 1, 0, 0, 0, 1014, 268, 1, 0, 0, 0, 1015, 1017, 3, 257, 128, 0, 1016, 1015, 1, 0, 0, 0, 1017, 1020, 1, 0, 0, 0, 1018, 1016, 1, 0, 0, 0, 1018, 1019, 1, 0, 0, 0, 1019, 1021, 1, 0, 0, 0, 1020, 1018, 1, 0, 0, 0, 1021, 1023, 5, 46, 0, 0, 1022, 1024, 3, 257, 128, 0, 1023, 1022, 1, 0, 0, 0, 1024, 1025, 1, 0, 0, 0, 1025, 1023, 1, 0, 0, 0, 1025, 1026, 1, 0, 0, 0, 1026, 270, 1, 0, 0, 0, 1027, 1032, 5, 34, 0, 0, 1028, 1031, 3, 333, 166, 0, 1029, 1031, 3, 273, 136, 0, 1030, 1028, 1, 0, 0, 0, 1030, 1029, 1, 0, 0, 0, 1031, 1034, 1, 0, 0, 0, 1032, 1030, 1, 0, 0, 0, 1032, 1033, 1, 0, 0, 0, 1033, 1035, 1, 0, 0, 0, 1034, 1032, 1, 0, 0, 0, 1035, 1046, 5, 34, 0, 0, 1036, 1041, 5, 39, 0, 0, 1037, 1040, 3, 313, 156, 0, 1038, 1040, 3, 273, 136, 0, 1039, 1037, 1, 0, 0, 0, 1039, 1038, 1, 0, 0, 0, 1040, 1043, 1, 0, 0, 0, 1041, 1039, 1, 0, 0, 0, 1041, 1042, 1, 0, 0, 0, 1042, 1044, 1, 0, 0, 0, 1043, 1041, 1, 0, 0, 0, 1044, 1046, 5, 39, 0, 0, 1045, 1027, 1, 0, 0, 0, 1045, 1036, 1, 0, 0, 0, 1046, 272, 1, 0, 0, 0, 1047, 1065, 5, 92, 0, 0, 1048, 1066, 7, 26, 0, 0, 1049, 1050, 7, 13, 0, 0, 1050, 1051, 3, 255, 127, 0, 1051, 1052, 3, 255, 127, 0, 1052, 1053, 3, 255, 127, 0, 1053, 1054, 3, 255, 127, 0, 1054, 1066, 1, 0, 0, 0, 1055, 1056, 7, 13, 0, 0, 1056, 1057, 3, 255, 127, 0, 1057, 1058, 3, 255, 127, 0, 1058, 1059, 3, 255, 127, 0, 1059, 1060, 3, 255, 127, 0, 1060, 1061, 3, 255, 127, 0, 1061, 1062, 3, 255, 127, 0, 1062, 1063, 3, 255, 127, 0, 1063, 1064, 3, 255, 127, 0, 1064, 1066, 1, 0, 0, 0, 1065, 1048, 1, 0, 0, 0, 1065, 1049, 1, 0, 0, 0, 1065, 1055, 1, 0, 0, 0, 1066, 274, 1, 0, 0, 0, 1067, 1068, 7, 16, 0, 0, 1068, 1069, 7, 11, 0, 0, 1069, 276, 1, 0, 0, 0, 1070, 1071, 7, 12, 0, 0, 1071, 1072, 7, 11, 0, 0, 1072, 1073, 7, 5, 0, 0, 1073, 278, 1, 0, 0, 0, 1074, 1075, 7, 5, 0, 0, 1075, 1076, 7, 4, 0, 0, 1076, 1077, 7, 19, 0, 0, 1077, 1078, 7, 13, 0, 0, 1078, 1079, 7, 9, 0, 0, 1079, 1080, 7, 5, 0, 0, 1080, 1081, 7, 4, 0, 0, 1081, 280, 1, 0, 0, 0, 1082, 1083, 7, 17, 0, 0, 1083, 1084, 7, 8, 0, 0, 1084, 1085, 7, 10, 0, 0, 1085, 1086, 7, 16, 0, 0, 1086, 1087, 7, 8, 0, 0, 1087, 1088, 7, 18, 0, 0, 1088, 1089, 7, 11, 0, 0, 1089, 1090, 7, 5, 0, 0, 1090, 1091, 7, 1, 0, 0, 1091, 282, 1, 0, 0, 0, 1092, 1093, 7, 14, 0, 0, 1093, 1094, 7, 0, 0, 0, 1094, 1095, 7, 8, 0, 0, 1095, 1096, 7, 7, 0, 0, 1096, 1097, 7, 8, 0, 0, 1097, 1098, 7, 5, 0, 0, 1098, 284, 1, 0, 0, 0, 1099, 1100, 7, 11, 0, 0, 1100, 1101, 7, 12, 0, 0, 1101, 286, 1, 0, 0, 0, 1102, 1103, 7, 8, 0, 0, 1103, 1104, 7, 16, 0, 0, 1104, 1105, 7, 16, 0, 0, 1105, 288, 1, 0, 0, 0, 1106, 1110, 3, 291, 145, 0, 1107, 1109, 3, 293, 146, 0, 1108, 1107, 1, 0, 0, 0, 1109, 1112, 1, 0, 0, 0, 1110, 1108, 1, 0, 0, 0, 1110, 1111, 1, 0, 0, 0, 1111, 290, 1, 0, 0, 0, 1112, 1110, 1, 0, 0, 0, 1113, 1116, 3, 341, 170, 0, 1114, 1116, 3, 329, 164, 0, 1115, 1113, 1, 0, 0, 0, 1115, 1114, 1, 0, 0, 0, 1116, 292, 1, 0, 0, 0, 1117, 1120, 3, 309, 154, 0, 1118, 1120, 3, 325, 162, 0, 1119, 1117, 1, 0, 0, 0, 1119, 1118, 1, 0, 0, 0, 1120, 294, 1, 0, 0, 0, 1121, 1125, 5, 96, 0, 0, 1122, 1124, 3, 305, 152, 0, 1123, 1122, 1, 0, 0, 0, 1124, 1127, 1, 0, 0, 0, 1125, 1123, 1, 0, 0, 0, 1125, 1126, 1, 0, 0, 0, 1126, 1128, 1, 0, 0, 0, 1127, 1125, 1, 0, 0, 0, 1128, 1130, 5, 96, 0, 0, 1129, 1121, 1, 0, 0, 0, 1130, 1131, 1, 0, 0, 0, 1131, 1129, 1, 0, 0, 0, 1131, 1132, 1, 0, 0, 0, 1132, 296, 1, 0, 0, 0, 1133, 1135, 3, 299, 149, 0, 1134, 1133, 1, 0, 0, 0, 1135, 1136, 1, 0, 0, 0, 1136, 1134, 1, 0, 0, 0, 1136, 1137, 1, 0, 0, 0, 1137, 298, 1, 0, 0, 0, 1138, 1151, 3, 327, 163, 0, 1139, 1151, 3, 331, 165, 0, 1140, 1151, 3, 335, 167, 0, 1141, 1151, 3, 337, 168, 0, 1142, 1151, 3, 303, 151, 0, 1143, 1151, 3, 323, 161, 0, 1144, 1151, 3, 321, 160, 0, 1145, 1151, 3, 319, 159, 0, 1146, 1151, 3, 307, 153, 0, 1147, 1151, 3, 339, 169, 0, 1148, 1151, 7, 27, 0, 0, 1149, 1151, 3, 301, 150, 0, 1150, 1138, 1, 0, 0, 0, 1150, 1139, 1, 0, 0, 0, 1150, 1140, 1, 0, 0, 0, 1150, 1141, 1, 0, 0, 0, 1150, 1142, 1, 0, 0, 0, 1150, 1143, 1, 0, 0, 0, 1150, 1144, 1, 0, 0, 0, 1150, 1145, 1, 0, 0, 0, 1150, 1146, 1, 0, 0, 0, 1150, 1147, 1, 0, 0, 0, 1150, 1148, 1, 0, 0, 0, 1150, 1149, 1, 0, 0, 0, 1151, 300, 1, 0, 0, 0, 1152, 1153, 5, 47, 0, 0, 1153, 1154, 5, 42, 0, 0, 1154, 1160, 1, 0, 0, 0, 1155, 1159, 3, 311, 155, 0, 1156, 1157, 5, 42, 0, 0, 1157, 1159, 3, 317, 158, 0, 1158, 1155, 1, 0, 0, 0, 1158, 1156, 1, 0, 0, 0, 1159, 1162, 1, 0, 0, 0, 1160, 1158, 1, 0, 0, 0, 1160, 1161, 1, 0, 0, 0, 1161, 1163, 1, 0, 0, 0, 1162, 1160, 1, 0, 0, 0, 1163, 1164, 5, 42, 0, 0, 1164, 1182, 5, 47, 0, 0, 1165, 1166, 5, 47, 0, 0, 1166, 1167, 5, 47, 0, 0, 1167, 1171, 1, 0, 0, 0, 1168, 1170, 3, 315, 157, 0, 1169, 1168, 1, 0, 0, 0, 1170, 1173, 1, 0, 0, 0, 1171, 1169, 1, 0, 0, 0, 1171, 1172, 1, 0, 0, 0, 1172, 1175, 1, 0, 0, 0, 1173, 1171, 1, 0, 0, 0, 1174, 1176, 3, 323, 161, 0, 1175, 1174, 1, 0, 0, 0, 1175, 1176, 1, 0, 0, 0, 1176, 1179, 1, 0, 0, 0, 1177, 1180, 3, 335, 167, 0, 1178, 1180, 5, 0, 0, 1, 1179, 1177, 1, 0, 0, 0, 1179, 1178, 1, 0, 0, 0, 1180, 1182, 1, 0, 0, 0, 1181, 1152, 1, 0, 0, 0, 1181, 1165, 1, 0, 0, 0, 1182, 302, 1, 0, 0, 0, 1183, 1184, 7, 28, 0, 0, 1184, 304, 1, 0, 0, 0, 1185, 1186, 8, 29, 0, 0, 1186, 306, 1, 0, 0, 0, 1187, 1188, 7, 30, 0, 0, 1188, 308, 1, 0, 0, 0, 1189, 1190, 7, 31, 0, 0, 1190, 310, 1, 0, 0, 0, 1191, 1192, 8, 32, 0, 0, 1192, 312, 1, 0, 0, 0, 1193, 1194, 8, 33, 0, 0, 1194, 314, 1, 0, 0, 0, 1195, 1196, 8, 34, 0, 0, 1196, 316, 1, 0, 0, 0, 1197, 1198, 8, 35, 0, 0, 1198, 318, 1, 0, 0, 0, 1199, 1200, 7, 36, 0, 0, 1200, 320, 1, 0, 0, 0, 1201, 1202, 7, 37, 0, 0, 1202, 322, 1, 0, 0, 0, 1203, 1204, 7, 38, 0, 0, 1204, 324, 1, 0, 0, 0, 1205, 1206, 7, 39, 0, 0, 1206, 326, 1, 0, 0, 0, 1207, 1208, 7, 40, 0, 0, 1208, 328, 1, 0, 0, 0, 1209, 1210, 7, 41, 0, 0, 1210, 330, 1, 0, 0, 0, 1211, 1212, 7, 42, 0, 0, 1212, 332, 1, 0, 0, 0, 1213, 1214, 8, 43, 0, 0, 1214, 334, 1, 0, 0, 0, 1215, 1216, 7, 44, 0, 0, 1216, 336, 1, 0, 0, 0, 1217, 1218, 7, 45, 0, 0, 1218, 338, 1, 0, 0, 0, 1219, 1220, 7, 46, 0, 0, 1220, 340, 1, 0, 0, 0, 1221, 1222, 7, 47, 0, 0, 1222, 342, 1, 0, 0, 0, 38, 0, 939, 946, 949, 957, 960, 964, 968, 972, 978, 985, 990, 996, 1002, 1004, 1008, 1013, 1018, 1025, 1030, 1032, 1039, 1041, 1045, 1065, 1110, 1115, 1119, 1125, 1131, 1136, 1150, 1158, 1160, 1171, 1175, 1179, 1181, 0] \ No newline at end of file diff --git a/tests/grammar/cypher/CypherLexer.tokens b/tests/grammar/cypher/CypherLexer.tokens new file mode 100644 index 0000000..fd86f11 --- /dev/null +++ b/tests/grammar/cypher/CypherLexer.tokens @@ -0,0 +1,198 @@ +T__0=1 +T__1=2 +T__2=3 +T__3=4 +T__4=5 +T__5=6 +T__6=7 +T__7=8 +T__8=9 +T__9=10 +T__10=11 +T__11=12 +T__12=13 +T__13=14 +T__14=15 +T__15=16 +T__16=17 +T__17=18 +T__18=19 +T__19=20 +T__20=21 +T__21=22 +T__22=23 +T__23=24 +T__24=25 +T__25=26 +T__26=27 +T__27=28 +T__28=29 +T__29=30 +T__30=31 +T__31=32 +T__32=33 +T__33=34 +T__34=35 +T__35=36 +T__36=37 +T__37=38 +T__38=39 +T__39=40 +T__40=41 +T__41=42 +T__42=43 +T__43=44 +T__44=45 +T__45=46 +CYPHER=47 +EXPLAIN=48 +PROFILE=49 +USING=50 +PERIODIC=51 +COMMIT=52 +UNION=53 +ALL=54 +CREATE=55 +DROP=56 +INDEX=57 +ON=58 +CONSTRAINT=59 +ASSERT=60 +IS=61 +UNIQUE=62 +EXISTS=63 +LOAD=64 +CSV=65 +WITH=66 +HEADERS=67 +FROM=68 +AS=69 +FIELDTERMINATOR=70 +OPTIONAL=71 +MATCH=72 +UNWIND=73 +MERGE=74 +SET=75 +DETACH=76 +DELETE=77 +REMOVE=78 +FOREACH=79 +IN=80 +CALL=81 +YIELD=82 +RETURN=83 +DISTINCT=84 +ORDER=85 +BY=86 +L_SKIP=87 +LIMIT=88 +ASCENDING=89 +ASC=90 +DESCENDING=91 +DESC=92 +JOIN=93 +SCAN=94 +START=95 +NODE=96 +RELATIONSHIP=97 +REL=98 +WHERE=99 +SHORTESTPATH=100 +ALLSHORTESTPATHS=101 +OR=102 +XOR=103 +AND=104 +NOT=105 +STARTS=106 +ENDS=107 +CONTAINS=108 +NULL=109 +COUNT=110 +CASE=111 +ELSE=112 +END=113 +WHEN=114 +THEN=115 +FILTER=116 +EXTRACT=117 +REDUCE=118 +ANY=119 +NONE=120 +SINGLE=121 +TRUE=122 +FALSE=123 +HexInteger=124 +DecimalInteger=125 +OctalInteger=126 +HexLetter=127 +HexDigit=128 +Digit=129 +NonZeroDigit=130 +NonZeroOctDigit=131 +OctDigit=132 +ZeroDigit=133 +ExponentDecimalReal=134 +RegularDecimalReal=135 +StringLiteral=136 +EscapedChar=137 +DO=138 +FOR=139 +REQUIRE=140 +MANDATORY=141 +SCALAR=142 +OF=143 +ADD=144 +UnescapedSymbolicName=145 +IdentifierStart=146 +IdentifierPart=147 +EscapedSymbolicName=148 +SP=149 +WHITESPACE=150 +Comment=151 +';'=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 +'\u27e8'=28 +'\u3008'=29 +'\ufe64'=30 +'\uff1c'=31 +'\u27e9'=32 +'\u3009'=33 +'\ufe65'=34 +'\uff1e'=35 +'\u00ad'=36 +'\u2010'=37 +'\u2011'=38 +'\u2012'=39 +'\u2013'=40 +'\u2014'=41 +'\u2015'=42 +'\u2212'=43 +'\ufe58'=44 +'\ufe63'=45 +'\uff0d'=46 +'0'=133 From 4378f31286944d9224d0a49531d64825009a0fc7 Mon Sep 17 00:00:00 2001 From: Joey Dreijer Date: Fri, 22 May 2026 20:34:25 +0200 Subject: [PATCH 6/8] Fixed Cypher syntax test to work with OpenHound models + added query that should fail syntax checks --- .github/workflows/test.yml | 8 +++ tests/test_cypher_syntax.py | 59 ++++++++----------- .../jamf_query_by_name_error.json | 5 ++ tests/test_saved_searches_bundle.py | 9 ++- 4 files changed, 42 insertions(+), 39 deletions(-) create mode 100644 tests/test_data/extensions/saved_searches/jamf_query_by_name_error.json diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 043e7f0..25ecb36 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -52,6 +52,14 @@ jobs: run: | .venv/bin/pytest tests/test_saved_searches_sync.py -v + - name: Run saved searches bundle test + run: | + .venv/bin/pytest tests/test_saved_searches_bundle.py -v + + - name: Run Cypher syntax tests + run: | + .venv/bin/pytest tests/test_cypher_syntax.py -v + - name: Run extension validation tests run: | .venv/bin/pytest tests/test_extensions_format.py -v diff --git a/tests/test_cypher_syntax.py b/tests/test_cypher_syntax.py index 3c3cbde..70126e9 100644 --- a/tests/test_cypher_syntax.py +++ b/tests/test_cypher_syntax.py @@ -3,17 +3,18 @@ import sys import pytest -import yaml from antlr4 import CommonTokenStream, InputStream from antlr4.error.ErrorListener import ErrorListener +from openhound.core.models.saved_search import SavedSearch from pydantic import ValidationError -from schema import CypherQuery -from grammar.CypherLexer import CypherLexer -from grammar.CypherParser import CypherParser +from .grammar.CypherLexer import CypherLexer +from .grammar.CypherParser import CypherParser sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +EXPECTED_CYPHER_FAILURES = {"jamf_query_by_name_error.json"} + class CypherErrorListener(ErrorListener): @@ -25,20 +26,24 @@ def syntaxError(self, recognizer, offendingSymbol, line: int, column: int, raise ValueError(f"Syntax error at line: {line}, msg: {msg}") -def get_query_files(cypher_dir: str = "queries") -> list: +def get_query_files(cypher_dir: str = "tests/test_data/extensions/saved_searches/") -> list: if not os.path.exists(cypher_dir): return [] - return glob.glob(os.path.join("queries", "**", "*.yml"), recursive=True) - - -@pytest.mark.parametrize("file_path", get_query_files("queries")) -def test_cypher_validation(file_path: str, request: pytest.FixtureRequest) -> None: - with open(file_path, "r") as f: - yaml_object = yaml.safe_load(f) - + return [ + pytest.param( + file_path, + os.path.basename(file_path) in EXPECTED_CYPHER_FAILURES, + id=os.path.basename(file_path), + ) + for file_path in sorted(glob.glob(os.path.join(cypher_dir, "*.json"), recursive=True)) + ] + + +@pytest.mark.parametrize("file_path,should_fail", get_query_files()) +def test_cypher_validation(file_path: str, should_fail: bool, request: pytest.FixtureRequest) -> None: try: # Load the query using the Pydantic schema - validate_schema = CypherQuery(**yaml_object) + validate_schema = SavedSearch.from_file(file_path) except ValidationError as e: pytest.fail(f"Pydantic validation failed for {file_path}: {str(e)}", pytrace=False) @@ -56,29 +61,15 @@ def test_cypher_validation(file_path: str, request: pytest.FixtureRequest) -> No parser = CypherParser(stream) parser.addErrorListener(CypherErrorListener()) + if should_fail: + with pytest.raises(ValueError): + parser.oC_Cypher() + return + # Attempt to parse the query or raise a generic exception try: - parse_query = parser.oC_Query() + parse_query = parser.oC_Cypher() assert parse_query.exception is None except Exception as e: pytest.fail(f"Parsing failed for file {file_path}: {str(e)}", pytrace=False) - - -def test_duplicate_guid() -> None: - query_files = get_query_files("queries") - guids = set() - - # Iterate over all query files and check for duplicate GUIDs - for file_path in query_files: - with open(file_path, "r") as f: - yaml_object = yaml.safe_load(f) - - query_guid = yaml_object["guid"] - if query_guid in guids: - pytest.fail(f"Duplicate GUID found: {query_guid} in file {file_path}", pytrace=False) - guids.add(query_guid) - - -if __name__ == "__main__": - pytest.main(["-v", __file__]) diff --git a/tests/test_data/extensions/saved_searches/jamf_query_by_name_error.json b/tests/test_data/extensions/saved_searches/jamf_query_by_name_error.json new file mode 100644 index 0000000..480c931 --- /dev/null +++ b/tests/test_data/extensions/saved_searches/jamf_query_by_name_error.json @@ -0,0 +1,5 @@ +{ + "name": "Jamf v2: Account Access by Name but with incorrect Cypher", + "description": "This is an identical query but duplicated for CICD tests", + "query": "MATCH p==(s:jamf_Account)-[*1..5]->(t)\nWHERE s.name STARTS WITH 'LC'\nRETURN p\nLIMIT 1000" +} diff --git a/tests/test_saved_searches_bundle.py b/tests/test_saved_searches_bundle.py index 83dc1fc..53118ef 100644 --- a/tests/test_saved_searches_bundle.py +++ b/tests/test_saved_searches_bundle.py @@ -2,9 +2,8 @@ import zipfile from pathlib import Path -from typer.testing import CliRunner - from openhound.main import app +from typer.testing import CliRunner TEST_DATA_DIR = Path(__file__).parent / "test_data" / "extensions" / "saved_searches" @@ -31,7 +30,7 @@ def test_saved_search_bundle_writes_json(tmp_path): assert output_path.suffix == ".json" saved_searches = json.loads(output_path.read_text()) - assert len(saved_searches) == 2 + assert len(saved_searches) == 3 def test_saved_search_bundle_writes_zip(tmp_path): @@ -57,10 +56,10 @@ def test_saved_search_bundle_writes_zip(tmp_path): with zipfile.ZipFile(output_path) as archive: archive_names = archive.namelist() - assert len(archive_names) == 2 + assert len(archive_names) == 3 assert all(name.endswith(".json") for name in archive_names) saved_searches = [ json.loads(archive.read(name).decode()) for name in archive_names ] - assert len(saved_searches) == 2 + assert len(saved_searches) == 3 From 80d13a54a726a8094773b395103ed465b81d76b3 Mon Sep 17 00:00:00 2001 From: Joey Dreijer Date: Fri, 22 May 2026 20:36:30 +0200 Subject: [PATCH 7/8] Update pyproject deps --- pyproject.toml | 33 +++++++++++++++++---------------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index a69cf8b..7d24a62 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,31 +10,32 @@ dependencies = [ "duckdb==1.5.2", "griffe>=1.15.0", "griffe-fieldz>=0.5.0", - "mkdocstrings[python]==1.0.4", + "mkdocstrings[python]>=1.0.0", "psutil>=7.2.1", "pydantic==2.13.3", "tqdm>=4.67.1", - "typer==0.25.1", + "typer>=0.25.1", "cookiecutter>=2.6.0", - "pydantic-extra-types>=2.11.0", "jinja2>=3.1.6", + "types-requests==2.33.0.20260503", + "pydantic-extra-types>=2.11.1", ] [project.optional-dependencies] all = [ - "openhound-jamf==0.1.0", + "openhound-jamf==0.1.3", "openhound-github==0.1.0", - "openhound-okta==0.1.1", + "openhound-okta==0.1.2", ] jamf = [ - "openhound-jamf==0.1.0", + "openhound-jamf==0.1.3", ] github = [ "openhound-github==0.1.0" ] okta = [ - "openhound-okta==0.1.1", + "openhound-okta==0.1.2", ] [project.scripts] @@ -65,16 +66,16 @@ local_scheme = "no-local-version" [dependency-groups] dev = [ - "openhound-faker==0.0.4", - "ipython>=9.12.0", - "pre-commit==4.6.0", + "openhound-faker==0.0.6", + "ipython>=9.13.0", + "pre-commit>=4.5.1", "pytest>=9.0.1", - "marimo==0.23.4", - "altair==6.1.0", - "fastapi==0.136.1", - "zensical>=0.0.38", - "ruff==0.15.12", - "mypy==1.20.2", + "marimo>=0.23.5", + "altair>=6.1.0", + "fastapi>=0.136.1", + "zensical>=0.0.40", + "ruff>=0.15.4", + "mypy>=1.19.1", "types-pyyaml>=6.0.12.20250915", "types-requests>=2.33.0.20260408", "httpx>=0.28.1", From 30886fe53af8fe3d090fe223e2294c110be7f5d9 Mon Sep 17 00:00:00 2001 From: Joey Dreijer Date: Fri, 22 May 2026 20:37:16 +0200 Subject: [PATCH 8/8] Remove cypher test/bundle from pre-commit hook, this should only be done on the collector repos --- .pre-commit-hooks.yaml | 11 ----------- 1 file changed, 11 deletions(-) delete mode 100644 .pre-commit-hooks.yaml diff --git a/.pre-commit-hooks.yaml b/.pre-commit-hooks.yaml deleted file mode 100644 index c8bf13b..0000000 --- a/.pre-commit-hooks.yaml +++ /dev/null @@ -1,11 +0,0 @@ -- id: openhound-cypher-bundle - name: OpenHound create a cypher query bundle - entry: scripts/bundle.py - language: python - pass_filenames: false - -- id: openhound-cypher-test - name: OpenHound validate cypher query syntax - entry: pytest tests/test_config_validation.py -q - language: python - pass_filenames: false \ No newline at end of file