diff --git a/.licenserc.yaml b/.licenserc.yaml index 390070a87..bbce65405 100644 --- a/.licenserc.yaml +++ b/.licenserc.yaml @@ -82,6 +82,9 @@ header: # `header` section is configurations for source codes license header. - '**/poetry.lock' - '.github/**/*' - 'docker/**/*' + - '**/*.interp' + - '**/*.tokens' + - '**/*.csv' comment: on-failure # on what condition license-eye will comment on the pull request, `on-failure`, `always`, `never`. diff --git a/pyproject.toml b/pyproject.toml index faa8c73c2..fa5cdc29d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -148,6 +148,9 @@ constraint-dependencies = [ [tool.ruff] line-length = 120 target-version = "py310" +extend-exclude = [ + "text2gremlin/AST_Text2Gremlin/base/gremlin/*.py", +] [tool.ruff.lint] # Select a broad set of rules for comprehensive checks. @@ -173,6 +176,18 @@ ignore = [ "tests/**/*.py" = ["T20"] "hugegraph-ml/src/hugegraph_ml/examples/**/*.py" = ["T20"] "hugegraph-python-client/src/pyhugegraph/structure/*.py" = ["N802"] +"text2gremlin/**/*.py" = [ + "E501", # Long Chinese prompts and generated Gremlin visitor fragments are kept readable. + "E741", # Gremlin examples use compact variable names in local comprehensions. + "F403", # ANTLR visitor code relies on antlr4's compatibility import style. + "F811", # Visitor methods mirror grammar alternatives and may intentionally repeat names. + "N999", # Keep existing module names used by standalone scripts. + "RUF002", # Chinese docstrings intentionally use full-width punctuation. + "RUF012", # Class-level step configuration dictionaries are constants in practice. + "SIM102", # Keep complex traversal-generation branching explicit. + "SIM108", # Keep complex traversal-generation branching explicit. + "T20", # Standalone CLI/data-generation scripts write progress to stdout. +] [tool.ruff.lint.isort] known-first-party = ["hugegraph_llm", "hugegraph_python_client", "hugegraph_ml", "vermeer_python_client"] diff --git a/text2gremlin/AST_Text2Gremlin/.gitignore b/text2gremlin/AST_Text2Gremlin/.gitignore new file mode 100644 index 000000000..4b7b70bd3 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/.gitignore @@ -0,0 +1,13 @@ +# 配置文件 +config.json +.env +output/ + +# Python +__pycache__/ +*.py[cod] +*$py.class +*.so +.Python +*.egg-info/ +.eggs/ diff --git a/text2gremlin/AST_Text2Gremlin/README.md b/text2gremlin/AST_Text2Gremlin/README.md new file mode 100644 index 000000000..24f37ce2d --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/README.md @@ -0,0 +1,371 @@ +# Text2Gremlin Corpus Generalization + +[English](README.md) | [中文](./README_zh.md) + +Generate a large and diverse set of Gremlin queries and their corresponding natural language descriptions based on ASTs and templates, and perform multi-stage data augmentation and preference data synthesis using LLMs for training and evaluating text-to-Gremlin models. + +The synthesized dataset is published on Hugging Face: [Lriver/Text2Gremlin](https://huggingface.co/datasets/Lriver/Text2Gremlin). Use it directly if you only need the generated data; run the local pipeline when you need to regenerate, customize, or audit the intermediate artifacts. + +## Dataset + +Pre-generated Text2Gremlin data is available at: + +```text +https://huggingface.co/datasets/Lriver/Text2Gremlin +``` + +The repository pipeline generates the same classes of artifacts locally under `output/`, including AST-generalized corpora, multi-style LLM translations, scenario migration results, merged text-to-Gremlin pairs, syntax analysis reports, and DPO preference data. `output/` is gitignored because these files can be large and can be regenerated or downloaded from Hugging Face. + +## Quick Start + +### 1. Environment Setup +Python version: 3.12.10 +```bash +pip install -r requirements.txt +``` + +### 2. Configuration +Copy the example config and fill in your settings: +```bash +cp config_example.json config.json +``` + +Edit `config.json` with your LLM API configuration: +```json +"llm": { + "base_url": "http://your-llm-server:port/v1", + "api_key": "your-api-key", + "model": "your-model-name", + "temperature": 1.0, + "max_retries": 3, + "max_concurrency": 5, + "save_interval": 50, + "timeout": 40 +}, +"migration": { + "migration_mode": "same_operation", + "same_operation_sample_count": 3 +} +``` + +> ⚠️ `config.json` contains sensitive information and is excluded via `.gitignore`. Do not commit it. + +### 3. Running + +#### Stage 1: AST Generalization +```bash +python generate_corpus.py +``` + +#### Stages 2–5: LLM Augmentation Pipeline +```bash +# Run all LLM augmentation stages (translate → migrate → merge → DPO) +python run_llm_pipeline.py + +# Start from a specific stage +python run_llm_pipeline.py --stage migrate + +# Run a single stage +python run_llm_pipeline.py --stage merge --stop merge +``` + +Each stage can also be run independently: +```bash +# Multi-style translation +python -m llm_augment.generalize_llm + +# Scenario migration +python -m llm_augment.migrate_scenario + +# Optional: generate mixed CRUD samples during scenario migration +python -m llm_augment.migrate_scenario --migration-mode mixed_operations + +# Dataset merging +python -m llm_augment.merge_dataset + +# DPO preference data generation +python -m llm_augment.generate_dpo_data +``` + +#### Syntax Analysis +```bash +python analyze_syntax.py +``` + +--- + +## Data Generation Pipeline + +```text +Stage 1: AST Generalization generate_corpus.py + 251 templates → ~1500 entries (query + simple description) + ↓ +Stage 2: LLM Multi-style llm_augment/generalize_llm.py + Translation + ×6 styles → ~9000 entries (4 fixed + 2 random tones) + ↓ +Stage 3: Scenario Migration llm_augment/migrate_scenario.py + ×20 domains → same-operation samples by default, optional mixed CRUD, syntax-checked + ↓ +Stage 4: Dataset Merging llm_augment/merge_dataset.py + Merge translations + migrations → text2gremlin_dataset_*.json for training/evaluation analysis + ↓ +Stage 5: DPO Preference Data llm_augment/generate_dpo_data.py + Uses text2gremlin_pairs_*.json + migrated_*.json as inputs + Type A (multi-task) + Type B (single-task) + Type C (long-chain) + → ~8900 preference pairs (21 domains) + ↓ +Published Dataset Hugging Face: Lriver/Text2Gremlin +``` + +--- + +## Project Structure + +```text +├── generate_corpus.py # AST generalization entry point +├── run_llm_pipeline.py # Unified LLM pipeline runner +├── analyze_syntax.py # Gremlin syntax distribution analysis +├── gremlin_templates.csv # Query templates (251 entries) +├── config.json # Configuration (gitignored) +├── config_example.json # Configuration example +├── requirements.txt # Python dependencies +│ +├── llm_augment/ # LLM augmentation package +│ ├── __init__.py +│ ├── generalize_llm.py # Stage 2: Multi-style translation +│ ├── migrate_scenario.py # Stage 3: Scenario migration +│ ├── merge_dataset.py # Stage 4: Dataset merging +│ └── generate_dpo_data.py # Stage 5: DPO preference data +│ +├── base/ # AST generalization core engine +│ ├── generator.py # Generalization controller + syntax checker +│ ├── Config.py # Configuration management +│ ├── Schema.py # Schema and data management +│ ├── GremlinParse.py # Data structure definitions +│ ├── GremlinExpr.py # Complex expressions (predicates, anonymous traversals) +│ ├── GremlinTransVisitor.py # AST parsing +│ ├── TraversalGenerator.py # Traversal generator +│ ├── GremlinBase.py # Translation engine +│ ├── gremlin/ # ANTLR-generated Gremlin parser +│ └── template/ # Translation dictionaries +│ +├── db_data/ # Data and schemas +│ ├── schema/ # Graph database schemas +│ └── reference/ # Multi-domain schemas for migration +│ +└── output/ # Output directory + ├── generated_corpus_*.json + ├── llm_translated_*.json + ├── text2gremlin_pairs_*.json + ├── migrated_*.json + ├── text2gremlin_dataset_*.json + └── preference_data/ # DPO preference data +``` + +--- + +## Configuration + +### LLM Configuration (`config.json` → `llm`) + +| Field | Description | Default | +|-------|-------------|---------| +| base_url | LLM API endpoint | Required | +| api_key | API key | Required | +| model | Model name | Required | +| temperature | Sampling temperature | 1.0 | +| max_retries | Max retries per item | 3 | +| max_concurrency | Concurrent requests | 5 | +| save_interval | Incremental save interval | 50 | +| timeout | Request timeout (seconds) | 40 | + +### Scenario Migration Configuration (`config.json` → `migration`) + +| Field | Description | Default | +|-------|-------------|---------| +| migration_mode | `same_operation` generates samples with the same operation type as the source query. `mixed_operations` keeps the legacy mixed CRUD prompt. | `same_operation` | +| same_operation_sample_count | Number of samples requested per migration task in `same_operation` mode. The model may return fewer if the source pattern does not fit the target schema. | 3 | + +CLI arguments override `config.json` for one run: + +```bash +python -m llm_augment.migrate_scenario --migration-mode same_operation --same-operation-sample-count 5 +python -m llm_augment.migrate_scenario --migration-mode mixed_operations +``` + +### Template File (`gremlin_templates.csv`) + +| Column | Description | Example | +|--------|-------------|---------| +| template | Gremlin query template | `g.V().hasLabel('person')` | +| description | Template description (optional) | Query all persons | + +### Combination Control (`base/combination_control_config.json`) + +Controls query generation volume during AST generalization: +- Chain length categories: short (≤4 steps), medium (5–6), long (7–8), extra-long (≥9) +- Data value filling: 1 value for intermediate steps, 2–3 for terminal steps +- Property generalization: dynamically adjusted based on chain length + +--- + +## Output Formats + +Published generated data can be downloaded from [Lriver/Text2Gremlin](https://huggingface.co/datasets/Lriver/Text2Gremlin). The formats below describe the local pipeline artifacts that lead to the published dataset. + +### AST Generalization (`generated_corpus_*.json`) +```json +{ + "metadata": { "total_unique_queries": 1564, "..." : "..." }, + "corpus": [ + { "query": "g.V().hasLabel('person')", "description": "..." } + ] +} +``` + +### LLM Translation (`llm_translated_*.json`) +```json +{ + "corpus": [ + { + "query": "g.V().hasLabel('person')", + "translations": [ + { "style": "zh_formal", "text": "查询所有人类型的顶点" }, + { "style": "en_casual", "text": "Find all person nodes" } + ] + } + ] +} +``` + +### Text2Gremlin Pairs (`text2gremlin_pairs_*.json`) +Generated by the scenario migration stage from `llm_translated_*.json`. It picks one fixed translation style per query for movie-domain DPO input. + +```json +{ + "metadata": { + "source_file": "output/llm_translated_20260531_120000.json", + "total_pairs": 1564, + "style_distribution": { "zh_formal": 392, "en_casual": 391 } + }, + "pairs": [ + { "text": "Query all persons", "gremlin": "g.V().hasLabel('person')", "style": "en_formal" } + ] +} +``` + +### Scenario Migration (`migrated_*.json`) +```json +{ + "migrations": [ + { + "target_domain": "ecommerce", + "generated_samples": [ + { "operation": "read", "query": "g.V()...", "natural_language": "..." } + ] + } + ] +} +``` + +### Merged Text2Gremlin Dataset (`text2gremlin_dataset_*.json`) +Generated by `merge_dataset.py` from the latest or explicitly supplied `llm_translated_*.json` and `migrated_*.json`. This file is compatible with `analyze_syntax.py`. + +```json +{ + "metadata": { + "total": 3, + "sources": { + "llm_translated": { "file": "output/llm_translated_20260531_120000.json", "count": 1 }, + "migrated": { "file": "output/migrated_20260531_130000.json", "count": 2 } + }, + "crud_distribution": { "read": 2, "create": 1 } + }, + "corpus": [ + { + "query": "g.V().hasLabel('person')", + "text": "Query all persons", + "domain": "movie", + "operation": "read", + "language_style": "en_formal", + "source": "llm_translated" + } + ] +} +``` + +### DPO Preference Data (`preference_data/dpo_data_*.json`) +```json +{ + "metadata": { + "total_samples": 8920, + "rejected_count": 3032, + "type_distribution": { "A": 4380, "B": 2318, "C": 2222 }, + "domain_distribution": { "movie": 401, "ecommerce": 399, "..." : "..." }, + + }, + "samples": [ + { + "task_id": "pref_MOVI_A_0001", + "task_type": "A", + "domain": "movie", + "source_queries": [ + { "text": "Query all actors", "gremlin": "g.V().hasLabel('person')" } + ], + "input": { "instruction": "Please query all actors and update..." }, + "chosen": { "style": "groovy", "code": "def actors = g.V()..." }, + "rejected": { "style": "gremlin", "code": "g.V().hasLabel..." }, + "preference_reason": ["Groovy style is clearer...", "..."] + } + ] +} +``` + +--- + +## Key Features + +### AST Generalization +Generates multiple variants from a single template with intelligent combinatorial control and automatic deduplication: +```text +Template: g.V().hasLabel('person').out('acted_in') + → g.V().hasLabel('movie').out('acted_in') + → g.V().hasLabel('person').out('directed') + → ... +``` + +### LLM Multi-style Translation +Each query is translated into 6 styles (4 fixed + 2 random): +- Chinese formal / Chinese casual / English formal / English casual +- Mixed Chinese-English / Abbreviated / Q&A style / With typos + +### Scenario Migration +Migrates movie-domain data to 20 business domains. By default, each migrated sample keeps the same operation type as the source query and asks for 3 samples per target scenario. The legacy mixed CRUD mode can still be enabled with `--migration-mode mixed_operations`. Every generated Gremlin query is validated via ANTLR syntax checking. + +During this stage, `text2gremlin_pairs_*.json` is also prepared from the translation output for movie-domain DPO generation. + +### DPO Preference Data +Three task types generate Groovy vs Gremlin preference pairs across 21 domains (movie + 20 migrated), totaling 8920 samples: + +- **Type A (Multi-task Composition, 4380 samples)**: Combines 2–5 simple queries into a composite task + - chosen: Groovy imperative style (def variables, .next(), return map) + - rejected: Pure Gremlin functional style (as/select/project forced into a single chain) + - Automatically detects command conflicts (e.g., delete before update), reorders or rejects +- **Type B (Single Task, 2318 samples)**: Simple queries that don't need Groovy wrapping + - chosen: Original pure Gremlin + - rejected: Over-engineered Groovy wrapper +- **Type C (Long-chain Decomposition, 2222 samples)**: Complex long-chain queries decomposed into steps + - chosen: Groovy multi-step style + - rejected: Original long-chain Gremlin + +### Pipeline Features +- Concurrency control: `asyncio.wait(FIRST_COMPLETED)` + Semaphore + batched task creation +- Incremental saving: auto-saves every 50 items, supports resumption +- Pydantic validation: strict format validation for all LLM outputs +- ANTLR syntax checking: pure Gremlin code is syntax-validated (Groovy code is skipped due to variable reference incompatibility with ANTLR) +- Per-item retry: failed items retry with exponential backoff without affecting others +- No-comment policy: all generated Groovy/Gremlin code is comment-free + +### Published Dataset +The final synthesized data has been uploaded to [Hugging Face datasets: Lriver/Text2Gremlin](https://huggingface.co/datasets/Lriver/Text2Gremlin). Prefer the Hugging Face dataset for downstream training/evaluation consumption, and use this repository when you need to reproduce or modify the generation pipeline. diff --git a/text2gremlin/AST_Text2Gremlin/README_zh.md b/text2gremlin/AST_Text2Gremlin/README_zh.md new file mode 100644 index 000000000..1d195afcd --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/README_zh.md @@ -0,0 +1,370 @@ +# Text2Gremlin 语料泛化 + +[English](./README.md) | [中文](README_zh.md) + +基于AST和模版生成大量多样化的 Gremlin 查询及其自然语言描述，并通过 LLM 进行多阶段数据增强与偏好数据合成，用于训练和评估 text2gremlin 模型。 + +合成后的数据集已发布到 Hugging Face：[Lriver/Text2Gremlin](https://huggingface.co/datasets/Lriver/Text2Gremlin)。如果只需要使用已生成数据，可以直接下载该数据集；如果需要重新生成、定制或审计中间过程，再运行本地流水线。 + +## 数据集 + +已生成的 Text2Gremlin 数据集地址： + +```text +https://huggingface.co/datasets/Lriver/Text2Gremlin +``` + +本仓库流水线会在本地 `output/` 下生成同类中间产物，包括 AST 泛化语料、多风格 LLM 翻译、场景迁移结果、合并后的 text-to-Gremlin 数据、语法分析报告和 DPO 偏好数据。`output/` 已被 `.gitignore` 忽略，因为这些文件通常较大，且可以重新生成或从 Hugging Face 下载。 + +## 快速开始 + +### 1. 环境配置 +Python 版本：3.12.10 +```bash +pip install -r requirements.txt +``` + +### 2. 配置文件 +复制示例配置文件并填入你的配置： +```bash +cp config_example.json config.json +``` + +编辑 `config.json`，填入 LLM API 配置： +```json +"llm": { + "base_url": "http://your-llm-server:port/v1", + "api_key": "your-api-key", + "model": "your-model-name", + "temperature": 1.0, + "max_retries": 3, + "max_concurrency": 5, + "save_interval": 50, + "timeout": 40 +}, +"migration": { + "migration_mode": "same_operation", + "same_operation_sample_count": 3 +} +``` + +> ⚠️ `config.json` 包含敏感信息，已被 `.gitignore` 忽略，请勿提交到版本控制。 + +### 3. 运行 + +#### 阶段一：AST 泛化生成语料库 +```bash +python generate_corpus.py +``` + +#### 阶段二～五：LLM 增强流水线 +```bash +# 执行全部 LLM 增强阶段（翻译 → 迁移 → 合并 → DPO） +python run_llm_pipeline.py + +# 从指定阶段开始 +python run_llm_pipeline.py --stage migrate + +# 只执行某个阶段 +python run_llm_pipeline.py --stage merge --stop merge +``` + +各阶段也可独立运行： +```bash +# 多风格翻译 +python -m llm_augment.generalize_llm + +# 场景迁移 +python -m llm_augment.migrate_scenario + +# 可选：场景迁移时生成混合 CRUD 样本 +python -m llm_augment.migrate_scenario --migration-mode mixed_operations + +# 数据集合并 +python -m llm_augment.merge_dataset + +# DPO 偏好数据生成 +python -m llm_augment.generate_dpo_data +``` + +#### 语法分析 +```bash +python analyze_syntax.py +``` + +--- + +## 数据生成流水线 + +```text +阶段 1: AST 泛化 generate_corpus.py + 251 模板 → ~1500 条 (query + 简单描述) + ↓ +阶段 2: LLM 多风格翻译 llm_augment/generalize_llm.py + ×6 风格 → ~9000 条 (4固定 + 2随机语气) + ↓ +阶段 3: 场景迁移 llm_augment/migrate_scenario.py + ×20 场景 → 默认同类型迁移, 可选混合 CRUD, 语法检查 + ↓ +阶段 4: 数据集合并 llm_augment/merge_dataset.py + 合并翻译+迁移 → text2gremlin_dataset_*.json，用于训练/评估分析 + ↓ +阶段 5: DPO 偏好数据 llm_augment/generate_dpo_data.py + 使用 text2gremlin_pairs_*.json + migrated_*.json 作为输入 + A类(多任务组合) + B类(单任务) + C类(长链拆解) + → ~8900 条偏好数据 (21 个领域) + ↓ +公开数据集 Hugging Face: Lriver/Text2Gremlin +``` + +--- + +## 项目结构 + +```text +├── generate_corpus.py # AST 泛化主程序 +├── run_llm_pipeline.py # LLM 增强流水线统一入口 +├── analyze_syntax.py # Gremlin 语法分布分析 +├── gremlin_templates.csv # 查询模板 (251条) +├── config.json # 配置文件 (gitignored) +├── config_example.json # 配置示例 +├── requirements.txt # Python 依赖 +│ +├── llm_augment/ # LLM 增强数据生成包 +│ ├── __init__.py +│ ├── generalize_llm.py # 阶段2: 多风格翻译 +│ ├── migrate_scenario.py # 阶段3: 场景迁移 +│ ├── merge_dataset.py # 阶段4: 数据集合并 +│ └── generate_dpo_data.py # 阶段5: DPO 偏好数据 +│ +├── base/ # AST 泛化核心引擎 +│ ├── generator.py # 解析泛化控制器 + 语法检查 +│ ├── Config.py # 配置管理 +│ ├── Schema.py # Schema 和数据管理 +│ ├── GremlinParse.py # 数据结构定义 +│ ├── GremlinExpr.py # 复杂表达式 (谓词、匿名遍历等) +│ ├── GremlinTransVisitor.py # AST 解析 +│ ├── TraversalGenerator.py # 遍历生成器 +│ ├── GremlinBase.py # 翻译引擎 +│ ├── gremlin/ # ANTLR 生成的 Gremlin 解析器 +│ └── template/ # 翻译字典 +│ +├── db_data/ # 数据和 Schema +│ ├── schema/ # 图数据库 schema +│ └── reference/ # 场景迁移用的多领域 schema +│ +└── output/ # 输出目录 + ├── generated_corpus_*.json + ├── llm_translated_*.json + ├── text2gremlin_pairs_*.json + ├── migrated_*.json + ├── text2gremlin_dataset_*.json + └── preference_data/ # DPO 偏好数据 +``` + +--- + +## 配置说明 + +### LLM 配置 (`config.json` → `llm`) + +| 字段 | 说明 | 默认值 | +|------|------|--------| +| base_url | LLM API 地址 | 必填 | +| api_key | API 密钥 | 必填 | +| model | 模型名称 | 必填 | +| temperature | 采样温度 | 1.0 | +| max_retries | 单条最大重试次数 | 3 | +| max_concurrency | 并发请求数 | 5 | +| save_interval | 增量保存间隔 | 50 | +| timeout | 单次请求超时 (秒) | 40 | + +### 场景迁移配置 (`config.json` → `migration`) + +| 字段 | 说明 | 默认值 | +|------|------|--------| +| migration_mode | `same_operation` 表示只生成与源 Gremlin 同类型的目标场景样本；`mixed_operations` 保留原来的混合 CRUD prompt。 | `same_operation` | +| same_operation_sample_count | `same_operation` 模式下每个迁移任务请求生成的样本数。若源模式不适合目标 schema，模型可以少生成。 | 3 | + +CLI 参数会覆盖 `config.json`，只对本次运行生效： + +```bash +python -m llm_augment.migrate_scenario --migration-mode same_operation --same-operation-sample-count 5 +python -m llm_augment.migrate_scenario --migration-mode mixed_operations +``` + +### 模板文件 (`gremlin_templates.csv`) + +| 列名 | 说明 | 示例 | +|------|------|------| +| template | Gremlin 查询模板 | `g.V().hasLabel('person')` | +| description | 模板描述（可选） | 查询所有人 | + +### 组合控制 (`base/combination_control_config.json`) + +控制 AST 泛化阶段的查询生成数量： +- 链长度分类: 短链(≤4步)、中链(5-6步)、长链(7-8步)、超长链(≥9步) +- 数据值填充: 中间步骤填1个值，终端步骤填2-3个值 +- 属性泛化: 根据链长度动态调整泛化程度 + +--- + +## 输出格式 + +已生成的数据可从 [Lriver/Text2Gremlin](https://huggingface.co/datasets/Lriver/Text2Gremlin) 下载。下面的格式说明对应本地流水线生成并最终汇总到公开数据集的中间产物。 + +### AST 泛化结果 (`generated_corpus_*.json`) +```json +{ + "metadata": { "total_unique_queries": 1564, "..." : "..." }, + "corpus": [ + { "query": "g.V().hasLabel('person')", "description": "..." } + ] +} +``` + +### LLM 翻译结果 (`llm_translated_*.json`) +```json +{ + "corpus": [ + { + "query": "g.V().hasLabel('person')", + "translations": [ + { "style": "zh_formal", "text": "查询所有人类型的顶点" }, + { "style": "en_casual", "text": "Find all person nodes" } + ] + } + ] +} +``` + +### Text2Gremlin 数据对 (`text2gremlin_pairs_*.json`) +由场景迁移阶段根据 `llm_translated_*.json` 生成，每条查询从固定翻译风格中选取一种，作为 movie 领域 DPO 输入。 + +```json +{ + "metadata": { + "source_file": "output/llm_translated_20260531_120000.json", + "total_pairs": 1564, + "style_distribution": { "zh_formal": 392, "en_casual": 391 } + }, + "pairs": [ + { "text": "查询所有人", "gremlin": "g.V().hasLabel('person')", "style": "zh_formal" } + ] +} +``` + +### 场景迁移结果 (`migrated_*.json`) +```json +{ + "migrations": [ + { + "target_domain": "ecommerce", + "generated_samples": [ + { "operation": "read", "query": "g.V()...", "natural_language": "..." } + ] + } + ] +} +``` + +### 合并后的 Text2Gremlin 数据集 (`text2gremlin_dataset_*.json`) +由 `merge_dataset.py` 根据最新或指定的 `llm_translated_*.json` 和 `migrated_*.json` 生成，可直接被 `analyze_syntax.py` 分析。 + +```json +{ + "metadata": { + "total": 3, + "sources": { + "llm_translated": { "file": "output/llm_translated_20260531_120000.json", "count": 1 }, + "migrated": { "file": "output/migrated_20260531_130000.json", "count": 2 } + }, + "crud_distribution": { "read": 2, "create": 1 } + }, + "corpus": [ + { + "query": "g.V().hasLabel('person')", + "text": "查询所有人", + "domain": "movie", + "operation": "read", + "language_style": "zh_formal", + "source": "llm_translated" + } + ] +} +``` + +### DPO 偏好数据 (`preference_data/dpo_data_*.json`) +```json +{ + "metadata": { + "total_samples": 8920, + "rejected_count": 3032, + "type_distribution": { "A": 4380, "B": 2318, "C": 2222 }, + "domain_distribution": { "movie": 401, "ecommerce": 399, "..." : "..." }, + + }, + "samples": [ + { + "task_id": "pref_MOVI_A_0001", + "task_type": "A", + "domain": "movie", + "source_queries": [ + { "text": "查询所有演员", "gremlin": "g.V().hasLabel('person')" } + ], + "input": { "instruction": "请帮我查询所有演员并更新..." }, + "chosen": { "style": "groovy", "code": "def actors = g.V()..." }, + "rejected": { "style": "gremlin", "code": "g.V().hasLabel..." }, + "preference_reason": ["Groovy 写法更清晰...", "..."] + } + ] +} +``` + +--- + +## 核心特性 + +### AST 泛化 +从一个模板生成多个变体，智能控制组合爆炸，自动去重： +```text +模板: g.V().hasLabel('person').out('acted_in') + → g.V().hasLabel('movie').out('acted_in') + → g.V().hasLabel('person').out('directed') + → ... +``` + +### LLM 多风格翻译 +每条查询翻译为 6 种风格（4 固定 + 2 随机）： +- 中文正式 / 中文口语 / 英文正式 / 英文口语 +- 中英混合 / 省略表达 / 问答式 / 错别字 + +### 场景迁移 +将电影领域数据迁移到 20 个业务场景。默认保持源语句的操作类型，每个目标场景请求生成 3 条样本；如需保留原来的混合 CRUD 生成方式，可使用 `--migration-mode mixed_operations`。每条 Gremlin 经过 ANTLR 语法检查。 + +该阶段还会从翻译结果中准备 `text2gremlin_pairs_*.json`，供 movie 领域 DPO 数据生成使用。 + +### DPO 偏好数据 +三类任务生成 Groovy vs Gremlin 偏好对，覆盖 21 个领域（movie + 20 个迁移领域），合计 8920 条： + +- **A 类（多任务组合，4380 条）**：选 2~5 条简单查询组合为复合任务 + - chosen: Groovy 命令式写法（def 变量、.next()、返回 map） + - rejected: 纯 Gremlin 函数式写法（as/select/project 强行单链） + - 自动分析命令冲突（如删除后更新），调整执行顺序或拒绝合成 +- **B 类（单任务，2318 条）**：简单查询不需要 Groovy 包装 + - chosen: 原始纯 Gremlin + - rejected: 过度工程化的 Groovy 包装 +- **C 类（长链拆解，2222 条）**：复杂长链查询拆解为多步 + - chosen: Groovy 分步写法 + - rejected: 原始长链 Gremlin + +### 流水线特性 +- 并发控制：`asyncio.wait(FIRST_COMPLETED)` + Semaphore + 批量任务创建 +- 增量保存：每 50 条自动保存，断点可恢复 +- Pydantic 验证：所有 LLM 输出严格校验格式 +- ANTLR 语法检查：纯 Gremlin 代码经过语法验证（Groovy 代码跳过，因变量引用不兼容 ANTLR） +- 单条重试：失败自动重试（指数退避），不影响其他任务 +- 代码无注释：所有生成的 Groovy/Gremlin 代码禁止包含注释 + +### 公开数据集 +最终合成数据已上传到 [Hugging Face datasets: Lriver/Text2Gremlin](https://huggingface.co/datasets/Lriver/Text2Gremlin)。下游训练或评估建议优先使用 Hugging Face 数据集；需要复现或调整生成过程时，再使用本仓库流水线。 diff --git a/text2gremlin/AST_Text2Gremlin/analyze_syntax.py b/text2gremlin/AST_Text2Gremlin/analyze_syntax.py new file mode 100644 index 000000000..646ba61b6 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/analyze_syntax.py @@ -0,0 +1,414 @@ +#!/usr/bin/env python3 +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +""" +Gremlin 语法分布分析工具 + +统计生成语料库中的 Gremlin 语法步骤、谓词分布，生成统计数据和分析报告。 + +用法: + python analyze_syntax.py # 自动找最新语料库 + python analyze_syntax.py --input output/xxx.json # 指定输入文件 + python analyze_syntax.py --top 30 # 显示前30个步骤 + +输出: + output/syntax_distribution_stats.json - 统计数据 + output/SYNTAX_ANALYSIS_SUMMARY.md - 分析报告 +""" + +import argparse +import json +import os +import re +from collections import Counter +from datetime import datetime +from glob import glob + +# Gremlin 步骤的正则匹配模式 +STEP_PATTERN = re.compile(r"\.(\w+)\s*\(") +# 起始步骤 +START_PATTERN = re.compile(r"^g\.(\w+)\s*\(") +# 谓词 P.xxx(...) +PREDICATE_PATTERN = re.compile(r"P\.(\w+)\s*\(") +# 文本谓词 TextP.xxx(...) +TEXT_PREDICATE_PATTERN = re.compile(r"TextP\.(\w+)\s*\(") +# 匿名遍历 __.xxx(...) +ANONYMOUS_PATTERN = re.compile(r"__\.(\w+)\s*\(") + +# 步骤分类 +STEP_CATEGORIES = { + "图遍历起始": ["V", "E"], + "过滤步骤": [ + "hasLabel", + "has", + "hasId", + "hasKey", + "hasValue", + "where", + "filter", + "is", + "dedup", + "simplePath", + "cyclicPath", + "not", + ], + "图导航": ["out", "in", "both", "outE", "inE", "bothE", "outV", "inV", "otherV"], + "聚合统计": ["groupCount", "count", "sum", "mean", "max", "min", "fold", "unfold"], + "排序限制": ["order", "limit", "range", "skip", "tail", "sample", "coin"], + "投影转换": [ + "values", + "valueMap", + "elementMap", + "properties", + "project", + "select", + "label", + "id", + "constant", + "identity", + ], + "分支条件": ["union", "coalesce", "choose", "optional"], + "循环": ["repeat", "times", "until", "emit"], + "路径": ["path", "tree"], + "副作用": ["aggregate", "store", "sideEffect", "group", "cap"], + "写操作": ["addV", "addE", "property", "drop"], + "逻辑": ["and", "or"], + "辅助": ["as", "by", "map", "flatMap", "barrier"], + "终端": ["iterate", "explain", "profile", "next", "toList"], +} + + +def analyze_query(query: str) -> dict: + """分析单条 Gremlin 查询，提取语法元素""" + stats = { + "steps": Counter(), + "predicates": Counter(), + "text_predicates": Counter(), + "step_count": 0, + } + + # 起始步骤 + start_match = START_PATTERN.search(query) + start_step_span = None + if start_match: + stats["steps"][start_match.group(1)] += 1 + start_step_span = start_match.span(1) + + # 链式步骤 + for match in STEP_PATTERN.finditer(query): + if start_step_span and match.span(1) == start_step_span: + continue + step_name = match.group(1) + # 排除非步骤的方法调用（如 property 的值参数中的方法） + if step_name not in ("get", "put", "toString"): + stats["steps"][step_name] += 1 + + # 谓词 + for match in PREDICATE_PATTERN.finditer(query): + stats["predicates"][match.group(1)] += 1 + + # 文本谓词 + for match in TEXT_PREDICATE_PATTERN.finditer(query): + stats["text_predicates"][match.group(1)] += 1 + + stats["step_count"] = sum(stats["steps"].values()) + return stats + + +def analyze_corpus(corpus: list) -> dict: + """分析整个语料库""" + total_stats = { + "steps": Counter(), + "predicates": Counter(), + "text_predicates": Counter(), + "step_counts": [], # 每条查询的步骤数 + } + + for item in corpus: + query = item.get("query", "") + q_stats = analyze_query(query) + total_stats["steps"].update(q_stats["steps"]) + total_stats["predicates"].update(q_stats["predicates"]) + total_stats["text_predicates"].update(q_stats["text_predicates"]) + total_stats["step_counts"].append(q_stats["step_count"]) + + return total_stats + + +def compute_category_stats(steps: Counter) -> list: + """按分类汇总步骤统计""" + total = sum(steps.values()) + results = [] + for cat_name, step_names in STEP_CATEGORIES.items(): + count = sum(steps.get(s, 0) for s in step_names) + if count > 0: + results.append((cat_name, count, count / total * 100 if total else 0)) + results.sort(key=lambda x: x[1], reverse=True) + return results + + +def compute_cumulative(steps: Counter) -> list: + """计算累计占比里程碑""" + sorted_steps = steps.most_common() + total = sum(steps.values()) + cumulative = 0 + milestones = [50, 80, 90, 95, 99] + milestone_idx = 0 + results = [] + for i, (name, count) in enumerate(sorted_steps, 1): + cumulative += count + pct = cumulative / total * 100 if total else 0 + if milestone_idx < len(milestones) and pct >= milestones[milestone_idx]: + results.append((milestones[milestone_idx], i, name)) + milestone_idx += 1 + return results + + +def print_bar(name: str, count: int, max_count: int, total: int, rank: int, bar_width: int = 40): + """打印单行条形图""" + bar_len = int((count / max_count) * bar_width) if max_count else 0 + pct = count / total * 100 if total else 0 + print(f" {rank:2d}. {name:<20} {'█' * bar_len} {count:>6} ({pct:5.2f}%)") + + +def print_results(stats: dict, total_queries: int, top_n: int = 25): + """终端打印统计结果""" + steps = stats["steps"] + total_steps = sum(steps.values()) + step_counts = stats["step_counts"] + + print("\n" + "=" * 70) + print("📊 Gremlin 语法分布统计") + print("=" * 70) + print(f" 总查询数: {total_queries:,}") + print(f" 总步骤数: {total_steps:,}") + print(f" 不同步骤类型: {len(steps)}") + if step_counts: + avg = sum(step_counts) / len(step_counts) + print(f" 平均步骤/查询: {avg:.2f}") + print(f" 最大步骤数: {max(step_counts)}") + print(f" 最小步骤数: {min(step_counts)}") + + # Top 步骤 + print(f"\n{'─' * 70}") + print(f"🏆 步骤分布 (Top {top_n})") + print(f"{'─' * 70}") + sorted_steps = steps.most_common(top_n) + max_count = sorted_steps[0][1] if sorted_steps else 1 + for i, (name, count) in enumerate(sorted_steps, 1): + print_bar(name, count, max_count, total_steps, i) + + # 谓词 + if stats["predicates"]: + print(f"\n{'─' * 70}") + print("🎯 谓词分布") + print(f"{'─' * 70}") + total_pred = sum(stats["predicates"].values()) + sorted_preds = stats["predicates"].most_common() + max_p = sorted_preds[0][1] if sorted_preds else 1 + for i, (name, count) in enumerate(sorted_preds, 1): + print_bar(name, count, max_p, total_pred, i) + + # 文本谓词 + if stats["text_predicates"]: + print(f"\n{'─' * 70}") + print("📝 文本谓词分布") + print(f"{'─' * 70}") + total_tp = sum(stats["text_predicates"].values()) + sorted_tp = stats["text_predicates"].most_common() + max_tp = sorted_tp[0][1] if sorted_tp else 1 + for i, (name, count) in enumerate(sorted_tp, 1): + print_bar(name, count, max_tp, total_tp, i) + + # 分类汇总 + print(f"\n{'─' * 70}") + print("📂 步骤分类汇总") + print(f"{'─' * 70}") + print(f" {'分类':<15} {'数量':>10} {'占比':>10}") + print(f" {'─' * 40}") + for cat_name, count, pct in compute_category_stats(steps): + print(f" {cat_name:<15} {count:>10} {pct:>9.2f}%") + + # 累计占比 + print(f"\n{'─' * 70}") + print("📈 累计占比") + print(f"{'─' * 70}") + for milestone_pct, step_count, _last_step in compute_cumulative(steps): + print(f" 前 {step_count:2d} 个步骤覆盖 {milestone_pct}% 的使用") + + print() + + +def save_stats_json(stats: dict, total_queries: int, output_path: str): + """保存统计数据到 JSON""" + step_counts = stats["step_counts"] + output_data = { + "metadata": { + "total_queries": total_queries, + "total_steps": sum(stats["steps"].values()), + "unique_step_types": len(stats["steps"]), + "avg_steps_per_query": round(sum(step_counts) / len(step_counts), 2) if step_counts else 0, + "max_steps": max(step_counts) if step_counts else 0, + "min_steps": min(step_counts) if step_counts else 0, + "total_predicates": sum(stats["predicates"].values()), + "unique_predicate_types": len(stats["predicates"]), + "total_text_predicates": sum(stats["text_predicates"].values()), + "unique_text_predicate_types": len(stats["text_predicates"]), + "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + }, + "steps": dict(stats["steps"].most_common()), + "predicates": dict(stats["predicates"].most_common()), + "text_predicates": dict(stats["text_predicates"].most_common()), + "step_categories": {cat: count for cat, count, _ in compute_category_stats(stats["steps"])}, + } + + os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True) + with open(output_path, "w", encoding="utf-8") as f: + json.dump(output_data, f, indent=2, ensure_ascii=False) + + +def generate_report(stats: dict, total_queries: int, input_file: str, report_path: str): + """生成 Markdown 分析报告""" + steps = stats["steps"] + total_steps = sum(steps.values()) + step_counts = stats["step_counts"] + + lines = [] + lines.append("# Gremlin 语法分布分析报告\n") + lines.append(f"- 数据来源: `{input_file}`") + lines.append(f"- 生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n") + + # 概览 + lines.append("## 概览\n") + lines.append("| 指标 | 值 |") + lines.append("|------|---:|") + lines.append(f"| 总查询数 | {total_queries:,} |") + lines.append(f"| 总步骤数 | {total_steps:,} |") + lines.append(f"| 不同步骤类型 | {len(steps)} |") + if step_counts: + lines.append(f"| 平均步骤/查询 | {sum(step_counts) / len(step_counts):.2f} |") + lines.append(f"| 最大步骤数 | {max(step_counts)} |") + lines.append(f"| 最小步骤数 | {min(step_counts)} |") + if stats["predicates"]: + lines.append(f"| 总谓词数 | {sum(stats['predicates'].values())} |") + lines.append("") + + # 步骤分布 + lines.append("## 步骤分布\n") + lines.append("| 排名 | 步骤 | 次数 | 占比 |") + lines.append("|-----:|------|-----:|-----:|") + for i, (name, count) in enumerate(steps.most_common(), 1): + pct = count / total_steps * 100 if total_steps else 0 + lines.append(f"| {i} | `{name}` | {count} | {pct:.2f}% |") + lines.append("") + + # 分类汇总 + lines.append("## 步骤分类汇总\n") + lines.append("| 分类 | 数量 | 占比 |") + lines.append("|------|-----:|-----:|") + for cat_name, count, pct in compute_category_stats(steps): + lines.append(f"| {cat_name} | {count} | {pct:.2f}% |") + lines.append("") + + # 谓词 + if stats["predicates"]: + lines.append("## 谓词分布\n") + lines.append("| 谓词 | 次数 | 占比 |") + lines.append("|------|-----:|-----:|") + total_pred = sum(stats["predicates"].values()) + for name, count in stats["predicates"].most_common(): + pct = count / total_pred * 100 if total_pred else 0 + lines.append(f"| `P.{name}` | {count} | {pct:.2f}% |") + lines.append("") + + if stats["text_predicates"]: + lines.append("## 文本谓词分布\n") + lines.append("| 文本谓词 | 次数 | 占比 |") + lines.append("|----------|-----:|-----:|") + total_tp = sum(stats["text_predicates"].values()) + for name, count in stats["text_predicates"].most_common(): + pct = count / total_tp * 100 if total_tp else 0 + lines.append(f"| `TextP.{name}` | {count} | {pct:.2f}% |") + lines.append("") + + # 累计占比 + lines.append("## 累计占比\n") + for milestone_pct, step_count, _last_step in compute_cumulative(steps): + lines.append(f"- 前 **{step_count}** 个步骤覆盖 **{milestone_pct}%** 的使用") + lines.append("") + + os.makedirs(os.path.dirname(os.path.abspath(report_path)), exist_ok=True) + with open(report_path, "w", encoding="utf-8") as f: + f.write("\n".join(lines)) + + +def find_latest_corpus(output_dir: str = "output") -> str: + """找到最新的泛化结果文件""" + pattern = os.path.join(output_dir, "generated_corpus_*.json") + files = sorted(glob(pattern), key=os.path.getmtime) + return files[-1] if files else None + + +def main(): + parser = argparse.ArgumentParser(description="Gremlin 语法分布分析") + parser.add_argument("--input", default=None, help="语料库文件路径（不指定则自动找最新的）") + parser.add_argument("--top", type=int, default=25, help="显示前N个步骤（默认25）") + parser.add_argument("--config", default="config.json", help="配置文件路径") + args = parser.parse_args() + + # 加载配置获取 output_dir + output_dir = "output" + if os.path.exists(args.config): + with open(args.config, encoding="utf-8") as f: + config = json.load(f) + output_dir = config.get("output_dir", "output") + + # 定位输入文件 + input_path = args.input or find_latest_corpus(output_dir) + if not input_path or not os.path.exists(input_path): + print("❌ 未找到语料库文件，请用 --input 指定") + return + + # 加载语料 + with open(input_path, encoding="utf-8") as f: + data = json.load(f) + corpus = data.get("corpus", []) + total_queries = len(corpus) + + print(f"📂 输入文件: {input_path}") + print(f"📊 查询总数: {total_queries}") + + # 分析 + stats = analyze_corpus(corpus) + + # 终端输出 + print_results(stats, total_queries, args.top) + + # 保存 JSON + stats_path = os.path.join(output_dir, "syntax_distribution_stats.json") + save_stats_json(stats, total_queries, stats_path) + print(f"💾 统计数据: {stats_path}") + + # 生成报告 + report_path = os.path.join(output_dir, "SYNTAX_ANALYSIS_SUMMARY.md") + generate_report(stats, total_queries, input_path, report_path) + print(f"📝 分析报告: {report_path}") + + +if __name__ == "__main__": + main() diff --git a/text2gremlin/AST_Text2Gremlin/base/CombinationController.py b/text2gremlin/AST_Text2Gremlin/base/CombinationController.py new file mode 100644 index 000000000..52fc781b8 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/CombinationController.py @@ -0,0 +1,370 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +""" +组合爆炸控制器 + +提供统一的配置驱动的控制策略，适用于所有Gremlin步骤和谓词的泛化生成。 +""" + +import random + +CHAIN_THRESHOLD_CATEGORIES = ("short", "medium", "long") +CHAIN_CATEGORIES = (*CHAIN_THRESHOLD_CATEGORIES, "ultra") + + +class CombinationController: + """组合爆炸控制器 - 基于配置文件的统一控制策略""" + + def __init__(self, config: dict): + """ + 初始化控制器 + + Args: + config: 从combination_control_config.json加载的配置字典 + """ + self.config = config + + # 验证必要配置项并加载 + try: + # 链长度分类阈值 + self.chain_thresholds = config["chain_thresholds"] + + # 随机增强控制 + self.random_enhancement = config["random_enhancement"] + + # 数据填充策略 + self.value_fill = config["value_fill_strategy"] + + # 属性泛化策略 + self.property_gen = config["property_generalization"] + except KeyError as e: + raise ValueError(f"缺少必要配置项: {e}") from None + + # 总数限制（可选） + self.max_total = config.get("max_total_combinations", {}) + + # 验证关键类别的存在性 + # chain_thresholds 只需要 short, medium, long（ultra 通过 else 分支隐式定义） + for category in CHAIN_THRESHOLD_CATEGORIES: + if category not in self.chain_thresholds: + raise ValueError(f"chain_thresholds 缺少 '{category}' 配置") + + # property_generalization 需要所有4个类别（包括 ultra） + for category in CHAIN_CATEGORIES: + if category not in self.property_gen: + raise ValueError(f"property_generalization 缺少 '{category}' 配置") + # 验证每个类别的必要字段 + required_fields = ["full_coverage_threshold", "additional_random_min", "additional_random_max"] + for field in required_fields: + if field not in self.property_gen[category]: + raise ValueError(f"property_generalization.{category} 缺少 '{field}' 字段") + + def get_chain_category(self, step_count: int) -> str: + """ + 根据步骤数确定链长度类别 + + Args: + step_count: 查询步骤数量 + + Returns: + 'short' | 'medium' | 'long' | 'ultra' + """ + if step_count <= self.chain_thresholds["short"]: + return CHAIN_CATEGORIES[0] + elif step_count <= self.chain_thresholds["medium"]: + return CHAIN_CATEGORIES[1] + elif step_count <= self.chain_thresholds["long"]: + return CHAIN_CATEGORIES[2] + else: + return CHAIN_CATEGORIES[3] + + def should_apply_random_enhancement(self, is_terminal: bool, enhancement_count: int) -> bool: + """ + 判断是否应该应用随机增强 + + Args: + is_terminal: 是否是终端步骤 + enhancement_count: 当前查询已经应用的增强次数 + + Returns: + True表示应该应用随机增强 + """ + # 检查是否超过最大增强次数 + if enhancement_count >= self.random_enhancement["max_enhancements_per_query"]: + return False + + # 根据位置决定概率 + probability = ( + self.random_enhancement["terminal_step_probability"] + if is_terminal + else self.random_enhancement["middle_step_probability"] + ) + + return random.random() < probability + + def get_value_fill_count(self, is_terminal: bool, available_count: int) -> int: + """ + 决定应该填充多少个数据值 + + Args: + is_terminal: 是否是终端步骤（配方的最后一步） + available_count: CSV中实际可用的数据数量 + + Returns: + 应该填充的值数量 + """ + if not is_terminal: + # 中间步骤：固定1个 + return min(self.value_fill["middle_step"]["count"], available_count) + else: + # 终端步骤：随机2-3个 + min_count = self.value_fill["terminal_step"]["min"] + max_count = self.value_fill["terminal_step"]["max"] + target = random.randint(min_count, max_count) + return min(target, available_count) + + def select_sibling_options(self, recipe_option: str, all_options: list[str], chain_category: str) -> list[str]: + """ + 通用的同级选项选择器 - 核心泛化方法 + + 适用于所有需要选择同级选项的场景： + - 顶点标签: hasLabel('person') → 其他顶点标签 + - 边标签: out('acted_in') → 其他边标签 + - 顶点属性: has('name', ?) → 其他顶点属性 + - 边属性: has('role', ?) → 其他边属性 + - 以及任何具有平级关系的选项 + + Args: + recipe_option: 配方中指定的选项（必须包含） + all_options: 所有同级选项列表 + chain_category: 链长度类别 ('short'|'medium'|'long'|'ultra') + + Returns: + 选中的选项列表（包含recipe_option + 随机选择的其他选项） + """ + strategy = self.property_gen[chain_category] + + # 1. 配方选项必须包含 + if recipe_option and recipe_option in all_options: + selected = [recipe_option] + other_options = [opt for opt in all_options if opt != recipe_option] + else: + # 如果配方选项不在列表中，从头开始 + selected = [] + other_options = all_options + + # 2. 判断是否全部遍历 + if len(all_options) <= strategy["full_coverage_threshold"]: + # 同级选项少，全部遍历 + return list(all_options) + + # 3. 同级选项多，随机选择额外的 + additional_count = random.randint(strategy["additional_random_min"], strategy["additional_random_max"]) + + if additional_count > 0 and other_options: + # 随机采样，确保不重复 + sample_count = min(additional_count, len(other_options)) + selected.extend(random.sample(other_options, sample_count)) + + return selected + + def select_multi_param_schema_options( + self, recipe_params: list[str], all_options: list[str], chain_category: str + ) -> list[list[str]]: + """ + 多参数Schema填充选择器 + + 适用于从schema获取参数的多参数步骤： + - hasLabel('person', 'movie') → 其他2参数标签组合 + - hasKey('name', 'age') → 其他2参数属性键组合 + - out('acted_in', 'directed') → 其他2参数边标签组合 + + Args: + recipe_params: 配方中的参数列表 ['person', 'movie'] + all_options: 所有可选项 ['person', 'movie', 'user', 'genre', 'keyword'] + chain_category: 链长度类别 + + Returns: + 多参数组合列表 [['person', 'movie'], ['user', 'genre'], ...] + """ + param_count = len(recipe_params) + if param_count <= 1: + # 单参数情况，使用原有方法 + return [self.select_sibling_options(recipe_params[0] if recipe_params else "", all_options, chain_category)] + + # 获取多参数策略配置 + multi_config = self.config.get("multi_param_strategy", {}) + schema_config = multi_config.get("schema_fill", {}) + max_combinations = schema_config.get(chain_category, {}).get("max_combinations", 1) + + combinations = [] + seen = set() # 用于去重的集合 + + # 1. 保留原配方组合 + combinations.append(recipe_params.copy()) + seen.add(tuple(sorted(recipe_params))) + + if max_combinations <= 1: + return combinations + + # 2. 生成其他同参数数量的组合 + other_options = [opt for opt in all_options if opt not in recipe_params] + + # 情况1：可选参数个数 < 多参数个数 + # 例如：需要3个参数，但只有1个可选项 + # 策略：不生成额外组合（因为无法组成完整的多参数组合） + if len(other_options) < param_count: + return combinations # 只返回原配方 + + # 情况2：可选参数个数 = 多参数个数 + # 例如：需要2个参数，恰好有2个可选项 + # 策略：不生成额外组合（因为只有一种组合方式，随机选择没意义） + if len(other_options) == param_count: + return combinations # 只返回原配方 + + # 情况3：可选参数个数 > 多参数个数 + # 例如：需要3个参数，有5个可选项 + # 策略：随机生成多个组合 + attempts = 0 + max_attempts = 20 # 避免无限循环 + + while len(combinations) < max_combinations and attempts < max_attempts: + # 随机选择同数量的参数 + combo = random.sample(other_options, param_count) + + # 使用排序后的元组作为key进行去重（因为参数顺序不影响语义） + key = tuple(sorted(combo)) + if key not in seen: + seen.add(key) + combinations.append(combo) + + attempts += 1 + + return combinations + + def get_multi_param_value_fill_count(self, is_terminal: bool) -> int: + """ + 多参数数据值填充次数控制 + + Args: + is_terminal: 是否是终端步骤 + + Returns: + 填充次数（每次填充的值个数由调用方根据参数个数决定） + """ + multi_config = self.config.get("multi_param_strategy", {}) + value_config = multi_config.get("value_fill", {}) + + if not is_terminal: + # 中间步骤：只填充1次 + return value_config.get("middle_step", {}).get("fill_times", 1) + else: + # 终端步骤：填充2-3次 + min_times = value_config.get("terminal_step", {}).get("fill_times_min", 2) + max_times = value_config.get("terminal_step", {}).get("fill_times_max", 3) + return random.randint(min_times, max_times) + + def should_stop_generation(self, current_count: int, chain_category: str) -> bool: + """ + 判断是否应该停止生成（可选功能） + + Args: + current_count: 当前已生成的查询数量 + chain_category: 链长度类别 + + Returns: + True表示应该停止生成 + """ + max_limit = self.max_total.get(chain_category) + if max_limit is None: + return False + + return current_count >= max_limit + + def print_strategy_info(self, step_count: int): + """ + 打印当前查询的控制策略信息（用于调试） + + Args: + step_count: 查询步骤数量 + """ + category = self.get_chain_category(step_count) + strategy = self.property_gen[category] + + print("🎯 组合控制策略") + print(f" 步骤数: {step_count}") + print(f" 类别: {category}") + print(f" 总数限制: {self.max_total.get(category, '无')}") + print( + f" 随机增强: 中间{self.random_enhancement['middle_step_probability'] * 100:.0f}%, " + f"末尾{self.random_enhancement['terminal_step_probability'] * 100:.0f}%, " + f"最多{self.random_enhancement['max_enhancements_per_query']}次" + ) + print( + f" 数据填充: 中间{self.value_fill['middle_step']['count']}个, " + f"终端{self.value_fill['terminal_step']['min']}-{self.value_fill['terminal_step']['max']}个" + ) + print( + f" 属性泛化: 阈值≤{strategy['full_coverage_threshold']}全遍历, " + f"否则配方+随机{strategy['additional_random_min']}-{strategy['additional_random_max']}个" + ) + + +# 使用示例 +if __name__ == "__main__": + import json + + # 加载配置 + with open("combination_control_config.json", encoding="utf-8") as f: + config = json.load(f) + + # 创建控制器 + controller = CombinationController(config) + + # 测试不同长度的链 + print("=" * 60) + for steps in [3, 5, 7, 10]: + controller.print_strategy_info(steps) + print() + + # 测试同级选项选择 + print("=" * 60) + print("🧪 测试同级选项选择:") + + test_cases = [ + { + "name": "5个顶点标签", + "recipe": "person", + "all": ["person", "movie", "genre", "keyword", "user"], + "category": "short", + }, + { + "name": "10个属性", + "recipe": "name", + "all": ["name", "born", "bio", "poster", "height", "weight", "age", "gender", "nationality", "occupation"], + "category": "medium", + }, + ] + + for case in test_cases: + print(f"\n{case['name']} ({case['category']}链):") + selected = controller.select_sibling_options(case["recipe"], case["all"], case["category"]) + print(f" 配方: {case['recipe']}") + print(f" 总数: {len(case['all'])}") + print(f" 选中: {selected} ({len(selected)}个)") diff --git a/text2gremlin/AST_Text2Gremlin/base/Config.py b/text2gremlin/AST_Text2Gremlin/base/Config.py new file mode 100644 index 000000000..5db5c4278 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/Config.py @@ -0,0 +1,89 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +""" +项目配置管理模块。 + +负责加载和管理项目配置文件，提供各模块所需的配置参数。 +""" + +import json +import os + + +class Config: + def __init__(self, file_path): + self.file_path = file_path + self.config_data = self.load_config() + self.gen_query = self.config_data.get("genQuery") # default genQuery，can be set as translate + self.db_id = self.config_data.get("db_id") + + def load_config(self): + try: + with open(self.file_path, encoding="utf-8") as file: + return json.load(file) + except FileNotFoundError as exc: + raise FileNotFoundError(f"配置文件不存在: {self.file_path}") from exc + except json.JSONDecodeError as exc: + raise ValueError(f"配置文件 JSON 格式错误: {self.file_path}, 错误: {exc}") from exc + + def get_input_query_path(self): + return self.config_data.get("input_query_path") + + def get_input_query_template_path(self): + return self.config_data.get("input_query_template_path") + + def get_input_corpus_dir_or_file(self): + return self.config_data.get("input_corpus_dir_or_path") + + def set_input_corpus_dir_or_file(self, dir_or_file): + self.config_data["input_corpus_dir_or_path"] = dir_or_file + + def get_output_path(self): + if self.gen_query: + dir_or_file = self.config_data.get("output_query_dir_or_file") + if os.path.isdir(dir_or_file): + output_path = os.path.join(dir_or_file, self.db_id + ".txt") + return output_path + else: + return dir_or_file + else: + return self.config_data.get("output_prompt_path") + + def get_output_corpus(self): + return self.config_data.get("output_corpus_path") + + def get_schema_dict_path(self): + return self.config_data.get("schema_dict_path") + + def get_syn_dict_path(self): + return self.config_data.get("syn_dict_path") + + def get_db_id(self): + return self.db_id + + def get_schema_path(self, db_id): + schema_dict = self.config_data.get("db_schema_path") + if not schema_dict: + raise ValueError("配置中缺少 'db_schema_path' 字段") + if db_id not in schema_dict: + raise KeyError(f"未找到 db_id '{db_id}' 对应的 schema 路径") + return schema_dict[db_id] + + def get_config(self, module_name): + return self.config_data.get(module_name) diff --git a/text2gremlin/AST_Text2Gremlin/base/GremlinBase.py b/text2gremlin/AST_Text2Gremlin/base/GremlinBase.py new file mode 100644 index 000000000..98010c611 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/GremlinBase.py @@ -0,0 +1,350 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +""" +Gremlin翻译引擎模块。 + +提供Gremlin术语到中文的智能翻译，负责生成自然流畅的中文查询描述。 +""" + +import os +import random + +from .gremlin.GremlinParser import GremlinParser + +TOKEN_TEMPLATE_ALIASES = { + "V": "v", + "E": "e", + "addV": "addv", + "addE": "adde", + "toList": "tolist", + "toSet": "toset", + "hasNext": "hasnext", + "tryNext": "trynext", +} + + +class GremlinBase: + def __init__(self, config): + """ + Gremlin 基础类，作为项目的“工具箱”和“字典”。 + """ + self.config = config + + # 从 GremlinParser 加载rule_names + self.rule_names = GremlinParser.ruleNames + + self.token_dict = {} + self.template = [] # 索引对应 token_dict 的值，每个元素是一个包含多种中文翻译模板的子列表。 + self._initialize_translation_templates() + + # 复用 schema_dict 加载同义词等 + self.schema_dict = {} + self._load_schema_translations() + + def get_rule_name(self, rule_index: int) -> str: + """根据索引获取 ANTLR 规则名。""" + if 0 <= rule_index < len(self.rule_names): + return self.rule_names[rule_index] + return "UnknownRule" + + def _load_schema_translations(self): + """加载schema翻译字典""" + current_dir = os.path.dirname(os.path.abspath(__file__)) + + def collect_config_paths(method_name: str) -> list[str]: + if not hasattr(self.config, method_name): + return [] + try: + configured_paths = getattr(self.config, method_name)() + except Exception as e: + print(f"[INFO] Config path {method_name} not available: {e}") + return [] + if isinstance(configured_paths, list): + return configured_paths + if isinstance(configured_paths, str): + return [configured_paths] + return [] + + def existing_or_default(configured_paths: list[str], default_filename: str) -> list[str]: + existing_paths = [path for path in configured_paths if os.path.exists(path)] + if existing_paths: + return existing_paths + default_path = os.path.join(current_dir, "template", default_filename) + if os.path.exists(default_path): + return [default_path] + return [] + + schema_paths = existing_or_default(collect_config_paths("get_schema_dict_path"), "schema_dict.txt") + syn_paths = existing_or_default(collect_config_paths("get_syn_dict_path"), "syn_dict.txt") + existing_paths = schema_paths + syn_paths + + if existing_paths: + self.load_dict_from_file(existing_paths) + else: + print("[WARNING] No dictionary files found") + + def _initialize_translation_templates(self): + """ + 初始化 Gremlin 步骤的翻译模板。 + """ + # 定义模板数据 + templates_data = { + # --- 起始步骤 --- + "v": ["查询图中的所有顶点", "获取所有节点"], + "e": ["查询图中的所有边", "获取所有关系"], + "addv": ["添加一个标签为 '{}' 的新顶点"], + "adde": ["添加一条从一个顶点到另一个顶点的 '{}' 边"], + # --- 导航步骤 --- + "out": ["从当前位置出发，沿着 '{}' 方向的出边前进", "找到 '{}' 类型的邻居"], + "in": ["从当前位置出发，沿着 '{}' 方向的入边前进", "找到拥有 '{}' 类型关系的来源"], + "both": ["沿着 '{}' 方向的双向边进行遍历"], + "outE": ["获取出边"], + "inE": ["获取入边"], + "bothE": ["获取双向边"], + "outV": ["从当前边，找到它的出射顶点", "获取边的头节点"], + "inV": ["从当前边，找到它的入射顶点", "获取边的尾节点"], + "otherV": ["获取边的另一端顶点"], + "bothV": ["从当前边，找到它的两个端点"], + # --- 过滤步骤 --- + "hasLabel": ["并筛选出标签为 '{}' 的元素"], + "has": ["并筛选出属性 '{}' 为 '{}' 的元素", "查找其中 '{}' 是 '{}' 的数据"], + "hasId": ["筛选ID为 '{}' 的元素"], + "hasKey": ["筛选包含键 '{}' 的元素"], + "hasValue": ["筛选包含值 '{}' 的元素"], + "where": ["并根据 '{}' 的条件进行过滤"], + "is": ["判断值是否为 '{}'"], + "not": ["取反"], + # --- 数值参数步骤 --- + "limit": ["并限制最多返回 {} 个结果", "取前 {} 条数据"], + "skip": ["跳过前 {} 个结果"], + "tail": ["取最后 {} 个结果"], + "sample": ["随机采样 {} 个结果"], + "range": ["取范围内的结果"], + # --- 转换步骤 --- + "dedup": ["并对结果进行去重"], + "order": ["然后对结果进行排序"], + "simplePath": ["过滤出简单路径"], + "cyclicPath": ["过滤出循环路径"], + # --- 属性访问步骤 --- + "values": ["然后获取它们的属性值", "提取属性值"], # 无参数版本 + "values_with_key": ["然后获取它们的 '{}' 属性值", "提取 '{}' 字段的值"], # 有参数版本 + "properties": ["获取属性对象"], + "properties_with_key": ["获取 '{}' 属性对象"], # 有参数版本 + "valueMap": ["然后以键值对的形式返回它们的属性"], + "valueMap_with_key": ["返回 '{}' 的键值对"], # 有参数版本 + "elementMap": ["获取元素映射"], + "keys": ["获取键"], + "key": ["获取键"], + "value": ["获取属性的值"], + # --- 聚合步骤 --- + "count": ["最后统计结果的总数"], + "group": ["然后对结果进行分组"], + "groupCount": ["分组并统计数量"], + "sum": ["求和"], + "mean": ["求平均值"], + "min": ["求最小值"], + "max": ["求最大值"], + # --- 终端步骤 --- + "tolist": ["转为列表"], + "toset": ["转为集合"], + "next": ["获取下一个"], + "hasnext": ["判断是否有下一个"], + "trynext": ["尝试获取下一个"], + # --- 简单步骤 --- + "fold": ["折叠为列表"], + "unfold": ["展开列表"], + "iterate": ["迭代执行"], + "explain": ["解释查询计划"], + "profile": ["性能分析"], + # --- 其他步骤 --- + "label": ["然后获取它们的标签"], + "id": ["然后获取它们的ID"], + "path": ["然后返回完整的遍历路径"], + "project": ["然后将结果投影为指定字段"], + "by": ["按指定属性进行分组或投影"], + "property": ["并将其 '{}' 属性的值更新为 '{}'"], + "drop": ["最后将这些元素从图中删除", "移除这些数据"], + "as": ["标记为 '{}'", "标记"], + "select": ["选择标记的元素"], + "repeat": ["重复遍历"], + "until": ["直到满足条件"], + "times": ["重复指定次数"], + "emit": ["发射中间结果"], + "choose": ["条件分支"], + "coalesce": ["合并多个遍历"], + "optional": ["可选遍历"], + "union": ["联合多个遍历"], + "match": ["模式匹配"], + "flatMap": ["扁平映射"], + "map": ["映射转换"], + "tree": ["构建树结构"], + # --- 新增步骤 --- + "loops": ["获取当前循环的次数"], + "coin": ["以 {} 的概率保留结果"], + "filter": ["应用过滤条件"], + "and": ["应用逻辑与过滤"], + "or": ["应用逻辑或过滤"], + "aggregate": ["将它们聚合到名为 '{}' 的侧边变量中"], + "store": ["将它们存储到名为 '{}' 的侧边变量中"], + "sideEffect": ["执行附加操作"], + "cap": ["然后取出 '{}' 中存储的内容"], + "sack": ["获取携带的值"], + "barrier": ["等待所有结果到齐"], + "constant": ["映射为常量值"], + "identity": ["保持元素不变"], + "local": ["在本地作用域内执行"], + # --- 剩余15个步骤 --- + # 图算法 + "pageRank": ["计算PageRank值"], + "peerPressure": ["应用同伴压力算法"], + "connectedComponent": ["计算连通分量"], + "shortestPath": ["计算最短路径"], + # 工具步骤 + "math": ["应用数学表达式"], + "subgraph": ["提取子图"], + "timeLimit": ["设置时间限制"], + "inject": ["注入值到遍历"], + "call": ["调用服务"], + "io": ["执行IO操作"], + "mergeE": ["合并边"], + "mergeV": ["合并顶点"], + "with": ["配置选项"], + # 边修改 + "from": ["指定边的起始顶点"], + "to": ["指定边的目标顶点"], + # --- 谓词 --- + # 数值谓词 + "eq": ["等于"], + "neq": ["不等于"], + "gt": ["大于"], + "gte": ["大于等于"], + "lt": ["小于"], + "lte": ["小于等于"], + "between": ["在...之间"], + "inside": ["在范围内"], + "outside": ["在范围外"], + "within": ["在集合中"], + "without": ["不在集合中"], + # 文本谓词 + "startingWith": ["以...开始"], + "endingWith": ["以...结束"], + "containing": ["包含"], + "notStartingWith": ["不以...开始"], + "notEndingWith": ["不以...结束"], + "notContaining": ["不包含"], + "regex": ["匹配正则表达式"], + "notRegex": ["不匹配正则表达式"], + } + + # 填充 self.token_dict 和 self.template + # 保持原始大小写，不进行转换 + for index, (key, value) in enumerate(templates_data.items()): + self.token_dict[key] = index + self.template.append(value) + for alias, canonical_key in TOKEN_TEMPLATE_ALIASES.items(): + self.token_dict[alias] = self.token_dict[canonical_key] + + def get_token_desc(self, token_key: str, *args) -> str: + """ + 根据 token 和参数获取一个随机的、格式化后的中文描述。 + """ + key = token_key # 保持原始大小写 + if key in self.token_dict: + index = self.token_dict[key] + # 随机选择一个模板 + selected_template = random.choice(self.template[index]) + try: + # 翻译参数中的schema术语 + translated_args = [] + for arg in args: + if isinstance(arg, str): + # 尝试翻译schema术语 + translated_arg = self.get_schema_desc(arg) + translated_args.append(translated_arg) + else: + translated_args.append(arg) + + # 使用翻译后的参数格式化模板 + return selected_template.format(*translated_args) + except (IndexError, KeyError): + # 如果参数数量不匹配，返回原始模板 + return selected_template + return "" # 如果 token 不存在，返回空字符串 + + # 复用的通用方法 + def merge_desc(self, desc_list: list) -> str: + """合并多个描述片段，移除空字符串并用合适的连接词连接。""" + # 过滤掉空字符串 + filtered_list = [s for s in desc_list if s and s.strip()] + return ",".join(filtered_list) + + def load_dict_from_file(self, file_paths: list): + """从文件加载字典，例如同义词词典。""" + for file_path in file_paths: + if not os.path.exists(file_path): + print(f"[WARNING] Dictionary file not found: {file_path}") + continue + with open(file_path, encoding="utf-8") as file: + for line in file: + elements = line.strip().split() + if elements: + key = elements[0] + values = elements[1:] + self.schema_dict[key] = values + + def get_schema_desc(self, key: str) -> str: + """从加载的字典中获取一个随机的同义词或描述。""" + try: + # 确保键存在 + if self.schema_dict.get(key): + return random.choice(self.schema_dict[key]) + return key # 如果没有同义词，返回原词 + except KeyError: + return key + + +if __name__ == "__main__": + # 临时创建config 对象，用于测试 + class MockConfig: + def get_schema_dict_path(self): + return ["./template/schema_dict.txt"] + + def get_syn_dict_path(self): + return ["./template/syn_dict.txt"] + + config = MockConfig() + gremlin_base = GremlinBase(config) + + print("--- GremlinBase.py 测试 ---") + + # 1. 测试规则名加载 + print(f"\n成功加载 {len(gremlin_base.rule_names)} 条 Gremlin 语法规则。") + print(f"第一条规则是: '{gremlin_base.get_rule_name(0)}'") + + # 2. 测试翻译模板 + print("\n--- 测试翻译功能 ---") + print("OUT('acted_in') 的一个翻译: ", gremlin_base.get_token_desc("OUT", "acted_in")) + print("HAS('name', 'marko') 的一个翻译: ", gremlin_base.get_token_desc("HAS", "name", "marko")) + print("LIMIT(10) 的一个翻译: ", gremlin_base.get_token_desc("LIMIT", 10)) + print("COUNT() 的一个翻译: ", gremlin_base.get_token_desc("COUNT")) + + # 3. 测试描述合并 + desc_parts = ["查找所有电影", "筛选出其中类型为科幻的", "最后统计总数"] + merged = gremlin_base.merge_desc(desc_parts) + print("\n合并后的描述: ", merged) diff --git a/text2gremlin/AST_Text2Gremlin/base/GremlinExpr.py b/text2gremlin/AST_Text2Gremlin/base/GremlinExpr.py new file mode 100644 index 000000000..495bd910b --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/GremlinExpr.py @@ -0,0 +1,127 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +""" +Gremlin复杂表达式定义模块。 + +定义谓词、匿名遍历、连接器等复杂Gremlin表达式的数据结构。 +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Any + +if TYPE_CHECKING: + from .GremlinParse import Step + + +class Predicate: + """ + 表示一个 Gremlin 谓词，例如 P.gt(30)、P.within('a', 'b') 等。 + 此类捕获操作符（如 'gt'、'within'）及其参数。 + """ + + def __init__(self, operator: str, value: Any): + """ + 参数: + operator (str): 谓词操作符名称（例如 'gt'、'lt'、'inside'、'neq'）。 + value (Any): 与操作符关联的值。可以是单个值或多个值（例如用于 'within'）。 + """ + self.operator = operator + self.value = value + + def __repr__(self) -> str: + return f"P.{self.operator}({self.value!r})" + + +class TextPredicate: + """ + 表示一个 Gremlin TextP 谓词，例如 TextP.startingWith('mark')。 + 这是用于基于文本比较的谓词的专用版本。 + """ + + def __init__(self, operator: str, value: Any): + """ + 参数: + operator (str): 文本谓词操作符名称（例如 'startingWith'、'endingWith'、'containing'）。 + value (Any): 用于比较的字符串值。 + """ + self.operator = operator + self.value = value + + def __repr__(self) -> str: + return f"TextP.{self.operator}({self.value!r})" + + +class AnonymousTraversal: + """ + 表示一个匿名遍历，通常以 __ 开头。 + 示例：__.out('knows')，__.values('age').mean() + + 该类保存构成遍历的一系列 Step 对象。 + """ + + def __init__(self): + # 构成此匿名遍历的 Step 对象列表。 + # 'Step' 是前向声明，以避免与 GremlinParse 的循环导入。 + self.steps: list[Step] = [] + + def add_step(self, step: Step): + """向匿名遍历中添加一个步骤。""" + self.steps.append(step) + + def __repr__(self) -> str: + step_reprs = ".".join(map(repr, self.steps)) + return f"__.{step_reprs}" + + +class Connector: + """ + 表示用于组合遍历过滤器的逻辑连接符，如 .and() 和 .or()。 + 示例：g.V().where(__.out('knows').and().out('likes')) + """ + + def __init__(self, operator: str, traversals: list[AnonymousTraversal]): + """ + 参数: + operator (str): 逻辑操作符，通常是 'and' 或 'or'。 + traversals (List[AnonymousTraversal]): 需要连接的匿名遍历列表。 + """ + self.operator = operator + self.traversals = traversals + + def __repr__(self) -> str: + traversal_reprs = ", ".join(map(repr, self.traversals)) + return f".{self.operator}({traversal_reprs})" + + +class Terminal: + """ + 表示不返回迭代器的终端步骤，例如 .next()、.hasNext()、.toList()。 + 虽然我们的生成器可能不会频繁生成这些步骤，但解析器需要能够识别它们。 + """ + + def __init__(self, name: str): + """ + 参数: + name (str): 终端步骤的名称（例如 'next'、'toList'）。 + """ + self.name = name + + def __repr__(self) -> str: + return f".{self.name}()" diff --git a/text2gremlin/AST_Text2Gremlin/base/GremlinParse.py b/text2gremlin/AST_Text2Gremlin/base/GremlinParse.py new file mode 100644 index 000000000..c1274e830 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/GremlinParse.py @@ -0,0 +1,101 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +""" +Gremlin查询结构化表示模块。 + +定义Step和Traversal数据结构，将解析后的Gremlin查询表示为结构化的"配方"对象。 +""" + +from typing import Any + +# 导入将在 Step 参数中存储的结构化表达式类。 + + +class Step: + """ + Gremlin 遍历中的单个原子操作（一个步骤）。 + 例如：.V(), .has('name', 'marko'), .out('knows'), .addV('person') + """ + + def __init__(self, name: str, params: list[Any] | None = None): + """ + 初始化一个 Step 实例。 + + Args: + name (str): Gremlin 步骤的名称，例如 'V', 'has', 'out', 'addV'。 + 应以一致的格式存储（例如，全小写）。 + params (List[Any], optional): 步骤的参数列表。 + 这是关键字段，可以包含简单值（str, int） + 或来自 GremlinExpr 的复杂对象 + （例如 Predicate, AnonymousTraversal）。 + 默认为 None。 + """ + self.name = name + self.params = params if params is not None else [] + + def __repr__(self) -> str: + """ + 提供一个对开发者友好的、该步骤的字符串表示形式。 + """ + # 格式化参数以便阅读。如果参数有自己的 __repr__ 方法，将会被自动调用。 + param_str = ", ".join(map(repr, self.params)) + return f"Step({self.name}, params=[{param_str}])" + + +class Traversal: + """ + 将整个 Gremlin 遍历表示为一个由 Step 对象组成的序列，捕获输入查询模板的意图和结构。 + """ + + def __init__(self): + """ + 初始化一个空的 Traversal 实例。 + """ + self.steps: list[Step] = [] + + def add_step(self, step: Step): + """ + 在遍历序列的末尾追加一个 Step。 + + Args: + step (Step): 要添加的 Step 对象。 + """ + self.steps.append(step) + + def __repr__(self) -> str: + """ + 提供一个链式风格、整个遍历的字符串表示形式。 + """ + if not self.steps: + return "Traversal(empty)" + + # 创建一个类似方法链的表示形式 + step_chain = " -> ".join([step.name for step in self.steps]) + return f"Traversal({step_chain})" + + +if __name__ == "__main__": + # 创建Traversal 实例 + traversal = Traversal() + traversal.add_step(Step("V")) + traversal.add_step(Step("has", ["name", "marko"])) + traversal.add_step(Step("out", ["knows"])) + traversal.add_step(Step("addV", ["person"])) + + print(traversal) diff --git a/text2gremlin/AST_Text2Gremlin/base/GremlinTransVisitor.py b/text2gremlin/AST_Text2Gremlin/base/GremlinTransVisitor.py new file mode 100644 index 000000000..1103936ca --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/GremlinTransVisitor.py @@ -0,0 +1,2433 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +""" +Gremlin查询AST访问器模块。 + +基于ANTLR访问器模式，将Gremlin查询字符串解析为结构化的配方对象。 +""" + +from antlr4 import * +from antlr4.CommonTokenStream import CommonTokenStream +from antlr4.InputStream import InputStream + +from .gremlin.GremlinLexer import GremlinLexer +from .gremlin.GremlinParser import GremlinParser +from .gremlin.GremlinVisitor import GremlinVisitor +from .GremlinExpr import AnonymousTraversal, Predicate, Terminal, TextPredicate +from .GremlinParse import Step, Traversal + + +class GremlinTransVisitor(GremlinVisitor): + def __init__(self): + super().__init__() + self.traversal = Traversal() + + def parse_and_visit(self, query_string: str): + """ + 解析 Gremlin 查询字符串并遍历 AST 以生成 Traversal 对象。 + + Args: + query_string (str): 要解析的 Gremlin 查询字符串 + + Returns: + Traversal: 包含步骤的解析后遍历对象 + """ + try: + # 重置traversal进行新的查询 + self.traversal = Traversal() + + input_stream = InputStream(query_string) + lexer = GremlinLexer(input_stream) + stream = CommonTokenStream(lexer) + parser = GremlinParser(stream) + tree = parser.queryList() + + # 访问第一个query + result = self.visit(tree.query(0)) + + return result if result else self.traversal + + except Exception as e: + print(f"Error parsing query '{query_string}': {e}") + return None + + # 核心结构访问器，控制流程 + def visitQueryList(self, ctx: GremlinParser.QueryListContext): + """处理查询列表，通常包含一个查询""" + if ctx.query(0): # 访问第一个查询 + return self.visit(ctx.query(0)) + return self.traversal + + def visitQuery(self, ctx: GremlinParser.QueryContext): + # 访问根遍历部分 + if ctx.rootTraversal(): + self.visit(ctx.rootTraversal()) + + # 如果有终端方法，访问它 + if ctx.traversalTerminalMethod(): + self.visit(ctx.traversalTerminalMethod()) + + # 如果有嵌套查询，递归访问 + if ctx.query(): + self.visit(ctx.query()) + return self.traversal + + def visitRootTraversal(self, ctx: GremlinParser.RootTraversalContext): + # 首先访问traversalSource + if ctx.traversalSource(): + self.visit(ctx.traversalSource()) + + # 访问起始步骤，例如 g.V() 或 g.addV() + if ctx.traversalSourceSpawnMethod(): + self.visit(ctx.traversalSourceSpawnMethod()) + + # 如果后面跟着链式调用，访问它们 + if ctx.chainedTraversal(): + self.visit(ctx.chainedTraversal()) + + def visitTraversalSource(self, ctx: GremlinParser.TraversalSourceContext): + """访问traversalSource，处理配置方法如with""" + # 递归访问嵌套的traversalSource + if ctx.traversalSource(): + self.visit(ctx.traversalSource()) + + # 访问selfMethod（如with） + if ctx.traversalSourceSelfMethod(): + self.visit(ctx.traversalSourceSelfMethod()) + + def visitChainedTraversal(self, ctx: GremlinParser.ChainedTraversalContext): + # 对于 a.b.c 这样的链，递归访问 a，然后访问 b + if ctx.chainedTraversal(): + self.visit(ctx.chainedTraversal()) + if ctx.traversalMethod(): + self.visit(ctx.traversalMethod()) + + # 动作类访问器 (添加 Step) + def visitTraversalSourceSpawnMethod_V(self, ctx: GremlinParser.TraversalSourceSpawnMethod_VContext): + params = self.visit(ctx.genericArgumentVarargs()) if ctx.genericArgumentVarargs() else [] + self.traversal.add_step(Step("V", params)) + + def visitTraversalSourceSpawnMethod_addV(self, ctx: GremlinParser.TraversalSourceSpawnMethod_addVContext): + params = [] + if ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + self.traversal.add_step(Step("addV", params)) + + def visitTraversalMethod_out(self, ctx: GremlinParser.TraversalMethod_outContext): + params = [] + varargs_ctx = ctx.stringNullableArgumentVarargs() + if varargs_ctx: + result = self.visit(varargs_ctx) + if result is not None: + params = result + self.traversal.add_step(Step("out", params)) + + def visitTraversalMethod_limit_long(self, ctx: GremlinParser.TraversalMethod_limit_longContext): + limit_val = self.visit(ctx.integerArgument()) + self.traversal.add_step(Step("limit", [limit_val])) + + def visitTraversalMethod_has_String_Object(self, ctx): + key = self.visit(ctx.stringNullableLiteral()) + value = self.visit(ctx.genericArgument()) + self.traversal.add_step(Step("has", [key, value])) + + def visitTraversalMethod_has_String_P(self, ctx): + key = self.visit(ctx.stringNullableLiteral()) + predicate = self.visit(ctx.traversalPredicate()) + self.traversal.add_step(Step("has", [key, predicate])) + + def visitTraversalMethod_has_String_String_Object(self, ctx): + label = self.visit(ctx.stringNullableArgument()) + key = self.visit(ctx.stringNullableLiteral()) + value = self.visit(ctx.genericArgument()) + self.traversal.add_step(Step("has", [label, key, value])) + + def visitTraversalMethod_has_String(self, ctx): + key = self.visit(ctx.stringNullableLiteral()) + self.traversal.add_step(Step("has", [key])) + + def visitTraversalMethod_has_String_String_P(self, ctx): + label = self.visit(ctx.stringNullableArgument()) + key = self.visit(ctx.stringNullableLiteral()) + predicate = self.visit(ctx.traversalPredicate()) + self.traversal.add_step(Step("has", [label, key, predicate])) + + def visitTraversalMethod_has_String_Traversal(self, ctx): + key = self.visit(ctx.stringNullableLiteral()) + traversal = self.visit(ctx.nestedTraversal()) + self.traversal.add_step(Step("has", [key, traversal])) + + def visitTraversalMethod_has_T_Object(self, ctx): + t_value = self.visit(ctx.traversalT()) + obj_value = self.visit(ctx.genericArgument()) + self.traversal.add_step(Step("has", [t_value, obj_value])) + + def visitTraversalMethod_has_T_P(self, ctx): + t_value = self.visit(ctx.traversalT()) + predicate = self.visit(ctx.traversalPredicate()) + self.traversal.add_step(Step("has", [t_value, predicate])) + + def visitTraversalMethod_has_T_Traversal(self, ctx): + t_value = self.visit(ctx.traversalT()) + traversal = self.visit(ctx.nestedTraversal()) + self.traversal.add_step(Step("has", [t_value, traversal])) + + def visitTraversalMethod_property_Object_Object_Object(self, ctx): + """处理property(key, value, ...)方法""" + params = [] + if ctx.genericArgument(0): + params.append(self.visit(ctx.genericArgument(0))) + if ctx.genericArgument(1): + params.append(self.visit(ctx.genericArgument(1))) + # 处理可选的额外参数 + if hasattr(ctx, "genericArgumentVarargs") and ctx.genericArgumentVarargs(): + varargs = self.visit(ctx.genericArgumentVarargs()) + if varargs: + params.extend(varargs) + self.traversal.add_step(Step("property", params)) + + def visitTraversalMethod_property_Object(self, ctx): + """处理property(map)方法""" + params = [] + if hasattr(ctx, "genericMapNullableArgument") and ctx.genericMapNullableArgument(): + params.append(self.visit(ctx.genericMapNullableArgument())) + self.traversal.add_step(Step("property", params)) + + def visitTraversalMethod_property_Cardinality_Object_Object_Object(self, ctx): + """处理property(cardinality, key, value, ...)方法""" + params = [] + if hasattr(ctx, "traversalCardinality") and ctx.traversalCardinality(): + params.append(self.visit(ctx.traversalCardinality())) + if ctx.genericArgument(0): + params.append(self.visit(ctx.genericArgument(0))) + if ctx.genericArgument(1): + params.append(self.visit(ctx.genericArgument(1))) + # 处理可选的额外参数 + if hasattr(ctx, "genericArgumentVarargs") and ctx.genericArgumentVarargs(): + varargs = self.visit(ctx.genericArgumentVarargs()) + if varargs: + params.extend(varargs) + self.traversal.add_step(Step("property", params)) + + def visitTraversalMethod_property_Cardinality_Object(self, ctx): + """处理property(cardinality, map)方法""" + params = [] + if hasattr(ctx, "traversalCardinality") and ctx.traversalCardinality(): + params.append(self.visit(ctx.traversalCardinality())) + if hasattr(ctx, "genericMapNullableArgument") and ctx.genericMapNullableArgument(): + params.append(self.visit(ctx.genericMapNullableArgument())) + self.traversal.add_step(Step("property", params)) + + def visitTraversalCardinality(self, ctx): + """处理traversalCardinality""" + # traversalCardinality包含类型和值，例如: Cardinality.list('multi') + text = ctx.getText() + # 提取cardinality类型 + if "list" in text.lower(): + card_type = "list" + elif "set" in text.lower(): + card_type = "set" + elif "single" in text.lower(): + card_type = "single" + else: + card_type = text + + # 提取值（如果有genericLiteral） + if hasattr(ctx, "genericLiteral") and ctx.genericLiteral(): + value = self.visit(ctx.genericLiteral()) + return {"type": card_type, "value": value} + else: + return card_type + + def visitTraversalMethod_values(self, ctx: GremlinParser.TraversalMethod_valuesContext): + params = self.visit(ctx.stringNullableLiteralVarargs()) if ctx.stringNullableLiteralVarargs() else [] + self.traversal.add_step(Step("values", params)) + + # 值提取访问器 + def visitStringLiteral(self, ctx: GremlinParser.StringLiteralContext) -> str: + return ctx.getText().strip("'\"") + + def visitIntegerLiteral(self, ctx: GremlinParser.IntegerLiteralContext) -> int: + text = ctx.getText().lower().rstrip("l") + return int(text) + + def visitGenericArgumentVarargs(self, ctx: GremlinParser.GenericArgumentVarargsContext) -> list: + if ctx is None: + return [] + args = [] + # 使用 genericArgument() 方法获取所有参数 + for i in range(len(ctx.genericArgument())): + args.append(self.visit(ctx.genericArgument(i))) + return args + + def visitStringNullableArgumentVarargs(self, ctx: GremlinParser.StringNullableArgumentVarargsContext) -> list: + if ctx is None: + return [] + args = [] + if ctx.children: + for child in ctx.children: + if isinstance(child, GremlinParser.StringNullableArgumentContext): + args.append(self.visit(child)) + return args + + def visitTraversalPredicate_gt(self, ctx: GremlinParser.TraversalPredicate_gtContext): + value = self.visit(ctx.genericArgument()) + return Predicate("gt", value) + + def visitTraversalPredicate_within(self, ctx: GremlinParser.TraversalPredicate_withinContext): + values = self.visit(ctx.genericArgumentVarargs()) + return Predicate("within", values) + + # 更多谓词的访问器 + def visitTraversalPredicate_lt(self, ctx): + value = self.visit(ctx.genericArgument()) + return Predicate("lt", value) + + def visitTraversalPredicate_lte(self, ctx): + value = self.visit(ctx.genericArgument()) + return Predicate("lte", value) + + def visitTraversalPredicate_gte(self, ctx): + value = self.visit(ctx.genericArgument()) + return Predicate("gte", value) + + def visitTraversalPredicate_eq(self, ctx): + value = self.visit(ctx.genericArgument()) + return Predicate("eq", value) + + def visitTraversalPredicate_neq(self, ctx): + value = self.visit(ctx.genericArgument()) + return Predicate("neq", value) + + def visitTraversalPredicate_between(self, ctx): + params = [] + if hasattr(ctx, "genericArgument"): + if ctx.genericArgument(0): + params.append(self.visit(ctx.genericArgument(0))) + if ctx.genericArgument(1): + params.append(self.visit(ctx.genericArgument(1))) + return Predicate("between", params) + + def visitTraversalPredicate_inside(self, ctx): + params = [] + if hasattr(ctx, "genericArgument"): + if ctx.genericArgument(0): + params.append(self.visit(ctx.genericArgument(0))) + if ctx.genericArgument(1): + params.append(self.visit(ctx.genericArgument(1))) + return Predicate("inside", params) + + def visitTraversalPredicate_outside(self, ctx): + params = [] + if hasattr(ctx, "genericArgument"): + if ctx.genericArgument(0): + params.append(self.visit(ctx.genericArgument(0))) + if ctx.genericArgument(1): + params.append(self.visit(ctx.genericArgument(1))) + return Predicate("outside", params) + + def visitTraversalPredicate_without(self, ctx): + values = self.visit(ctx.genericArgumentVarargs()) + return Predicate("without", values) + + # TextPredicate 访问器 + def visitTraversalPredicate_startingWith(self, ctx): + value = self.visit(ctx.stringArgument()) + return TextPredicate("startingWith", value) + + def visitTraversalPredicate_endingWith(self, ctx): + value = self.visit(ctx.stringArgument()) + return TextPredicate("endingWith", value) + + def visitTraversalPredicate_containing(self, ctx): + value = self.visit(ctx.stringArgument()) + return TextPredicate("containing", value) + + def visitTraversalPredicate_notStartingWith(self, ctx): + value = self.visit(ctx.stringArgument()) + return TextPredicate("notStartingWith", value) + + def visitTraversalPredicate_notEndingWith(self, ctx): + value = self.visit(ctx.stringArgument()) + return TextPredicate("notEndingWith", value) + + def visitTraversalPredicate_notContaining(self, ctx): + value = self.visit(ctx.stringArgument()) + return TextPredicate("notContaining", value) + + def visitTraversalPredicate_not(self, ctx): + """处理 not() 谓词 - 否定另一个谓词""" + # not() 接受另一个谓词作为参数 + if hasattr(ctx, "traversalPredicate") and ctx.traversalPredicate(): + inner_predicate = self.visit(ctx.traversalPredicate()) + # 返回一个否定的谓词 + # 注意：这里需要特殊处理，因为 not() 包装了另一个谓词 + return Predicate("not", inner_predicate) + return None + + def visitTraversalPredicate_regex(self, ctx): + """处理 regex() 谓词 - 正则表达式匹配""" + value = self.visit(ctx.stringArgument()) + return TextPredicate("regex", value) + + def visitTraversalPredicate_notRegex(self, ctx): + """处理 notRegex() 谓词 - 不匹配正则表达式""" + value = self.visit(ctx.stringArgument()) + return TextPredicate("notRegex", value) + + # 匿名遍历和嵌套遍历访问器 + def visitNestedTraversal(self, ctx: GremlinParser.NestedTraversalContext): + # 创建一个新的匿名遍历 + anonymous_traversal = AnonymousTraversal() + + # 保存当前遍历状态 + current_traversal = self.traversal + + # 创建临时遍历来收集匿名遍历的步骤 + temp_traversal = Traversal() + self.traversal = temp_traversal + + # 访问嵌套遍历的内容 + if ctx.chainedTraversal(): + self.visit(ctx.chainedTraversal()) + + # 将临时遍历的步骤添加到匿名遍历中 + for step in temp_traversal.steps: + anonymous_traversal.add_step(step) + + # 恢复原始遍历状态 + self.traversal = current_traversal + + return anonymous_traversal + + def visitNestedTraversalVarargs(self, ctx): + if ctx is None: + return [] + + traversals = [] + for child in ctx.children: + if isinstance(child, GremlinParser.NestedTraversalContext): + traversals.append(self.visit(child)) + return traversals + + # 连接器访问器 (and, or) + def visitTraversalMethod_and(self, ctx): + params = [] + if hasattr(ctx, "nestedTraversalList") and ctx.nestedTraversalList(): + traversals = self.visit(ctx.nestedTraversalList()) + if traversals: + # and接受多个遍历作为参数 + params.extend(traversals) + self.traversal.add_step(Step("and", params)) + + def visitTraversalMethod_or(self, ctx): + params = [] + if hasattr(ctx, "nestedTraversalList") and ctx.nestedTraversalList(): + traversals = self.visit(ctx.nestedTraversalList()) + if traversals: + # or接受多个遍历作为参数 + params.extend(traversals) + self.traversal.add_step(Step("or", params)) + + # 分支和条件方法 + def visitTraversalMethod_choose_Traversal(self, ctx): + """处理choose(traversal)方法""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("choose", params)) + + def visitTraversalMethod_coalesce(self, ctx): + """处理coalesce()方法""" + params = [] + if hasattr(ctx, "nestedTraversalList") and ctx.nestedTraversalList(): + params = self.visit(ctx.nestedTraversalList()) + elif hasattr(ctx, "nestedTraversalVarargs") and ctx.nestedTraversalVarargs(): + params = self.visit(ctx.nestedTraversalVarargs()) + self.traversal.add_step(Step("coalesce", params)) + + def visitTraversalMethod_optional(self, ctx): + """处理optional()方法""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("optional", params)) + + def visitTraversalMethod_union(self, ctx): + """处理union()方法""" + params = [] + if hasattr(ctx, "nestedTraversalList") and ctx.nestedTraversalList(): + params = self.visit(ctx.nestedTraversalList()) + elif hasattr(ctx, "nestedTraversalVarargs") and ctx.nestedTraversalVarargs(): + params = self.visit(ctx.nestedTraversalVarargs()) + self.traversal.add_step(Step("union", params)) + + # 循环和重复方法 + def visitTraversalMethod_repeat_Traversal(self, ctx): + """处理repeat(traversal)方法""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("repeat", params)) + + def visitTraversalMethod_repeat_String_Traversal(self, ctx): + """处理repeat(string, traversal)方法""" + params = [] + if hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("repeat", params)) + + def visitTraversalMethod_times(self, ctx): + """处理times()方法""" + params = [] + if hasattr(ctx, "integerLiteral") and ctx.integerLiteral(): + params.append(self.visit(ctx.integerLiteral())) + self.traversal.add_step(Step("times", params)) + + def visitTraversalMethod_until_Traversal(self, ctx): + """处理until(traversal)方法""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("until", params)) + + def visitTraversalMethod_until_Predicate(self, ctx): + """处理until(predicate)方法""" + params = [] + if hasattr(ctx, "traversalPredicate") and ctx.traversalPredicate(): + params.append(self.visit(ctx.traversalPredicate())) + self.traversal.add_step(Step("until", params)) + + def visitTraversalMethod_emit_Empty(self, ctx): + """处理无参数的emit()方法""" + self.traversal.add_step(Step("emit", [])) + + def visitTraversalMethod_emit_Predicate(self, ctx): + """处理emit(predicate)方法""" + params = [] + if hasattr(ctx, "traversalPredicate") and ctx.traversalPredicate(): + params.append(self.visit(ctx.traversalPredicate())) + self.traversal.add_step(Step("emit", params)) + + def visitTraversalMethod_emit_Traversal(self, ctx): + """处理emit(traversal)方法""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("emit", params)) + + # 终端方法访问器 + def visitTraversalTerminalMethod(self, ctx): + """处理终端方法的通用分发器""" + # 直接访问具体的终端方法子节点 + if ctx.traversalTerminalMethod_next(): + self.visit(ctx.traversalTerminalMethod_next()) + elif ctx.traversalTerminalMethod_hasNext(): + self.visit(ctx.traversalTerminalMethod_hasNext()) + elif ctx.traversalTerminalMethod_toList(): + self.visit(ctx.traversalTerminalMethod_toList()) + elif ctx.traversalTerminalMethod_toSet(): + self.visit(ctx.traversalTerminalMethod_toSet()) + elif ctx.traversalTerminalMethod_iterate(): + self.visit(ctx.traversalTerminalMethod_iterate()) + else: + # 尝试默认的visitChildren + return self.visitChildren(ctx) + + def visitTraversalTerminalMethod_next(self, ctx): + """处理next()终端方法，支持 next() 和 next(n)""" + params = [] + # 检查是否有整数参数 + if hasattr(ctx, "integerLiteral") and ctx.integerLiteral(): + params.append(self.visit(ctx.integerLiteral())) + else: + # 无参数版本，使用 Terminal 对象 + terminal = Terminal("next") + params.append(terminal) + self.traversal.add_step(Step("next", params)) + + def visitTraversalTerminalMethod_hasNext(self, ctx): + """处理hasNext()终端方法""" + terminal = Terminal("hasNext") + self.traversal.add_step(Step("hasNext", [terminal])) + + def visitTraversalTerminalMethod_toList(self, ctx): + """处理toList()终端方法""" + terminal = Terminal("toList") + self.traversal.add_step(Step("toList", [terminal])) + + def visitTraversalTerminalMethod_toSet(self, ctx): + """处理toSet()终端方法""" + terminal = Terminal("toSet") + self.traversal.add_step(Step("toSet", [terminal])) + + def visitTraversalTerminalMethod_iterate(self, ctx): + """处理iterate()终端方法""" + terminal = Terminal("iterate") + self.traversal.add_step(Step("iterate", [terminal])) + + def visitTraversalTerminalMethod_tryNext(self, ctx): + """处理tryNext()终端方法""" + terminal = Terminal("tryNext") + self.traversal.add_step(Step("tryNext", [terminal])) + + def visitTraversalTerminalMethod_explain(self, ctx): + """处理explain()终端方法 - 显示执行计划""" + terminal = Terminal("explain") + self.traversal.add_step(Step("explain", [terminal])) + + # 去重和其他方法 + + # Context方法 - 终端方法的Context版本 + def visitTraversalTerminalMethodContext(self, ctx): + """处理终端方法Context - 委托给visitTraversalTerminalMethod""" + return self.visitTraversalTerminalMethod(ctx) + + def visitTraversalTerminalMethod_nextContext(self, ctx): + """处理next()终端方法Context""" + return self.visitTraversalTerminalMethod_next(ctx) + + def visitTraversalTerminalMethod_hasNextContext(self, ctx): + """处理hasNext()终端方法Context""" + return self.visitTraversalTerminalMethod_hasNext(ctx) + + def visitTraversalTerminalMethod_toListContext(self, ctx): + """处理toList()终端方法Context""" + return self.visitTraversalTerminalMethod_toList(ctx) + + def visitTraversalTerminalMethod_toSetContext(self, ctx): + """处理toSet()终端方法Context""" + return self.visitTraversalTerminalMethod_toSet(ctx) + + def visitTraversalTerminalMethod_iterateContext(self, ctx): + """处理iterate()终端方法Context""" + return self.visitTraversalTerminalMethod_iterate(ctx) + + def visitTraversalTerminalMethod_tryNextContext(self, ctx): + """处理tryNext()终端方法Context""" + return self.visitTraversalTerminalMethod_tryNext(ctx) + + def visitTraversalMethod_valueMap_String(self, ctx): + """处理valueMap(string)方法""" + params = [] + if hasattr(ctx, "stringNullableLiteralVarargs") and ctx.stringNullableLiteralVarargs(): + params = self.visit(ctx.stringNullableLiteralVarargs()) + self.traversal.add_step(Step("valueMap", params)) + + def visitTraversalMethod_valueMap_boolean_String(self, ctx): + """处理valueMap(boolean, string)方法""" + params = [] + if hasattr(ctx, "booleanLiteral") and ctx.booleanLiteral(): + params.append(self.visit(ctx.booleanLiteral())) + if hasattr(ctx, "stringNullableLiteralVarargs") and ctx.stringNullableLiteralVarargs(): + string_params = self.visit(ctx.stringNullableLiteralVarargs()) + if string_params: + params.extend(string_params) + self.traversal.add_step(Step("valueMap", params)) + + def visitTraversalMethod_valueMap_StringContext(self, ctx): + """处理valueMap(string)方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_dedup_String(self, ctx): + """处理dedup()方法""" + params = [] + if hasattr(ctx, "stringNullableLiteralVarargs") and ctx.stringNullableLiteralVarargs(): + params = self.visit(ctx.stringNullableLiteralVarargs()) + self.traversal.add_step(Step("dedup", params)) + + def visitTraversalMethod_path(self, ctx): + """处理path()方法""" + self.traversal.add_step(Step("path", [])) + + def visitTraversalMethod_as(self, ctx): + """处理as()方法""" + params = [] + if hasattr(ctx, "stringArgument") and ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + elif hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("as", params)) + + def visitTraversalMethod_select_String(self, ctx): + """处理select(string)方法""" + params = [] + if hasattr(ctx, "stringArgument") and ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + elif hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("select", params)) + + # 基础Context方法 - 这些是ANTLR visitor模式必需的 + def visitQueryContext(self, ctx): + """处理查询的根Context""" + return self.visitChildren(ctx) + + def visitRootTraversalContext(self, ctx): + """处理根遍历Context""" + return self.visitChildren(ctx) + + def visitTraversalSourceContext(self, ctx): + """处理遍历源Context""" + return self.visitChildren(ctx) + + def visitTraversalSourceSpawnMethodContext(self, ctx): + """处理遍历源生成方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethodContext(self, ctx): + """处理遍历方法Context""" + return self.visitChildren(ctx) + + def visitChainedTraversalContext(self, ctx): + """处理链式遍历Context""" + return self.visitChildren(ctx) + + # 参数和字面量Context方法 + def visitGenericArgumentVarargsContext(self, ctx): + """处理通用参数变长列表""" + return self.visitChildren(ctx) + + def visitStringLiteralContext(self, ctx): + """处理字符串字面量""" + return ctx.getText().strip("'\"") + + def visitIntegerLiteralContext(self, ctx): + """处理整数字面量""" + text = ctx.getText().lower().rstrip("l") + return int(text) + + def visitFloatLiteralContext(self, ctx): + """处理浮点数字面量""" + return float(ctx.getText()) + + def visitGenericLiteralContext(self, ctx): + """处理通用字面量""" + return self.visitChildren(ctx) + + def visitNumericLiteralContext(self, ctx): + """处理数值字面量""" + return self.visitChildren(ctx) + + def visitStringArgumentContext(self, ctx): + """处理字符串参数""" + return self.visitChildren(ctx) + + def visitIntegerArgumentContext(self, ctx): + """处理整数参数""" + return self.visitChildren(ctx) + + def visitFloatArgumentContext(self, ctx): + """处理浮点数参数""" + return self.visitChildren(ctx) + + def visitGenericArgumentContext(self, ctx): + """处理通用参数""" + return self.visitChildren(ctx) + + def visitStringNullableLiteralContext(self, ctx): + """处理可空字符串字面量""" + if ctx.getText() == "null": + return None + return ctx.getText().strip("'\"") + + def visitStringNullableLiteralVarargsContext(self, ctx): + """处理可空字符串字面量变长列表""" + return self.visitChildren(ctx) + + def visitStringNullableArgumentContext(self, ctx): + """处理可空字符串参数""" + return self.visitChildren(ctx) + + def visitStringNullableArgumentVarargsContext(self, ctx): + """处理可空字符串参数变长列表""" + return self.visitChildren(ctx) + + # 其他重要方法 + def visitTraversalMethod_identity(self, ctx): + """处理identity()方法""" + self.traversal.add_step(Step("identity", [])) + + def visitTraversalMethod_barrier_Empty(self, ctx): + """处理无参数的barrier()方法""" + self.traversal.add_step(Step("barrier", [])) + + def visitTraversalMethod_constant(self, ctx): + """处理constant()方法""" + params = [] + if hasattr(ctx, "genericArgument") and ctx.genericArgument(): + params.append(self.visit(ctx.genericArgument())) + self.traversal.add_step(Step("constant", params)) + + def visitTraversalMethod_math(self, ctx): + """处理math()方法""" + params = [] + if hasattr(ctx, "stringArgument") and ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + elif hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("math", params)) + + def visitTraversalMethod_timeLimit(self, ctx): + """处理timeLimit()方法""" + params = [] + if hasattr(ctx, "integerArgument") and ctx.integerArgument(): + params.append(self.visit(ctx.integerArgument())) + self.traversal.add_step(Step("timeLimit", params)) + + def visitTraversalMethod_subgraph(self, ctx): + """处理subgraph()方法""" + params = [] + if hasattr(ctx, "stringArgument") and ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + elif hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("subgraph", params)) + + def visitTraversalMethod_cyclicPath(self, ctx): + """处理cyclicPath()方法""" + self.traversal.add_step(Step("cyclicPath", [])) + + def visitTraversalMethod_simplePath(self, ctx): + """处理simplePath()方法""" + self.traversal.add_step(Step("simplePath", [])) + + def visitTraversalMethod_match(self, ctx): + """处理match()方法""" + params = [] + if hasattr(ctx, "nestedTraversalList") and ctx.nestedTraversalList(): + params = self.visit(ctx.nestedTraversalList()) + self.traversal.add_step(Step("match", params)) + + # 高级转换和映射方法 + def visitTraversalMethod_map(self, ctx): + """处理map()方法 - 将对象转换为另一个对象""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("map", params)) + + def visitTraversalMethod_local(self, ctx): + """处理local()方法 - 将遍历应用于遍历器内部的对象""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("local", params)) + + # 副作用和聚合方法 + def visitTraversalMethod_aggregate_String(self, ctx): + """处理aggregate(string)方法 - 收集结果到副作用集合""" + params = [] + if hasattr(ctx, "stringArgument") and ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + elif hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("aggregate", params)) + + def visitTraversalMethod_aggregate_Scope_String(self, ctx): + """处理aggregate(scope, string)方法""" + params = [] + if hasattr(ctx, "traversalScope") and ctx.traversalScope(): + params.append(self.visit(ctx.traversalScope())) + if hasattr(ctx, "stringArgument") and ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + elif hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("aggregate", params)) + + def visitTraversalMethod_store(self, ctx): + """处理store()方法 - 惰性地收集遍历器到副作用集合""" + params = [] + if hasattr(ctx, "stringArgument") and ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + elif hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("store", params)) + + def visitTraversalMethod_sideEffect(self, ctx): + """处理sideEffect()方法 - 执行副作用操作""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("sideEffect", params)) + + def visitTraversalMethod_cap(self, ctx): + """处理cap()方法 - 从副作用中发射内容""" + params = [] + if hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + if hasattr(ctx, "stringNullableLiteralVarargs") and ctx.stringNullableLiteralVarargs(): + varargs = self.visit(ctx.stringNullableLiteralVarargs()) + if varargs: + params.extend(varargs) + self.traversal.add_step(Step("cap", params)) + + # Sack方法 - 管理遍历器私有值 + def visitTraversalMethod_sack_Empty(self, ctx): + """处理无参数的sack()方法""" + self.traversal.add_step(Step("sack", [])) + + def visitTraversalMethod_sack_BiFunction(self, ctx): + """处理sack(biFunction)方法""" + params = [] + if hasattr(ctx, "traversalBiFunction") and ctx.traversalBiFunction(): + params.append(self.visit(ctx.traversalBiFunction())) + self.traversal.add_step(Step("sack", params)) + + # 图算法方法 + def visitTraversalMethod_pageRank_Empty(self, ctx): + """处理无参数的pageRank()方法""" + self.traversal.add_step(Step("pageRank", [])) + + def visitTraversalMethod_pageRank_double(self, ctx): + """处理pageRank(double)方法""" + params = [] + if hasattr(ctx, "floatArgument") and ctx.floatArgument(): + params.append(self.visit(ctx.floatArgument())) + self.traversal.add_step(Step("pageRank", params)) + + def visitTraversalMethod_peerPressure(self, ctx): + """处理peerPressure()方法 - 标签传播算法""" + self.traversal.add_step(Step("peerPressure", [])) + + def visitTraversalMethod_connectedComponent(self, ctx): + """处理connectedComponent()方法 - 查找连通分量""" + self.traversal.add_step(Step("connectedComponent", [])) + + def visitTraversalMethod_shortestPath(self, ctx): + """处理shortestPath()方法 - 计算最短路径""" + self.traversal.add_step(Step("shortestPath", [])) + + # 树和层级结构方法 + def visitTraversalMethod_tree_Empty(self, ctx): + """处理无参数的tree()方法""" + self.traversal.add_step(Step("tree", [])) + + def visitTraversalMethod_tree_String(self, ctx): + """处理tree(string)方法""" + params = [] + if hasattr(ctx, "stringArgument") and ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + elif hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("tree", params)) + + # 调试和分析方法 + def visitTraversalMethod_profile_Empty(self, ctx): + """处理无参数的profile()方法""" + self.traversal.add_step(Step("profile", [])) + + def visitTraversalMethod_profile_String(self, ctx): + """处理profile(string)方法""" + params = [] + if hasattr(ctx, "stringArgument") and ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + elif hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("profile", params)) + + # 循环控制方法 + def visitTraversalMethod_loops_Empty(self, ctx): + """处理无参数的loops()方法""" + self.traversal.add_step(Step("loops", [])) + + def visitTraversalMethod_loops_String(self, ctx): + """处理loops(string)方法""" + params = [] + if hasattr(ctx, "stringArgument") and ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + elif hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("loops", params)) + + # 嵌套遍历Context方法 - 委托给原有的visitNestedTraversal实现 + def visitNestedTraversalContext(self, ctx): + """处理嵌套遍历Context - 委托给visitNestedTraversal""" + # 直接调用原有的visitNestedTraversal方法 + return self.visitNestedTraversal(ctx) + + def visitNestedTraversalExpr(self, ctx): + """处理嵌套遍历表达式 - 返回多个嵌套遍历的列表""" + result = [] + # nestedTraversalExpr包含多个nestedTraversal，用逗号分隔 + if hasattr(ctx, "nestedTraversal"): + nested_traversals = ctx.nestedTraversal() + if isinstance(nested_traversals, list): + for nt in nested_traversals: + result.append(self.visit(nt)) + else: + result.append(self.visit(nested_traversals)) + return result + + def visitNestedTraversalExprContext(self, ctx): + """处理嵌套遍历表达式Context""" + return self.visitNestedTraversalExpr(ctx) + + def visitNestedTraversalList(self, ctx): + """处理嵌套遍历列表 - 可能包含0个或多个嵌套遍历""" + # nestedTraversalList包含一个可选的nestedTraversalExpr + if hasattr(ctx, "nestedTraversalExpr") and ctx.nestedTraversalExpr(): + return self.visit(ctx.nestedTraversalExpr()) + return [] + + def visitNestedTraversalListContext(self, ctx): + """处理嵌套遍历列表Context""" + return self.visitNestedTraversalList(ctx) + + # 谓词和比较器Context方法 + def visitTraversalPredicateContext(self, ctx): + """处理遍历谓词Context""" + return self.visitChildren(ctx) + + def visitTraversalPredicate_gtContext(self, ctx): + """处理gt谓词Context""" + return self.visitChildren(ctx) + + def visitTraversalComparatorContext(self, ctx): + """处理遍历比较器Context""" + return self.visitChildren(ctx) + + def visitTraversalOrderContext(self, ctx): + """处理遍历排序Context""" + return self.visitChildren(ctx) + + # 更多具体方法的Context版本 + def visitTraversalMethod_count_EmptyContext(self, ctx): + """处理count()空参数Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_sum_EmptyContext(self, ctx): + """处理sum()空参数Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_mean_EmptyContext(self, ctx): + """处理mean()空参数Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_max_EmptyContext(self, ctx): + """处理max()空参数Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_min_EmptyContext(self, ctx): + """处理min()空参数Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_fold_EmptyContext(self, ctx): + """处理fold()空参数Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_order_EmptyContext(self, ctx): + """处理order()空参数Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_group_EmptyContext(self, ctx): + """处理group()空参数Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_group_StringContext(self, ctx): + """处理group(string)带标签参数Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_groupCount_EmptyContext(self, ctx): + """处理groupCount()空参数Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_groupCount_StringContext(self, ctx): + """处理groupCount(string)带标签参数Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_by_StringContext(self, ctx): + """处理by(string)Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_by_String_ComparatorContext(self, ctx): + """处理by(string, comparator)Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_by_TraversalContext(self, ctx): + """处理by(traversal)Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_dedup_StringContext(self, ctx): + """处理dedup()Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_pathContext(self, ctx): + """处理path()Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_asContext(self, ctx): + """处理as()Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_select_StringContext(self, ctx): + """处理select(string)Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_select_String_String_StringContext(self, ctx): + """处理select(string, string, string)Context""" + return self.visitChildren(ctx) + + # 剩余的缺失方法 + def visitTraversalMethod_barrier_EmptyContext(self, ctx): + """处理barrier()空参数Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_choose_TraversalContext(self, ctx): + """处理choose(traversal)Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_coalesceContext(self, ctx): + """处理coalesce()Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_constantContext(self, ctx): + """处理constant()Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_cyclicPathContext(self, ctx): + """处理cyclicPath()Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_emit_EmptyContext(self, ctx): + """处理emit()空参数Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_hasLabel_String_StringContext(self, ctx): + """处理hasLabel(string, string)Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_has_String_ObjectContext(self, ctx): + """处理has(string, object)Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_has_String_PContext(self, ctx): + """处理has(string, predicate)Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_identityContext(self, ctx): + """处理identity()Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_matchContext(self, ctx): + """处理match()Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_mathContext(self, ctx): + """处理math()Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_optionalContext(self, ctx): + """处理optional()Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_range_long_longContext(self, ctx): + """处理range(long, long)Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_repeat_TraversalContext(self, ctx): + """处理repeat(traversal)Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_sample_intContext(self, ctx): + """处理sample(int)Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_simplePathContext(self, ctx): + """处理simplePath()Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_skip_longContext(self, ctx): + """处理skip(long)Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_subgraphContext(self, ctx): + """处理subgraph()Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_tail_longContext(self, ctx): + """处理tail(long)Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_timeLimitContext(self, ctx): + """处理timeLimit()Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_timesContext(self, ctx): + """处理times()Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_unionContext(self, ctx): + """处理union()Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_until_TraversalContext(self, ctx): + """处理until(traversal)Context""" + return self.visitChildren(ctx) + + # 更多具体的Context方法 + def visitTraversalSourceSpawnMethod_VContext(self, ctx): + """处理V()生成方法Context""" + return self.visitChildren(ctx) + + def visitTraversalSourceSpawnMethod_EContext(self, ctx): + """处理E()生成方法Context""" + return self.visitChildren(ctx) + + def visitTraversalSourceSpawnMethod_addVContext(self, ctx): + """处理addV()生成方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_outContext(self, ctx): + """处理out()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_inEContext(self, ctx): + """处理inE()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_outEContext(self, ctx): + """处理outE()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_bothEContext(self, ctx): + """处理bothE()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_inVContext(self, ctx): + """处理inV()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_outVContext(self, ctx): + """处理outV()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_bothVContext(self, ctx): + """处理bothV()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_idContext(self, ctx): + """处理id()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_labelContext(self, ctx): + """处理label()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_keyContext(self, ctx): + """处理key()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_valueContext(self, ctx): + """处理value()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_valuesContext(self, ctx): + """处理values()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_propertiesContext(self, ctx): + """处理properties()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_elementMapContext(self, ctx): + """处理elementMap()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_dropContext(self, ctx): + """处理drop()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_addE_StringContext(self, ctx): + """处理addE(string)方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_property_Object_Object_ObjectContext(self, ctx): + """处理property()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_limit_longContext(self, ctx): + """处理limit()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_coinContext(self, ctx): + """处理coin()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalMethod_unfoldContext(self, ctx): + """处理unfold()方法Context""" + return self.visitChildren(ctx) + + def visitTraversalSourceSpawnMethod_E(self, ctx: GremlinParser.TraversalSourceSpawnMethod_EContext): + params = self.visit(ctx.genericArgumentVarargs()) if ctx.genericArgumentVarargs() else [] + self.traversal.add_step(Step("E", params)) + + def visitTraversalSourceSpawnMethod_addE(self, ctx: GremlinParser.TraversalSourceSpawnMethod_addEContext): + params = [] + if ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + elif ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("addE", params)) + + def visitTraversalSourceSpawnMethod_inject(self, ctx: GremlinParser.TraversalSourceSpawnMethod_injectContext): + params = self.visit(ctx.genericArgumentVarargs()) if ctx.genericArgumentVarargs() else [] + self.traversal.add_step(Step("inject", params)) + + # Call方法的各种变体支持 + def visitTraversalSourceSpawnMethod_call_empty( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_emptyContext + ): + """处理 g.call() 空参数调用""" + self.traversal.add_step(Step("call", [])) + + def visitTraversalSourceSpawnMethod_call_string( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_stringContext + ): + """处理 g.call('methodName') 单字符串参数调用""" + params = [] + # 查找StringLiteralContext子节点 + for child in ctx.children: + if hasattr(child, "getRuleIndex") and "StringLiteral" in type(child).__name__: + string_val = child.getText() + # 移除引号 + if (string_val.startswith('"') and string_val.endswith('"')) or ( + string_val.startswith("'") and string_val.endswith("'") + ): + string_val = string_val[1:-1] + params.append(string_val) + break + self.traversal.add_step(Step("call", params)) + + def visitTraversalSourceSpawnMethod_call_string_map( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_string_mapContext + ): + """处理 g.call('methodName', map) 字符串+映射参数调用""" + params = [] + if ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + if ctx.genericLiteralMap(): + params.append(self.visit(ctx.genericLiteralMap())) + self.traversal.add_step(Step("call", params)) + + def visitTraversalSourceSpawnMethod_call_string_traversal( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_string_traversalContext + ): + """处理 g.call('methodName', traversal) 字符串+遍历参数调用""" + params = [] + if ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + if ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("call", params)) + + def visitTraversalSourceSpawnMethod_call_string_map_traversal( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_string_map_traversalContext + ): + """处理 g.call('methodName', map, traversal) 字符串+映射+遍历参数调用""" + params = [] + if ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + if ctx.genericLiteralMap(): + params.append(self.visit(ctx.genericLiteralMap())) + if ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("call", params)) + + def visitTraversalSourceSpawnMethod_io(self, ctx: GremlinParser.TraversalSourceSpawnMethod_ioContext): + params = [] + if ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("io", params)) + + # 辅助方法访问器 + def visitStringArgument(self, ctx: GremlinParser.StringArgumentContext): + if ctx.stringLiteral(): + return self.visit(ctx.stringLiteral()) + elif ctx.stringNullableLiteral(): + return self.visit(ctx.stringNullableLiteral()) + return None + + def visitStringNullableLiteral(self, ctx: GremlinParser.StringNullableLiteralContext): + if ctx.EmptyStringLiteral(): + return "" + elif ctx.NonEmptyStringLiteral(): + text = ctx.NonEmptyStringLiteral().getText() + return text.strip("'\"") + elif ctx.K_NULL(): + return None + return None + + def visitStringNullableArgument(self, ctx: GremlinParser.StringNullableArgumentContext): + if ctx.stringNullableLiteral(): + return self.visit(ctx.stringNullableLiteral()) + elif ctx.variable(): + return self.visit(ctx.variable()) + return None + + def visitGenericArgument(self, ctx: GremlinParser.GenericArgumentContext): + if ctx.genericLiteral(): + return self.visit(ctx.genericLiteral()) + elif ctx.variable(): + return self.visit(ctx.variable()) + return None + + def visitIntegerArgument(self, ctx: GremlinParser.IntegerArgumentContext): + if ctx.integerLiteral(): + return self.visit(ctx.integerLiteral()) + return 0 + + def visitFloatLiteral(self, ctx: GremlinParser.FloatLiteralContext) -> float: + text = ctx.getText().lower().rstrip("f").rstrip("d") + return float(text) + + def visitBooleanLiteral(self, ctx: GremlinParser.BooleanLiteralContext) -> bool: + text = ctx.getText().lower() + return text == "true" + + def visitNullLiteral(self, ctx: GremlinParser.NullLiteralContext): + return None + + def visitGenericLiteral(self, ctx: GremlinParser.GenericLiteralContext): + # 处理通用字面量，可能是字符串、数字等 + text = ctx.getText() + # 尝试解析为不同类型 + if text.startswith('"') or text.startswith("'"): + return text.strip("'\"") + try: + if "." in text: + return float(text) + else: + return int(text) + except ValueError: + return text + + def visitVariable(self, ctx: GremlinParser.VariableContext): + # 变量通常以 $ 开头，返回变量名 + return ctx.getText() + + def visitTraversalT(self, ctx): + # T 枚举值，如 T.id, T.label, T.key, T.value + return ctx.getText() + + def visitStringNullableLiteralVarargs(self, ctx: GremlinParser.StringNullableLiteralVarargsContext) -> list: + if ctx is None: + return [] + args = [] + # 使用 stringNullableLiteral() 方法获取所有参数 + for i in range(len(ctx.stringNullableLiteral())): + args.append(self.visit(ctx.stringNullableLiteral(i))) + return args + + def visitFloatArgument(self, ctx): + if hasattr(ctx, "floatLiteral") and ctx.floatLiteral(): + return self.visit(ctx.floatLiteral()) + return 0.0 + + def visitBooleanArgument(self, ctx): + if hasattr(ctx, "booleanLiteral") and ctx.booleanLiteral(): + return self.visit(ctx.booleanLiteral()) + return False + + def visitTraversalPredicate(self, ctx): + # 通用的谓词访问器，根据具体类型调用相应的方法 + # 避免无限递归，直接调用默认的 visitChildren + return self.visitChildren(ctx) + + # 导航方法访问器 + def visitTraversalMethod_in(self, ctx: GremlinParser.TraversalMethod_inContext): + params = [] + if ctx.stringNullableArgumentVarargs(): + result = self.visit(ctx.stringNullableArgumentVarargs()) + if result is not None: + params = result + self.traversal.add_step(Step("in", params)) + + def visitTraversalMethod_both(self, ctx: GremlinParser.TraversalMethod_bothContext): + params = [] + if ctx.stringNullableArgumentVarargs(): + result = self.visit(ctx.stringNullableArgumentVarargs()) + if result is not None: + params = result + self.traversal.add_step(Step("both", params)) + + def visitTraversalMethod_bothE(self, ctx: GremlinParser.TraversalMethod_bothEContext): + params = [] + if ctx.stringNullableArgumentVarargs(): + result = self.visit(ctx.stringNullableArgumentVarargs()) + if result is not None: + params = result + self.traversal.add_step(Step("bothE", params)) + + def visitTraversalMethod_bothV(self, ctx: GremlinParser.TraversalMethod_bothVContext): + self.traversal.add_step(Step("bothV", [])) + + def visitTraversalMethod_inE(self, ctx: GremlinParser.TraversalMethod_inEContext): + params = [] + if ctx.stringNullableArgumentVarargs(): + result = self.visit(ctx.stringNullableArgumentVarargs()) + if result is not None: + params = result + self.traversal.add_step(Step("inE", params)) + + def visitTraversalMethod_outE(self, ctx: GremlinParser.TraversalMethod_outEContext): + params = [] + if ctx.stringNullableArgumentVarargs(): + result = self.visit(ctx.stringNullableArgumentVarargs()) + if result is not None: + params = result + self.traversal.add_step(Step("outE", params)) + + def visitTraversalMethod_inV(self, ctx: GremlinParser.TraversalMethod_inVContext): + self.traversal.add_step(Step("inV", [])) + + def visitTraversalMethod_outV(self, ctx: GremlinParser.TraversalMethod_outVContext): + self.traversal.add_step(Step("outV", [])) + + def visitTraversalMethod_otherV(self, ctx: GremlinParser.TraversalMethod_otherVContext): + self.traversal.add_step(Step("otherV", [])) + + # 更多过滤方法访问器 + # where的特定变体（删除了冗余的通用方法） + def visitTraversalMethod_where_P(self, ctx): + """where(Predicate)变体""" + params = [] + if hasattr(ctx, "traversalPredicate") and ctx.traversalPredicate(): + params.append(self.visit(ctx.traversalPredicate())) + self.traversal.add_step(Step("where", params)) + + def visitTraversalMethod_where_String_P(self, ctx): + """where(String, Predicate)变体""" + params = [] + if hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + if hasattr(ctx, "traversalPredicate") and ctx.traversalPredicate(): + params.append(self.visit(ctx.traversalPredicate())) + self.traversal.add_step(Step("where", params)) + + def visitTraversalMethod_where_Traversal(self, ctx): + """where(Traversal)变体 - 接受嵌套遍历""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("where", params)) + + # filter的特定变体（删除了冗余的通用方法） + def visitTraversalMethod_filter_Predicate(self, ctx): + """filter(Predicate)变体""" + params = [] + if hasattr(ctx, "traversalPredicate") and ctx.traversalPredicate(): + params.append(self.visit(ctx.traversalPredicate())) + self.traversal.add_step(Step("filter", params)) + + def visitTraversalMethod_filter_Traversal(self, ctx): + """filter(Traversal)变体 - 接受嵌套遍历""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("filter", params)) + + def visitTraversalMethod_is(self, ctx): + params = [] + if hasattr(ctx, "genericArgument") and ctx.genericArgument(): + params.append(self.visit(ctx.genericArgument())) + elif hasattr(ctx, "traversalPredicate") and ctx.traversalPredicate(): + params.append(self.visit(ctx.traversalPredicate())) + self.traversal.add_step(Step("is", params)) + + def visitTraversalMethod_not(self, ctx): + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("not", params)) + + # ========== 高优先级缺失方法 - 2024修复 ========== + + # select的特定变体 + def visitTraversalMethod_select_Traversal(self, ctx): + """select(Traversal)变体""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("select", params)) + + def visitTraversalMethod_select_Pop_String(self, ctx): + """select(Pop, String)变体""" + params = [] + if hasattr(ctx, "traversalPop") and ctx.traversalPop(): + params.append(self.visit(ctx.traversalPop())) + if hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("select", params)) + + def visitTraversalMethod_select_Pop_Traversal(self, ctx): + """select(Pop, Traversal)变体""" + params = [] + if hasattr(ctx, "traversalPop") and ctx.traversalPop(): + params.append(self.visit(ctx.traversalPop())) + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("select", params)) + + # from的特定变体 + def visitTraversalMethod_from_String(self, ctx): + """from(String)变体""" + params = [] + if hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("from", params)) + + def visitTraversalMethod_from_Vertex(self, ctx): + """from(Vertex)变体""" + params = [] + if hasattr(ctx, "structureVertex") and ctx.structureVertex(): + params.append(self.visit(ctx.structureVertex())) + self.traversal.add_step(Step("from", params)) + + def visitTraversalMethod_from_Traversal(self, ctx): + """from(Traversal)变体""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("from", params)) + + # to的特定变体 + def visitTraversalMethod_to_String(self, ctx): + """to(String)变体""" + params = [] + if hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("to", params)) + + def visitTraversalMethod_to_Vertex(self, ctx): + """to(Vertex)变体""" + params = [] + if hasattr(ctx, "structureVertex") and ctx.structureVertex(): + params.append(self.visit(ctx.structureVertex())) + self.traversal.add_step(Step("to", params)) + + def visitTraversalMethod_to_Traversal(self, ctx): + """to(Traversal)变体""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("to", params)) + + # emit的特定变体 + def visitTraversalMethod_emit_Predicate(self, ctx): + """emit(Predicate)变体""" + params = [] + if hasattr(ctx, "traversalPredicate") and ctx.traversalPredicate(): + params.append(self.visit(ctx.traversalPredicate())) + self.traversal.add_step(Step("emit", params)) + + def visitTraversalMethod_emit_Traversal(self, ctx): + """emit(Traversal)变体""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("emit", params)) + + # by的特定变体 + def visitTraversalMethod_by_Empty(self, ctx): + """by()变体 - 无参数""" + self.traversal.add_step(Step("by", [])) + + def visitTraversalMethod_by_Function(self, ctx): + """by(Function)变体""" + params = [] + if hasattr(ctx, "traversalFunction") and ctx.traversalFunction(): + params.append(self.visit(ctx.traversalFunction())) + self.traversal.add_step(Step("by", params)) + + def visitTraversalMethod_by_Order(self, ctx): + """by(Order)变体""" + params = [] + if hasattr(ctx, "traversalOrder") and ctx.traversalOrder(): + params.append(self.visit(ctx.traversalOrder())) + self.traversal.add_step(Step("by", params)) + + def visitTraversalMethod_by_T(self, ctx): + """by(T)变体""" + params = [] + if hasattr(ctx, "traversalT") and ctx.traversalT(): + params.append(self.visit(ctx.traversalT())) + self.traversal.add_step(Step("by", params)) + + # tail的特定变体 + def visitTraversalMethod_tail_Scope(self, ctx): + """tail(Scope)变体""" + params = [] + if hasattr(ctx, "traversalScope") and ctx.traversalScope(): + params.append(self.visit(ctx.traversalScope())) + self.traversal.add_step(Step("tail", params)) + + # barrier的特定变体 + def visitTraversalMethod_barrier_int(self, ctx): + """barrier(int)变体""" + params = [] + if hasattr(ctx, "integerLiteral") and ctx.integerLiteral(): + params.append(self.visit(ctx.integerLiteral())) + self.traversal.add_step(Step("barrier", params)) + + # V和E的实现 + def visitTraversalMethod_V(self, ctx): + """V()方法 - 获取顶点""" + params = [] + if hasattr(ctx, "genericArgumentVarargs") and ctx.genericArgumentVarargs(): + args = self.visit(ctx.genericArgumentVarargs()) + if args: + params.extend(args if isinstance(args, list) else [args]) + self.traversal.add_step(Step("V", params)) + + def visitTraversalMethod_E(self, ctx): + """E()方法 - 获取边""" + params = [] + if hasattr(ctx, "genericArgumentVarargs") and ctx.genericArgumentVarargs(): + args = self.visit(ctx.genericArgumentVarargs()) + if args: + params.extend(args if isinstance(args, list) else [args]) + self.traversal.add_step(Step("E", params)) + + # choose的所有变体 + def visitTraversalMethod_choose_Function(self, ctx): + """choose(Function)变体""" + params = [] + if hasattr(ctx, "traversalFunction") and ctx.traversalFunction(): + params.append(self.visit(ctx.traversalFunction())) + self.traversal.add_step(Step("choose", params)) + + def visitTraversalMethod_choose_Traversal_Traversal(self, ctx): + """choose(Traversal, Traversal)变体""" + params = [] + # 获取所有nestedTraversal + if hasattr(ctx, "nestedTraversal"): + traversals = ctx.nestedTraversal() + if traversals: + if isinstance(traversals, list): + for t in traversals: + params.append(self.visit(t)) + else: + params.append(self.visit(traversals)) + self.traversal.add_step(Step("choose", params)) + + def visitTraversalMethod_choose_Predicate_Traversal(self, ctx): + """choose(Predicate, Traversal)变体""" + params = [] + if hasattr(ctx, "traversalPredicate") and ctx.traversalPredicate(): + params.append(self.visit(ctx.traversalPredicate())) + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("choose", params)) + + def visitTraversalMethod_choose_Predicate_Traversal_Traversal(self, ctx): + """choose(Predicate, Traversal, Traversal)变体 - 三参数版本""" + params = [] + if hasattr(ctx, "traversalPredicate") and ctx.traversalPredicate(): + params.append(self.visit(ctx.traversalPredicate())) + # 获取两个nestedTraversal参数 + if hasattr(ctx, "nestedTraversal"): + traversals = ctx.nestedTraversal() + if traversals: + if isinstance(traversals, list): + for t in traversals: + params.append(self.visit(t)) + else: + params.append(self.visit(traversals)) + self.traversal.add_step(Step("choose", params)) + + def visitTraversalMethod_choose_Traversal_Traversal_Traversal(self, ctx): + """choose(Traversal, Traversal, Traversal)变体 - 三遍历版本""" + params = [] + if hasattr(ctx, "nestedTraversal"): + traversals = ctx.nestedTraversal() + if traversals: + if isinstance(traversals, list): + for t in traversals: + params.append(self.visit(t)) + else: + params.append(self.visit(traversals)) + self.traversal.add_step(Step("choose", params)) + + # flatMap方法 + def visitTraversalMethod_flatMap(self, ctx): + """flatMap(Traversal)方法""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("flatMap", params)) + + # is的特定变体 + def visitTraversalMethod_is_Object(self, ctx): + """is(Object)变体""" + params = [] + if hasattr(ctx, "genericArgument") and ctx.genericArgument(): + params.append(self.visit(ctx.genericArgument())) + self.traversal.add_step(Step("is", params)) + + def visitTraversalMethod_is_P(self, ctx): + """is(Predicate)变体""" + params = [] + if hasattr(ctx, "traversalPredicate") and ctx.traversalPredicate(): + params.append(self.visit(ctx.traversalPredicate())) + self.traversal.add_step(Step("is", params)) + + # ========== 高优先级缺失方法结束 ========== + + def visitTraversalMethod_hasLabel(self, ctx): + params = ( + self.visit(ctx.stringNullableArgumentVarargs()) + if hasattr(ctx, "stringNullableArgumentVarargs") and ctx.stringNullableArgumentVarargs() + else [] + ) + self.traversal.add_step(Step("hasLabel", params)) + + def visitTraversalMethod_hasLabel_P(self, ctx): + predicate = self.visit(ctx.traversalPredicate()) + self.traversal.add_step(Step("hasLabel", [predicate])) + + def visitTraversalMethod_hasLabel_String_String(self, ctx): + params = [] + if ctx.stringNullableArgument(): + params.append(self.visit(ctx.stringNullableArgument())) + if ctx.stringNullableArgumentVarargs(): + params.extend(self.visit(ctx.stringNullableArgumentVarargs())) + self.traversal.add_step(Step("hasLabel", params)) + + def visitTraversalMethod_hasId(self, ctx): + params = ( + self.visit(ctx.genericArgumentVarargs()) + if hasattr(ctx, "genericArgumentVarargs") and ctx.genericArgumentVarargs() + else [] + ) + self.traversal.add_step(Step("hasId", params)) + + def visitTraversalMethod_hasId_Object_Object(self, ctx): + params = [] + if ctx.genericArgument(): + params.append(self.visit(ctx.genericArgument())) + if ctx.genericArgumentVarargs(): + params.extend(self.visit(ctx.genericArgumentVarargs())) + self.traversal.add_step(Step("hasId", params)) + + def visitTraversalMethod_hasId_P(self, ctx): + predicate = self.visit(ctx.traversalPredicate()) + self.traversal.add_step(Step("hasId", [predicate])) + + def visitTraversalMethod_hasKey(self, ctx): + params = ( + self.visit(ctx.stringNullableArgumentVarargs()) + if hasattr(ctx, "stringNullableArgumentVarargs") and ctx.stringNullableArgumentVarargs() + else [] + ) + self.traversal.add_step(Step("hasKey", params)) + + def visitTraversalMethod_hasKey_P(self, ctx): + predicate = self.visit(ctx.traversalPredicate()) + self.traversal.add_step(Step("hasKey", [predicate])) + + def visitTraversalMethod_hasKey_String_String(self, ctx): + params = [] + if ctx.stringNullableLiteral(): + params.append(self.visit(ctx.stringNullableLiteral())) + if ctx.stringNullableLiteralVarargs(): + params.extend(self.visit(ctx.stringNullableLiteralVarargs())) + self.traversal.add_step(Step("hasKey", params)) + + def visitTraversalMethod_hasValue(self, ctx): + params = ( + self.visit(ctx.genericArgumentVarargs()) + if hasattr(ctx, "genericArgumentVarargs") and ctx.genericArgumentVarargs() + else [] + ) + self.traversal.add_step(Step("hasValue", params)) + + def visitTraversalMethod_hasValue_Object_Object(self, ctx): + params = [] + if ctx.genericArgument(): + params.append(self.visit(ctx.genericArgument())) + if ctx.genericArgumentVarargs(): + params.extend(self.visit(ctx.genericArgumentVarargs())) + self.traversal.add_step(Step("hasValue", params)) + + def visitTraversalMethod_hasValue_P(self, ctx): + predicate = self.visit(ctx.traversalPredicate()) + self.traversal.add_step(Step("hasValue", [predicate])) + + # 删除操作访问器 + def visitTraversalMethod_drop(self, ctx): + self.traversal.add_step(Step("drop", [])) + + # Call方法的各种变体支持 (traversalMethod版本) + def visitTraversalMethod_call_string(self, ctx: GremlinParser.TraversalMethod_call_stringContext): + """处理 .call('methodName') 单字符串参数调用""" + params = [] + if ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + self.traversal.add_step(Step("call", params)) + + def visitTraversalMethod_call_string_map(self, ctx: GremlinParser.TraversalMethod_call_string_mapContext): + """处理 .call('methodName', map) 字符串+映射参数调用""" + params = [] + if ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + if ctx.genericLiteralMap(): + params.append(self.visit(ctx.genericLiteralMap())) + self.traversal.add_step(Step("call", params)) + + def visitTraversalMethod_call_string_traversal( + self, ctx: GremlinParser.TraversalMethod_call_string_traversalContext + ): + """处理 .call('methodName', traversal) 字符串+遍历参数调用""" + params = [] + if ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + if ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("call", params)) + + def visitTraversalMethod_call_string_map_traversal( + self, ctx: GremlinParser.TraversalMethod_call_string_map_traversalContext + ): + """处理 .call('methodName', map, traversal) 字符串+映射+遍历参数调用""" + params = [] + if ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + if ctx.genericLiteralMap(): + params.append(self.visit(ctx.genericLiteralMap())) + if ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("call", params)) + + # 更多修改操作访问器 + def visitTraversalMethod_addE_String(self, ctx): + params = [] + if ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + self.traversal.add_step(Step("addE", params)) + + def visitTraversalMethod_addE_Traversal(self, ctx): + params = [] + if ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("addE", params)) + + def visitTraversalMethod_addV_Empty(self, ctx): + self.traversal.add_step(Step("addV", [])) + + def visitTraversalMethod_addV_String(self, ctx): + params = [] + if ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + self.traversal.add_step(Step("addV", params)) + + def visitTraversalMethod_addV_Traversal(self, ctx): + params = [] + if ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("addV", params)) + + def visitTraversalMethod_from(self, ctx): + params = [] + if hasattr(ctx, "stringArgument") and ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + elif hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("from", params)) + + def visitTraversalMethod_to(self, ctx): + params = [] + if hasattr(ctx, "stringArgument") and ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + elif hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("to", params)) + + # With方法的各种变体支持 + def visitTraversalMethod_with_String(self, ctx: GremlinParser.TraversalMethod_with_StringContext): + """处理 .with('key') 单字符串参数调用""" + params = [] + # 查找StringLiteralContext子节点 + for child in ctx.children: + if hasattr(child, "getRuleIndex") and "StringLiteral" in type(child).__name__: + string_val = child.getText() + # 移除引号 + if (string_val.startswith('"') and string_val.endswith('"')) or ( + string_val.startswith("'") and string_val.endswith("'") + ): + string_val = string_val[1:-1] + params.append(string_val) + break + self.traversal.add_step(Step("with", params)) + + def visitTraversalMethod_with_String_Object(self, ctx: GremlinParser.TraversalMethod_with_String_ObjectContext): + """处理 .with('key', value) 字符串+对象参数调用""" + params = [] + # 查找StringLiteralContext和GenericArgumentContext子节点 + for child in ctx.children: + if hasattr(child, "getRuleIndex"): + if "StringLiteral" in type(child).__name__: + string_val = child.getText() + # 移除引号 + if (string_val.startswith('"') and string_val.endswith('"')) or ( + string_val.startswith("'") and string_val.endswith("'") + ): + string_val = string_val[1:-1] + params.append(string_val) + elif "GenericArgument" in type(child).__name__: + # 处理GenericArgument，可能包含字符串或数字 + arg_text = child.getText() + # 如果是字符串，移除引号 + if (arg_text.startswith('"') and arg_text.endswith('"')) or ( + arg_text.startswith("'") and arg_text.endswith("'") + ): + arg_text = arg_text[1:-1] + params.append(arg_text) + self.traversal.add_step(Step("with", params)) + + # TraversalSourceSelfMethod的with方法支持 + def visitTraversalSourceSelfMethod_with(self, ctx: GremlinParser.TraversalSourceSelfMethod_withContext): + """处理 g.with() 方法""" + params = [] + if hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + if hasattr(ctx, "genericArgument") and ctx.genericArgument(): + params.append(self.visit(ctx.genericArgument())) + self.traversal.add_step(Step("with", params)) + + def visitTraversalSourceSelfMethod_withSideEffect( + self, ctx: GremlinParser.TraversalSourceSelfMethod_withSideEffectContext + ): + """处理 g.withSideEffect() 方法""" + params = [] + if hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + if hasattr(ctx, "genericArgument") and ctx.genericArgument(): + params.append(self.visit(ctx.genericArgument())) + self.traversal.add_step(Step("withSideEffect", params)) + + def visitTraversalSourceSelfMethod_withBulk(self, ctx: GremlinParser.TraversalSourceSelfMethod_withBulkContext): + """处理 g.withBulk() 方法""" + params = [] + if hasattr(ctx, "booleanArgument") and ctx.booleanArgument(): + params.append(self.visit(ctx.booleanArgument())) + self.traversal.add_step(Step("withBulk", params)) + + def visitTraversalSourceSelfMethod_withPath(self, ctx: GremlinParser.TraversalSourceSelfMethod_withPathContext): + """处理 g.withPath() 方法""" + self.traversal.add_step(Step("withPath", [])) + + def visitTraversalSourceSelfMethod_withSack(self, ctx: GremlinParser.TraversalSourceSelfMethod_withSackContext): + """处理 g.withSack() 方法""" + params = [] + if hasattr(ctx, "genericArgument") and ctx.genericArgument(): + params.append(self.visit(ctx.genericArgument())) + if hasattr(ctx, "traversalBiFunction") and ctx.traversalBiFunction(): + params.append(self.visit(ctx.traversalBiFunction())) + self.traversal.add_step(Step("withSack", params)) + + def visitTraversalSourceSelfMethod_withStrategies( + self, ctx: GremlinParser.TraversalSourceSelfMethod_withStrategiesContext + ): + """处理 g.withStrategies() 方法""" + params = [] + if hasattr(ctx, "traversalStrategy") and ctx.traversalStrategy(): + params.append(self.visit(ctx.traversalStrategy())) + self.traversal.add_step(Step("withStrategies", params)) + + def visitTraversalSourceSelfMethod_withoutStrategies( + self, ctx: GremlinParser.TraversalSourceSelfMethod_withoutStrategiesContext + ): + """处理 g.withoutStrategies() 方法""" + params = [] + if hasattr(ctx, "classType") and ctx.classType(): + params.append(self.visit(ctx.classType())) + self.traversal.add_step(Step("withoutStrategies", params)) + + # SpawnMethod缺失方法 + def visitTraversalSourceSpawnMethod_mergeE_Map(self, ctx): + """处理 g.mergeE(map) 方法 + + TODO: 完整实现 Map 参数解析 + 当前实现：忽略 Map 参数内容，只记录步骤名称 + 完整实现需要： + 1. 解析 genericMapNullableArgument (如 [:] 或 [(T.id): 1]) + 2. 提取 Map 中的键值对 + 3. 将 Map 对象作为参数传递给 Step + 4. 在 TraversalGenerator 中支持 Map 参数的泛化 + + 参考：base_v2/MAP_PARAMETER_FIX_PLAN.md + """ + params = [] + # Map参数暂时简化处理 - 见上方 TODO + self.traversal.add_step(Step("mergeE", params)) + + def visitTraversalSourceSpawnMethod_mergeE_Traversal(self, ctx): + """处理 g.mergeE(traversal) 方法""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("mergeE", params)) + + def visitTraversalSourceSpawnMethod_mergeV_Map(self, ctx): + """处理 g.mergeV(map) 方法 + + TODO: 完整实现 Map 参数解析 + 当前实现：忽略 Map 参数内容，只记录步骤名称 + 完整实现需要： + 1. 解析 genericMapNullableArgument (如 [:] 或 [(T.id): 1]) + 2. 提取 Map 中的键值对 + 3. 将 Map 对象作为参数传递给 Step + 4. 在 TraversalGenerator 中支持 Map 参数的泛化 + + 参考：base_v2/MAP_PARAMETER_FIX_PLAN.md + """ + params = [] + # Map参数暂时简化处理 - 见上方 TODO + self.traversal.add_step(Step("mergeV", params)) + + def visitTraversalSourceSpawnMethod_mergeV_Traversal(self, ctx): + """处理 g.mergeV(traversal) 方法""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("mergeV", params)) + + def visitTraversalMethod_mergeE_empty(self, ctx): + """处理 .mergeE() 无参数方法""" + self.traversal.add_step(Step("mergeE", [])) + + def visitTraversalMethod_mergeE_Map(self, ctx): + """处理 .mergeE(map) 方法 + + TODO: 完整实现 Map 参数解析 + 当前实现：忽略 Map 参数内容，只记录步骤名称 + 完整实现需要： + 1. 解析 genericMapNullableArgument (如 [:] 或 [(T.id): 1]) + 2. 提取 Map 中的键值对 + 3. 将 Map 对象作为参数传递给 Step + 4. 在 TraversalGenerator 中支持 Map 参数的泛化 + + 参考：base_v2/MAP_PARAMETER_FIX_PLAN.md + """ + params = [] + # Map参数暂时简化处理 - 见上方 TODO + self.traversal.add_step(Step("mergeE", params)) + + def visitTraversalMethod_mergeE_Traversal(self, ctx): + """处理 .mergeE(traversal) 方法""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("mergeE", params)) + + def visitTraversalMethod_mergeV_empty(self, ctx): + """处理 .mergeV() 无参数方法""" + self.traversal.add_step(Step("mergeV", [])) + + def visitTraversalMethod_mergeV_Map(self, ctx): + """处理 .mergeV(map) 方法 + + TODO: 完整实现 Map 参数解析 + 当前实现：忽略 Map 参数内容，只记录步骤名称 + 完整实现需要： + 1. 解析 genericMapNullableArgument (如 [:] 或 [(T.id): 1]) + 2. 提取 Map 中的键值对 + 3. 将 Map 对象作为参数传递给 Step + 4. 在 TraversalGenerator 中支持 Map 参数的泛化 + + 参考：base_v2/MAP_PARAMETER_FIX_PLAN.md + """ + params = [] + # Map参数暂时简化处理 - 见上方 TODO + self.traversal.add_step(Step("mergeV", params)) + + def visitTraversalMethod_mergeV_Traversal(self, ctx): + """处理 .mergeV(traversal) 方法""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("mergeV", params)) + + def visitTraversalSourceSpawnMethod_union(self, ctx: GremlinParser.TraversalSourceSpawnMethod_unionContext): + """处理 g.union() 方法""" + params = [] + if hasattr(ctx, "nestedTraversalVarargs") and ctx.nestedTraversalVarargs(): + params = self.visit(ctx.nestedTraversalVarargs()) + self.traversal.add_step(Step("union", params)) + + # 转换方法访问器 + def visitTraversalMethod_properties(self, ctx): + params = ( + self.visit(ctx.stringNullableLiteralVarargs()) + if hasattr(ctx, "stringNullableLiteralVarargs") and ctx.stringNullableLiteralVarargs() + else [] + ) + self.traversal.add_step(Step("properties", params)) + + def visitTraversalMethod_select(self, ctx): + params = [] + if hasattr(ctx, "stringNullableArgumentVarargs") and ctx.stringNullableArgumentVarargs(): + params = self.visit(ctx.stringNullableArgumentVarargs()) + elif hasattr(ctx, "stringArgument") and ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + self.traversal.add_step(Step("select", params)) + + def visitTraversalMethod_select_String_String_String( + self, ctx: GremlinParser.TraversalMethod_select_String_String_StringContext + ): + """处理 .select('key1', 'key2', 'key3') 多字符串参数调用""" + params = [] + # 获取前两个 stringLiteral + if hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + literals = ctx.stringLiteral() + if isinstance(literals, list): + for lit in literals: + params.append(self.visit(lit)) + else: + params.append(self.visit(literals)) + # 获取额外的参数（第三个及以后） + if hasattr(ctx, "stringNullableLiteralVarargs") and ctx.stringNullableLiteralVarargs(): + extra_params = self.visit(ctx.stringNullableLiteralVarargs()) + if extra_params: + params.extend(extra_params if isinstance(extra_params, list) else [extra_params]) + self.traversal.add_step(Step("select", params)) + + def visitTraversalMethod_project(self, ctx): + """处理project()方法""" + params = [] + # 第一个参数是必需的stringLiteral + if hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + # 后面可选的stringNullableLiteralVarargs + if hasattr(ctx, "stringNullableLiteralVarargs") and ctx.stringNullableLiteralVarargs(): + varargs = self.visit(ctx.stringNullableLiteralVarargs()) + if varargs: + params.extend(varargs) + self.traversal.add_step(Step("project", params)) + + def visitTraversalMethod_valueMap(self, ctx): + params = [] + if hasattr(ctx, "stringNullableLiteralVarargs") and ctx.stringNullableLiteralVarargs(): + params = self.visit(ctx.stringNullableLiteralVarargs()) + elif hasattr(ctx, "booleanArgument") and ctx.booleanArgument(): + params.append(self.visit(ctx.booleanArgument())) + self.traversal.add_step(Step("valueMap", params)) + + def visitTraversalMethod_elementMap(self, ctx): + params = ( + self.visit(ctx.stringNullableLiteralVarargs()) + if hasattr(ctx, "stringNullableLiteralVarargs") and ctx.stringNullableLiteralVarargs() + else [] + ) + self.traversal.add_step(Step("elementMap", params)) + + def visitTraversalMethod_label(self, ctx): + self.traversal.add_step(Step("label", [])) + + def visitTraversalMethod_id(self, ctx): + self.traversal.add_step(Step("id", [])) + + def visitTraversalMethod_key(self, ctx): + self.traversal.add_step(Step("key", [])) + + def visitTraversalMethod_value(self, ctx): + self.traversal.add_step(Step("value", [])) + + # 聚合方法访问器 + # 聚合方法的正确实现 - 使用正确的Context类型 + def visitTraversalMethod_count_Empty(self, ctx): + """处理无参数的count()方法""" + self.traversal.add_step(Step("count", [])) + + def visitTraversalMethod_count_Scope(self, ctx): + """处理有参数的count()方法""" + # 处理scope参数 + params = [] + if hasattr(ctx, "traversalScope") and ctx.traversalScope(): + params.append(self.visit(ctx.traversalScope())) + self.traversal.add_step(Step("count", params)) + + def visitTraversalMethod_sum_Empty(self, ctx): + """处理无参数的sum()方法""" + self.traversal.add_step(Step("sum", [])) + + def visitTraversalMethod_sum_Scope(self, ctx): + """处理有参数的sum()方法""" + params = [] + if hasattr(ctx, "traversalScope") and ctx.traversalScope(): + params.append(self.visit(ctx.traversalScope())) + self.traversal.add_step(Step("sum", params)) + + def visitTraversalMethod_mean_Empty(self, ctx): + """处理无参数的mean()方法""" + self.traversal.add_step(Step("mean", [])) + + def visitTraversalMethod_mean_Scope(self, ctx): + """处理有参数的mean()方法""" + params = [] + if hasattr(ctx, "traversalScope") and ctx.traversalScope(): + params.append(self.visit(ctx.traversalScope())) + self.traversal.add_step(Step("mean", params)) + + def visitTraversalMethod_max_Empty(self, ctx): + """处理无参数的max()方法""" + self.traversal.add_step(Step("max", [])) + + def visitTraversalMethod_max_Scope(self, ctx): + """处理有参数的max()方法""" + params = [] + if hasattr(ctx, "traversalScope") and ctx.traversalScope(): + params.append(self.visit(ctx.traversalScope())) + self.traversal.add_step(Step("max", params)) + + def visitTraversalMethod_min_Empty(self, ctx): + """处理无参数的min()方法""" + self.traversal.add_step(Step("min", [])) + + def visitTraversalMethod_min_Scope(self, ctx): + """处理有参数的min()方法""" + params = [] + if hasattr(ctx, "traversalScope") and ctx.traversalScope(): + params.append(self.visit(ctx.traversalScope())) + self.traversal.add_step(Step("min", params)) + + def visitTraversalMethod_fold_Empty(self, ctx): + """处理无参数的fold()方法""" + self.traversal.add_step(Step("fold", [])) + + def visitTraversalMethod_unfold(self, ctx): + self.traversal.add_step(Step("unfold", [])) + + # 分组方法 + def visitTraversalMethod_group_Empty(self, ctx): + """处理无参数的group()方法""" + self.traversal.add_step(Step("group", [])) + + def visitTraversalMethod_group_String(self, ctx): + """处理带标签参数的group(string)方法""" + params = [] + if hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("group", params)) + + def visitTraversalMethod_groupCount_Empty(self, ctx): + """处理无参数的groupCount()方法""" + self.traversal.add_step(Step("groupCount", [])) + + def visitTraversalMethod_groupCount_String(self, ctx): + """处理带标签参数的groupCount(string)方法""" + params = [] + if hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("groupCount", params)) + + # 排序和限制方法访问器 + # 排序和限制方法的正确实现 + def visitTraversalMethod_order_Empty(self, ctx): + """处理无参数的order()方法""" + self.traversal.add_step(Step("order", [])) + + def visitTraversalMethod_order_Scope(self, ctx): + """处理有参数的order()方法""" + params = [] + if hasattr(ctx, "traversalScope") and ctx.traversalScope(): + params.append(self.visit(ctx.traversalScope())) + self.traversal.add_step(Step("order", params)) + + def visitTraversalMethod_by_String(self, ctx): + """处理by(string)方法""" + params = [] + if hasattr(ctx, "stringArgument") and ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + elif hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + self.traversal.add_step(Step("by", params)) + + def visitTraversalMethod_by_String_Comparator(self, ctx): + """处理by(string, comparator)方法""" + params = [] + if hasattr(ctx, "stringArgument") and ctx.stringArgument(): + params.append(self.visit(ctx.stringArgument())) + elif hasattr(ctx, "stringLiteral") and ctx.stringLiteral(): + params.append(self.visit(ctx.stringLiteral())) + if hasattr(ctx, "traversalComparator") and ctx.traversalComparator(): + params.append(self.visit(ctx.traversalComparator())) + self.traversal.add_step(Step("by", params)) + + def visitTraversalMethod_by_Traversal(self, ctx): + """处理by(traversal)方法""" + params = [] + if hasattr(ctx, "nestedTraversal") and ctx.nestedTraversal(): + params.append(self.visit(ctx.nestedTraversal())) + self.traversal.add_step(Step("by", params)) + + def visitTraversalMethod_range_long_long(self, ctx): + """处理range(long, long)方法""" + params = [] + if hasattr(ctx, "integerArgument"): + for arg in ctx.integerArgument(): + params.append(self.visit(arg)) + self.traversal.add_step(Step("range", params)) + + def visitTraversalMethod_skip_long(self, ctx): + """处理skip(long)方法""" + params = [] + if hasattr(ctx, "integerArgument") and ctx.integerArgument(): + params.append(self.visit(ctx.integerArgument())) + self.traversal.add_step(Step("skip", params)) + + def visitTraversalMethod_tail_long(self, ctx): + """处理tail(long)方法""" + params = [] + if hasattr(ctx, "integerArgument") and ctx.integerArgument(): + params.append(self.visit(ctx.integerArgument())) + self.traversal.add_step(Step("tail", params)) + + def visitTraversalMethod_sample_int(self, ctx): + """处理sample(int)方法""" + params = [] + if hasattr(ctx, "integerArgument") and ctx.integerArgument(): + params.append(self.visit(ctx.integerArgument())) + self.traversal.add_step(Step("sample", params)) + + def visitTraversalMethod_coin(self, ctx): + params = [] + if hasattr(ctx, "floatArgument") and ctx.floatArgument(): + params.append(self.visit(ctx.floatArgument())) + self.traversal.add_step(Step("coin", params)) + + # 分支和条件方法访问器 + + +# 测试入口函数 +def parse_gremlin_query(query_string: str) -> Traversal: + """ + 便捷的模块级函数，用于解析Gremlin查询字符串。 + + Args: + query_string (str): 要解析的 Gremlin 查询字符串 + + Returns: + Traversal: 包含步骤的解析后遍历对象 + """ + visitor = GremlinTransVisitor() + return visitor.parse_and_visit(query_string) diff --git a/text2gremlin/AST_Text2Gremlin/base/Schema.py b/text2gremlin/AST_Text2Gremlin/base/Schema.py new file mode 100644 index 000000000..65f5c036c --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/Schema.py @@ -0,0 +1,241 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +""" +图数据库Schema管理模块。 + +负责解析Schema定义和CSV数据文件，为查询生成器提供图结构信息和真实数据实例。 +""" + +import json +import os +import random +from typing import Any + +import pandas as pd + +DEFAULT_SAMPLE_MIN = 2 +DEFAULT_SAMPLE_MAX = 5 + + +class Schema: + def __init__(self, schema_file: str, data_dir: str): + self.data_dir = data_dir + self.vertices: dict[str, dict[str, Any]] = {} + self.edges: dict[str, dict[str, Any]] = {} + self.vertex_data: dict[str, pd.DataFrame] = {} + self.edge_data: dict[str, pd.DataFrame] = {} + + with open(schema_file, encoding="utf-8") as f: + schema_data = json.load(f) + + # 解析 schema 定义 + for item in schema_data.get("schema", []): + label = item["label"] + if item["type"] == "VERTEX": + self.vertices[label] = { + "primary": item.get("primary", None), + "properties": { + prop["name"]: {"type": prop["type"], "optional": prop.get("optional", False)} + for prop in item.get("properties", []) + }, + } + elif item["type"] == "EDGE": + self.edges[label] = { + "source": None, + "destination": None, + "properties": { + prop["name"]: {"type": prop["type"], "optional": prop.get("optional", False)} + for prop in item.get("properties", []) + }, + } + + # 2. 解析 files 定义，获取路径、header行数和边的端点 + self.vertex_files: dict[str, dict] = {} + self.edge_files: dict[str, dict] = {} + for file_info in schema_data.get("files", []): + label = file_info["label"] + path = os.path.join(self.data_dir, file_info["path"]) + header_rows = file_info.get("header", 1) # 获取header行数，默认为1 + + file_details = {"path": path, "header_rows": header_rows} + + is_edge = "SRC_ID" in file_info and "DST_ID" in file_info + if is_edge: + self.edge_files[label] = file_details + if label in self.edges: + self.edges[label]["source"] = file_info["SRC_ID"] + self.edges[label]["destination"] = file_info["DST_ID"] + else: + self.vertex_files[label] = file_details + + def _parse_custom_csv(self, file_path: str, header_line_index: int) -> pd.DataFrame: + """解析自定义多行表头的 CSV 文件。""" + try: + with open(file_path, encoding="utf-8") as f: + lines = f.readlines() + + # 从第二行解析列名 + header_line = lines[header_line_index - 1] + column_defs = header_line.strip().split(",") + column_names = [d.split(":")[0] for d in column_defs] + + # 处理重复的列名（为重复的列添加后缀） + seen = {} + unique_names = [] + for name in column_names: + if name in seen: + seen[name] += 1 + unique_names.append(f"{name}_{seen[name]}") + else: + seen[name] = 0 + unique_names.append(name) + column_names = unique_names + + # 从指定header行之后开始读取数据 + data_lines = lines[header_line_index:] + + if not data_lines: + return pd.DataFrame(columns=column_names) + + # 使用pandas从内存中的字符串列表读取数据 + from io import StringIO + + csv_data = StringIO("".join(data_lines)) + df = pd.read_csv(csv_data, header=None, names=column_names) + return df + + except (FileNotFoundError, IndexError) as e: + print(f"警告: 读取或解析文件失败: {file_path}, 错误: {e}") + return pd.DataFrame() + + def _load_vertex_data(self, label: str): + if label not in self.vertex_data and label in self.vertex_files: + file_info = self.vertex_files[label] + self.vertex_data[label] = self._parse_custom_csv(file_info["path"], file_info["header_rows"]) + + def _load_edge_data(self, label: str): + if label not in self.edge_data and label in self.edge_files: + file_info = self.edge_files[label] + self.edge_data[label] = self._parse_custom_csv(file_info["path"], file_info["header_rows"]) + + # --- Schema 查询方法 (保持不变) --- + def get_vertex_labels(self) -> list[str]: + return list(self.vertices.keys()) + + def get_edge_labels(self) -> list[str]: + return list(self.edges.keys()) + + def get_properties_with_type(self, label: str) -> list[dict[str, str]]: + props_dict = self.vertices.get(label, {}).get("properties", {}) or self.edges.get(label, {}).get( + "properties", {} + ) + return [{"name": name, "type": meta["type"]} for name, meta in props_dict.items()] + + def get_valid_steps(self, current_label: str, element_type: str = "vertex") -> list[dict]: + if element_type == "vertex": + if current_label not in self.vertices: + return [] + valid_steps = [] + outgoing = [l for l, e in self.edges.items() if e["source"] == current_label] + if outgoing: + valid_steps.append({"step": "out", "params": outgoing}) + incoming = [l for l, e in self.edges.items() if e["destination"] == current_label] + if incoming: + valid_steps.append({"step": "in", "params": incoming}) + props = self.get_properties_with_type(current_label) + if props: + valid_steps.append({"step": "properties", "params": [p["name"] for p in props]}) + valid_steps.append({"step": "has", "params": props}) + return valid_steps + return [] + + def get_step_result_label(self, start_label: str, step: dict) -> tuple[str, str]: + step_name, step_param = step.get("step"), step.get("param") + if step_name == "out": + if step_param not in self.edges: + raise KeyError(f"边标签 '{step_param}' 不存在于 schema 中") + return self.edges[step_param]["destination"], "vertex" + if step_name == "in": + if step_param not in self.edges: + raise KeyError(f"边标签 '{step_param}' 不存在于 schema 中") + return self.edges[step_param]["source"], "vertex" + if step_name in ["properties", "has", "values"]: + return start_label, "vertex" + return None, None + + def get_vertex_creation_info(self, label: str) -> dict: + if label not in self.vertices: + return {} + schema_info = self.vertices[label] + required = [name for name, meta in schema_info["properties"].items() if not meta["optional"]] + return {"primary": schema_info.get("primary"), "required": required} + + def get_edge_creation_info(self, label: str) -> tuple[str, str]: + if label in self.edges: + return (self.edges[label]["source"], self.edges[label]["destination"]) + return (None, None) + + def get_updatable_properties(self, label: str) -> list[dict[str, str]]: + if label not in self.vertices: + return [] + schema_info = self.vertices[label] + primary_key = schema_info.get("primary") + return [ + {"name": name, "type": meta["type"]} + for name, meta in schema_info["properties"].items() + if name != primary_key + ] + + def get_instance(self, label: str) -> dict: + """获取单个实例（保持向后兼容）""" + instances = self.get_instances(label, count=1) + return instances[0] if instances else {} + + def get_instances(self, label: str, count: int | None = None) -> list[dict]: + """获取多个实例 + + Args: + label: 标签名 + count: 要获取的实例数量，如果为None则随机选择2-5个 + + Returns: + 实例列表 + """ + + is_edge = label in self.edges + data_cache = self.edge_data if is_edge else self.vertex_data + load_func = self._load_edge_data if is_edge else self._load_vertex_data + + if label not in data_cache: + load_func(label) + + df = data_cache.get(label) + if df is None or df.empty: + return [] + + # 如果没有指定数量，使用默认随机样本范围 + if count is None: + count = random.randint(DEFAULT_SAMPLE_MIN, DEFAULT_SAMPLE_MAX) + + # 如果实际数据量小于要求的数量，就全部取出 + actual_count = min(count, len(df)) + + # 随机采样 + sampled_df = df.sample(actual_count) + return sampled_df.to_dict("records") diff --git a/text2gremlin/AST_Text2Gremlin/base/TraversalGenerator.py b/text2gremlin/AST_Text2Gremlin/base/TraversalGenerator.py new file mode 100644 index 000000000..aaa2724a9 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/TraversalGenerator.py @@ -0,0 +1,3750 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +import json +import os +import random +import string +from typing import Any + +from .CombinationController import CombinationController +from .GremlinBase import GremlinBase +from .GremlinExpr import Predicate +from .GremlinParse import Step, Traversal +from .Schema import Schema + + +class TraversalGenerator: + """Gremlin查询生成器 - 分层泛化架构""" + + # A. 简单步骤（无参数，直接生成） + SIMPLE_STEPS = { + "count": {"output_type": "number"}, + "id": {"output_type": "value"}, + "label": {"output_type": "string"}, + "fold": {"output_type": "list"}, + "unfold": {"output_type": None}, + "drop": {"output_type": "none"}, + "iterate": {"output_type": "none"}, + "explain": {"output_type": "string"}, + "profile": {"output_type": "map"}, + "loops": {"output_type": "number"}, + "value": {"output_type": "value"}, + "identity": {"output_type": None}, + "barrier": {"output_type": None}, + } + + # B. 属性访问步骤（需要Schema + 泛化） + PROPERTY_ACCESS_STEPS = { + "values": {"output_type": "value", "supports_params": True}, + "properties": {"output_type": "property", "supports_params": True}, + "valueMap": {"output_type": "map", "supports_params": True}, + "elementMap": {"output_type": "map", "supports_params": True}, + "key": {"output_type": "string", "supports_params": False}, + } + + # C. 数值参数步骤 + NUMERIC_PARAM_STEPS = { + "limit": {"range": (1, 100)}, + "skip": {"range": (0, 50)}, + "tail": {"range": (1, 20)}, + "sample": {"range": (1, 10)}, + "range": {"range": (0, 100)}, + "coin": {"range": (0.1, 0.9), "type": "float"}, # 概率值，0.0-1.0 + } + + # D. 导航步骤（需要Schema关系 + 泛化） + NAVIGATION_STEPS = { + "out": {"direction": "outgoing", "target": "vertex"}, + "in": {"direction": "incoming", "target": "vertex"}, + "both": {"direction": "both", "target": "vertex"}, + "outE": {"direction": "outgoing", "target": "edge"}, + "inE": {"direction": "incoming", "target": "edge"}, + "bothE": {"direction": "both", "target": "edge"}, + "outV": {"direction": "out", "target": "vertex"}, + "inV": {"direction": "in", "target": "vertex"}, + "bothV": {"direction": "both", "target": "vertex"}, # 从边到两端顶点 + "otherV": {"direction": "other", "target": "vertex"}, + } + + # E. 过滤步骤（需要条件 + 泛化） + FILTER_STEPS = { + "has": {"type": "property_filter", "needs_value": True}, + "hasLabel": {"type": "label_filter", "needs_value": True}, + "hasId": {"type": "id_filter", "needs_value": True}, + "hasKey": {"type": "key_filter", "needs_value": True}, + "hasValue": {"type": "value_filter", "needs_value": True}, + "where": {"type": "complex_filter", "needs_traversal": True}, + "is": {"type": "value_comparison", "needs_value": True}, + "not": {"type": "negation", "needs_traversal": True}, + "as": {"type": "label_marker", "needs_value": True}, + "filter": {"type": "traversal_filter", "needs_traversal": True}, # 通用过滤 + "and": {"type": "logical_and", "needs_traversal": True, "multi_param": True}, # 逻辑与 + "or": {"type": "logical_or", "needs_traversal": True, "multi_param": True}, # 逻辑或 + } + + # F. 转换步骤 + TRANSFORM_STEPS = { + "order": {"output_type": None}, + "dedup": {"output_type": None}, + "simplePath": {"output_type": None}, + "cyclicPath": {"output_type": None}, + "by": {"output_type": None, "is_modulator": True}, # 修饰符步骤 + "constant": {"output_type": "value", "needs_value": True}, # 常量映射 + } + + # G. 聚合步骤 + AGGREGATE_STEPS = { + "group": {"output_type": "map"}, + "groupCount": {"output_type": "map"}, + "sum": {"output_type": "number"}, + "mean": {"output_type": "number"}, + "min": {"output_type": "value"}, + "max": {"output_type": "value"}, + } + + # G2. 副作用步骤（Side Effect） + SIDE_EFFECT_STEPS = { + "aggregate": {"output_type": None, "needs_key": True}, # 聚合到侧效果 + "store": {"output_type": None, "needs_key": True}, # 存储到侧效果 + "sideEffect": {"output_type": None, "needs_traversal": True}, # 执行侧效果遍历 + "cap": {"output_type": "value", "needs_key": True}, # 获取侧效果值 + "sack": {"output_type": "value"}, # 获取sack值 + } + + # H. 终端步骤 + TERMINAL_STEPS = { + "toList": {"output_type": "list"}, + "toSet": {"output_type": "set"}, + "next": {"output_type": "value"}, + "hasNext": {"output_type": "boolean"}, + "tryNext": {"output_type": "optional"}, # 返回 Optional + } + + # I. 边修改步骤 + EDGE_MODIFICATION_STEPS = { + "from": {"output_type": None, "needs_label_or_traversal": True}, + "to": {"output_type": None, "needs_label_or_traversal": True}, + } + + # J. 谓词（用于has等步骤） + # 谓词由 Visitor 解析为 Predicate/TextPredicate 对象，在 E 层过滤步骤中处理 + PREDICATES = { + # 数值谓词 + "eq": {"types": ["numeric", "string", "any"]}, + "neq": {"types": ["numeric", "string", "any"]}, + "gt": {"types": ["numeric"]}, + "gte": {"types": ["numeric"]}, + "lt": {"types": ["numeric"]}, + "lte": {"types": ["numeric"]}, + "between": {"types": ["numeric"]}, + "inside": {"types": ["numeric"]}, + "outside": {"types": ["numeric"]}, + # 字符串谓词（TextP） + "startingWith": {"types": ["string"]}, + "endingWith": {"types": ["string"]}, + "containing": {"types": ["string"]}, + "notStartingWith": {"types": ["string"]}, + "notEndingWith": {"types": ["string"]}, + "notContaining": {"types": ["string"]}, + "regex": {"types": ["string"]}, + "notRegex": {"types": ["string"]}, + # 集合谓词 + "within": {"types": ["any"]}, + "without": {"types": ["any"]}, + # 否定谓词 + "not": {"types": ["any"]}, + } + + # K. 图算法步骤 + GRAPH_ALGORITHM_STEPS = { + "pageRank": {"output_type": None}, + "peerPressure": {"output_type": None}, + "connectedComponent": {"output_type": None}, + "shortestPath": {"output_type": None}, + } + + # L. 工具步骤 + UTILITY_STEPS = { + "math": {"output_type": "number", "needs_expression": True}, + "subgraph": {"output_type": None, "needs_key": True}, + "timeLimit": {"output_type": None, "needs_number": True}, + "inject": {"output_type": None, "multi_param": True}, # 支持多参数 + "call": {"output_type": None, "needs_string": True}, + "io": {"output_type": None, "needs_string": True}, + "mergeE": {"output_type": None}, # 合并边 + "mergeV": {"output_type": None}, # 合并顶点 + "with": {"output_type": None, "multi_param": True}, # 配置选项 + } + + # M. 特殊步骤（需要单独实现） + SPECIAL_STEPS = { + # 起始步骤 + "V": {"category": "start"}, + "E": {"category": "start"}, + # 写操作 + "addV": {"category": "write"}, + "addE": {"category": "write"}, + "property": {"category": "write"}, + # 分支逻辑 + "choose": {"category": "branch"}, + "coalesce": {"category": "branch"}, + "optional": {"category": "branch"}, + # 循环逻辑 + "repeat": {"category": "loop"}, + "until": {"category": "loop"}, + "times": {"category": "loop"}, + "emit": {"category": "loop"}, + # 模式匹配 + "match": {"category": "pattern"}, + # 投影 + "select": {"category": "projection"}, + "project": {"category": "projection"}, + # 路径 + "path": {"category": "path"}, + "tree": {"category": "path"}, + # 高阶操作 + "union": {"category": "higher_order"}, + "flatMap": {"category": "higher_order"}, + "map": {"category": "higher_order"}, + "local": {"category": "higher_order"}, # 本地作用域遍历 + } + + def __init__( + self, + schema: Schema, + recipe: Traversal, + gremlin_base: GremlinBase, + controller: CombinationController | None = None, + ): + """ + 初始化生成器 + + Args: + schema: 图Schema + recipe: 查询配方 + gremlin_base: Gremlin基础工具 + controller: 组合控制器（可选） + """ + self.schema = schema + self.recipe = recipe + self.gremlin_base = gremlin_base + self.generated_pairs: set[tuple[str, str]] = set() + + # 集成组合控制器 + if controller is None: + try: + possible_paths = [ + "combination_control_config.json", + os.path.join(os.path.dirname(__file__), "combination_control_config.json"), + ] + + config_loaded = False + for config_path in possible_paths: + if os.path.exists(config_path): + with open(config_path, encoding="utf-8") as f: + config = json.load(f) + self.controller = CombinationController(config) + config_loaded = True + break + + if not config_loaded: + print("⚠️ 未找到CombinationController配置文件") + self.controller = None + + except (FileNotFoundError, json.JSONDecodeError) as e: + print(f"⚠️ 无法加载CombinationController配置: {e}") + self.controller = None + else: + self.controller = controller + + # 随机增强计数器（跟踪每个查询路径的增强次数） + self.enhancement_counts: dict[str, int] = {} + + # 配方路径完成标记 + self.recipe_path_completed = False + + def generate(self) -> list[tuple[str, str]]: + """ + 主生成函数，启动递归生成过程 + + 保护机制： + 1. 优先完成配方路径（忽略数量限制） + 2. 配方完成后，才应用数量限制 + 3. 如果最终超出限制，优先保留深层查询 + + Returns: + 去重后的 (查询, 描述) 对列表 + """ + self.generated_pairs.clear() + self.enhancement_counts.clear() + self.recipe_path_completed = False + + self._recursive_generate( + recipe_steps=self.recipe.steps, + current_query="g", + current_desc="从图中开始", + current_label=None, + current_type="graph", + ) + + # 后处理：如果超出限制，优先保留深层查询 + results = list(self.generated_pairs) + + if self.controller: + category = self.controller.get_chain_category(len(self.recipe.steps)) + max_limit = self.controller.max_total.get(category) + + if max_limit and len(results) > max_limit: + # 超出限制，按深度排序，保留深层查询 + def get_depth(query_desc_pair): + query = query_desc_pair[0] + # 统计步骤数（排除字符串中的点号） + # 简单方法：统计方法调用（大写字母开头或小写方法名） + import re + + steps = re.findall(r"\.\w+\(", query) + return len(steps) + + # 按深度降序排序 + results.sort(key=get_depth, reverse=True) + + # 保留前max_limit个 + results = results[:max_limit] + + print(f"⚠️ 生成数量超出限制，已裁剪：{len(self.generated_pairs)} → {max_limit}") + + return results + + def _recursive_generate( + self, recipe_steps: list[Step], current_query: str, current_desc: str, current_label: str, current_type: str + ): + """ + 核心递归生成函数 - 深度优先搜索 + 回溯 + + Args: + recipe_steps: 剩余的配方步骤 + current_query: 当前查询字符串 + current_desc: 当前描述字符串 + current_label: 当前顶点/边标签 + current_type: 当前类型 (graph/vertex/edge/value/...) + """ + # 1. 终止条件：配方步骤用完 + if not recipe_steps: + self.generated_pairs.add((current_query, current_desc)) + + # 标记配方路径完成（第一次到达终点） + if not self.recipe_path_completed: + self.recipe_path_completed = True + print(f"✅ 配方路径完成: {current_query}") + + # 尝试随机增强（终端步骤） + if self.controller: + enhancement_count = self.enhancement_counts.get(current_query, 0) + if self.controller.should_apply_random_enhancement(True, enhancement_count): + enhanced = self._apply_random_enhancement(current_query, current_desc, current_label, current_type) + for enh_query, enh_desc in enhanced: + self.generated_pairs.add((enh_query, enh_desc)) + self.enhancement_counts[enh_query] = enhancement_count + 1 + return + + # 2. 取出当前步骤 + step_recipe = recipe_steps[0] + remaining_steps = recipe_steps[1:] + + # 3. 检查是否应该停止生成（保护机制） + if self.controller: + category = self.controller.get_chain_category(len(self.recipe.steps)) + + # 如果配方路径未完成，不停止（保护机制） + if self.recipe_path_completed: + if self.controller.should_stop_generation(len(self.generated_pairs), category): + return + + # 4. 获取当前步骤的所有合法选项 + options = self._get_valid_options_for_step(step_recipe, current_label, current_type, remaining_steps) + + # 5. 遍历每个选项，继续递归 + for option in options: + next_query = current_query + option["query_part"] + next_desc = current_desc + option["desc_part"] + + # 保存中间结果 + self.generated_pairs.add((next_query, next_desc)) + + # 尝试随机增强（中间步骤） + if self.controller and remaining_steps: + enhancement_count = self.enhancement_counts.get(next_query, 0) + if self.controller.should_apply_random_enhancement(False, enhancement_count): + enhanced = self._apply_random_enhancement( + next_query, next_desc, option["new_label"], option["new_type"] + ) + for enh_query, enh_desc in enhanced: + # 对增强后的查询继续执行剩余步骤 + self._recursive_generate( + remaining_steps, enh_query, enh_desc, option["new_label"], option["new_type"] + ) + self.enhancement_counts[enh_query] = enhancement_count + 1 + + # 继续递归（如果不是终止类型） + if option["new_type"] != "none": + self._recursive_generate( + remaining_steps, next_query, next_desc, option["new_label"], option["new_type"] + ) + + # 步骤选项生成（分发器） + + def _get_valid_options_for_step( + self, step_recipe: Step, current_label: str, current_type: str, remaining_steps: list[Step] | None = None + ) -> list[dict]: + """ + 根据步骤类型分发到对应的处理器 + + Args: + step_recipe: 配方步骤 + current_label: 当前标签 + current_type: 当前类型 + remaining_steps: 剩余步骤（用于判断是否是终端步骤） + + Returns: + 选项列表，每个选项包含: query_part, desc_part, new_label, new_type + """ + step_name = step_recipe.name + + # 优先级1: 特殊步骤（复杂逻辑） + if step_name in self.SPECIAL_STEPS: + return self._handle_special_step(step_recipe, current_label, current_type, remaining_steps) + + # 优先级2: 过滤步骤（需要泛化） + if step_name in self.FILTER_STEPS: + return self._handle_filter_step(step_recipe, current_label, current_type, remaining_steps) + + # 优先级3: 导航步骤（需要Schema） + if step_name in self.NAVIGATION_STEPS: + return self._handle_navigation_step(step_recipe, current_label, current_type) + + # 优先级4: 属性访问步骤 + if step_name in self.PROPERTY_ACCESS_STEPS: + return self._handle_property_access_step(step_recipe, current_label, current_type) + + # 优先级5: 简单步骤 + if step_name in self.SIMPLE_STEPS: + return self._handle_simple_step(step_name, current_label, current_type) + + # 优先级6: 转换步骤 + if step_name in self.TRANSFORM_STEPS: + return self._handle_transform_step(step_recipe, current_label, current_type) + + # 优先级7: 聚合步骤 + if step_name in self.AGGREGATE_STEPS: + return self._handle_aggregate_step(step_recipe, current_label, current_type) + + # 优先级7.5: 副作用步骤 + if step_name in self.SIDE_EFFECT_STEPS: + return self._handle_side_effect_step(step_recipe, current_label, current_type) + + # 优先级8: 终端步骤 + if step_name in self.TERMINAL_STEPS: + return self._handle_terminal_step(step_recipe, current_label, current_type) + + # 优先级9: 数值参数步骤 + if step_name in self.NUMERIC_PARAM_STEPS: + return self._handle_numeric_param_step(step_name, step_recipe.params, current_label, current_type) + + # 优先级10: 图算法步骤 + if step_name in self.GRAPH_ALGORITHM_STEPS: + return self._handle_graph_algorithm_step(step_name, current_label, current_type) + + # 优先级11: 工具步骤 + if step_name in self.UTILITY_STEPS: + return self._handle_utility_step(step_recipe, current_label, current_type) + + # 优先级12: 边修改步骤 + if step_name in self.EDGE_MODIFICATION_STEPS: + return self._handle_edge_modification_step(step_recipe, current_label, current_type) + + # 未知步骤 + print(f"⚠️ 未知步骤: {step_name}") + return [] + + # A. 简单步骤处理器 + + def _handle_simple_step(self, step_name: str, current_label: str, current_type: str) -> list[dict]: + """ + 处理简单步骤（无参数） + + Args: + step_name: 步骤名称 + current_label: 当前标签 + current_type: 当前类型 + + Returns: + 选项列表 + """ + step_info = self.SIMPLE_STEPS[step_name] + new_type = step_info["output_type"] + + # 如果new_type是None，保持当前类型 + if new_type is None: + new_type = current_type + + # 从GremlinBase获取翻译 + desc = self.gremlin_base.get_token_desc(step_name) + + return [ + { + "query_part": f".{step_name}()", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ] + + # F. 转换步骤处理器 + + def _handle_transform_step(self, step_recipe: Step, current_label: str, current_type: str) -> list[dict]: + """ + 处理转换步骤（order, dedup等） + + 转换步骤通常不改变数据的结构，只是对数据进行排序、去重、限制等操作 + + Args: + step_recipe: 配方步骤 + current_label: 当前标签 + current_type: 当前类型 + + Returns: + 选项列表 + """ + step_name = step_recipe.name + step_params = step_recipe.params + step_info = self.TRANSFORM_STEPS[step_name] + new_type = step_info["output_type"] + + if new_type is None: + new_type = current_type + + options = [] + + # 从GremlinBase获取翻译 + desc = self.gremlin_base.get_token_desc(step_name) + + # order() 步骤 - 排序 + if step_name == "order": + # order() 不接受参数，必须用 .by() 修饰符 + # 如果配方中有参数，说明是错误的语法，忽略参数 + options.append( + { + "query_part": f".{step_name}()", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + + # dedup() 步骤 - 去重 + elif step_name == "dedup": + # dedup() 可以接受标签参数（用于 as/select 场景） + # dedup('a') - 按标签 'a' 去重 + # dedup() - 去重整个元素 + # 注意：如果要按属性去重，应该用 .dedup().by('name') + if step_params: + # 有参数：这是标签参数，保留原样 + params_str = ", ".join([f"'{p}'" if isinstance(p, str) else str(p) for p in step_params]) + options.append( + { + "query_part": f".{step_name}({params_str})", + "desc_part": f"，{desc}（按标签）", + "new_label": current_label, + "new_type": new_type, + } + ) + else: + # 无参数 + options.append( + { + "query_part": f".{step_name}()", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + + # simplePath() 和 cyclicPath() - 路径过滤 + elif step_name in ["simplePath", "cyclicPath"]: + # 这些步骤通常无参数 + options.append( + { + "query_part": f".{step_name}()", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + + # by() 步骤 - 修饰符 + elif step_name == "by": + # by() 是修饰符步骤，用于修饰 order(), dedup(), group() 等 + # 通常有参数，保留原样 + from .GremlinExpr import AnonymousTraversal + + if step_params: + first_param = step_params[0] + if isinstance(first_param, AnonymousTraversal): + # by(__.xxx) 嵌套遍历参数 + nested_variants = self._generate_nested_traversal_variants(first_param, current_depth=0) + nested_desc = self._describe_nested_traversal(first_param) + variant_str = f"__.{nested_variants[0]}" if nested_variants else "__.identity()" + # 处理额外参数（如排序方向） + if len(step_params) > 1: + extra = ", ".join([f"'{p}'" if isinstance(p, str) else str(p) for p in step_params[1:]]) + options.append( + { + "query_part": f".{step_name}({variant_str}, {extra})", + "desc_part": f"，按{nested_desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + else: + options.append( + { + "query_part": f".{step_name}({variant_str})", + "desc_part": f"，按{nested_desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + elif isinstance(first_param, str): + # by('name') 或 by('name', desc) 字符串属性参数 + prop_desc = self.gremlin_base.get_schema_desc(first_param) + params_str = ", ".join( + [f"'{p}'" if isinstance(p, str) else str(p) if p is not None else "" for p in step_params] + ) + params_str = params_str.rstrip(", ") + # 检查是否有排序方向参数 + if len(step_params) > 1: + direction = step_params[1] + dir_desc = "降序" if str(direction) in ("desc", "Order.desc", "decr") else "升序" + options.append( + { + "query_part": f".{step_name}({params_str})", + "desc_part": f"，按'{prop_desc}'{dir_desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + else: + options.append( + { + "query_part": f".{step_name}({params_str})", + "desc_part": f"，按'{prop_desc}'", + "new_label": current_label, + "new_type": new_type, + } + ) + else: + # 其他类型参数（如 T.label, T.id 等） + params_str = ", ".join( + [f"'{p}'" if isinstance(p, str) else str(p) if p is not None else "" for p in step_params] + ) + params_str = params_str.rstrip(", ") + options.append( + { + "query_part": f".{step_name}({params_str})", + "desc_part": f"，按'{first_param}'", + "new_label": current_label, + "new_type": new_type, + } + ) + else: + # 无参数 + options.append( + {"query_part": f".{step_name}()", "desc_part": "", "new_label": current_label, "new_type": new_type} + ) + + # constant() 步骤 - 常量映射 + elif step_name == "constant": + # constant接受一个值参数 + if step_params: + value = step_params[0] + value_str = f"'{value}'" if isinstance(value, str) else str(value) + options.append( + { + "query_part": f".{step_name}({value_str})", + "desc_part": f"，{desc}（值：{value}）", + "new_label": current_label, + "new_type": new_type, + } + ) + else: + # 无参数，生成一个默认值 + options.append( + { + "query_part": f'.{step_name}("value")', + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + + # 其他转换步骤 + else: + options.append( + { + "query_part": f".{step_name}()", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + + return options + + # G. 聚合步骤处理器 + + def _handle_aggregate_step(self, step_recipe: Step, current_label: str, current_type: str) -> list[dict]: + """ + 处理聚合步骤（group, sum等） + + 聚合步骤通常将数据转换为聚合结果（如 map、number 等） + + Args: + step_recipe: 配方步骤 + current_label: 当前标签 + current_type: 当前类型 + + Returns: + 选项列表 + """ + step_name = step_recipe.name + step_params = step_recipe.params + step_info = self.AGGREGATE_STEPS[step_name] + new_type = step_info["output_type"] + + # 从GremlinBase获取翻译 + desc = self.gremlin_base.get_token_desc(step_name) + + # group() 和 groupCount() 可以接受标签参数（用于 side-effect） + if step_name in ["group", "groupCount"] and step_params: + # 有参数：这是标签参数，保留原样 + params_str = ", ".join([f"'{p}'" if isinstance(p, str) else str(p) for p in step_params]) + return [ + { + "query_part": f".{step_name}({params_str})", + "desc_part": f"，{desc}（副作用）", + "new_label": None, + "new_type": new_type, + } + ] + else: + # 无参数版本 + return [ + { + "query_part": f".{step_name}()", + "desc_part": f"，{desc}", + "new_label": None, # 聚合后通常没有标签 + "new_type": new_type, + } + ] + + # G2. 副作用步骤处理器 + + def _handle_side_effect_step(self, step_recipe: Step, current_label: str, current_type: str) -> list[dict]: + """ + 处理副作用步骤（aggregate, store, sideEffect等） + + 副作用步骤通常不改变遍历流，但会产生副作用 + + Args: + step_recipe: 配方步骤 + current_label: 当前标签 + current_type: 当前类型 + + Returns: + 选项列表 + """ + from .GremlinExpr import AnonymousTraversal + + step_name = step_recipe.name + step_params = step_recipe.params + step_info = self.SIDE_EFFECT_STEPS[step_name] + new_type = step_info.get("output_type", current_type) + + # aggregate, store, cap需要key参数 + if step_info.get("needs_key"): + if not step_params: + # 生成一个默认key + key = "x" + else: + key = step_params[0] + + # 从GremlinBase获取翻译，传入key参数 + desc = self.gremlin_base.get_token_desc(step_name, key) + + return [ + { + "query_part": f".{step_name}('{key}')", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ] + + # sideEffect需要traversal参数 + elif step_info.get("needs_traversal"): + if not step_params or not isinstance(step_params[0], AnonymousTraversal): + # 没有遍历参数，使用通用描述 + desc = self.gremlin_base.get_token_desc(step_name) + return [ + { + "query_part": f".{step_name}(__.identity())", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ] + else: + # 使用提供的遍历，递归生成变体 + traversal = step_params[0] + nested_variants = self._generate_nested_traversal_variants(traversal, current_depth=0) + + # 为嵌套遍历生成可读描述 + nested_desc = self._describe_nested_traversal(traversal) + + result = [] + for variant in nested_variants[:1]: # 只取第一个变体避免组合爆炸 + result.append( + { + "query_part": f".{step_name}({variant})", + "desc_part": f"，执行副作用操作（{nested_desc}）", + "new_label": current_label, + "new_type": new_type, + } + ) + return ( + result + if result + else [ + { + "query_part": f".{step_name}(__.identity())", + "desc_part": f"，{self.gremlin_base.get_token_desc(step_name)}", + "new_label": current_label, + "new_type": new_type, + } + ] + ) + + # sack无参数 + else: + # 从GremlinBase获取翻译 + desc = self.gremlin_base.get_token_desc(step_name) + + return [ + { + "query_part": f".{step_name}()", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ] + + # H. 终端步骤处理器 + + def _handle_terminal_step(self, step_recipe: Step, current_label: str, current_type: str) -> list[dict]: + """ + 处理终端步骤（toList, next等） + + 终端步骤通常是查询的最后一步，用于获取结果 + + Args: + step_recipe: 配方步骤 + current_label: 当前标签 + current_type: 当前类型 + + Returns: + 选项列表 + """ + step_name = step_recipe.name + step_params = step_recipe.params + step_info = self.TERMINAL_STEPS[step_name] + new_type = step_info["output_type"] + + # 从GremlinBase获取翻译 + desc = self.gremlin_base.get_token_desc(step_name) + + # next() 可以接受整数参数：next(n) 获取 n 个元素 + if step_name == "next" and step_params: + # 检查参数是否是整数（不是 Terminal 对象） + from .GremlinExpr import Terminal + + if step_params and not isinstance(step_params[0], Terminal): + # 有整数参数 + param_val = step_params[0] + return [ + { + "query_part": f".{step_name}({param_val})", + "desc_part": f"，{desc}（获取{param_val}个）", + "new_label": current_label, + "new_type": new_type, + } + ] + + # 无参数版本 + return [ + { + "query_part": f".{step_name}()", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ] + + # C. 数值参数步骤处理器 + + def _handle_numeric_param_step( + self, step_name: str, params: list, current_label: str, current_type: str + ) -> list[dict]: + """ + 处理数值参数步骤（limit, skip等） + + Args: + step_name: 步骤名称 + params: 配方参数 + current_label: 当前标签 + current_type: 当前类型 + + Returns: + 选项列表 + """ + config = self.NUMERIC_PARAM_STEPS[step_name] + + # 如果配方提供了参数，使用配方参数 + if params: + value = params[0] + else: + # 否则在合理范围内随机生成 + min_val, max_val = config["range"] + value = random.randint(min_val, max_val) + + # 从GremlinBase获取翻译 + desc = self.gremlin_base.get_token_desc(step_name) + + # 如果翻译中包含占位符，替换它 + if "{}" in desc: + desc = desc.format(value) + + return [ + { + "query_part": f".{step_name}({value})", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": current_type, + } + ] + + # K. 图算法步骤处理器 + + def _handle_graph_algorithm_step(self, step_name: str, current_label: str, current_type: str) -> list[dict]: + """ + 处理图算法步骤（pageRank, connectedComponent等） + + 这些步骤通常无参数或有配置参数，主要用于图分析 + + Args: + step_name: 步骤名称 + current_label: 当前标签 + current_type: 当前类型 + + Returns: + 选项列表 + """ + # 从GremlinBase获取翻译 + desc = self.gremlin_base.get_token_desc(step_name) + + return [ + { + "query_part": f".{step_name}()", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": current_type, + } + ] + + # L. 工具步骤处理器 + + def _handle_utility_step(self, step_recipe: Step, current_label: str, current_type: str) -> list[dict]: + """ + 处理工具步骤（math, subgraph, timeLimit, inject, call, io等） + + 这些步骤有各种不同的参数类型 + + Args: + step_recipe: 配方步骤 + current_label: 当前标签 + current_type: 当前类型 + + Returns: + 选项列表 + """ + step_name = step_recipe.name + step_params = step_recipe.params + step_info = self.UTILITY_STEPS[step_name] + new_type = step_info.get("output_type", current_type) + + # 从GremlinBase获取翻译 + desc = self.gremlin_base.get_token_desc(step_name) + + # math - 需要表达式字符串 + if step_info.get("needs_expression"): + if step_params: + expr = step_params[0] + else: + expr = "_ + 1" # 默认表达式 + return [ + { + "query_part": f".{step_name}('{expr}')", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ] + + # subgraph - 需要键参数 + elif step_info.get("needs_key"): + if step_params: + key = step_params[0] + else: + key = "sg" # 默认键 + return [ + { + "query_part": f".{step_name}('{key}')", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ] + + # timeLimit - 需要数值参数 + elif step_info.get("needs_number"): + if step_params: + value = step_params[0] + else: + value = 1000 # 默认1秒 + return [ + { + "query_part": f".{step_name}({value})", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ] + + # inject - 支持多参数 + elif step_info.get("multi_param"): + if step_params: + params_str = ", ".join([str(p) for p in step_params]) + else: + params_str = "1, 2, 3" # 默认值 + return [ + { + "query_part": f".{step_name}({params_str})", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ] + + # call, io - 需要字符串参数 + elif step_info.get("needs_string"): + value = step_params[0] if step_params else "service" if step_name == "call" else "file.json" + return [ + { + "query_part": f".{step_name}('{value}')", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ] + + # 默认无参数 + return [ + { + "query_part": f".{step_name}()", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": new_type, + } + ] + + # M. 边修改步骤处理器 + + def _handle_edge_modification_step(self, step_recipe: Step, current_label: str, current_type: str) -> list[dict]: + """ + 处理边修改步骤（from, to） + + 这些步骤用于指定边的起点和终点 + + Args: + step_recipe: 配方步骤 + current_label: 当前标签 + current_type: 当前类型 + + Returns: + 选项列表 + """ + from .GremlinExpr import AnonymousTraversal + + step_name = step_recipe.name + step_params = step_recipe.params + + # 从GremlinBase获取翻译 + desc = self.gremlin_base.get_token_desc(step_name) + + if not step_params: + # 无参数，生成默认标签 + label = "a" if step_name == "from" else "b" + return [ + { + "query_part": f".{step_name}('{label}')", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": current_type, + } + ] + + param = step_params[0] + + # 如果是嵌套遍历 + if isinstance(param, AnonymousTraversal): + nested_variants = self._generate_nested_traversal_variants(param, current_depth=0) + result = [] + for variant in nested_variants[:1]: # 只取第一个变体避免组合爆炸 + result.append( + { + "query_part": f".{step_name}({variant})", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": current_type, + } + ) + return ( + result + if result + else [ + { + "query_part": f".{step_name}('a')", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": current_type, + } + ] + ) + + # 字符串标签 + return [ + { + "query_part": f".{step_name}('{param}')", + "desc_part": f"，{desc}", + "new_label": current_label, + "new_type": current_type, + } + ] + + # B. 属性访问步骤处理器 + + def _handle_property_access_step(self, step_recipe: Step, current_label: str, current_type: str) -> list[dict]: + """ + 处理属性访问步骤（values, properties, valueMap等） + + 支持两种模式： + 1. 无参数：返回所有属性 + 2. 有参数：返回指定属性 + 泛化到同级属性 + + Args: + step_recipe: 配方步骤 + current_label: 当前标签 + current_type: 当前类型 + + Returns: + 选项列表 + """ + step_name = step_recipe.name + step_params = step_recipe.params + step_info = self.PROPERTY_ACCESS_STEPS[step_name] + new_type = step_info["output_type"] + + options = [] + + # 如果没有当前标签，只能生成无参数版本 + if not current_label: + step_desc = self.gremlin_base.get_token_desc(step_name) + options.append( + { + "query_part": f".{step_name}()", + "desc_part": f"，{step_desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + return options + + # 获取当前标签的所有属性 + all_properties = [p["name"] for p in self.schema.get_properties_with_type(current_label)] + + if not all_properties: + # 没有属性，返回无参数版本 + step_desc = self.gremlin_base.get_token_desc(step_name) + options.append( + { + "query_part": f".{step_name}()", + "desc_part": f"，{step_desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + return options + + # 情况1：配方指定了属性 + if step_params and step_params[0]: + # 支持多参数：values('name', 'age') + recipe_props = step_params if isinstance(step_params, list) else [step_params] + param_count = len(recipe_props) + + if self.controller: + chain_category = self.controller.get_chain_category(len(self.recipe.steps)) + + if param_count == 1: + # 单参数：使用原有的单参数泛化 + selected_properties = self.controller.select_sibling_options( + recipe_option=recipe_props[0], all_options=all_properties, chain_category=chain_category + ) + + for prop_name in selected_properties: + prop_desc = self.gremlin_base.get_schema_desc(prop_name) + step_desc = self.gremlin_base.get_token_desc(f"{step_name}_with_key") + if not step_desc or step_desc == f"{step_name}_with_key": + step_desc = self.gremlin_base.get_token_desc(step_name) + step_desc = step_desc.format(prop_desc) if "{}" in step_desc else f"{step_desc}：{prop_desc}" + options.append( + { + "query_part": f'.{step_name}("{prop_name}")', + "desc_part": f"，{step_desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + else: + # 多参数：使用多参数泛化，保持参数数量一致 + prop_combinations = self.controller.select_multi_param_schema_options( + recipe_params=recipe_props, all_options=all_properties, chain_category=chain_category + ) + + for combo in prop_combinations: + props_str = '", "'.join(combo) + props_desc = "、".join([self.gremlin_base.get_schema_desc(p) for p in combo]) + step_desc = self.gremlin_base.get_token_desc(f"{step_name}_with_key") + if not step_desc or step_desc == f"{step_name}_with_key": + step_desc = self.gremlin_base.get_token_desc(step_name) + step_desc = step_desc.format(props_desc) if "{}" in step_desc else f"{step_desc}：{props_desc}" + options.append( + { + "query_part": f'.{step_name}("{props_str}")', + "desc_part": f"，{step_desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + else: + # 没有控制器，只保留原配方 + if param_count == 1: + prop_name = recipe_props[0] + if prop_name in all_properties: + prop_desc = self.gremlin_base.get_schema_desc(prop_name) + step_desc = self.gremlin_base.get_token_desc(f"{step_name}_with_key") + if not step_desc or step_desc == f"{step_name}_with_key": + step_desc = self.gremlin_base.get_token_desc(step_name) + step_desc = step_desc.format(prop_desc) if "{}" in step_desc else f"{step_desc}：{prop_desc}" + options.append( + { + "query_part": f'.{step_name}("{prop_name}")', + "desc_part": f"，{step_desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + else: + props_str = '", "'.join(recipe_props) + props_desc = "、".join([self.gremlin_base.get_schema_desc(p) for p in recipe_props]) + step_desc = self.gremlin_base.get_token_desc(f"{step_name}_with_key") + if not step_desc or step_desc == f"{step_name}_with_key": + step_desc = self.gremlin_base.get_token_desc(step_name) + step_desc = step_desc.format(props_desc) if "{}" in step_desc else f"{step_desc}：{props_desc}" + options.append( + { + "query_part": f'.{step_name}("{props_str}")', + "desc_part": f"，{step_desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + + # 情况2：配方没有指定属性 + else: + # 生成无参数版本 + step_desc = self.gremlin_base.get_token_desc(step_name) + options.append( + { + "query_part": f".{step_name}()", + "desc_part": f"，{step_desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + + # 可选：也生成一些带参数的版本（使用控制器限制数量） + if self.controller and all_properties: + chain_category = self.controller.get_chain_category(len(self.recipe.steps)) + strategy = self.controller.property_gen[chain_category] + + # 随机选择一些属性 + max_props = strategy.get("additional_random_max", 2) + selected_count = min(max_props, len(all_properties)) + + if selected_count > 0: + selected_props = random.sample(all_properties, selected_count) + for prop_name in selected_props: + prop_desc = self.gremlin_base.get_schema_desc(prop_name) + # 有参数时，使用 step_name_with_key 获取翻译 + step_desc = self.gremlin_base.get_token_desc(f"{step_name}_with_key") + # 如果没有找到 _with_key 版本，回退到普通版本 + if not step_desc or step_desc == f"{step_name}_with_key": + step_desc = self.gremlin_base.get_token_desc(step_name) + # 替换占位符 + step_desc = step_desc.format(prop_desc) if "{}" in step_desc else f"{step_desc}：{prop_desc}" + options.append( + { + "query_part": f'.{step_name}("{prop_name}")', + "desc_part": f"，{step_desc}", + "new_label": current_label, + "new_type": new_type, + } + ) + + return options + + # 嵌套遍历泛化辅助方法 + + def _generate_nested_traversal_variants(self, anonymous_trav, current_depth=0): + """ + 递归生成嵌套遍历的变体 + + Args: + anonymous_trav: AnonymousTraversal 对象 + current_depth: 当前嵌套深度 + + Returns: + 嵌套遍历字符串的列表 + """ + from .GremlinExpr import AnonymousTraversal + + # 获取配置 + max_depth = 3 # 默认值 + max_variants_per_step = 2 # 默认值 + + if self.controller and hasattr(self.controller, "config"): + nested_config = self.controller.config.get("nested_traversal_strategy", {}) + max_depth = nested_config.get("max_nesting_depth", 3) + max_variants_per_step = nested_config.get("max_variants_per_nested_step", 2) + + # 深度限制 + if current_depth >= max_depth: + # 超过最大深度，返回占位符 + return ["..."] + + if not anonymous_trav or not anonymous_trav.steps: + return [""] + + # 递归生成每个步骤的变体 + all_step_variants = [] + + for step in anonymous_trav.steps: + step_variants = [] + + # 检查步骤是否包含嵌套遍历 + has_nested = False + for param in step.params: + if isinstance(param, AnonymousTraversal): + has_nested = True + break + + if has_nested: + # 步骤包含嵌套遍历，递归处理 + for _param_idx, param in enumerate(step.params): + if isinstance(param, AnonymousTraversal): + # 递归生成嵌套的变体 + nested_variants = self._generate_nested_traversal_variants(param, current_depth + 1) + + # 为当前步骤生成变体（限制数量） + for nested_var in nested_variants[:max_variants_per_step]: + step_str = f"{step.name}({nested_var})" + step_variants.append(step_str) + else: + # 非嵌套参数，直接使用 + pass + else: + # 步骤不包含嵌套遍历，生成简单变体 + step_variants = self._generate_simple_step_variants(step, max_variants_per_step) + + all_step_variants.append(step_variants) + + # 组合所有步骤的变体 + if not all_step_variants: + return [""] + + # 使用笛卡尔积组合（但限制总数） + import itertools + + combinations = list(itertools.product(*all_step_variants)) + + # 限制组合数量（避免爆炸） + max_combinations = max_variants_per_step ** len(all_step_variants) + max_combinations = min(max_combinations, 10) # 最多10个组合 + + if len(combinations) > max_combinations: + import random + + combinations = random.sample(combinations, max_combinations) + + # 生成遍历字符串 + result = [] + for combo in combinations: + traversal_str = ".".join(combo) + result.append(traversal_str) + + return result + + def _describe_nested_traversal(self, anonymous_trav) -> str: + """ + 为嵌套遍历生成可读的中文描述。 + + 识别常见模式并生成对应描述，未识别的模式回退到通用描述。 + + Args: + anonymous_trav: AnonymousTraversal 对象 + + Returns: + 中文描述字符串 + """ + from .GremlinExpr import AnonymousTraversal + + if not anonymous_trav or not anonymous_trav.steps: + return "执行附加操作" + + step_names = [s.name for s in anonymous_trav.steps] + + # 常见模式识别 + # properties().drop() -> 删除所有属性 + if step_names == ["properties", "drop"]: + return "删除该元素的所有属性" + + # drop() -> 删除元素 + if step_names == ["drop"]: + return "删除该元素" + + # 逐步拼接描述 + parts = [] + for step in anonymous_trav.steps: + name = step.name + params = step.params + + if name == "properties": + if params: + prop_descs = [self.gremlin_base.get_schema_desc(str(p)) for p in params] + parts.append(f"获取'{', '.join(prop_descs)}'属性") + else: + parts.append("获取所有属性") + elif name == "drop": + parts.append("并删除") + elif name in ("out", "in", "both", "outE", "inE", "bothE"): + if params and isinstance(params[0], str): + edge_desc = self.gremlin_base.get_schema_desc(params[0]) + parts.append(f"沿'{edge_desc}'边{name}方向遍历") + else: + parts.append(f"沿{name}方向遍历") + elif name == "has": + if len(params) >= 2: + prop_desc = self.gremlin_base.get_schema_desc(str(params[0])) + # 检查第二个参数是否是 Predicate + if isinstance(params[1], Predicate): + pred = params[1] + op_map = { + "gt": "大于", + "gte": "大于等于", + "lt": "小于", + "lte": "小于等于", + "eq": "等于", + "neq": "不等于", + "between": "介于", + "inside": "在范围内", + "outside": "在范围外", + "within": "在列表中", + "without": "不在列表中", + } + op_desc = op_map.get(pred.operator, pred.operator) + parts.append(f"筛选'{prop_desc}'{op_desc}{pred.value}") + else: + parts.append(f"筛选'{prop_desc}'为'{params[1]}'") + elif len(params) == 1: + prop_desc = self.gremlin_base.get_schema_desc(str(params[0])) + parts.append(f"筛选含'{prop_desc}'属性") + elif name == "hasLabel": + if params: + label_desc = self.gremlin_base.get_schema_desc(str(params[0])) + parts.append(f"过滤出'{label_desc}'类型") + elif name == "hasId": + if params: + parts.append(f"筛选ID为{params[0]}") + elif name == "values": + if params: + val_descs = [self.gremlin_base.get_schema_desc(str(p)) for p in params] + parts.append(f"获取'{', '.join(val_descs)}'的值") + else: + parts.append("获取属性值") + elif name == "count": + parts.append("统计数量") + elif name == "sum": + parts.append("求和") + elif name == "mean": + parts.append("求平均值") + elif name == "max": + parts.append("取最大值") + elif name == "min": + parts.append("取最小值") + elif name == "dedup": + parts.append("去重") + elif name == "limit": + if params: + parts.append(f"取前{params[0]}条") + else: + parts.append("限制数量") + elif name == "range": + if len(params) >= 2: + parts.append(f"取第{params[0]}到{params[1]}条") + elif name == "order": + parts.append("排序") + elif name == "groupCount": + parts.append("分组计数") + elif name == "group": + parts.append("分组") + elif name == "fold": + parts.append("折叠为列表") + elif name == "unfold": + parts.append("展开列表") + elif name == "identity": + pass # 忽略 identity + elif name == "is": + if params and isinstance(params[0], Predicate): + pred = params[0] + op_map = { + "gt": "大于", + "gte": "大于等于", + "lt": "小于", + "lte": "小于等于", + "eq": "等于", + "neq": "不等于", + } + op_desc = op_map.get(pred.operator, pred.operator) + parts.append(f"判断值{op_desc}{pred.value}") + elif params: + parts.append(f"判断值为{params[0]}") + elif name in ("and", "or"): + # and/or 内部可能包含多个嵌套遍历参数 + logic_word = "且" if name == "and" else "或" + sub_descs = [] + for p in params or []: + if isinstance(p, AnonymousTraversal): + sub_descs.append(self._describe_nested_traversal(p)) + else: + sub_descs.append(str(p)) + if sub_descs: + parts.append(f"（{logic_word}：{f'，{logic_word}'.join(sub_descs)}）") + else: + parts.append(f"逻辑{logic_word}") + elif name == "select": + if params: + parts.append(f"选择标记{', '.join(str(p) for p in params)}") + elif name == "as": + if params: + parts.append(f"标记为'{params[0]}'") + elif name == "by": + if params: + parts.append(f"按'{self.gremlin_base.get_schema_desc(str(params[0]))}'") + elif name == "valueMap": + if params: + val_descs = [self.gremlin_base.get_schema_desc(str(p)) for p in params] + parts.append(f"获取'{', '.join(val_descs)}'的键值对") + else: + parts.append("获取所有键值对") + elif name == "label": + parts.append("获取标签") + elif name == "id": + parts.append("获取ID") + elif name == "path": + parts.append("获取路径") + elif name == "sample": + if params: + parts.append(f"随机采样{params[0]}个") + elif name == "coin": + if params: + parts.append(f"以{params[0]}概率随机保留") + elif name == "aggregate": + if params: + parts.append(f"聚合到'{params[0]}'") + elif name == "store": + if params: + parts.append(f"存储到'{params[0]}'") + elif name == "where": + # 嵌套的 where + if params and isinstance(params[0], AnonymousTraversal): + sub_desc = self._describe_nested_traversal(params[0]) + parts.append(f"条件过滤：{sub_desc}") + elif params and isinstance(params[0], Predicate): + pred = params[0] + op_map = { + "neq": "不等于", + "eq": "等于", + "within": "在列表中", + "without": "不在列表中", + } + op_desc = op_map.get(pred.operator, pred.operator) + parts.append(f"条件过滤（{op_desc}{pred.value}）") + elif name == "not": + if params and isinstance(params[0], AnonymousTraversal): + sub_desc = self._describe_nested_traversal(params[0]) + parts.append(f"排除{sub_desc}") + elif name == "union": + if params: + sub_descs = [] + for p in params: + if isinstance(p, AnonymousTraversal): + sub_descs.append(self._describe_nested_traversal(p)) + if sub_descs: + parts.append(f"联合（{'、'.join(sub_descs)}）") + elif name == "coalesce": + if params: + sub_descs = [] + for p in params: + if isinstance(p, AnonymousTraversal): + sub_descs.append(self._describe_nested_traversal(p)) + if sub_descs: + parts.append(f"优先尝试{'、'.join(sub_descs)}") + elif name == "choose": + if params and len(params) == 3: + descs = [ + self._describe_nested_traversal(p) if isinstance(p, AnonymousTraversal) else str(p) + for p in params + ] + parts.append(f"若{descs[0]}则{descs[1]}否则{descs[2]}") + elif params and len(params) == 2: + descs = [ + self._describe_nested_traversal(p) if isinstance(p, AnonymousTraversal) else str(p) + for p in params + ] + parts.append(f"若{descs[0]}则{descs[1]}") + elif name == "repeat": + if params and isinstance(params[0], AnonymousTraversal): + sub_desc = self._describe_nested_traversal(params[0]) + parts.append(f"重复{sub_desc}") + elif name == "emit": + parts.append("发射中间结果") + elif name == "times": + if params: + parts.append(f"重复{params[0]}次") + elif name == "until": + if params and isinstance(params[0], AnonymousTraversal): + sub_desc = self._describe_nested_traversal(params[0]) + parts.append(f"直到{sub_desc}") + elif name == "sideEffect": + if params and isinstance(params[0], AnonymousTraversal): + sub_desc = self._describe_nested_traversal(params[0]) + parts.append(f"附加操作：{sub_desc}") + elif name == "addV": + if params: + parts.append(f"添加'{params[0]}'顶点") + else: + parts.append("添加顶点") + elif name == "addE": + if params: + parts.append(f"添加'{params[0]}'边") + else: + parts.append("添加边") + elif name == "property": + if len(params) >= 2: + parts.append(f"设置'{params[0]}'为'{params[1]}'") + else: + desc = self.gremlin_base.get_token_desc(name) + if desc and desc != name: + parts.append(desc) + else: + parts.append(f"执行{name}操作") + + if parts: + return "，".join(parts) + return "执行附加操作" + + def _generate_simple_step_variants(self, step, max_variants): + """ + 为简单步骤（不包含嵌套遍历）生成变体 + + 这个方法专门用于嵌套遍历内部的步骤泛化。 + 策略： + - Schema 属性（标签、边等）：固定泛化 max_variants 个 + - 数据值（具体的值）：只保留原值，不泛化 + + Args: + step: Step 对象 + max_variants: 最多生成的变体数（来自配置） + + Returns: + 步骤字符串的列表 + """ + variants = [] + step_name = step.name + step_params = step.params + + # 根据步骤类型生成变体 + if step_name in ["out", "in", "both", "outE", "inE", "bothE"]: + # 导航步骤：泛化边标签（Schema 属性） + if step_params and isinstance(step_params[0], str): + edge_label = step_params[0] + all_edges = self.schema.get_edge_labels() + + # 原标签必须包含 + variants.append(f"{step_name}('{edge_label}')") + + # 添加其他边标签（限制数量） + other_edges = [e for e in all_edges if e != edge_label] + for edge in other_edges[: max_variants - 1]: + variants.append(f"{step_name}('{edge}')") + else: + variants.append(f"{step_name}()") + + elif step_name == "hasLabel": + # hasLabel: 泛化顶点标签（Schema 属性） + if len(step_params) == 1 and isinstance(step_params[0], str): + label = step_params[0] + all_labels = self.schema.get_vertex_labels() + + # 原标签必须包含 + variants.append(f"hasLabel('{label}')") + + # 添加其他标签（限制数量） + other_labels = [l for l in all_labels if l != label] + for other_label in other_labels[: max_variants - 1]: + variants.append(f"hasLabel('{other_label}')") + else: + # 多参数或其他情况：保留原样 + params_str = ", ".join([self._format_param(p) for p in step_params]) + variants.append(f"hasLabel({params_str})") + + elif step_name == "has": + # has: 区分 Schema 属性和数据值 + if len(step_params) == 2: + # has('property', value) - 第一个是属性名（Schema），第二个是值（数据） + # 嵌套内部：只保留原样，不泛化数据值 + param1_str = self._format_param(step_params[0]) + param2_str = self._format_param(step_params[1]) + variants.append(f"has({param1_str}, {param2_str})") + elif len(step_params) == 1: + # has('property') - 只有属性名 + param_str = self._format_param(step_params[0]) + variants.append(f"has({param_str})") + else: + variants.append("has(...)") + + elif step_name in ["hasKey", "hasValue"]: + # hasKey/hasValue: 保留原样（数据值，不泛化） + if len(step_params) == 1: + param_str = self._format_param(step_params[0]) + variants.append(f"{step_name}({param_str})") + else: + params_str = ", ".join([self._format_param(p) for p in step_params]) + variants.append(f"{step_name}({params_str})") + + elif step_name in ["values", "properties"]: + # 属性访问步骤：保留原样（属性名是 Schema，但在嵌套内部不泛化） + if step_params: + param_str = self._format_param(step_params[0]) + variants.append(f"{step_name}({param_str})") + else: + variants.append(f"{step_name}()") + + elif step_name in ["where", "not"]: + # 嵌套的 where/not：保留原样（避免过深递归） + variants.append(f"{step_name}(...)") + + else: + # 其他步骤：保留原样 + if step_params: + variants.append(f"{step_name}(...)") + else: + variants.append(f"{step_name}()") + + return variants[:max_variants] + + def _format_param(self, param): + """格式化参数为字符串""" + + if isinstance(param, str): + return f"'{param}'" + elif isinstance(param, Predicate): + return f"P.{param.operator}({param.value})" + elif isinstance(param, (int, float)): + return str(param) + else: + return "..." + + # E. 过滤步骤处理器 + + def _handle_filter_step( + self, step_recipe: Step, current_label: str, current_type: str, remaining_steps: list[Step] + ) -> list[dict]: + """ + 处理过滤步骤（hasLabel, has等） + + 核心泛化逻辑： + 1. hasLabel: 泛化到所有同级顶点标签 + 2. has: 泛化到所有同级属性 + 填充数据值 + + Args: + step_recipe: 配方步骤 + current_label: 当前标签 + current_type: 当前类型 + remaining_steps: 剩余步骤（用于判断是否是终端步骤） + + Returns: + 选项列表 + """ + step_name = step_recipe.name + step_params = step_recipe.params + options = [] + + # hasLabel() 步骤 + if step_name == "hasLabel": + if not step_params: + return [] + + # 支持多参数：hasLabel('person', 'movie') + recipe_labels = step_params if isinstance(step_params, list) else [step_params] + all_labels = self.schema.get_vertex_labels() + param_count = len(recipe_labels) + + if self.controller: + chain_category = self.controller.get_chain_category(len(self.recipe.steps)) + + if param_count == 1: + # 单参数：使用原有的单参数泛化 + selected_labels = self.controller.select_sibling_options( + recipe_option=recipe_labels[0], all_options=all_labels, chain_category=chain_category + ) + + for label in selected_labels: + label_desc = self.gremlin_base.get_schema_desc(label) + options.append( + { + "query_part": f".hasLabel('{label}')", + "desc_part": f"，过滤出'{label_desc}'类型的顶点", + "new_label": label, + "new_type": current_type, + } + ) + else: + # 多参数：使用多参数泛化，保持参数数量一致 + label_combinations = self.controller.select_multi_param_schema_options( + recipe_params=recipe_labels, all_options=all_labels, chain_category=chain_category + ) + + for combo in label_combinations: + labels_str = "', '".join(combo) + labels_desc = "、".join([self.gremlin_base.get_schema_desc(l) for l in combo]) + options.append( + { + "query_part": f".hasLabel('{labels_str}')", + "desc_part": f"，过滤出'{labels_desc}'类型的顶点", + "new_label": combo[0], # 使用第一个作为主标签 + "new_type": current_type, + } + ) + else: + # 没有控制器，只保留原配方 + if param_count == 1: + label = recipe_labels[0] + if label in all_labels: + label_desc = self.gremlin_base.get_schema_desc(label) + options.append( + { + "query_part": f".hasLabel('{label}')", + "desc_part": f"，过滤出'{label_desc}'类型的顶点", + "new_label": label, + "new_type": current_type, + } + ) + else: + labels_str = "', '".join(recipe_labels) + labels_desc = "、".join([self.gremlin_base.get_schema_desc(l) for l in recipe_labels]) + options.append( + { + "query_part": f".hasLabel('{labels_str}')", + "desc_part": f"，过滤出'{labels_desc}'类型的顶点", + "new_label": recipe_labels[0], + "new_type": current_type, + } + ) + + # has() 步骤 + elif step_name == "has": + if not step_params: + return [] + + # has() 可以有多种形式： + # 1. has('name') - 只有属性名 + # 2. has('name', 'Tom') - 属性名 + 单个值 + # 3. has('name', 'Tom', 'Jerry') - 属性名 + 多个值（OR语义） + recipe_prop = step_params[0] + recipe_values = step_params[1:] if len(step_params) > 1 else [] + value_count = len(recipe_values) + + # 判断是否是终端步骤 + is_terminal_step = remaining_steps is None or len(remaining_steps) == 0 + + if current_label: + # 知道当前标签，获取该标签的所有属性 + all_properties = [p["name"] for p in self.schema.get_properties_with_type(current_label)] + + # 使用控制器选择需要泛化的属性 + if self.controller: + chain_category = self.controller.get_chain_category(len(self.recipe.steps)) + selected_properties = self.controller.select_sibling_options( + recipe_option=recipe_prop, all_options=all_properties, chain_category=chain_category + ) + else: + # 没有控制器，只使用配方指定的属性 + selected_properties = [recipe_prop] if recipe_prop in all_properties else [] + + # 为选中的属性生成选项 + for prop_name in selected_properties: + prop_info = next( + (p for p in self.schema.get_properties_with_type(current_label) if p["name"] == prop_name), None + ) + if prop_info: + # 获取所有可用的值 + all_values = self._get_multiple_values(current_label, prop_info) + + if value_count == 0: + # has('name') - 只有属性名，不需要值 + prop_desc = self.gremlin_base.get_schema_desc(prop_name) + options.append( + { + "query_part": f".has('{prop_name}')", + "desc_part": f"，筛选包含'{prop_desc}'属性的元素", + "new_label": current_label, + "new_type": current_type, + } + ) + elif value_count == 1: + # has('name', 'Tom') - 单个值 + if self.controller: + fill_count = self.controller.get_value_fill_count( + is_terminal=is_terminal_step, available_count=len(all_values) + ) + else: + fill_count = len(all_values) + + # 确保包含配方值 + selected_values = [recipe_values[0]] if recipe_values[0] in all_values else [] + other_values = [v for v in all_values if v != recipe_values[0]] + if other_values and fill_count > 1: + selected_values.extend( + random.sample(other_values, min(fill_count - 1, len(other_values))) + ) + + prop_desc = self.gremlin_base.get_schema_desc(prop_name) + for value in selected_values: + options.append( + { + "query_part": f".has('{prop_name}', {value!r})", + "desc_part": f"，其'{prop_desc}'为'{value}'", + "new_label": current_label, + "new_type": current_type, + } + ) + else: + # has('name', 'Tom', 'Jerry') - 多个值 + if self.controller: + fill_times = self.controller.get_multi_param_value_fill_count( + is_terminal=is_terminal_step + ) + else: + fill_times = 1 + + # 调整填充次数：不能超过实际可生成的不同组合数 + if len(all_values) >= value_count: + # 使用集合去重，避免生成重复组合 + generated_combos = set() + attempts = 0 + max_attempts = fill_times * 10 # 避免无限循环 + + while len(generated_combos) < fill_times and attempts < max_attempts: + selected_combo = tuple(sorted(random.sample(all_values, value_count))) + generated_combos.add(selected_combo) + attempts += 1 + + # 生成查询选项 + prop_desc = self.gremlin_base.get_schema_desc(prop_name) + for combo in generated_combos: + values_str = ", ".join(repr(v) for v in combo) + options.append( + { + "query_part": f".has('{prop_name}', {values_str})", + "desc_part": f"，其'{prop_desc}'为{values_str}之一", + "new_label": current_label, + "new_type": current_type, + } + ) + + # 确保包含原配方组合 + values_str = ", ".join(repr(v) for v in recipe_values) + prop_desc = self.gremlin_base.get_schema_desc(prop_name) + recipe_option = { + "query_part": f".has('{prop_name}', {values_str})", + "desc_part": f"，其'{prop_desc}'为{values_str}之一", + "new_label": current_label, + "new_type": current_type, + } + if recipe_option not in options: + options.insert(0, recipe_option) + else: + # 不知道当前标签，遍历所有标签 + for label in self.schema.get_vertex_labels(): + prop_info = next( + (p for p in self.schema.get_properties_with_type(label) if p["name"] == recipe_prop), None + ) + if prop_info: + all_values = self._get_multiple_values(label, prop_info) + + if value_count == 0: + # has('name') - 只有属性名 + prop_desc = self.gremlin_base.get_schema_desc(recipe_prop) + options.append( + { + "query_part": f".has('{recipe_prop}')", + "desc_part": f"，筛选包含'{prop_desc}'属性的元素", + "new_label": label, + "new_type": current_type, + } + ) + elif value_count == 1: + # has('name', 'Tom') - 单个值 + if self.controller: + fill_count = self.controller.get_value_fill_count( + is_terminal=is_terminal_step, available_count=len(all_values) + ) + else: + fill_count = len(all_values) + + selected_values = [recipe_values[0]] if recipe_values[0] in all_values else [] + other_values = [v for v in all_values if v != recipe_values[0]] + if other_values and fill_count > 1: + selected_values.extend( + random.sample(other_values, min(fill_count - 1, len(other_values))) + ) + + prop_desc = self.gremlin_base.get_schema_desc(recipe_prop) + for value in selected_values: + options.append( + { + "query_part": f".has('{recipe_prop}', {value!r})", + "desc_part": f"，其'{prop_desc}'为'{value}'", + "new_label": label, + "new_type": current_type, + } + ) + else: + # has('name', 'Tom', 'Jerry') - 多个值 + if self.controller: + fill_times = self.controller.get_multi_param_value_fill_count( + is_terminal=is_terminal_step + ) + else: + fill_times = 1 + + # 调整填充次数：不能超过实际可生成的不同组合数 + if len(all_values) >= value_count: + # 使用集合去重，避免生成重复组合 + generated_combos = set() + attempts = 0 + max_attempts = fill_times * 10 # 避免无限循环 + + while len(generated_combos) < fill_times and attempts < max_attempts: + selected_combo = tuple(sorted(random.sample(all_values, value_count))) + generated_combos.add(selected_combo) + attempts += 1 + + # 生成查询选项 + prop_desc = self.gremlin_base.get_schema_desc(recipe_prop) + for combo in generated_combos: + values_str = ", ".join(repr(v) for v in combo) + options.append( + { + "query_part": f".has('{recipe_prop}', {values_str})", + "desc_part": f"，其'{prop_desc}'为{values_str}之一", + "new_label": label, + "new_type": current_type, + } + ) + + # 确保包含原配方组合 + values_str = ", ".join(repr(v) for v in recipe_values) + prop_desc = self.gremlin_base.get_schema_desc(recipe_prop) + recipe_option = { + "query_part": f".has('{recipe_prop}', {values_str})", + "desc_part": f"，其'{prop_desc}'为{values_str}之一", + "new_label": label, + "new_type": current_type, + } + if recipe_option not in options: + options.insert(0, recipe_option) + + # hasId() 步骤 - ID过滤 + elif step_name == "hasId": + if not step_params: + return [] + + # 支持多参数：hasId(1, 2, 3) + recipe_ids = step_params if isinstance(step_params, list) else [step_params] + all_ids = list(range(1, 101)) + param_count = len(recipe_ids) + + if self.controller: + chain_category = self.controller.get_chain_category(len(self.recipe.steps)) + + if param_count == 1: + # 单参数：使用原有的单参数泛化 + recipe_id = recipe_ids[0] + strategy = self.controller.config["property_generalization"][chain_category] + max_ids = strategy.get("additional_random_max", 3) + selected_ids = [ + recipe_id, + *random.sample([i for i in all_ids if i != recipe_id], min(max_ids, len(all_ids) - 1)), + ] + + for id_val in selected_ids: + options.append( + { + "query_part": f".hasId({id_val})", + "desc_part": f"，筛选ID为{id_val}的元素", + "new_label": current_label, + "new_type": current_type, + } + ) + else: + # 多参数：使用多参数泛化，保持参数数量一致 + id_combinations = self.controller.select_multi_param_schema_options( + recipe_params=[str(i) for i in recipe_ids], # 转为字符串便于处理 + all_options=[str(i) for i in all_ids], + chain_category=chain_category, + ) + + for combo in id_combinations: + # 转回整数 + int_combo = [int(i) for i in combo] + ids_str = ", ".join(str(i) for i in int_combo) + options.append( + { + "query_part": f".hasId({ids_str})", + "desc_part": f"，筛选ID为{ids_str}的元素", + "new_label": current_label, + "new_type": current_type, + } + ) + else: + # 没有控制器，只保留原配方 + if param_count == 1: + options.append( + { + "query_part": f".hasId({recipe_ids[0]})", + "desc_part": f"，筛选ID为{recipe_ids[0]}的元素", + "new_label": current_label, + "new_type": current_type, + } + ) + else: + ids_str = ", ".join(str(i) for i in recipe_ids) + options.append( + { + "query_part": f".hasId({ids_str})", + "desc_part": f"，筛选ID为{ids_str}的元素", + "new_label": current_label, + "new_type": current_type, + } + ) + + # is() 步骤 - 值比较（用于值流） + elif step_name == "is": + if not step_params: + return [] + + recipe_value = step_params[0] + + # 判断是否是终端步骤 + is_terminal_step = remaining_steps is None or len(remaining_steps) == 0 + + # 如果有当前标签，尝试从数据中获取值 + if current_label: + # 获取该标签的所有属性 + all_properties = self.schema.get_properties_with_type(current_label) + if all_properties: + # 随机选一个属性获取值 + prop_info = random.choice(all_properties) + all_values = self._get_multiple_values(current_label, prop_info) + + # 使用控制器决定填充多少个值 + if self.controller: + fill_count = self.controller.get_value_fill_count( + is_terminal=is_terminal_step, available_count=len(all_values) + ) + else: + fill_count = min(3, len(all_values)) + + # 确保包含配方值 + selected_values = [recipe_value] + other_values = [v for v in all_values if v != recipe_value] + if other_values and fill_count > 1: + selected_values.extend(random.sample(other_values, min(fill_count - 1, len(other_values)))) + else: + selected_values = [recipe_value] + else: + selected_values = [recipe_value] + + for value in selected_values: + options.append( + { + "query_part": f".is({value!r})", + "desc_part": f"，判断值是否为{value!r}", + "new_label": current_label, + "new_type": current_type, + } + ) + + # hasKey() 步骤 - 键过滤（用于属性流） + elif step_name == "hasKey": + if not step_params: + return [] + + # 支持多参数：hasKey('name', 'age') + recipe_keys = step_params if isinstance(step_params, list) else [step_params] + + # 如果有当前标签，获取该标签的所有属性键 + if current_label: + all_keys = [p["name"] for p in self.schema.get_properties_with_type(current_label)] + else: + # 没有标签，获取所有可能的属性键 + all_keys = set() + for label in self.schema.get_vertex_labels(): + all_keys.update([p["name"] for p in self.schema.get_properties_with_type(label)]) + all_keys = list(all_keys) + + # 对每个配方键进行泛化 + all_selected_keys = set() + for recipe_key in recipe_keys: + if self.controller and all_keys: + chain_category = self.controller.get_chain_category(len(self.recipe.steps)) + selected = self.controller.select_sibling_options( + recipe_option=recipe_key, all_options=all_keys, chain_category=chain_category + ) + all_selected_keys.update(selected) + else: + if recipe_key in all_keys: + all_selected_keys.add(recipe_key) + + # 生成单键选项 + for key in all_selected_keys: + key_desc = self.gremlin_base.get_schema_desc(key) + options.append( + { + "query_part": f".hasKey('{key}')", + "desc_part": f"，筛选包含键'{key_desc}'的属性", + "new_label": current_label, + "new_type": current_type, + } + ) + + # 如果配方有多个键，也生成多键选项 + if len(recipe_keys) > 1: + keys_str = "', '".join(recipe_keys) + keys_desc = "、".join([self.gremlin_base.get_schema_desc(k) for k in recipe_keys]) + options.append( + { + "query_part": f".hasKey('{keys_str}')", + "desc_part": f"，筛选包含键'{keys_desc}'的属性", + "new_label": current_label, + "new_type": current_type, + } + ) + + # hasValue() 步骤 - 值过滤（用于属性流） + elif step_name == "hasValue": + if not step_params: + return [] + + # 支持多参数：hasValue('Tom', 'Jerry') + recipe_values = step_params if isinstance(step_params, list) else [step_params] + + # 判断是否是终端步骤 + is_terminal_step = remaining_steps is None or len(remaining_steps) == 0 + + # 如果有当前标签，从数据中获取值 + if current_label: + all_properties = self.schema.get_properties_with_type(current_label) + if all_properties: + # 从所有属性中收集值 + all_values = [] + for prop_info in all_properties: + values = self._get_multiple_values(current_label, prop_info) + all_values.extend(values) + + # 去重 + all_values = list(set(all_values)) + + # 使用控制器决定填充多少个值 + if self.controller: + fill_count = self.controller.get_value_fill_count( + is_terminal=is_terminal_step, available_count=len(all_values) + ) + else: + fill_count = min(3, len(all_values)) + + # 确保包含所有配方值 + selected_values = list(recipe_values) + other_values = [v for v in all_values if v not in recipe_values] + if other_values and fill_count > len(recipe_values): + additional_count = min(fill_count - len(recipe_values), len(other_values)) + selected_values.extend(random.sample(other_values, additional_count)) + else: + selected_values = recipe_values + else: + selected_values = recipe_values + + # 生成单值选项 + for value in selected_values: + options.append( + { + "query_part": f".hasValue({value!r})", + "desc_part": f"，筛选包含值{value!r}的属性", + "new_label": current_label, + "new_type": current_type, + } + ) + + # 如果配方有多个值，也生成多值选项 + if len(recipe_values) > 1: + values_str = ", ".join(repr(v) for v in recipe_values) + options.append( + { + "query_part": f".hasValue({values_str})", + "desc_part": f"，筛选包含值{values_str}的属性", + "new_label": current_label, + "new_type": current_type, + } + ) + + # where() 步骤 - 条件过滤 + elif step_name == "where": + if not step_params: + return [] + + # where 步骤可以有多种形式： + # 1. where(AnonymousTraversal) - 嵌套遍历 + # 2. where(Predicate) - 谓词 + # 3. where('property', Predicate) - 属性 + 谓词 + + from .GremlinExpr import AnonymousTraversal, Predicate + + first_param = step_params[0] + + if isinstance(first_param, AnonymousTraversal): + # 嵌套遍历：递归生成变体 + nested_variants = self._generate_nested_traversal_variants(first_param, current_depth=0) + nested_desc = self._describe_nested_traversal(first_param) + + for nested_str in nested_variants: + options.append( + { + "query_part": f".where(__.{nested_str})", + "desc_part": f"，条件过滤：{nested_desc}", + "new_label": current_label, + "new_type": current_type, + } + ) + + elif isinstance(first_param, Predicate): + # 谓词：保留原谓词 + options.append( + { + "query_part": f".where(P.{first_param.operator}({first_param.value}))", + "desc_part": f"，条件过滤（{first_param.operator}）", + "new_label": current_label, + "new_type": current_type, + } + ) + + elif len(step_params) == 2 and isinstance(step_params[1], Predicate): + # 属性 + 谓词：where('name', P.eq('Tom')) + prop_name = step_params[0] + predicate = step_params[1] + + prop_desc = self.gremlin_base.get_schema_desc(prop_name) + options.append( + { + "query_part": f".where('{prop_name}', P.{predicate.operator}({predicate.value}))", + "desc_part": f"，条件过滤（{prop_desc} {predicate.operator}）", + "new_label": current_label, + "new_type": current_type, + } + ) + else: + # 其他情况：保留原结构 + options.append( + { + "query_part": ".where(...)", + "desc_part": "，条件过滤", + "new_label": current_label, + "new_type": current_type, + } + ) + + return options + + # not() 步骤 - 否定过滤 + elif step_name == "not": + if not step_params: + return [] + + # not 步骤通常接受一个 AnonymousTraversal 作为参数 + # 例如：not(__.out('knows')) + + from .GremlinExpr import AnonymousTraversal + + first_param = step_params[0] + + if isinstance(first_param, AnonymousTraversal): + # 嵌套遍历：递归生成变体 + nested_variants = self._generate_nested_traversal_variants(first_param, current_depth=0) + nested_desc = self._describe_nested_traversal(first_param) + + for nested_str in nested_variants: + options.append( + { + "query_part": f".not(__.{nested_str})", + "desc_part": f"，排除{nested_desc}的结果", + "new_label": current_label, + "new_type": current_type, + } + ) + else: + # 其他类型的参数：保留原结构 + options.append( + { + "query_part": ".not(...)", + "desc_part": "，否定过滤", + "new_label": current_label, + "new_type": current_type, + } + ) + + # filter() 步骤 - 通用过滤 + elif step_name == "filter": + if not step_params: + return [] + + from .GremlinExpr import AnonymousTraversal + + first_param = step_params[0] + + if isinstance(first_param, AnonymousTraversal): + # 嵌套遍历：递归生成变体 + nested_variants = self._generate_nested_traversal_variants(first_param, current_depth=0) + nested_desc = self._describe_nested_traversal(first_param) + + for nested_str in nested_variants[:1]: # 只取第一个避免组合爆炸 + options.append( + { + "query_part": f".filter({nested_str})", + "desc_part": f"，过滤：{nested_desc}", + "new_label": current_label, + "new_type": current_type, + } + ) + else: + options.append( + { + "query_part": ".filter(...)", + "desc_part": "，通用过滤", + "new_label": current_label, + "new_type": current_type, + } + ) + + # and() 步骤 - 逻辑与 + elif step_name == "and": + if not step_params: + return [] + + from .GremlinExpr import AnonymousTraversal + + # and接受多个遍历作为参数 + if all(isinstance(p, AnonymousTraversal) for p in step_params): + # 为每个参数生成一个变体（避免组合爆炸） + variants_list = [] + for param in step_params: + variants = self._generate_nested_traversal_variants(param, current_depth=0) + variants_list.append(variants[0] if variants else "__.identity()") + + variants_str = ", ".join(variants_list) + options.append( + { + "query_part": f".and({variants_str})", + "desc_part": "，逻辑与过滤", + "new_label": current_label, + "new_type": current_type, + } + ) + else: + options.append( + { + "query_part": ".and(...)", + "desc_part": "，逻辑与过滤", + "new_label": current_label, + "new_type": current_type, + } + ) + + # or() 步骤 - 逻辑或 + elif step_name == "or": + if not step_params: + return [] + + from .GremlinExpr import AnonymousTraversal + + # or接受多个遍历作为参数 + if all(isinstance(p, AnonymousTraversal) for p in step_params): + # 为每个参数生成一个变体（避免组合爆炸） + variants_list = [] + for param in step_params: + variants = self._generate_nested_traversal_variants(param, current_depth=0) + variants_list.append(variants[0] if variants else "__.identity()") + + variants_str = ", ".join(variants_list) + options.append( + { + "query_part": f".or({variants_str})", + "desc_part": "，逻辑或过滤", + "new_label": current_label, + "new_type": current_type, + } + ) + else: + options.append( + { + "query_part": ".or(...)", + "desc_part": "，逻辑或过滤", + "new_label": current_label, + "new_type": current_type, + } + ) + + return options + + # as() 步骤 - 标记步骤 + elif step_name == "as": + if not step_params: + return [] + + # as('label') - 为当前步骤添加标记 + label_name = step_params[0] + options.append( + { + "query_part": f".as('{label_name}')", + "desc_part": f"，标记为'{label_name}'", + "new_label": current_label, # 保持当前标签不变 + "new_type": current_type, # 保持当前类型不变 + } + ) + + return options + + return options + + # D. 导航步骤处理器 + + def _handle_navigation_step(self, step_recipe: Step, current_label: str, current_type: str) -> list[dict]: + """ + 处理导航步骤（out, in, both, outE, inE, bothE等） + + 核心泛化逻辑： + - 泛化到所有同级边标签 + + Args: + step_recipe: 配方步骤 + current_label: 当前标签 + current_type: 当前类型 + + Returns: + 选项列表 + """ + step_name = step_recipe.name + step_params = step_recipe.params + options = [] + + # 确定导航方向和目标类型 + if step_name in ["out", "in", "both"]: + # 顶点导航 + target_type = "vertex" + elif step_name in ["outE", "inE", "bothE"]: + # 边导航 + target_type = "edge" + elif step_name in ["outV", "inV", "otherV"]: + # 从边到顶点 + target_type = "vertex" + else: + return [] + + # 如果没有当前标签，无法确定可用的边 + if not current_label: + # 生成无参数版本 + options.append( + { + "query_part": f".{step_name}()", + "desc_part": f"，沿{step_name}方向遍历", + "new_label": None, + "new_type": target_type, + } + ) + return options + + # 获取当前标签可用的边 + if step_name in ["out", "outE"]: + # 出边：source == current_label + all_edges = [ + {"label": label, "target_label": edge_info["destination"]} + for label, edge_info in self.schema.edges.items() + if edge_info["source"] == current_label + ] + elif step_name in ["in", "inE"]: + # 入边：destination == current_label + all_edges = [ + {"label": label, "target_label": edge_info["source"]} + for label, edge_info in self.schema.edges.items() + if edge_info["destination"] == current_label + ] + elif step_name in ["both", "bothE"]: + # 双向边 + outgoing = [ + {"label": label, "target_label": edge_info["destination"]} + for label, edge_info in self.schema.edges.items() + if edge_info["source"] == current_label + ] + incoming = [ + {"label": label, "target_label": edge_info["source"]} + for label, edge_info in self.schema.edges.items() + if edge_info["destination"] == current_label + ] + all_edges = outgoing + incoming + else: + # outV, inV, otherV 不需要边标签 + options.append( + { + "query_part": f".{step_name}()", + "desc_part": f"，获取{step_name}顶点", + "new_label": None, + "new_type": target_type, + } + ) + return options + + if not all_edges: + # 没有可用的边，返回无参数版本 + options.append( + { + "query_part": f".{step_name}()", + "desc_part": f"，沿{step_name}方向遍历", + "new_label": None, + "new_type": target_type, + } + ) + return options + + # 提取边标签 + edge_labels = list({edge["label"] for edge in all_edges}) + + # 如果配方指定了边标签 + if step_params and step_params[0]: + # 支持多参数：out('knows', 'created') + recipe_edges = step_params if isinstance(step_params, list) else [step_params] + param_count = len(recipe_edges) + + # 使用控制器选择需要泛化的边标签 + if self.controller: + chain_category = self.controller.get_chain_category(len(self.recipe.steps)) + + if param_count == 1: + # 单参数：使用原有的单参数泛化 + selected_edges = self.controller.select_sibling_options( + recipe_option=recipe_edges[0], all_options=edge_labels, chain_category=chain_category + ) + else: + # 多参数：使用多参数泛化，保持参数数量一致 + edge_combinations = self.controller.select_multi_param_schema_options( + recipe_params=recipe_edges, all_options=edge_labels, chain_category=chain_category + ) + # 对于多参数，我们需要生成组合形式 + selected_edges = edge_combinations + else: + # 没有控制器，只使用配方指定的边 + if param_count == 1: + selected_edges = [recipe_edges[0]] if recipe_edges[0] in edge_labels else [] + else: + # 多参数情况，保留原配方组合 + selected_edges = [recipe_edges] + else: + # 配方没有指定边标签，使用控制器选择一些 + if self.controller: + chain_category = self.controller.get_chain_category(len(self.recipe.steps)) + strategy = self.controller.property_gen[chain_category] + max_edges = strategy.get("additional_random_max", 2) + selected_count = min(max_edges, len(edge_labels)) + selected_edges = random.sample(edge_labels, selected_count) if selected_count > 0 else [] + else: + selected_edges = edge_labels[:2] # 默认选择前2个 + + # 为选中的边生成选项 + for edge_item in selected_edges: + # 判断是单个边标签还是边标签组合 + if isinstance(edge_item, list): + # 多参数组合 + edges_str = "', '".join(edge_item) + edges_desc = "、".join([self.gremlin_base.get_schema_desc(e) for e in edge_item]) + + # 对于多参数，目标标签不确定（可能有多个），设为 None + options.append( + { + "query_part": f".{step_name}('{edges_str}')", + "desc_part": f"，沿'{edges_desc}'边{step_name}方向遍历", + "new_label": None, + "new_type": target_type, + } + ) + else: + # 单个边标签 + edge_label = edge_item + # 找到对应的边信息，确定目标标签 + edge_info = next((e for e in all_edges if e["label"] == edge_label), None) + if edge_info: + target_label = edge_info.get("target_label") + edge_desc = self.gremlin_base.get_schema_desc(edge_label) + + # 根据目标类型设置 new_label + # - 如果目标是顶点，new_label 是目标顶点的标签 + # - 如果目标是边，new_label 是边的标签（用于访问边的属性） + if target_type == "vertex": + new_label = target_label + elif target_type == "edge": + new_label = edge_label # 边的标签，用于后续访问边的属性 + else: + new_label = None + + options.append( + { + "query_part": f".{step_name}('{edge_label}')", + "desc_part": f"，沿'{edge_desc}'边{step_name}方向遍历", + "new_label": new_label, + "new_type": target_type, + } + ) + + # 如果没有生成任何选项，添加无参数版本 + if not options: + options.append( + { + "query_part": f".{step_name}()", + "desc_part": f"，沿{step_name}方向遍历", + "new_label": None, + "new_type": target_type, + } + ) + + return options + + # J. 特殊步骤处理器 + + def _handle_special_step( + self, step_recipe: Step, current_label: str, current_type: str, remaining_steps: list[Step] + ) -> list[dict]: + """ + 处理特殊步骤 + + 已实现： + - V(): 起始步骤 + - addV(): 添加顶点 + + 未实现（按需添加）： + - addE(): 添加边 + - property(): 设置属性 + - choose/coalesce/optional: 分支逻辑 + - repeat/until/times/emit: 循环逻辑 + - match: 模式匹配 + - select/project: 投影 + - path/tree: 路径 + - union/flatMap/map: 高阶操作 + + Args: + step_recipe: 配方步骤 + current_label: 当前标签 + current_type: 当前类型 + remaining_steps: 剩余步骤 + + Returns: + 选项列表 + """ + step_name = step_recipe.name + step_params = step_recipe.params + + # V() 步骤 + if step_name == "V": + if step_params: + # V(id) - 指定ID + ids = ", ".join([repr(p) for p in step_params]) + return [ + { + "query_part": f".V({ids})", + "desc_part": f"查找ID为{ids}的顶点", + "new_label": None, + "new_type": "vertex", + } + ] + else: + # V() - 所有顶点 + return [{"query_part": ".V()", "desc_part": "查找所有顶点", "new_label": None, "new_type": "vertex"}] + + # addV() 步骤 + elif step_name == "addV": + if not step_params: + return [] + + label = step_params[0] + creation_info = self.schema.get_vertex_creation_info(label) + + query_part = f".addV('{label}')" + desc_part = f"添加一个'{self.gremlin_base.get_schema_desc(label)}'顶点" + + # 添加必需属性 + for prop_name in creation_info.get("required", []): + prop_info = next( + (p for p in self.schema.get_properties_with_type(label) if p["name"] == prop_name), None + ) + if prop_info: + prop_value = self._get_random_value(label, prop_info, for_update=True) + query_part += f".property('{prop_name}', {prop_value!r})" + desc_part += f"，并设置其'{self.gremlin_base.get_schema_desc(prop_name)}'为'{prop_value}'" + + return [{"query_part": query_part, "desc_part": desc_part, "new_label": label, "new_type": "vertex"}] + + # E() 步骤 - 边遍历起点 + elif step_name == "E": + if step_params: + # E(id1, id2, ...) - 指定ID的边，支持多参数 + param_count = len(step_params) + all_ids = list(range(1, 101)) + + if self.controller and param_count > 1: + # 多参数：使用多参数泛化 + chain_category = self.controller.get_chain_category(len(self.recipe.steps)) + id_combinations = self.controller.select_multi_param_schema_options( + recipe_params=[str(i) for i in step_params], + all_options=[str(i) for i in all_ids], + chain_category=chain_category, + ) + + options = [] + for combo in id_combinations: + int_combo = [int(i) for i in combo] + ids_str = ", ".join(str(i) for i in int_combo) + options.append( + { + "query_part": f".E({ids_str})", + "desc_part": f"查找ID为{ids_str}的边", + "new_label": None, + "new_type": "edge", + } + ) + return options + else: + # 单参数或无控制器：保留原配方 + ids = ", ".join([repr(p) for p in step_params]) + return [ + { + "query_part": f".E({ids})", + "desc_part": f"查找ID为{ids}的边", + "new_label": None, + "new_type": "edge", + } + ] + else: + # E() - 所有边 + return [{"query_part": ".E()", "desc_part": "查找所有边", "new_label": None, "new_type": "edge"}] + + # select() 步骤 - 投影选择 + elif step_name == "select": + if not step_params: + return [] + + from .GremlinExpr import AnonymousTraversal + + desc = self.gremlin_base.get_token_desc("select") + + # 检查第一个参数是否是嵌套遍历 + first_param = step_params[0] + if isinstance(first_param, AnonymousTraversal): + # select(__.out()) - 嵌套遍历 + nested_variants = self._generate_nested_traversal_variants(first_param, current_depth=0) + + options = [] + for nested_str in nested_variants: + options.append( + { + "query_part": f".select(__.{nested_str})", + "desc_part": f"，{desc}（嵌套遍历）", + "new_label": None, + "new_type": "value", + } + ) + return options + + elif len(step_params) == 1: + # select('a') - 选择单个标记 + param = step_params[0] + return [ + { + "query_part": f".select('{param}')", + "desc_part": f"，{desc}标记'{param}'", + "new_label": None, + "new_type": "value", + } + ] + else: + # select('a', 'b', ...) - 选择多个标记 + params_str = ", ".join([f"'{p}'" for p in step_params]) + return [ + { + "query_part": f".select({params_str})", + "desc_part": f"，{desc}多个标记", + "new_label": None, + "new_type": "map", + } + ] + + # path() 步骤 - 获取遍历路径 + elif step_name == "path": + desc = self.gremlin_base.get_token_desc("path") + return [{"query_part": ".path()", "desc_part": f"，{desc}", "new_label": None, "new_type": "path"}] + + # addE() 步骤 - 添加边 + elif step_name == "addE": + from .GremlinExpr import AnonymousTraversal + + if not step_params: + return [] + + # 检查参数类型 + if isinstance(step_params[0], str): + # string变体: addE('knows') + label = step_params[0] + return [ + { + "query_part": f".addE('{label}')", + "desc_part": f"添加标签为'{label}'的边", + "new_label": label, + "new_type": "edge", + } + ] + elif isinstance(step_params[0], AnonymousTraversal): + # traversal变体: addE(__.constant('knows')) + # 生成嵌套遍历的变体 + variants = self._generate_nested_traversal_variants(step_params[0], current_depth=0) + result = [] + for variant in variants[:2]: # 最多2个变体 + result.append( + { + "query_part": f".addE(__.{variant})", + "desc_part": "添加边（通过遍历获取标签）", + "new_label": None, + "new_type": "edge", + } + ) + return result if result else [] + else: + return [] + + # property() 步骤 - 设置属性 + elif step_name == "property": + if not step_params: + return [] + + # 检查不同的property变体 + if len(step_params) == 1: + # property(map) 变体 + map_param = step_params[0] + return [ + { + "query_part": f".property({map_param})", + "desc_part": "设置属性（映射）", + "new_label": current_label, + "new_type": current_type, + } + ] + + elif len(step_params) >= 2: + # 检查第一个参数是否是cardinality + first_param = step_params[0] + if isinstance(first_param, dict) and "type" in first_param: + # property(cardinality, key, value, ...) 变体 + card_type = first_param["type"] + card_value = first_param.get("value", "multi") + + if len(step_params) == 2: + # property(cardinality, map) + map_param = step_params[1] + return [ + { + "query_part": f".property({card_type}('{card_value}'), {map_param})", + "desc_part": f"设置属性（{card_type}基数，映射）", + "new_label": current_label, + "new_type": current_type, + } + ] + else: + # property(cardinality, key, value, ...) + key = step_params[1] + value = step_params[2] + extra_params = step_params[3:] if len(step_params) > 3 else [] + + result = [] + # 基础变体 + if extra_params: + extra_str = ", ".join([f"'{p}'" if isinstance(p, str) else str(p) for p in extra_params]) + query_part = f".property({card_type}('{card_value}'), '{key}', '{value}', {extra_str})" + else: + query_part = f".property({card_type}('{card_value}'), '{key}', '{value}')" + + result.append( + { + "query_part": query_part, + "desc_part": f"设置属性 {key}={value}（{card_type}基数）", + "new_label": current_label, + "new_type": current_type, + } + ) + return result + else: + # property(key, value, ...) 变体（无cardinality） + key = step_params[0] + value = step_params[1] + extra_params = step_params[2:] if len(step_params) > 2 else [] + + result = [] + # 基础变体 + if extra_params: + extra_str = ", ".join([f"'{p}'" if isinstance(p, str) else str(p) for p in extra_params]) + query_part = f".property('{key}', '{value}', {extra_str})" + else: + query_part = f".property('{key}', '{value}')" + + result.append( + { + "query_part": query_part, + "desc_part": f"设置属性 {key}={value}", + "new_label": current_label, + "new_type": current_type, + } + ) + return result + + return [] + + # project() 步骤 - 投影 + elif step_name == "project": + if not step_params: + return [] + keys_str = "', '".join(step_params) + return [ + { + "query_part": f".project('{keys_str}')", + "desc_part": "投影字段", + "new_label": None, + "new_type": "map", + } + ] + + # union() 步骤 - 联合 + elif step_name == "union": + from .GremlinExpr import AnonymousTraversal + + if not step_params or not all(isinstance(p, AnonymousTraversal) for p in step_params): + return [] + + # 为每个嵌套遍历生成变体（每个参数独立泛化） + all_param_variants = [] + for param in step_params: + variants = self._generate_nested_traversal_variants(param, current_depth=0) + if variants: + # 每个参数最多取2个变体（根据嵌套策略） + all_param_variants.append([f"__.{v}" for v in variants[:2]]) + else: + all_param_variants.append(["__.identity()"]) # 默认值 + + # 组合所有参数的变体（笛卡尔积） + import itertools + + result = [] + combinations = list(itertools.product(*all_param_variants)) + + # 限制组合数量（避免爆炸） + max_combinations = min(len(combinations), 4) # 最多4个组合 + if len(combinations) > max_combinations: + import random + + combinations = random.sample(combinations, max_combinations) + + for combo in combinations: + union_str = ", ".join(combo) + # 为每个分支生成描述 + branch_descs = [self._describe_nested_traversal(p) for p in step_params] + desc_detail = "、".join(branch_descs) + result.append( + { + "query_part": f".union({union_str})", + "desc_part": f"联合遍历（{desc_detail}）", + "new_label": None, + "new_type": current_type, + } + ) + + return result if result else [] + + # coalesce() 步骤 - 合并 + elif step_name == "coalesce": + from .GremlinExpr import AnonymousTraversal + + if not step_params or not all(isinstance(p, AnonymousTraversal) for p in step_params): + return [] + + # 为每个嵌套遍历生成变体（每个参数独立泛化） + all_param_variants = [] + for param in step_params: + variants = self._generate_nested_traversal_variants(param, current_depth=0) + if variants: + # 每个参数最多取2个变体（根据嵌套策略） + all_param_variants.append([f"__.{v}" for v in variants[:2]]) + else: + all_param_variants.append(["__.identity()"]) # 默认值 + + # 组合所有参数的变体（笛卡尔积） + import itertools + + result = [] + combinations = list(itertools.product(*all_param_variants)) + + # 限制组合数量（避免爆炸） + max_combinations = min(len(combinations), 4) # 最多4个组合 + if len(combinations) > max_combinations: + import random + + combinations = random.sample(combinations, max_combinations) + + for combo in combinations: + coalesce_str = ", ".join(combo) + # 为每个分支生成描述 + branch_descs = [self._describe_nested_traversal(p) for p in step_params] + desc_detail = "、".join(branch_descs) + result.append( + { + "query_part": f".coalesce({coalesce_str})", + "desc_part": f"合并遍历，依次尝试：{desc_detail}，返回第一个非空结果", + "new_label": None, + "new_type": current_type, + } + ) + + return result if result else [] + + # choose() 步骤 - 条件分支 + elif step_name == "choose": + from .GremlinExpr import AnonymousTraversal, Predicate + + if not step_params: + return [] + + # choose有多个变体，根据参数数量和类型处理 + if len(step_params) == 1: + # choose(traversal) - 单参数 + if isinstance(step_params[0], AnonymousTraversal): + variants = self._generate_nested_traversal_variants(step_params[0], current_depth=0) + cond_desc = self._describe_nested_traversal(step_params[0]) + result = [] + for variant in variants[:2]: + result.append( + { + "query_part": f".choose(__.{variant})", + "desc_part": f"条件分支（条件：{cond_desc}）", + "new_label": None, + "new_type": current_type, + } + ) + return result if result else [] + + elif len(step_params) == 2: + # choose(traversal, traversal) - 两参数 + if all(isinstance(p, AnonymousTraversal) for p in step_params): + # 为每个参数生成变体 + variants1 = self._generate_nested_traversal_variants(step_params[0], current_depth=0) + variants2 = self._generate_nested_traversal_variants(step_params[1], current_depth=0) + cond_desc = self._describe_nested_traversal(step_params[0]) + then_desc = self._describe_nested_traversal(step_params[1]) + + result = [] + # 组合（限制数量） + for v1 in variants1[:2]: + for v2 in variants2[:2]: + result.append( + { + "query_part": f".choose(__.{v1}, __.{v2})", + "desc_part": f"条件分支（若{cond_desc}，则{then_desc}）", + "new_label": None, + "new_type": current_type, + } + ) + if len(result) >= 4: # 最多4个组合 + break + if len(result) >= 4: + break + return result if result else [] + + elif len(step_params) == 3: + # choose(traversal, traversal, traversal) - 三参数 + if all(isinstance(p, AnonymousTraversal) for p in step_params): + # 为每个参数生成变体 + variants1 = self._generate_nested_traversal_variants(step_params[0], current_depth=0) + variants2 = self._generate_nested_traversal_variants(step_params[1], current_depth=0) + variants3 = self._generate_nested_traversal_variants(step_params[2], current_depth=0) + cond_desc = self._describe_nested_traversal(step_params[0]) + then_desc = self._describe_nested_traversal(step_params[1]) + else_desc = self._describe_nested_traversal(step_params[2]) + + result = [] + # 组合（限制数量） + for v1 in variants1[:2]: + for v2 in variants2[:1]: # 减少组合 + for v3 in variants3[:1]: + result.append( + { + "query_part": f".choose(__.{v1}, __.{v2}, __.{v3})", + "desc_part": f"条件分支（若{cond_desc}，则{then_desc}，否则{else_desc}）", + "new_label": None, + "new_type": current_type, + } + ) + if len(result) >= 4: # 最多4个组合 + break + if len(result) >= 4: + break + if len(result) >= 4: + break + return result if result else [] + + return [] + + # optional() 步骤 - 可选遍历 + elif step_name == "optional": + from .GremlinExpr import AnonymousTraversal + + if not step_params or not isinstance(step_params[0], AnonymousTraversal): + return [] + + nested_variants = self._generate_nested_traversal_variants(step_params[0], current_depth=0) + nested_desc = self._describe_nested_traversal(step_params[0]) + if nested_variants: + return [ + { + "query_part": f".optional(__.{nested_variants[0]})", + "desc_part": f"可选遍历（{nested_desc}）", + "new_label": None, + "new_type": current_type, + } + ] + return [] + + # repeat() 步骤 - 重复遍历 + elif step_name == "repeat": + from .GremlinExpr import AnonymousTraversal + + if not step_params: + return [] + + # 检查是否是string+traversal变体 + if ( + len(step_params) == 2 + and isinstance(step_params[0], str) + and isinstance(step_params[1], AnonymousTraversal) + ): + # repeat(label, traversal) + label = step_params[0] + nested_variants = self._generate_nested_traversal_variants(step_params[1], current_depth=0) + nested_desc = self._describe_nested_traversal(step_params[1]) + result = [] + for variant in nested_variants[:2]: + result.append( + { + "query_part": f".repeat('{label}', __.{variant})", + "desc_part": f"重复遍历（{nested_desc}，标签：{label}）", + "new_label": None, + "new_type": current_type, + } + ) + return result if result else [] + + # 单参数traversal变体 + elif len(step_params) == 1 and isinstance(step_params[0], AnonymousTraversal): + nested_variants = self._generate_nested_traversal_variants(step_params[0], current_depth=0) + nested_desc = self._describe_nested_traversal(step_params[0]) + result = [] + for variant in nested_variants[:2]: + result.append( + { + "query_part": f".repeat(__.{variant})", + "desc_part": f"重复遍历（{nested_desc}）", + "new_label": None, + "new_type": current_type, + } + ) + return result if result else [] + + return [] + + # until() 步骤 - 终止条件 + elif step_name == "until": + from .GremlinExpr import AnonymousTraversal, Predicate + + if not step_params: + return [] + + # 检查参数类型 + if isinstance(step_params[0], AnonymousTraversal): + # traversal变体 + nested_variants = self._generate_nested_traversal_variants(step_params[0], current_depth=0) + nested_desc = self._describe_nested_traversal(step_params[0]) + result = [] + for variant in nested_variants[:2]: + result.append( + { + "query_part": f".until(__.{variant})", + "desc_part": f"终止条件（{nested_desc}）", + "new_label": None, + "new_type": current_type, + } + ) + return result if result else [] + elif isinstance(step_params[0], Predicate): + # predicate变体 + pred_str = self._format_predicate(step_params[0]) + return [ + { + "query_part": f".until({pred_str})", + "desc_part": "终止条件（谓词）", + "new_label": None, + "new_type": current_type, + } + ] + + return [] + + # times() 步骤 - 重复次数 + elif step_name == "times": + if not step_params: + return [] + times_count = step_params[0] + return [ + { + "query_part": f".times({times_count})", + "desc_part": f"重复{times_count}次", + "new_label": current_label, + "new_type": current_type, + } + ] + + # emit() 步骤 - 发射中间结果 + elif step_name == "emit": + from .GremlinExpr import AnonymousTraversal, Predicate + + if not step_params: + # emit() 无参数 + return [ + { + "query_part": ".emit()", + "desc_part": "发射中间结果", + "new_label": current_label, + "new_type": current_type, + } + ] + + # 检查参数类型 + if isinstance(step_params[0], AnonymousTraversal): + # emit(traversal) 带遍历条件 + nested_variants = self._generate_nested_traversal_variants(step_params[0], current_depth=0) + nested_desc = self._describe_nested_traversal(step_params[0]) + result = [] + for variant in nested_variants[:2]: + result.append( + { + "query_part": f".emit(__.{variant})", + "desc_part": f"条件发射（{nested_desc}）", + "new_label": current_label, + "new_type": current_type, + } + ) + return result if result else [] + elif isinstance(step_params[0], Predicate): + # emit(predicate) 带谓词条件 + pred_str = self._format_predicate(step_params[0]) + return [ + { + "query_part": f".emit({pred_str})", + "desc_part": "条件发射（谓词）", + "new_label": current_label, + "new_type": current_type, + } + ] + + return [] + + # flatMap() 步骤 - 扁平映射 + elif step_name == "flatMap": + from .GremlinExpr import AnonymousTraversal + + if not step_params or not isinstance(step_params[0], AnonymousTraversal): + return [] + + nested_variants = self._generate_nested_traversal_variants(step_params[0], current_depth=0) + nested_desc = self._describe_nested_traversal(step_params[0]) + if nested_variants: + return [ + { + "query_part": f".flatMap(__.{nested_variants[0]})", + "desc_part": f"扁平映射（{nested_desc}）", + "new_label": None, + "new_type": current_type, + } + ] + return [] + + # map() 步骤 - 映射 + elif step_name == "map": + from .GremlinExpr import AnonymousTraversal + + if not step_params or not isinstance(step_params[0], AnonymousTraversal): + return [] + + nested_variants = self._generate_nested_traversal_variants(step_params[0], current_depth=0) + nested_desc = self._describe_nested_traversal(step_params[0]) + if nested_variants: + return [ + { + "query_part": f".map(__.{nested_variants[0]})", + "desc_part": f"映射（{nested_desc}）", + "new_label": None, + "new_type": "value", + } + ] + return [] + + # match() 步骤 - 模式匹配 + elif step_name == "match": + from .GremlinExpr import AnonymousTraversal + + if not step_params or not all(isinstance(p, AnonymousTraversal) for p in step_params): + return [] + + # 为每个模式生成变体（每个参数独立泛化） + all_pattern_variants = [] + for param in step_params: + variants = self._generate_nested_traversal_variants(param, current_depth=0) + if variants: + # 每个模式最多取2个变体（根据嵌套策略） + all_pattern_variants.append([f"__.{v}" for v in variants[:2]]) + else: + all_pattern_variants.append(["__.identity()"]) # 默认值 + + # 组合所有模式的变体（笛卡尔积） + import itertools + + result = [] + combinations = list(itertools.product(*all_pattern_variants)) + + # 限制组合数量（避免爆炸） + max_combinations = min(len(combinations), 4) # 最多4个组合 + if len(combinations) > max_combinations: + import random + + combinations = random.sample(combinations, max_combinations) + + for combo in combinations: + match_str = ", ".join(combo) + # 为每个模式生成描述 + pattern_descs = [self._describe_nested_traversal(p) for p in step_params] + desc_detail = "、".join(pattern_descs) + result.append( + { + "query_part": f".match({match_str})", + "desc_part": f"模式匹配（{desc_detail}）", + "new_label": None, + "new_type": "map", + } + ) + + return result if result else [] + + # tree() 步骤 - 树结构 + elif step_name == "tree": + return [{"query_part": ".tree()", "desc_part": "构建树结构", "new_label": None, "new_type": "tree"}] + + # 其他特殊步骤暂未实现 + return [] + + def _apply_random_enhancement( + self, query: str, desc: str, current_label: str, current_type: str + ) -> list[tuple[str, str]]: + """ + 应用随机增强（可选功能） + + 根据流类型智能选择增强步骤： + - 元素流（vertex, edge）：limit, range, sample, dedup, order + - 值流（value, string, number）：limit, dedup, order + + Args: + query: 当前查询字符串 + desc: 当前描述字符串 + current_label: 当前标签 + current_type: 当前类型 + + Returns: + 增强后的查询-描述对列表 + """ + results = [] + + # 判断流类型 + is_element_stream = current_type in ["vertex", "edge", "element"] + is_value_stream = current_type in ["value", "string", "number", "list", "map"] + + # 如果是终端类型（boolean, none）或不适合增强的类型，跳过增强 + if current_type in ["boolean", "none", "graph"]: + return results + + # 检查查询中已存在的步骤，避免重复添加 + existing_steps = set() + import re + + # 提取查询中的所有步骤名（不带参数） + step_pattern = r"\.(\w+)\(" + for match in re.finditer(step_pattern, query): + existing_steps.add(match.group(1)) + + # 定义可用的增强步骤及其权重 + enhancements = [] + + # === 元素流增强选项 === + if is_element_stream: + # limit - 40% 权重 + if random.random() < 0.4: + # 70% 使用常见值，30% 使用随机值 + if random.random() < 0.7: + limit_value = random.choice([1, 3, 5, 10, 20, 50, 100]) + else: + limit_value = random.randint(1, 200) + + limit_desc = self.gremlin_base.get_token_desc("limit") + if "{}" in limit_desc: + limit_desc = limit_desc.format(limit_value) + enhancements.append( + { + "query_part": f".limit({limit_value})", + "desc_part": f"，{limit_desc}", + "new_type": current_type, + "weight": 0.4, + } + ) + + # range - 20% 权重 + if random.random() < 0.2: + # 60% 使用常见范围，40% 使用随机范围 + if random.random() < 0.6: + start, end = random.choice([(0, 5), (1, 10), (5, 20), (0, 10)]) + else: + start = random.randint(0, 50) + end = start + random.randint(10, 100) + + range_desc = self.gremlin_base.get_token_desc("range") + if not range_desc or range_desc == "range": + range_desc = "取范围内的结果" + enhancements.append( + { + "query_part": f".range({start}, {end})", + "desc_part": f"，{range_desc}", + "new_type": current_type, + "weight": 0.2, + } + ) + + # sample - 30% 权重 + if random.random() < 0.3: + # 80% 使用常见值，20% 使用随机值 + sample_value = random.choice([1, 2, 3, 5, 10]) if random.random() < 0.8 else random.randint(1, 50) + + sample_desc = self.gremlin_base.get_token_desc("sample") + if "{}" in sample_desc: + sample_desc = sample_desc.format(sample_value) + elif not sample_desc or sample_desc == "sample": + sample_desc = f"随机采样 {sample_value} 个结果" + enhancements.append( + { + "query_part": f".sample({sample_value})", + "desc_part": f"，{sample_desc}", + "new_type": current_type, + "weight": 0.3, + } + ) + + # dedup - 30% 权重（检查是否已存在） + if random.random() < 0.3 and "dedup" not in existing_steps: + dedup_desc = self.gremlin_base.get_token_desc("dedup") + enhancements.append( + {"query_part": ".dedup()", "desc_part": f"，{dedup_desc}", "new_type": current_type, "weight": 0.3} + ) + + # order - 20% 权重（检查是否已存在） + if random.random() < 0.2 and "order" not in existing_steps: + order_desc = self.gremlin_base.get_token_desc("order") + enhancements.append( + {"query_part": ".order()", "desc_part": f"，{order_desc}", "new_type": current_type, "weight": 0.2} + ) + + # === 值流增强选项 === + elif is_value_stream: + # limit - 40% 权重 + if random.random() < 0.4: + # 70% 使用常见值，30% 使用随机值 + limit_value = random.choice([1, 3, 5, 10, 20, 50]) if random.random() < 0.7 else random.randint(1, 100) + + limit_desc = self.gremlin_base.get_token_desc("limit") + if "{}" in limit_desc: + limit_desc = limit_desc.format(limit_value) + enhancements.append( + { + "query_part": f".limit({limit_value})", + "desc_part": f"，{limit_desc}", + "new_type": current_type, + "weight": 0.4, + } + ) + + # dedup - 40% 权重（值流中去重更重要，检查是否已存在） + if random.random() < 0.4 and "dedup" not in existing_steps: + dedup_desc = self.gremlin_base.get_token_desc("dedup") + enhancements.append( + {"query_part": ".dedup()", "desc_part": f"，{dedup_desc}", "new_type": current_type, "weight": 0.4} + ) + + # order - 30% 权重（值流中排序较常见，检查是否已存在） + if random.random() < 0.3 and "order" not in existing_steps: + order_desc = self.gremlin_base.get_token_desc("order") + enhancements.append( + {"query_part": ".order()", "desc_part": f"，{order_desc}", "new_type": current_type, "weight": 0.3} + ) + + # 随机选择一个增强步骤 + if enhancements: + enhancement = random.choice(enhancements) + enhanced_query = query + enhancement["query_part"] + enhanced_desc = desc + enhancement["desc_part"] + results.append((enhanced_query, enhanced_desc)) + + return results + + # 辅助方法 + + def _get_random_value(self, label: str, prop_info: dict, for_update: bool = False) -> Any: + """根据属性类型生成随机值""" + prop_name, prop_type = prop_info["name"], prop_info["type"] + instance = self.schema.get_instance(label) + + if instance and prop_name in instance and not for_update: + value = instance.get(prop_name) + if value is not None: + return value + + if prop_type == "STRING": + return "".join(random.choices(string.ascii_letters, k=random.randint(5, 8))) + if prop_type in ["INT32", "INT64"]: + return random.randint(1, 10000) + + return "default_value" + + def _get_multiple_values(self, label: str, prop_info: dict, for_update: bool = False) -> list[Any]: + """获取多个真实数据值""" + prop_name, prop_type = prop_info["name"], prop_info["type"] + instances = self.schema.get_instances(label) + + values = [] + for instance in instances: + if instance and prop_name in instance and not for_update: + value = instance.get(prop_name) + if value is not None: + values.append(value) + + # 如果没有真实数据，生成随机值 + if not values: + if prop_type == "STRING": + values = [ + "".join(random.choices(string.ascii_letters, k=random.randint(5, 8))) + for _ in range(random.randint(2, 5)) + ] + elif prop_type in ["INT32", "INT64"]: + values = [random.randint(1, 10000) for _ in range(random.randint(2, 5))] + else: + values = ["default_value"] + + return values diff --git a/text2gremlin/AST_Text2Gremlin/base/__init__.py b/text2gremlin/AST_Text2Gremlin/base/__init__.py new file mode 100644 index 000000000..a63aa936e --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/__init__.py @@ -0,0 +1,27 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +""" +Gremlin 查询生成器包 + +这个包提供了从模板生成 Gremlin 查询语料库的功能。 +""" + +from .generator import generate_gremlin_corpus + +__all__ = ["generate_gremlin_corpus"] diff --git a/text2gremlin/AST_Text2Gremlin/base/combination_control_config.json b/text2gremlin/AST_Text2Gremlin/base/combination_control_config.json new file mode 100644 index 000000000..c439001c5 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/combination_control_config.json @@ -0,0 +1,279 @@ +{ + "description": "组合爆炸控制配置 - 用于控制Gremlin查询生成的数量和多样性", + "version": "2.0", + "last_updated": "2025-10-25", + "chain_thresholds": { + "description": "链长度分类阈值", + "short": 4, + "medium": 6, + "long": 8, + "comment": "short: ≤4步, medium: 5-6步, long: 7-8步, ultra: ≥9步" + }, + "random_enhancement": { + "description": "随机增强控制策略", + "middle_step_probability": 0.05, + "terminal_step_probability": 0.20, + "max_enhancements_per_query": 3, + "comment": "中间步骤5%概率，末尾步骤20%概率，每个查询路径最多累计3次随机增强" + }, + "value_fill_strategy": { + "description": "数据值填充策略 - 控制具体值的实例化数量", + "middle_step": { + "count": 1, + "description": "中间步骤（除最后一步外）只填充1个值", + "examples": [ + "has('name', ?) → 只随机选1个name值", + "has('born', ?) → 只随机选1个born年份" + ] + }, + "terminal_step": { + "min": 2, + "max": 3, + "description": "终端步骤（配方的最后一步）随机填充2-3个值", + "fallback": "如果CSV数据不足，以实际数据量为准", + "examples": [ + "配置要求3个，CSV只有2个 → 填充2个", + "配置要求2个，CSV有10个 → 随机选2个" + ] + }, + "notes": [ + "这个策略适用于所有需要填充具体值的场景", + "包括：has()的值、out()的边标签、hasLabel()的顶点标签等" + ] + }, + "property_generalization": { + "description": "通用的同级属性泛化策略 - 适用于所有需要选择同级选项的场景", + "applicable_to": [ + "顶点标签选择: hasLabel('person') → 遍历其他顶点标签", + "边标签选择: out('acted_in') → 遍历其他边标签", + "顶点属性选择: has('name', ?) → 遍历其他顶点属性", + "边属性选择: has('role', ?) → 遍历其他边属性", + "所有步骤: values(), properties(), where(), filter() 等", + "所有谓词: P.eq(), P.neq(), P.gt() 等", + "任何具有平级关系的选项" + ], + "strategy_principle": [ + "1. 配方指定的属性/标签必须包含", + "2. 根据链长度和同级总数决定是否全部遍历", + "3. 如果不全部遍历，则随机选择额外的同级属性", + "4. 使用random.sample()确保每次随机性" + ], + "short": { + "description": "短链（≤4步）：较高的泛化程度", + "full_coverage_threshold": 5, + "additional_random_min": 2, + "additional_random_max": 4, + "logic": "如果同级总数≤5，全部遍历；否则：配方属性 + 随机2-4个", + "examples": [ + "5个顶点标签 → 全部遍历（5≤5）", + "10个属性 → 配方属性 + 随机2-4个（10>5）" + ] + }, + "medium": { + "description": "中链（5-6步）：适度的泛化程度", + "full_coverage_threshold": 4, + "additional_random_min": 1, + "additional_random_max": 3, + "logic": "如果同级总数≤4，全部遍历；否则：配方属性 + 随机1-3个", + "examples": [ + "4个边标签 → 全部遍历（4≤4）", + "8个属性 → 配方属性 + 随机1-3个（8>4）" + ] + }, + "long": { + "description": "长链（7-8步）：较低的泛化程度", + "full_coverage_threshold": 3, + "additional_random_min": 1, + "additional_random_max": 2, + "logic": "如果同级总数≤3，全部遍历；否则：配方属性 + 随机1-2个", + "examples": [ + "3个属性 → 全部遍历（3≤3）", + "6个属性 → 配方属性 + 随机1-2个（6>3）" + ] + }, + "ultra": { + "description": "超长链（≥9步）：最低的泛化程度", + "full_coverage_threshold": 2, + "additional_random_min": 0, + "additional_random_max": 1, + "logic": "如果同级总数≤2，全部遍历；否则：配方属性 + 随机0-1个", + "examples": [ + "2个属性 → 全部遍历（2≤2）", + "5个属性 → 配方属性 + 随机0-1个（5>2）" + ] + } + }, + "max_total_combinations": { + "description": "总查询数量限制", + "short": null, + "medium": 100, + "long": 500, + "ultra": 50, + "comment": "null表示不限制" + }, + "max_per_step_choices": { + "description": "单步选项数量限制（可选，用于进一步控制）", + "short": null, + "medium": 8, + "long": 5, + "ultra": 3, + "comment": "限制每个步骤生成的选项数量" + }, + "multi_param_strategy": { + "description": "多参数泛化控制策略 - 保持参数数量一致性", + "principle": [ + "1. 参数数量一致性: 配方是多少个参数，泛化也必须是多少个参数", + "2. 支持任意参数个数: 不限于2个参数，支持3个、4个等任意数量", + "3. 语义一致性: 保持多参数的OR语义" + ], + "schema_fill": { + "description": "Schema填充策略 - 适用于标签、属性名等从schema获取的参数", + "applicable_to": [ + "hasLabel('person', 'movie') - 顶点标签", + "hasKey('name', 'age') - 属性键", + "out('acted_in', 'directed') - 边标签", + "values('name', 'age') - 属性名" + ], + "short": { + "max_combinations": 4, + "description": "短链最多生成4个多参数组合" + }, + "medium": { + "max_combinations": 3, + "description": "中链最多生成3个多参数组合" + }, + "long": { + "max_combinations": 2, + "description": "长链最多生成2个多参数组合" + }, + "ultra": { + "max_combinations": 1, + "description": "超长链只保留原配方组合" + } + }, + "value_fill": { + "description": "数据值填充策略 - 适用于需要从实际数据中获取值的参数", + "applicable_to": [ + "hasValue('Tom', 'Jerry') - 属性值", + "has('name', 'Tom', 'Jerry') - 多值属性过滤" + ], + "middle_step": { + "fill_times": 1, + "description": "中间步骤只填充1次，每次随机选x个值（x=参数个数）" + }, + "terminal_step": { + "fill_times_min": 2, + "fill_times_max": 3, + "description": "终端步骤填充2-3次，每次随机选x个值（x=参数个数）" + } + } + }, + "nested_traversal_strategy": { + "description": "嵌套遍历泛化控制策略 - 用于where/not等包含AnonymousTraversal的步骤", + "principle": [ + "1. 递归泛化: 嵌套内部的每个步骤都应该被泛化", + "2. 深度限制: 防止无限递归，设置最大嵌套深度", + "3. 数量控制: 每层嵌套的每个步骤限制泛化数量", + "4. 组合控制: 嵌套内部的组合数量受外层链长度影响", + "5. 区分策略: Schema属性泛化，数据值不泛化" + ], + "max_nesting_depth": 3, + "max_variants_per_nested_step": 2, + "schema_generalization": { + "description": "Schema 属性泛化策略（嵌套内部）", + "enabled": true, + "max_variants": 2, + "applicable_to": [ + "hasLabel('person') - 顶点标签", + "out('knows') - 边标签", + "in('acted_in') - 边标签" + ], + "note": "嵌套内部的 Schema 属性固定泛化 2 个变体" + }, + "value_generalization": { + "description": "数据值泛化策略（嵌套内部）", + "enabled": false, + "note": "嵌套内部的数据值不泛化，只保留原值", + "applicable_to": [ + "has('age', 30) - 保留原值 30", + "hasValue('Tom') - 保留原值 'Tom'" + ] + }, + "description_detail": { + "max_nesting_depth": "最大支持的嵌套深度，超过此深度不再递归泛化", + "max_variants_per_nested_step": "嵌套内部每个步骤最多生成2个变体（避免组合爆炸）" + }, + "examples": [ + { + "query": "g.V().where(__.out('knows').has('age', 30))", + "nesting_depth": 1, + "generalization": [ + "__.out('knows').has('age', 30) - 原样", + "__.out('created').has('age', 30) - 泛化out的边标签", + "__.in('knows').has('age', 30) - 泛化out为in", + "__.out('knows').has('name', 'Tom') - 泛化has的属性" + ], + "note": "每个嵌套步骤最多2个变体，总共约4个嵌套变体" + }, + { + "query": "g.V().where(__.out('knows').where(__.has('age')))", + "nesting_depth": 2, + "generalization": [ + "第一层: out('knows').where(...) - 泛化out", + "第二层: __.has('age') - 泛化has", + "组合: 2 × 2 = 4个嵌套变体" + ], + "note": "多层嵌套时，每层独立泛化，最终组合" + } + ] + }, + "implementation_notes": [ + "1. 通用处理器: 创建select_sibling_options()函数供所有步骤使用", + "2. 特殊处理: 某些步骤如有特殊需求，可在调用通用处理器后再调整", + "3. 随机性: 使用random.sample()确保每次运行选择不同的属性", + "4. 数据驱动: 所有阈值和参数都从此配置文件读取", + "5. 可扩展性: 新增步骤和谓词都应使用这套通用策略", + "6. 多参数支持: 使用multi_param_strategy配置控制多参数泛化", + "7. 嵌套遍历: 使用nested_traversal_strategy配置控制嵌套遍历泛化" + ], + "usage_examples": [ + { + "scenario": "hasLabel('person') - 顶点标签泛化", + "sibling_options": [ + "person", + "movie", + "genre", + "keyword", + "user" + ], + "total_count": 5, + "short_chain": "5≤5 → 全部遍历 → 5个变体", + "medium_chain": "5>4 → 配方('person') + 随机1-3个 → 2-4个变体" + }, + { + "scenario": "has('name', 'john') - 属性泛化", + "current_label": "person", + "sibling_options": [ + "name", + "born", + "bio", + "poster_image" + ], + "total_count": 4, + "short_chain": "4≤5 → 全部遍历 → 4个属性都生成变体", + "long_chain": "4>3 → 配方('name') + 随机1-2个 → 2-3个属性生成变体" + }, + { + "scenario": "out('acted_in') - 边标签泛化", + "sibling_options": [ + "acted_in", + "directed", + "produced", + "wrote" + ], + "total_count": 4, + "medium_chain": "4≤4 → 全部遍历 → 4个变体", + "ultra_chain": "4>2 → 配方('acted_in') + 随机0-1个 → 1-2个变体" + } + ] +} \ No newline at end of file diff --git a/text2gremlin/AST_Text2Gremlin/base/generator.py b/text2gremlin/AST_Text2Gremlin/base/generator.py new file mode 100644 index 000000000..a10d67f09 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/generator.py @@ -0,0 +1,441 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +""" +Gremlin语料库生成器主入口脚本。 + +从Gremlin查询模板生成大量多样化的查询-描述对，用于Text-to-Gremlin任务的训练数据。 +""" + +import json +import os +from datetime import datetime + +from antlr4 import CommonTokenStream, InputStream +from antlr4.error.ErrorListener import ErrorListener + +from .Config import Config +from .gremlin.GremlinLexer import GremlinLexer +from .gremlin.GremlinParser import GremlinParser +from .GremlinBase import GremlinBase +from .GremlinTransVisitor import GremlinTransVisitor +from .Schema import Schema +from .TraversalGenerator import TraversalGenerator + +LARGE_GENERATION_THRESHOLD = 5000 + + +class SyntaxErrorListener(ErrorListener): + """私有错误监听器类，捕获语法错误。""" + + def __init__(self): + super().__init__() + self.has_error = False + self.error_message = "" + + def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e): + """当语法错误发生时，此方法被调用。""" + self.has_error = True + self.error_message = f"Syntax Error at line {line}, column {column}: {msg}" + + +def check_gremlin_syntax(query_string: str) -> tuple[bool, str]: + """ + 检查给定的Gremlin查询语句的语法。 + + Args: + query_string: The Gremlin query to check. + + Returns: + A tuple containing: + - bool: True if syntax is correct, False otherwise. + - str: An error message if syntax is incorrect, or "Syntax OK" if correct. + """ + try: + input_stream = InputStream(query_string) + lexer = GremlinLexer(input_stream) + token_stream = CommonTokenStream(lexer) + parser = GremlinParser(token_stream) + + # 移除默认的控制台错误监听器 + lexer.removeErrorListeners() + parser.removeErrorListeners() + + # 添加自定义的监听器 + error_listener = SyntaxErrorListener() + lexer.addErrorListener(error_listener) + parser.addErrorListener(error_listener) + + # 尝试解析查询 + parser.queryList() + + if error_listener.has_error: + return (False, error_listener.error_message) + else: + return (True, "Syntax OK") + + except Exception as e: + return (False, f"Parser Exception: {e!s}") + + +def generate_corpus_from_template( + template_string: str, config: Config, schema: Schema, gremlin_base: GremlinBase, global_corpus_dict: dict +) -> tuple[int, dict]: + """ + 执行单个 Gremlin 模板字符串的完整 pipeline。 + + Args: + template_string: 用作模板的 Gremlin query。 + config: 加载的 Config 对象。 + schema: 加载的 Schema 对象。 + gremlin_base: 加载的 GremlinBase 对象。 + global_corpus_dict: 用于存储唯一 query-description 对的全局字典。 + + Returns: + tuple: (添加到全局语料库的新的唯一对的数量, 处理统计信息) + """ + # 初始化统计信息 + stats = { + "success": False, + "error_stage": "", + "error_message": "", + "generated_count": 0, + "new_pairs_count": 0, + "duplicate_count": 0, + "syntax_error_count": 0, + } + + try: + # ANTLR 解析为 AST,并提取模版 + visitor = GremlinTransVisitor() + recipe = visitor.parse_and_visit(template_string) + + if not recipe: + stats["error_stage"] = "recipe_extraction" + stats["error_message"] = "Recipe extraction failed" + return 0, stats + + if not hasattr(recipe, "steps") or not recipe.steps: + stats["error_stage"] = "recipe_validation" + stats["error_message"] = "Recipe has no steps" + return 0, stats + + # 泛化 + generator = TraversalGenerator(schema, recipe, gremlin_base) + corpus = generator.generate() + + if not corpus: + stats["error_stage"] = "generation" + stats["error_message"] = "Generator returned empty corpus" + return 0, stats + + stats["generated_count"] = len(corpus) + + # 语法检查 & 全局去重 + new_pairs_count = 0 + duplicate_count = 0 + syntax_error_count = 0 + + for query, description in corpus: + try: + # 先判重，避免对重复项做语法检查 + if query in global_corpus_dict: + duplicate_count += 1 + continue + + # 再进行语法检查 + is_valid, _error_msg = check_gremlin_syntax(query) + + if not is_valid: + syntax_error_count += 1 + continue + + # 新的查询且语法正确，添加到全局字典 + global_corpus_dict[query] = description + new_pairs_count += 1 + + except Exception: + syntax_error_count += 1 + continue + + # 更新统计信息 + stats["new_pairs_count"] = new_pairs_count + stats["duplicate_count"] = duplicate_count + stats["syntax_error_count"] = syntax_error_count + stats["success"] = True + + # 添加生成数量的警告信息 + if stats["generated_count"] > LARGE_GENERATION_THRESHOLD: + stats["warning"] = f"由于本条模版的Recipe复杂,生成了大量查询({stats['generated_count']}条)" + elif new_pairs_count == 0 and stats["generated_count"] > 0: + stats["warning"] = f"生成了{stats['generated_count']}条查询但全部重复" + + return new_pairs_count, stats + + except Exception as e: + # 捕获所有其他异常 + stats["error_stage"] = "unknown" + stats["error_message"] = str(e) + return 0, stats + + +def generate_gremlin_corpus( + templates: list[str], config_path: str, schema_path: str, data_path: str, output_file: str | None = None +) -> dict: + """ + 从Gremlin模板列表生成完整的语料库。 + + 查询数量由 combination_control_config.json 中的 max_total_combinations 控制。 + + Args: + templates: Gremlin查询模板列表或CSV文件路径 + config_path: 配置文件路径（必需） + schema_path: Schema文件路径（必需） + data_path: 数据文件路径（必需） + output_file: 输出文件名（可选） + + Returns: + 包含生成统计信息的字典 + + Raises: + FileNotFoundError: 当必需的文件不存在时 + ValueError: 当参数无效时 + """ + # 验证必需参数 + if not config_path or not os.path.exists(config_path): + raise FileNotFoundError(f"配置文件不存在: {config_path}") + if not schema_path or not os.path.exists(schema_path): + raise FileNotFoundError(f"模式文件不存在: {schema_path}") + if not data_path or not os.path.exists(data_path): + raise FileNotFoundError(f"数据目录不存在: {data_path}") + + # 处理模板输入 + if isinstance(templates, str) and templates.endswith(".csv"): + if not os.path.exists(templates): + raise FileNotFoundError(f"模板文件不存在: {templates}") + # 从CSV文件读取模板 + import csv + + template_list = [] + with open(templates, encoding="utf-8") as f: + reader = csv.DictReader(f) + for row in reader: + if "gremlin_query" in row: + template_list.append(row["gremlin_query"]) + elif "template" in row: + template_list.append(row["template"]) + templates = template_list + + if not templates: + raise ValueError("没有找到有效的模板") + + # Load all necessary components once + config = Config(file_path=config_path) + schema = Schema(schema_path, data_path) + gremlin_base = GremlinBase(config) + + # --- Run the generation process for each template with global deduplication --- + global_corpus_dict = {} # 使用字典进行去重，key是query，value是description + total_new_pairs = 0 + + # 处理统计信息 + processing_stats = { + "total_templates": len(templates), + "successful_templates": 0, + "failed_templates": 0, + "failed_details": [], + "total_generated": 0, + "total_syntax_errors": 0, + "total_duplicates": 0, + } + + print(f"🚀 开始处理 {len(templates)} 个模板...") + + for i, template in enumerate(templates, 1): + try: + new_pairs_count, template_stats = generate_corpus_from_template( + template_string=template, + config=config, + schema=schema, + gremlin_base=gremlin_base, + global_corpus_dict=global_corpus_dict, + ) + + total_new_pairs += new_pairs_count + + # 更新统计信息 + if template_stats["success"]: + processing_stats["successful_templates"] += 1 + processing_stats["total_generated"] += template_stats["generated_count"] + processing_stats["total_syntax_errors"] += template_stats["syntax_error_count"] + processing_stats["total_duplicates"] += template_stats["duplicate_count"] + + # 根据情况显示不同的消息 + if new_pairs_count == 0 and template_stats["generated_count"] > 0: + print(f"[{i}/{len(templates)}] ⚠️ 生成 {template_stats['generated_count']} 条查询但全部重复") + elif template_stats["generated_count"] > LARGE_GENERATION_THRESHOLD: + print( + f"[{i}/{len(templates)}] ⚡ 大量生成 {new_pairs_count} 条新查询 (总生成{template_stats['generated_count']}条)" + ) + else: + print(f"[{i}/{len(templates)}] ✅ 成功生成 {new_pairs_count} 条新查询") + else: + processing_stats["failed_templates"] += 1 + processing_stats["failed_details"].append( + { + "template_index": i, + "template": template[:100] + "..." if len(template) > 100 else template, + "error_stage": template_stats["error_stage"], + "error_message": template_stats["error_message"], + } + ) + print(f"[{i}/{len(templates)}] ❌ 处理失败: {template_stats['error_message']}") + + except Exception as e: + # 处理单个模板时的意外错误 + processing_stats["failed_templates"] += 1 + processing_stats["failed_details"].append( + { + "template_index": i, + "template": template[:100] + "..." if len(template) > 100 else template, + "error_stage": "unexpected_error", + "error_message": str(e), + } + ) + print(f"[{i}/{len(templates)}] ❌ 意外错误: {e!s}") + continue # 继续处理下一个模板 + + # 转换为列表格式以便后续处理 + full_corpus = list(global_corpus_dict.items()) + + # --- Save the full corpus to a local file (if output_file is provided) --- + if output_file: + # 确保输出目录存在 + out_dir = os.path.dirname(os.path.abspath(output_file)) + if out_dir: + os.makedirs(out_dir, exist_ok=True) + + # 确保只保存成功生成的查询-描述对 + corpus_data = { + "metadata": { + "total_templates": len(templates), + "successful_templates": processing_stats["successful_templates"], + "failed_templates": processing_stats["failed_templates"], + "total_unique_queries": len(full_corpus), + "generation_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + }, + "corpus": [{"query": query, "description": desc} for query, desc in full_corpus], + } + + with open(output_file, "w", encoding="utf-8") as f: + json.dump(corpus_data, f, ensure_ascii=False, indent=2) + + # --- Generate statistics and display results --- + stats = _generate_statistics(templates, full_corpus, output_file) + stats.update( + { + "total_templates": len(templates), + "successful_templates": processing_stats["successful_templates"], + "failed_templates": processing_stats["failed_templates"], + } + ) + + if output_file: + stats["output_file"] = output_file + + _display_final_results(full_corpus, stats) + + result = { + "total_templates": len(templates), + "successful_templates": processing_stats["successful_templates"], + "failed_templates": processing_stats["failed_templates"], + "total_unique_queries": len(full_corpus), + "statistics": stats, + "queries": full_corpus, + } + + if output_file: + result["output_file"] = output_file + + return result + + +def _generate_statistics(templates: list, full_corpus: list, output_file: str) -> dict: + """生成统计信息""" + # 按查询长度分类统计 + length_stats = {} + for query, _ in full_corpus: + steps = query.count(".") + length_stats[steps] = length_stats.get(steps, 0) + 1 + + # 按操作类型分类统计 + operation_stats = {"查询(V/E)": 0, "创建(addV/addE)": 0, "更新(property)": 0, "删除(drop)": 0} + + for query, _ in full_corpus: + if query.startswith("g.V(") or query.startswith("g.E("): + if ".drop()" in query: + operation_stats["删除(drop)"] += 1 + elif ".property(" in query: + operation_stats["更新(property)"] += 1 + else: + operation_stats["查询(V/E)"] += 1 + elif ".addV(" in query or ".addE(" in query: + operation_stats["创建(addV/addE)"] += 1 + + return { + "length_stats": length_stats, + "operation_stats": operation_stats, + "avg_per_template": len(full_corpus) / len(templates) if templates else 0, + } + + +def _display_final_results(full_corpus: list, stats: dict): + """显示最终生成结果和统计信息""" + print(f"\n{'=' * 50}") + print("📊 生成完成统计") + print(f"{'=' * 50}") + print(f"处理的模板数量: {stats.get('total_templates', 0)}") + print(f"成功处理: {stats.get('successful_templates', 0)}") + print(f"处理失败: {stats.get('failed_templates', 0)}") + print(f"生成的独特查询数量: {len(full_corpus)}") + + if "output_file" in stats: + print(f"语料库已保存到: {stats['output_file']}") + else: + print("语料库未保存到文件（仅返回结果）") + + # 按查询长度分类统计 + print(f"\n{'=' * 50}") + print("📈 查询复杂度分析:") + print(f"{'=' * 50}") + + for steps in sorted(stats["length_stats"].keys()): + print(f" {steps}步查询: {stats['length_stats'][steps]} 个") + + # 按操作类型分类统计 + print(f"\n{'=' * 50}") + print("🔍 操作类型分析:") + print(f"{'=' * 50}") + + for op_type, count in stats["operation_stats"].items(): + percentage = (count / len(full_corpus)) * 100 if full_corpus else 0 + print(f" {op_type}: {count} 个 ({percentage:.1f}%)") + + print(f"\n{'=' * 50}") + print(f"✅ 生成完成！共生成 {len(full_corpus)} 个独特查询") + print(f"{'=' * 50}") diff --git a/text2gremlin/AST_Text2Gremlin/base/gremlin/Gremlin.g4 b/text2gremlin/AST_Text2Gremlin/base/gremlin/Gremlin.g4 new file mode 100644 index 000000000..ef4d9a4e4 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/gremlin/Gremlin.g4 @@ -0,0 +1,3094 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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. + */ +grammar Gremlin; + +/********************************************* + PARSER RULES +**********************************************/ + +queryList + : query (SEMI? query)* SEMI? EOF + ; + +query + : traversalSource + | traversalSource DOT transactionPart + | rootTraversal + | rootTraversal DOT traversalTerminalMethod + | query DOT K_TOSTRING LPAREN RPAREN + | emptyQuery + ; + +emptyQuery + : EmptyStringLiteral + ; + +traversalSource + : TRAVERSAL_ROOT + | TRAVERSAL_ROOT DOT traversalSourceSelfMethod + | traversalSource DOT traversalSourceSelfMethod + ; + +transactionPart + : K_TX LPAREN RPAREN DOT K_BEGIN LPAREN RPAREN + | K_TX LPAREN RPAREN DOT K_COMMIT LPAREN RPAREN + | K_TX LPAREN RPAREN DOT K_ROLLBACK LPAREN RPAREN + ; + +rootTraversal + : traversalSource DOT traversalSourceSpawnMethod + | traversalSource DOT traversalSourceSpawnMethod DOT chainedTraversal + ; + +traversalSourceSelfMethod + : traversalSourceSelfMethod_withBulk + | traversalSourceSelfMethod_withPath + | traversalSourceSelfMethod_withSack + | traversalSourceSelfMethod_withSideEffect + | traversalSourceSelfMethod_withStrategies + | traversalSourceSelfMethod_withoutStrategies + | traversalSourceSelfMethod_with + ; + +traversalSourceSelfMethod_withBulk + : K_WITHBULK LPAREN booleanArgument RPAREN + ; + +traversalSourceSelfMethod_withPath + : K_WITHPATH LPAREN RPAREN + ; + +traversalSourceSelfMethod_withSack + : K_WITHSACK LPAREN genericArgument RPAREN + | K_WITHSACK LPAREN genericArgument COMMA traversalBiFunction RPAREN + ; + +traversalSourceSelfMethod_withSideEffect + : K_WITHSIDEEFFECT LPAREN stringLiteral COMMA genericArgument RPAREN + | K_WITHSIDEEFFECT LPAREN stringLiteral COMMA genericArgument COMMA traversalBiFunction RPAREN + ; + +traversalSourceSelfMethod_withStrategies + : K_WITHSTRATEGIES LPAREN traversalStrategy (COMMA traversalStrategyVarargs)? RPAREN + ; + +traversalSourceSelfMethod_withoutStrategies + : K_WITHOUTSTRATEGIES LPAREN classType (COMMA classTypeList)? RPAREN + ; + +traversalSourceSelfMethod_with + : K_WITH LPAREN stringLiteral RPAREN + | K_WITH LPAREN stringLiteral COMMA genericArgument RPAREN + ; + +traversalSourceSpawnMethod + : traversalSourceSpawnMethod_addE + | traversalSourceSpawnMethod_addV + | traversalSourceSpawnMethod_E + | traversalSourceSpawnMethod_V + | traversalSourceSpawnMethod_mergeE + | traversalSourceSpawnMethod_mergeV + | traversalSourceSpawnMethod_inject + | traversalSourceSpawnMethod_io + | traversalSourceSpawnMethod_call + | traversalSourceSpawnMethod_union + ; + +traversalSourceSpawnMethod_addE + : K_ADDE LPAREN stringArgument RPAREN + | K_ADDE LPAREN nestedTraversal RPAREN + ; + +traversalSourceSpawnMethod_addV + : K_ADDV LPAREN RPAREN + | K_ADDV LPAREN stringArgument RPAREN + | K_ADDV LPAREN nestedTraversal RPAREN + ; + +traversalSourceSpawnMethod_E + : K_E LPAREN genericArgumentVarargs RPAREN + ; + +traversalSourceSpawnMethod_V + : K_V LPAREN genericArgumentVarargs RPAREN + ; + +traversalSourceSpawnMethod_inject + : K_INJECT LPAREN genericArgumentVarargs RPAREN + ; + +traversalSourceSpawnMethod_io + : K_IO LPAREN stringLiteral RPAREN + ; + +traversalSourceSpawnMethod_mergeV + : K_MERGEV LPAREN genericMapNullableArgument RPAREN #traversalSourceSpawnMethod_mergeV_Map + | K_MERGEV LPAREN nestedTraversal RPAREN #traversalSourceSpawnMethod_mergeV_Traversal + ; + +traversalSourceSpawnMethod_mergeE + : K_MERGEE LPAREN genericMapNullableArgument RPAREN #traversalSourceSpawnMethod_mergeE_Map + | K_MERGEE LPAREN nestedTraversal RPAREN #traversalSourceSpawnMethod_mergeE_Traversal + ; + +traversalSourceSpawnMethod_call + : K_CALL LPAREN RPAREN #traversalSourceSpawnMethod_call_empty + | K_CALL LPAREN stringLiteral RPAREN #traversalSourceSpawnMethod_call_string + | K_CALL LPAREN stringLiteral COMMA genericMapArgument RPAREN #traversalSourceSpawnMethod_call_string_map + | K_CALL LPAREN stringLiteral COMMA nestedTraversal RPAREN #traversalSourceSpawnMethod_call_string_traversal + | K_CALL LPAREN stringLiteral COMMA genericMapArgument COMMA nestedTraversal RPAREN #traversalSourceSpawnMethod_call_string_map_traversal + ; + +traversalSourceSpawnMethod_union + : K_UNION LPAREN nestedTraversalList RPAREN + ; + +chainedTraversal + : traversalMethod + | chainedTraversal DOT traversalMethod + ; + +nestedTraversal + : chainedTraversal + | ANON_TRAVERSAL_ROOT DOT chainedTraversal + ; + +terminatedTraversal + : rootTraversal DOT traversalTerminalMethod + ; + +traversalMethod + : traversalMethod_V + | traversalMethod_E + | traversalMethod_addE + | traversalMethod_addV + | traversalMethod_mergeE + | traversalMethod_mergeV + | traversalMethod_aggregate + | traversalMethod_all + | traversalMethod_and + | traversalMethod_any + | traversalMethod_as + | traversalMethod_barrier + | traversalMethod_both + | traversalMethod_bothE + | traversalMethod_bothV + | traversalMethod_branch + | traversalMethod_by + | traversalMethod_cap + | traversalMethod_choose + | traversalMethod_coalesce + | traversalMethod_coin + | traversalMethod_conjoin + | traversalMethod_connectedComponent + | traversalMethod_constant + | traversalMethod_count + | traversalMethod_cyclicPath + | traversalMethod_dedup + | traversalMethod_difference + | traversalMethod_discard + | traversalMethod_disjunct + | traversalMethod_drop + | traversalMethod_elementMap + | traversalMethod_emit + | traversalMethod_filter + | traversalMethod_flatMap + | traversalMethod_fold + | traversalMethod_from + | traversalMethod_group + | traversalMethod_groupCount + | traversalMethod_has + | traversalMethod_hasId + | traversalMethod_hasKey + | traversalMethod_hasLabel + | traversalMethod_hasNot + | traversalMethod_hasValue + | traversalMethod_id + | traversalMethod_identity + | traversalMethod_in + | traversalMethod_inE + | traversalMethod_intersect + | traversalMethod_inV + | traversalMethod_index + | traversalMethod_inject + | traversalMethod_is + | traversalMethod_key + | traversalMethod_label + | traversalMethod_limit + | traversalMethod_local + | traversalMethod_loops + | traversalMethod_map + | traversalMethod_match + | traversalMethod_math + | traversalMethod_max + | traversalMethod_mean + | traversalMethod_min + | traversalMethod_none + | traversalMethod_not + | traversalMethod_option + | traversalMethod_optional + | traversalMethod_or + | traversalMethod_order + | traversalMethod_otherV + | traversalMethod_out + | traversalMethod_outE + | traversalMethod_outV + | traversalMethod_pageRank + | traversalMethod_path + | traversalMethod_peerPressure + | traversalMethod_profile + | traversalMethod_project + | traversalMethod_properties + | traversalMethod_property + | traversalMethod_propertyMap + | traversalMethod_range + | traversalMethod_read + | traversalMethod_repeat + | traversalMethod_sack + | traversalMethod_sample + | traversalMethod_select + | traversalMethod_combine + | traversalMethod_product + | traversalMethod_merge + | traversalMethod_shortestPath + | traversalMethod_sideEffect + | traversalMethod_simplePath + | traversalMethod_skip + | traversalMethod_store + | traversalMethod_subgraph + | traversalMethod_sum + | traversalMethod_tail + | traversalMethod_fail + | traversalMethod_timeLimit + | traversalMethod_times + | traversalMethod_to + | traversalMethod_toE + | traversalMethod_toV + | traversalMethod_tree + | traversalMethod_unfold + | traversalMethod_union + | traversalMethod_until + | traversalMethod_value + | traversalMethod_valueMap + | traversalMethod_values + | traversalMethod_where + | traversalMethod_with + | traversalMethod_write + | traversalMethod_element + | traversalMethod_call + | traversalMethod_concat + | traversalMethod_asString + | traversalMethod_format + | traversalMethod_toUpper + | traversalMethod_toLower + | traversalMethod_length + | traversalMethod_trim + | traversalMethod_lTrim + | traversalMethod_rTrim + | traversalMethod_reverse + | traversalMethod_replace + | traversalMethod_split + | traversalMethod_substring + | traversalMethod_asDate + | traversalMethod_dateAdd + | traversalMethod_dateDiff + ; + +traversalMethod_V + : K_V LPAREN genericArgumentVarargs RPAREN + ; + +traversalMethod_E + : K_E LPAREN genericArgumentVarargs RPAREN + ; + +traversalMethod_addE + : K_ADDE LPAREN stringArgument RPAREN #traversalMethod_addE_String + | K_ADDE LPAREN nestedTraversal RPAREN #traversalMethod_addE_Traversal + ; + +traversalMethod_addV + : K_ADDV LPAREN RPAREN #traversalMethod_addV_Empty + | K_ADDV LPAREN stringArgument RPAREN #traversalMethod_addV_String + | K_ADDV LPAREN nestedTraversal RPAREN #traversalMethod_addV_Traversal + ; + +traversalMethod_aggregate + : K_AGGREGATE LPAREN traversalScope COMMA stringLiteral RPAREN #traversalMethod_aggregate_Scope_String + | K_AGGREGATE LPAREN stringLiteral RPAREN #traversalMethod_aggregate_String + ; + +traversalMethod_all + : K_ALL LPAREN traversalPredicate RPAREN #traversalMethod_all_P + ; + +traversalMethod_and + : K_AND LPAREN nestedTraversalList RPAREN + ; + +traversalMethod_any + : K_ANY LPAREN traversalPredicate RPAREN #traversalMethod_any_P + ; + +traversalMethod_as + : K_AS LPAREN stringLiteral (COMMA stringNullableLiteralVarargs)? RPAREN + ; + +traversalMethod_asDate + : K_ASDATE LPAREN RPAREN + ; + +traversalMethod_asString + : K_ASSTRING LPAREN RPAREN #traversalMethod_asString_Empty + | K_ASSTRING LPAREN traversalScope RPAREN #traversalMethod_asString_Scope + ; + +traversalMethod_barrier + : K_BARRIER LPAREN traversalSackMethod RPAREN #traversalMethod_barrier_Consumer + | K_BARRIER LPAREN RPAREN #traversalMethod_barrier_Empty + | K_BARRIER LPAREN integerLiteral RPAREN #traversalMethod_barrier_int + ; + +traversalMethod_both + : K_BOTH LPAREN stringNullableArgumentVarargs RPAREN + ; + +traversalMethod_bothE + : K_BOTHE LPAREN stringNullableArgumentVarargs RPAREN + ; + +traversalMethod_bothV + : K_BOTHV LPAREN RPAREN + ; + +traversalMethod_branch + : K_BRANCH LPAREN nestedTraversal RPAREN + ; + +traversalMethod_by + : K_BY LPAREN traversalComparator RPAREN #traversalMethod_by_Comparator + | K_BY LPAREN RPAREN #traversalMethod_by_Empty + | K_BY LPAREN traversalFunction RPAREN #traversalMethod_by_Function + | K_BY LPAREN traversalFunction COMMA traversalComparator RPAREN #traversalMethod_by_Function_Comparator + | K_BY LPAREN traversalOrder RPAREN #traversalMethod_by_Order + | K_BY LPAREN stringLiteral RPAREN #traversalMethod_by_String + | K_BY LPAREN stringLiteral COMMA traversalComparator RPAREN #traversalMethod_by_String_Comparator + | K_BY LPAREN traversalT RPAREN #traversalMethod_by_T + | K_BY LPAREN nestedTraversal RPAREN #traversalMethod_by_Traversal + | K_BY LPAREN nestedTraversal COMMA traversalComparator RPAREN #traversalMethod_by_Traversal_Comparator + ; + +traversalMethod_call + : K_CALL LPAREN stringLiteral RPAREN #traversalMethod_call_string + | K_CALL LPAREN stringLiteral COMMA genericMapArgument RPAREN #traversalMethod_call_string_map + | K_CALL LPAREN stringLiteral COMMA nestedTraversal RPAREN #traversalMethod_call_string_traversal + | K_CALL LPAREN stringLiteral COMMA genericMapArgument COMMA nestedTraversal RPAREN #traversalMethod_call_string_map_traversal + ; + +traversalMethod_cap + : K_CAP LPAREN stringLiteral (COMMA stringNullableLiteralVarargs)? RPAREN + ; + +traversalMethod_choose + : K_CHOOSE LPAREN traversalFunction RPAREN #traversalMethod_choose_Function + | K_CHOOSE LPAREN traversalPredicate COMMA nestedTraversal RPAREN #traversalMethod_choose_Predicate_Traversal + | K_CHOOSE LPAREN traversalPredicate COMMA nestedTraversal COMMA nestedTraversal RPAREN #traversalMethod_choose_Predicate_Traversal_Traversal + | K_CHOOSE LPAREN nestedTraversal RPAREN #traversalMethod_choose_Traversal + | K_CHOOSE LPAREN nestedTraversal COMMA nestedTraversal RPAREN #traversalMethod_choose_Traversal_Traversal + | K_CHOOSE LPAREN nestedTraversal COMMA nestedTraversal COMMA nestedTraversal RPAREN #traversalMethod_choose_Traversal_Traversal_Traversal + ; + +traversalMethod_coalesce + : K_COALESCE LPAREN nestedTraversalList RPAREN + ; + +traversalMethod_coin + : K_COIN LPAREN floatArgument RPAREN + ; + +traversalMethod_combine + : K_COMBINE LPAREN genericArgument RPAREN #traversalMethod_combine_Object + ; + +traversalMethod_concat + : K_CONCAT LPAREN nestedTraversal (COMMA nestedTraversalList)? RPAREN #traversalMethod_concat_Traversal_Traversal + | K_CONCAT LPAREN stringNullableLiteralVarargs RPAREN #traversalMethod_concat_String + ; + +traversalMethod_conjoin + : K_CONJOIN LPAREN stringArgument RPAREN #traversalMethod_conjoin_String + ; + +traversalMethod_connectedComponent + : K_CONNECTEDCOMPONENT LPAREN RPAREN + ; + +traversalMethod_constant + : K_CONSTANT LPAREN genericArgument RPAREN + ; + +traversalMethod_count + : K_COUNT LPAREN RPAREN #traversalMethod_count_Empty + | K_COUNT LPAREN traversalScope RPAREN #traversalMethod_count_Scope + ; + +traversalMethod_cyclicPath + : K_CYCLICPATH LPAREN RPAREN + ; + +traversalMethod_dateAdd + : K_DATEADD LPAREN traversalDT COMMA integerLiteral RPAREN + ; + +traversalMethod_dateDiff + : K_DATEDIFF LPAREN nestedTraversal RPAREN #traversalMethod_dateDiff_Traversal + | K_DATEDIFF LPAREN dateLiteral RPAREN #traversalMethod_dateDiff_Date + ; + +traversalMethod_dedup + : K_DEDUP LPAREN traversalScope (COMMA stringNullableLiteralVarargs)? RPAREN #traversalMethod_dedup_Scope_String + | K_DEDUP LPAREN stringNullableLiteralVarargs RPAREN #traversalMethod_dedup_String + ; + +traversalMethod_difference + : K_DIFFERENCE LPAREN genericArgument RPAREN #traversalMethod_difference_Object + ; + +traversalMethod_discard + : 'discard' LPAREN RPAREN + ; + +traversalMethod_disjunct + : K_DISJUNCT LPAREN genericArgument RPAREN #traversalMethod_disjunct_Object + ; + +traversalMethod_drop + : K_DROP LPAREN RPAREN + ; + +traversalMethod_element + : K_ELEMENT LPAREN RPAREN + ; + +traversalMethod_elementMap + : K_ELEMENTMAP LPAREN stringNullableLiteralVarargs RPAREN + ; + +traversalMethod_emit + : K_EMIT LPAREN RPAREN #traversalMethod_emit_Empty + | K_EMIT LPAREN traversalPredicate RPAREN #traversalMethod_emit_Predicate + | K_EMIT LPAREN nestedTraversal RPAREN #traversalMethod_emit_Traversal + ; + +traversalMethod_fail + : K_FAIL LPAREN RPAREN #traversalMethod_fail_Empty + | K_FAIL LPAREN stringLiteral RPAREN #traversalMethod_fail_String + ; + +traversalMethod_filter + : K_FILTER LPAREN traversalPredicate RPAREN #traversalMethod_filter_Predicate + | K_FILTER LPAREN nestedTraversal RPAREN #traversalMethod_filter_Traversal + ; + +traversalMethod_flatMap + : K_FLATMAP LPAREN nestedTraversal RPAREN + ; + +traversalMethod_fold + : K_FOLD LPAREN RPAREN #traversalMethod_fold_Empty + | K_FOLD LPAREN genericArgument COMMA traversalBiFunction RPAREN #traversalMethod_fold_Object_BiFunction + ; + +traversalMethod_format + : K_FORMAT LPAREN stringLiteral RPAREN #traversalMethod_format_String + ; + +traversalMethod_from + : K_FROM LPAREN stringLiteral RPAREN #traversalMethod_from_String + | K_FROM LPAREN structureVertexArgument RPAREN #traversalMethod_from_Vertex + | K_FROM LPAREN nestedTraversal RPAREN #traversalMethod_from_Traversal + ; + +traversalMethod_group + : K_GROUP LPAREN RPAREN #traversalMethod_group_Empty + | K_GROUP LPAREN stringLiteral RPAREN #traversalMethod_group_String + ; + +traversalMethod_groupCount + : K_GROUPCOUNT LPAREN RPAREN #traversalMethod_groupCount_Empty + | K_GROUPCOUNT LPAREN stringLiteral RPAREN #traversalMethod_groupCount_String + ; + +traversalMethod_has + : K_HAS LPAREN stringNullableLiteral RPAREN #traversalMethod_has_String + | K_HAS LPAREN stringNullableLiteral COMMA genericArgument RPAREN #traversalMethod_has_String_Object + | K_HAS LPAREN stringNullableLiteral COMMA traversalPredicate RPAREN #traversalMethod_has_String_P + | K_HAS LPAREN stringNullableArgument COMMA stringNullableLiteral COMMA genericArgument RPAREN #traversalMethod_has_String_String_Object + | K_HAS LPAREN stringNullableArgument COMMA stringNullableLiteral COMMA traversalPredicate RPAREN #traversalMethod_has_String_String_P + | K_HAS LPAREN stringNullableLiteral COMMA nestedTraversal RPAREN #traversalMethod_has_String_Traversal + | K_HAS LPAREN traversalT COMMA genericArgument RPAREN #traversalMethod_has_T_Object + | K_HAS LPAREN traversalT COMMA traversalPredicate RPAREN #traversalMethod_has_T_P + | K_HAS LPAREN traversalT COMMA nestedTraversal RPAREN #traversalMethod_has_T_Traversal + ; + +traversalMethod_hasId + : K_HASID LPAREN genericArgument (COMMA genericArgumentVarargs)? RPAREN #traversalMethod_hasId_Object_Object + | K_HASID LPAREN traversalPredicate RPAREN #traversalMethod_hasId_P + ; + +traversalMethod_hasKey + : K_HASKEY LPAREN traversalPredicate RPAREN #traversalMethod_hasKey_P + | K_HASKEY LPAREN stringNullableLiteral (COMMA stringNullableLiteralVarargs)? RPAREN #traversalMethod_hasKey_String_String + ; + +traversalMethod_hasLabel + : K_HASLABEL LPAREN traversalPredicate RPAREN #traversalMethod_hasLabel_P + | K_HASLABEL LPAREN stringNullableArgument (COMMA stringNullableArgumentVarargs)? RPAREN #traversalMethod_hasLabel_String_String + ; + +traversalMethod_hasNot + : K_HASNOT LPAREN stringNullableLiteral RPAREN + ; + +traversalMethod_hasValue + : K_HASVALUE LPAREN genericArgument (COMMA genericArgumentVarargs)? RPAREN #traversalMethod_hasValue_Object_Object + | K_HASVALUE LPAREN traversalPredicate RPAREN #traversalMethod_hasValue_P + ; + +traversalMethod_id + : K_ID LPAREN RPAREN + ; + +traversalMethod_identity + : K_IDENTITY LPAREN RPAREN + ; + +traversalMethod_in + : K_IN LPAREN stringNullableArgumentVarargs RPAREN + ; + +traversalMethod_inE + : K_INE LPAREN stringNullableArgumentVarargs RPAREN + ; + +traversalMethod_intersect + : K_INTERSECT LPAREN genericArgument RPAREN #traversalMethod_intersect_Object + ; + +traversalMethod_inV + : K_INV LPAREN RPAREN + ; + +traversalMethod_index + : K_INDEX LPAREN RPAREN + ; + +traversalMethod_inject + : K_INJECT LPAREN genericArgumentVarargs RPAREN + ; + +traversalMethod_is + : K_IS LPAREN genericArgument RPAREN #traversalMethod_is_Object + | K_IS LPAREN traversalPredicate RPAREN #traversalMethod_is_P + ; + +traversalMethod_key + : K_KEY LPAREN RPAREN + ; + +traversalMethod_label + : K_LABEL LPAREN RPAREN + ; + +traversalMethod_length + : K_LENGTH LPAREN RPAREN #traversalMethod_length_Empty + | K_LENGTH LPAREN traversalScope RPAREN #traversalMethod_length_Scope + ; + +traversalMethod_limit + : K_LIMIT LPAREN traversalScope COMMA integerArgument RPAREN #traversalMethod_limit_Scope_long + | K_LIMIT LPAREN integerArgument RPAREN #traversalMethod_limit_long + ; + +traversalMethod_local + : K_LOCAL LPAREN nestedTraversal RPAREN + ; + +traversalMethod_loops + : K_LOOPS LPAREN RPAREN #traversalMethod_loops_Empty + | K_LOOPS LPAREN stringLiteral RPAREN #traversalMethod_loops_String + ; + +traversalMethod_lTrim + : K_LTRIM LPAREN RPAREN #traversalMethod_lTrim_Empty + | K_LTRIM LPAREN traversalScope RPAREN #traversalMethod_lTrim_Scope + ; + +traversalMethod_map + : K_MAP LPAREN nestedTraversal RPAREN + ; + +traversalMethod_match + : K_MATCH LPAREN nestedTraversalList RPAREN + ; + +traversalMethod_math + : K_MATH LPAREN stringLiteral RPAREN + ; + +traversalMethod_max + : K_MAX LPAREN RPAREN #traversalMethod_max_Empty + | K_MAX LPAREN traversalScope RPAREN #traversalMethod_max_Scope + ; + +traversalMethod_mean + : K_MEAN LPAREN RPAREN #traversalMethod_mean_Empty + | K_MEAN LPAREN traversalScope RPAREN #traversalMethod_mean_Scope + ; + +traversalMethod_merge + : K_MERGE LPAREN genericArgument RPAREN #traversalMethod_merge_Object + ; + +traversalMethod_mergeV + : K_MERGEV LPAREN RPAREN #traversalMethod_mergeV_empty + | K_MERGEV LPAREN genericMapNullableArgument RPAREN #traversalMethod_mergeV_Map + | K_MERGEV LPAREN nestedTraversal RPAREN #traversalMethod_mergeV_Traversal + ; + +traversalMethod_mergeE + : K_MERGEE LPAREN RPAREN #traversalMethod_mergeE_empty + | K_MERGEE LPAREN genericMapNullableArgument RPAREN #traversalMethod_mergeE_Map + | K_MERGEE LPAREN nestedTraversal RPAREN #traversalMethod_mergeE_Traversal + ; + +traversalMethod_min + : K_MIN LPAREN RPAREN #traversalMethod_min_Empty + | K_MIN LPAREN traversalScope RPAREN #traversalMethod_min_Scope + ; + +traversalMethod_none + : K_NONE LPAREN traversalPredicate RPAREN #traversalMethod_none_P + ; + +traversalMethod_not + : K_NOT LPAREN nestedTraversal RPAREN + ; + +traversalMethod_option + : K_OPTION LPAREN traversalPredicate COMMA nestedTraversal RPAREN #traversalMethod_option_Predicate_Traversal + | K_OPTION LPAREN traversalMerge COMMA genericMapNullableArgument RPAREN #traversalMethod_option_Merge_Map + | K_OPTION LPAREN traversalMerge COMMA genericMapNullableArgument COMMA traversalCardinality RPAREN #traversalMethod_option_Merge_Map_Cardinality + | K_OPTION LPAREN traversalMerge COMMA nestedTraversal RPAREN #traversalMethod_option_Merge_Traversal + | K_OPTION LPAREN genericArgument COMMA nestedTraversal RPAREN #traversalMethod_option_Object_Traversal + | K_OPTION LPAREN nestedTraversal RPAREN #traversalMethod_option_Traversal + ; + +traversalMethod_optional + : K_OPTIONAL LPAREN nestedTraversal RPAREN + ; + +traversalMethod_or + : K_OR LPAREN nestedTraversalList RPAREN + ; + +traversalMethod_order + : K_ORDER LPAREN RPAREN #traversalMethod_order_Empty + | K_ORDER LPAREN traversalScope RPAREN #traversalMethod_order_Scope + ; + +traversalMethod_otherV + : K_OTHERV LPAREN RPAREN + ; + +traversalMethod_out + : K_OUT LPAREN stringNullableArgumentVarargs RPAREN + ; + +traversalMethod_outE + : K_OUTE LPAREN stringNullableArgumentVarargs RPAREN + ; + +traversalMethod_outV + : K_OUTV LPAREN RPAREN + ; + +traversalMethod_pageRank + : K_PAGERANK LPAREN RPAREN #traversalMethod_pageRank_Empty + | K_PAGERANK LPAREN floatArgument RPAREN #traversalMethod_pageRank_double + ; + +traversalMethod_path + : K_PATH LPAREN RPAREN + ; + +traversalMethod_peerPressure + : K_PEERPRESSURE LPAREN RPAREN + ; + +traversalMethod_product + : K_PRODUCT LPAREN genericArgument RPAREN #traversalMethod_product_Object + ; + +traversalMethod_profile + : K_PROFILE LPAREN RPAREN #traversalMethod_profile_Empty + | K_PROFILE LPAREN stringLiteral RPAREN #traversalMethod_profile_String + ; + +traversalMethod_project + : K_PROJECT LPAREN stringLiteral (COMMA stringNullableLiteralVarargs)? RPAREN + ; + +traversalMethod_properties + : K_PROPERTIES LPAREN stringNullableLiteralVarargs RPAREN + ; + +traversalMethod_property + : K_PROPERTY LPAREN traversalCardinality COMMA genericArgument COMMA genericArgument (COMMA genericArgumentVarargs)? RPAREN #traversalMethod_property_Cardinality_Object_Object_Object + | K_PROPERTY LPAREN traversalCardinality COMMA genericMapNullableArgument RPAREN # traversalMethod_property_Cardinality_Object + | K_PROPERTY LPAREN genericArgument COMMA genericArgument (COMMA genericArgumentVarargs)? RPAREN #traversalMethod_property_Object_Object_Object + | K_PROPERTY LPAREN genericMapNullableArgument RPAREN # traversalMethod_property_Object + ; + +traversalMethod_propertyMap + : K_PROPERTYMAP LPAREN stringNullableLiteralVarargs RPAREN + ; + +traversalMethod_range + : K_RANGE LPAREN traversalScope COMMA integerArgument COMMA integerArgument RPAREN #traversalMethod_range_Scope_long_long + | K_RANGE LPAREN integerArgument COMMA integerArgument RPAREN #traversalMethod_range_long_long + ; + +traversalMethod_read + : K_READ LPAREN RPAREN + ; + +traversalMethod_repeat + : K_REPEAT LPAREN stringLiteral COMMA nestedTraversal RPAREN #traversalMethod_repeat_String_Traversal + | K_REPEAT LPAREN nestedTraversal RPAREN #traversalMethod_repeat_Traversal + ; + +traversalMethod_replace + : K_REPLACE LPAREN stringNullableLiteral COMMA stringNullableLiteral RPAREN #traversalMethod_replace_String_String + | K_REPLACE LPAREN traversalScope COMMA stringNullableLiteral COMMA stringNullableLiteral RPAREN #traversalMethod_replace_Scope_String_String + ; + +traversalMethod_reverse + : K_REVERSE LPAREN RPAREN #traversalMethod_reverse_Empty + ; + +traversalMethod_rTrim + : K_RTRIM LPAREN RPAREN #traversalMethod_rTrim_Empty + | K_RTRIM LPAREN traversalScope RPAREN #traversalMethod_rTrim_Scope + ; + +traversalMethod_sack + : K_SACK LPAREN traversalBiFunction RPAREN #traversalMethod_sack_BiFunction + | K_SACK LPAREN RPAREN #traversalMethod_sack_Empty + ; + +traversalMethod_sample + : K_SAMPLE LPAREN traversalScope COMMA integerLiteral RPAREN #traversalMethod_sample_Scope_int + | K_SAMPLE LPAREN integerLiteral RPAREN #traversalMethod_sample_int + ; + +traversalMethod_select + : K_SELECT LPAREN traversalColumn RPAREN #traversalMethod_select_Column + | K_SELECT LPAREN traversalPop COMMA stringLiteral RPAREN #traversalMethod_select_Pop_String + | K_SELECT LPAREN traversalPop COMMA stringLiteral COMMA stringLiteral (COMMA stringNullableLiteralVarargs)? RPAREN #traversalMethod_select_Pop_String_String_String + | K_SELECT LPAREN traversalPop COMMA nestedTraversal RPAREN #traversalMethod_select_Pop_Traversal + | K_SELECT LPAREN stringLiteral RPAREN #traversalMethod_select_String + | K_SELECT LPAREN stringLiteral COMMA stringLiteral (COMMA stringNullableLiteralVarargs)? RPAREN #traversalMethod_select_String_String_String + | K_SELECT LPAREN nestedTraversal RPAREN #traversalMethod_select_Traversal + ; + +traversalMethod_shortestPath + : K_SHORTESTPATH LPAREN RPAREN + ; + +traversalMethod_sideEffect + : K_SIDEEFFECT LPAREN nestedTraversal RPAREN + ; + +traversalMethod_simplePath + : K_SIMPLEPATH LPAREN RPAREN + ; + +traversalMethod_skip + : K_SKIP LPAREN traversalScope COMMA integerArgument RPAREN #traversalMethod_skip_Scope_long + | K_SKIP LPAREN integerArgument RPAREN #traversalMethod_skip_long + ; + +traversalMethod_split + : K_SPLIT LPAREN stringNullableLiteral RPAREN #traversalMethod_split_String + | K_SPLIT LPAREN traversalScope COMMA stringNullableLiteral RPAREN #traversalMethod_split_Scope_String + ; + +traversalMethod_store + : K_STORE LPAREN stringLiteral RPAREN + ; + +traversalMethod_subgraph + : K_SUBGRAPH LPAREN stringLiteral RPAREN + ; + +traversalMethod_substring + : K_SUBSTRING LPAREN integerLiteral RPAREN #traversalMethod_substring_int + | K_SUBSTRING LPAREN traversalScope COMMA integerLiteral RPAREN #traversalMethod_substring_Scope_int + | K_SUBSTRING LPAREN integerLiteral COMMA integerLiteral RPAREN #traversalMethod_substring_int_int + | K_SUBSTRING LPAREN traversalScope COMMA integerLiteral COMMA integerLiteral RPAREN #traversalMethod_substring_Scope_int_int + ; + +traversalMethod_sum + : K_SUM LPAREN RPAREN #traversalMethod_sum_Empty + | K_SUM LPAREN traversalScope RPAREN #traversalMethod_sum_Scope + ; + +traversalMethod_tail + : K_TAIL LPAREN RPAREN #traversalMethod_tail_Empty + | K_TAIL LPAREN traversalScope RPAREN #traversalMethod_tail_Scope + | K_TAIL LPAREN traversalScope COMMA integerArgument RPAREN #traversalMethod_tail_Scope_long + | K_TAIL LPAREN integerArgument RPAREN #traversalMethod_tail_long + ; + +traversalMethod_timeLimit + : K_TIMELIMIT LPAREN integerLiteral RPAREN + ; + +traversalMethod_times + : K_TIMES LPAREN integerLiteral RPAREN + ; + +traversalMethod_to + : K_TO LPAREN traversalDirection (COMMA stringNullableLiteralVarargs)? RPAREN #traversalMethod_to_Direction_String + | K_TO LPAREN stringLiteral RPAREN #traversalMethod_to_String + | K_TO LPAREN structureVertexArgument RPAREN #traversalMethod_to_Vertex + | K_TO LPAREN nestedTraversal RPAREN #traversalMethod_to_Traversal + ; + +traversalMethod_toE + : K_TOE LPAREN traversalDirection (COMMA stringNullableArgumentVarargs)? RPAREN + ; + +traversalMethod_toLower + : K_TOLOWER LPAREN RPAREN #traversalMethod_toLower_Empty + | K_TOLOWER LPAREN traversalScope RPAREN #traversalMethod_toLower_Scope + ; + +traversalMethod_toUpper + : K_TOUPPER LPAREN RPAREN #traversalMethod_toUpper_Empty + | K_TOUPPER LPAREN traversalScope RPAREN #traversalMethod_toUpper_Scope + ; + +traversalMethod_toV + : K_TOV LPAREN traversalDirection RPAREN + ; + +traversalMethod_tree + : K_TREE LPAREN RPAREN #traversalMethod_tree_Empty + | K_TREE LPAREN stringLiteral RPAREN #traversalMethod_tree_String + ; + +traversalMethod_trim + : K_TRIM LPAREN RPAREN #traversalMethod_trim_Empty + | K_TRIM LPAREN traversalScope RPAREN #traversalMethod_trim_Scope + ; + +traversalMethod_unfold + : K_UNFOLD LPAREN RPAREN + ; + +traversalMethod_union + : K_UNION LPAREN nestedTraversalList RPAREN + ; + +traversalMethod_until + : K_UNTIL LPAREN traversalPredicate RPAREN #traversalMethod_until_Predicate + | K_UNTIL LPAREN nestedTraversal RPAREN #traversalMethod_until_Traversal + ; + +traversalMethod_value + : K_VALUE LPAREN RPAREN + ; + +traversalMethod_valueMap + : K_VALUEMAP LPAREN stringNullableLiteralVarargs RPAREN #traversalMethod_valueMap_String + | K_VALUEMAP LPAREN booleanLiteral (COMMA stringNullableLiteralVarargs)? RPAREN #traversalMethod_valueMap_boolean_String + ; + +traversalMethod_values + : K_VALUES LPAREN stringNullableLiteralVarargs RPAREN + ; + +traversalMethod_where + : K_WHERE LPAREN traversalPredicate RPAREN #traversalMethod_where_P + | K_WHERE LPAREN stringLiteral COMMA traversalPredicate RPAREN #traversalMethod_where_String_P + | K_WHERE LPAREN nestedTraversal RPAREN #traversalMethod_where_Traversal + ; + +traversalMethod_with + : K_WITH LPAREN (withOptionKeys | stringLiteral) RPAREN #traversalMethod_with_String + | K_WITH LPAREN (withOptionKeys | stringLiteral) COMMA (withOptionsValues | ioOptionsValues | genericArgument) RPAREN #traversalMethod_with_String_Object + ; + +traversalMethod_write + : K_WRITE LPAREN RPAREN + ; + +/********************************************* + ARGUMENT AND TERMINAL RULES +**********************************************/ + +// There is syntax available in the construction of a ReferenceVertex, that allows the label to not be specified. +// That use case is related to OLAP when the StarGraph does not preserve the label of adjacent vertices or other +// fail fast scenarios in that processing model. It is not relevant to the grammar however when a user is creating +// the Vertex to be used in a Traversal and therefore both id and label are required. +structureVertexLiteral + : K_NEW? (K_VERTEX | K_REFERENCEVERTEX) LPAREN genericArgument COMMA stringArgument RPAREN + ; + +traversalStrategy + : K_NEW? classType (LPAREN (configuration (COMMA configuration)*)? RPAREN)? + ; + +configuration + : (keyword | nakedKey) COLON genericArgument + ; + +traversalScope + : K_LOCAL | K_SCOPE DOT K_LOCAL + | K_GLOBAL | K_SCOPE DOT K_GLOBAL + ; + +traversalBarrier + : K_NORMSACK | K_BARRIERU DOT K_NORMSACK + ; + +traversalT + : traversalTShort + | traversalTLong + ; + +traversalTShort + : K_ID + | K_LABEL + | K_KEY + | K_VALUE + ; + +traversalTLong + : K_T DOT K_ID + | K_T DOT K_LABEL + | K_T DOT K_KEY + | K_T DOT K_VALUE + ; + +traversalMerge + : K_ONCREATE | K_MERGEU DOT K_ONCREATE + | K_ONMATCH | K_MERGEU DOT K_ONMATCH + | K_OUTV | K_MERGEU DOT K_OUTV + | K_INV | K_MERGEU DOT K_INV + ; + +traversalOrder + : K_ASC | K_ORDERU DOT K_ASC + | K_DESC | K_ORDERU DOT K_DESC + | K_SHUFFLE | K_ORDERU DOT K_SHUFFLE + ; + +traversalDirection + : traversalDirectionShort + | traversalDirectionLong + ; + +traversalDirectionShort + : K_INU | K_FROM + | K_OUTU | K_TO + | K_BOTHU + ; + +traversalDirectionLong + : K_DIRECTION DOT K_INU | K_DIRECTION DOT K_FROM + | K_DIRECTION DOT K_OUTU | K_DIRECTION DOT K_TO + | K_DIRECTION DOT K_BOTHU + ; + +traversalCardinality + : (K_CARDINALITY DOT K_SINGLE | K_SINGLE) LPAREN genericLiteral RPAREN + | (K_CARDINALITY DOT K_SET | K_SET) LPAREN genericLiteral RPAREN + | (K_CARDINALITY DOT K_LIST | K_LIST) LPAREN genericLiteral RPAREN + | K_SINGLE | K_CARDINALITY DOT K_SINGLE + | K_SET | K_CARDINALITY DOT K_SET + | K_LIST | K_CARDINALITY DOT K_LIST + ; + +traversalColumn + : K_KEYS | K_COLUMN DOT K_KEYS + | K_VALUES | K_COLUMN DOT K_VALUES + ; + +traversalPop + : K_FIRST | K_POP DOT K_FIRST + | K_LAST | K_POP DOT K_LAST + | K_ALL | K_POP DOT K_ALL + | K_MIXED | K_POP DOT K_MIXED + ; + +traversalOperator + : K_ADDALL | K_OPERATOR DOT K_ADDALL + | K_AND | K_OPERATOR DOT K_AND + | K_ASSIGN | K_OPERATOR DOT K_ASSIGN + | K_DIV | K_OPERATOR DOT K_DIV + | K_MAX | K_OPERATOR DOT K_MAX + | K_MIN | K_OPERATOR DOT K_MIN + | K_MINUS | K_OPERATOR DOT K_MINUS + | K_MULT | K_OPERATOR DOT K_MULT + | K_OR | K_OPERATOR DOT K_OR + | K_SUM | K_OPERATOR DOT K_SUM + | K_SUMLONG | K_OPERATOR DOT K_SUMLONG + ; + +traversalPick + : K_ANY | K_PICK DOT K_ANY + | K_NONE | K_PICK DOT K_NONE + ; + +traversalDT + : K_SECOND | K_DT DOT K_SECOND + | K_MINUTE | K_DT DOT K_MINUTE + | K_HOUR | K_DT DOT K_HOUR + | K_DAY | K_DT DOT K_DAY + ; + +traversalPredicate + : traversalPredicate_eq + | traversalPredicate_neq + | traversalPredicate_lt + | traversalPredicate_lte + | traversalPredicate_gt + | traversalPredicate_gte + | traversalPredicate_inside + | traversalPredicate_outside + | traversalPredicate_between + | traversalPredicate_within + | traversalPredicate_without + | traversalPredicate_not + | traversalPredicate_startingWith + | traversalPredicate_notStartingWith + | traversalPredicate_endingWith + | traversalPredicate_notEndingWith + | traversalPredicate_containing + | traversalPredicate_notContaining + | traversalPredicate_regex + | traversalPredicate_notRegex + | traversalPredicate DOT K_AND LPAREN traversalPredicate RPAREN + | traversalPredicate DOT K_OR LPAREN traversalPredicate RPAREN + | traversalPredicate DOT K_NEGATE LPAREN RPAREN + ; + +traversalTerminalMethod + : traversalTerminalMethod_explain + | traversalTerminalMethod_iterate + | traversalTerminalMethod_hasNext + | traversalTerminalMethod_tryNext + | traversalTerminalMethod_next + | traversalTerminalMethod_toList + | traversalTerminalMethod_toSet + | traversalTerminalMethod_toBulkSet + ; + +traversalSackMethod + : traversalBarrier + ; + +// Additional special rules that are derived from above +// These are used to restrict broad method signatures that accept lambdas +// to a smaller set. +traversalComparator + : traversalOrder + ; + +traversalFunction + : traversalT + | traversalColumn + ; + +traversalBiFunction + : traversalOperator + ; + +traversalPredicate_eq + : (K_P DOT K_EQ | K_EQ) LPAREN genericArgument RPAREN + ; + +traversalPredicate_neq + : (K_P DOT K_NEQ | K_NEQ) LPAREN genericArgument RPAREN + ; + +traversalPredicate_lt + : (K_P DOT K_LT | K_LT) LPAREN genericArgument RPAREN + ; + +traversalPredicate_lte + : (K_P DOT K_LTE | K_LTE) LPAREN genericArgument RPAREN + ; + +traversalPredicate_gt + : (K_P DOT K_GT | K_GT) LPAREN genericArgument RPAREN + ; + +traversalPredicate_gte + : (K_P DOT K_GTE | K_GTE) LPAREN genericArgument RPAREN + ; + +traversalPredicate_inside + : (K_P DOT K_INSIDE | K_INSIDE) LPAREN genericArgument COMMA genericArgument RPAREN + ; + +traversalPredicate_outside + : (K_P DOT K_OUTSIDE | K_OUTSIDE) LPAREN genericArgument COMMA genericArgument RPAREN + ; + +traversalPredicate_between + : (K_P DOT K_BETWEEN | K_BETWEEN) LPAREN genericArgument COMMA genericArgument RPAREN + ; + +traversalPredicate_within + : (K_P DOT K_WITHIN | K_WITHIN) LPAREN RPAREN + | (K_P DOT K_WITHIN | K_WITHIN) LPAREN genericArgumentVarargs RPAREN + ; + +traversalPredicate_without + : (K_P DOT K_WITHOUT | K_WITHOUT) LPAREN RPAREN + | (K_P DOT K_WITHOUT | K_WITHOUT) LPAREN genericArgumentVarargs RPAREN + ; + +traversalPredicate_not + : (K_P DOT K_NOT | K_NOT) LPAREN traversalPredicate RPAREN + ; + +traversalPredicate_containing + : (K_TEXTP DOT K_CONTAINING | K_CONTAINING) LPAREN stringArgument RPAREN + ; + +traversalPredicate_notContaining + : (K_TEXTP DOT K_NOTCONTAINING | K_NOTCONTAINING) LPAREN stringArgument RPAREN + ; + +traversalPredicate_startingWith + : (K_TEXTP DOT K_STARTINGWITH | K_STARTINGWITH) LPAREN stringArgument RPAREN + ; + +traversalPredicate_notStartingWith + : (K_TEXTP DOT K_NOTSTARTINGWITH | K_NOTSTARTINGWITH) LPAREN stringArgument RPAREN + ; + +traversalPredicate_endingWith + : (K_TEXTP DOT K_ENDINGWITH | K_ENDINGWITH) LPAREN stringArgument RPAREN + ; + +traversalPredicate_notEndingWith + : (K_TEXTP DOT K_NOTENDINGWITH | K_NOTENDINGWITH) LPAREN stringArgument RPAREN + ; + +traversalPredicate_regex + : (K_TEXTP DOT K_REGEX | K_REGEX) LPAREN stringArgument RPAREN + ; + +traversalPredicate_notRegex + : (K_TEXTP DOT K_NOTREGEX | K_NOTREGEX) LPAREN stringArgument RPAREN + ; + +traversalTerminalMethod_explain + : K_EXPLAIN LPAREN RPAREN + ; + +traversalTerminalMethod_hasNext + : K_HASNEXT LPAREN RPAREN + ; + +traversalTerminalMethod_iterate + : K_ITERATE LPAREN RPAREN + ; + +traversalTerminalMethod_tryNext + : K_TRYNEXT LPAREN RPAREN + ; + +traversalTerminalMethod_next + : K_NEXT LPAREN RPAREN + | K_NEXT LPAREN integerLiteral RPAREN + ; + +traversalTerminalMethod_toList + : K_TOLIST LPAREN RPAREN + ; + +traversalTerminalMethod_toSet + : K_TOSET LPAREN RPAREN + ; + +traversalTerminalMethod_toBulkSet + : K_TOBULKSET LPAREN RPAREN + ; + +// Gremlin specific lexer rules + +withOptionKeys + : shortestPathConstants + | connectedComponentConstants + | pageRankConstants + | peerPressureConstants + | ioOptionsKeys + | withOptionsConstants_tokens + | withOptionsConstants_indexer + ; + +connectedComponentConstants + : connectedComponentConstants_component + | connectedComponentConstants_edges + | connectedComponentConstants_propertyName + ; + +pageRankConstants + : pageRankConstants_edges + | pageRankConstants_times + | pageRankConstants_propertyName + ; + +peerPressureConstants + : peerPressureConstants_edges + | peerPressureConstants_times + | peerPressureConstants_propertyName + ; + +shortestPathConstants + : shortestPathConstants_target + | shortestPathConstants_edges + | shortestPathConstants_distance + | shortestPathConstants_maxDistance + | shortestPathConstants_includeEdges + ; + +withOptionsValues + : withOptionsConstants_tokens + | withOptionsConstants_none + | withOptionsConstants_ids + | withOptionsConstants_labels + | withOptionsConstants_keys + | withOptionsConstants_values + | withOptionsConstants_all + | withOptionsConstants_list + | withOptionsConstants_map + ; + +ioOptionsKeys + : ioOptionsConstants_reader + | ioOptionsConstants_writer + ; + +ioOptionsValues + : ioOptionsConstants_gryo + | ioOptionsConstants_graphson + | ioOptionsConstants_graphml + ; + +connectedComponentConstants_component + : connectedComponentStringConstant DOT K_COMPONENT + ; + +connectedComponentConstants_edges + : connectedComponentStringConstant DOT K_EDGES + ; + +connectedComponentConstants_propertyName + : connectedComponentStringConstant DOT K_PROPERTYNAME + ; + +pageRankConstants_edges + : pageRankStringConstant DOT K_EDGES + ; + +pageRankConstants_times + : pageRankStringConstant DOT K_TIMES + ; + +pageRankConstants_propertyName + : pageRankStringConstant DOT K_PROPERTYNAME + ; + +peerPressureConstants_edges + : peerPressureStringConstant DOT K_EDGES + ; + +peerPressureConstants_times + : peerPressureStringConstant DOT K_TIMES + ; + +peerPressureConstants_propertyName + : peerPressureStringConstant DOT K_PROPERTYNAME + ; + +shortestPathConstants_target + : shortestPathStringConstant DOT K_TARGET + ; + +shortestPathConstants_edges + : shortestPathStringConstant DOT K_EDGES + ; + +shortestPathConstants_distance + : shortestPathStringConstant DOT K_DISTANCE + ; + +shortestPathConstants_maxDistance + : shortestPathStringConstant DOT K_MAXDISTANCE + ; + +shortestPathConstants_includeEdges + : shortestPathStringConstant DOT K_INCLUDEEDGES + ; + +withOptionsConstants_tokens + : withOptionsStringConstant DOT K_TOKENS + ; + +withOptionsConstants_none + : withOptionsStringConstant DOT K_NONE + ; + +withOptionsConstants_ids + : withOptionsStringConstant DOT K_IDS + ; + +withOptionsConstants_labels + : withOptionsStringConstant DOT K_LABELS + ; + +withOptionsConstants_keys + : withOptionsStringConstant DOT K_KEYS + ; + +withOptionsConstants_values + : withOptionsStringConstant DOT K_VALUES + ; + +withOptionsConstants_all + : withOptionsStringConstant DOT K_ALL + ; + +withOptionsConstants_indexer + : withOptionsStringConstant DOT K_INDEXER + ; + +withOptionsConstants_list + : withOptionsStringConstant DOT K_LIST + ; + +withOptionsConstants_map + : withOptionsStringConstant DOT K_MAP + ; + +ioOptionsConstants_reader + : ioOptionsStringConstant DOT K_READER + ; + +ioOptionsConstants_writer + : ioOptionsStringConstant DOT K_WRITER + ; + +ioOptionsConstants_gryo + : ioOptionsStringConstant DOT K_GRYO + ; + +ioOptionsConstants_graphson + : ioOptionsStringConstant DOT K_GRAPHSON + ; + +ioOptionsConstants_graphml + : ioOptionsStringConstant DOT K_GRAPHML + ; + +connectedComponentStringConstant + : K_CONNECTEDCOMPONENTU + ; + +pageRankStringConstant + : K_PAGERANKU + ; + +peerPressureStringConstant + : K_PEERPRESSUREU + ; + +shortestPathStringConstant + : K_SHORTESTPATHU + ; + +withOptionsStringConstant + : K_WITHOPTOPTIONS + ; + +ioOptionsStringConstant + : K_IOU + ; + +booleanArgument + : booleanLiteral + | variable + ; + +integerArgument + : integerLiteral + | variable + ; + +floatArgument + : floatLiteral + | variable + ; + +stringArgument + : stringLiteral + | variable + ; + +stringNullableArgument + : stringNullableLiteral + | variable + ; + +stringNullableArgumentVarargs + : (stringNullableArgument (COMMA stringNullableArgument)*)? + ; + +dateArgument + : dateLiteral + | variable + ; + +genericArgument + : genericLiteral + | variable + ; + +genericArgumentVarargs + : (genericArgument (COMMA genericArgument)*)? + ; + +genericMapArgument + : genericMapLiteral + | variable + ; + +genericMapNullableArgument + : genericMapNullableLiteral + | variable + ; + +nullableGenericLiteralMap + : genericMapLiteral + | nullLiteral + ; + +structureVertexArgument + : structureVertexLiteral + | variable + ; + +traversalStrategyVarargs + : traversalStrategyExpr? + ; + +traversalStrategyExpr + : traversalStrategy (COMMA traversalStrategy)* + ; + +classTypeList + : classTypeExpr? + ; + +classTypeExpr + : classType (COMMA classType)* + ; + +nestedTraversalList + : nestedTraversalExpr? + ; + +nestedTraversalExpr + : nestedTraversal (COMMA nestedTraversal)* + ; + +genericCollectionLiteral + : LBRACK (genericLiteral (COMMA genericLiteral)*)? RBRACK + ; + +genericLiteralVarargs + : genericLiteralExpr? + ; + +genericLiteralExpr + : genericLiteral (COMMA genericLiteral)* + ; + +genericMapNullableLiteral + : genericMapLiteral + | nullLiteral + ; + +genericRangeLiteral + : integerLiteral DOT DOT integerLiteral + | stringLiteral DOT DOT stringLiteral + ; + +genericSetLiteral + : LBRACE (genericLiteral (COMMA genericLiteral)*)? RBRACE + ; + +stringNullableLiteralVarargs + : (stringNullableLiteral (COMMA stringNullableLiteral)*)? + ; + +genericLiteral + : numericLiteral + | booleanLiteral + | stringLiteral + | dateLiteral + | nullLiteral + // Allow the generic literal to match specific gremlin tokens also + | traversalT + | traversalCardinality + | traversalDirection + | traversalMerge + | traversalPick + | traversalDT + | structureVertexLiteral + | genericSetLiteral + | genericCollectionLiteral + | genericRangeLiteral + | nestedTraversal + | terminatedTraversal + | uuidLiteral + | genericMapLiteral + ; + +genericMapLiteral + : LBRACK COLON RBRACK + | LBRACK mapEntry (COMMA mapEntry)* RBRACK + ; + +mapKey + : (LPAREN traversalT RPAREN | traversalTLong) + | (LPAREN traversalDirection RPAREN | traversalDirectionLong) + | (LPAREN genericSetLiteral RPAREN | genericSetLiteral) + | (LPAREN genericCollectionLiteral RPAREN | genericCollectionLiteral) + | (LPAREN genericMapLiteral RPAREN | genericMapLiteral) + | (LPAREN stringLiteral RPAREN | stringLiteral) + | (LPAREN numericLiteral RPAREN | numericLiteral) + | (keyword | nakedKey) + ; + +mapEntry + : mapKey COLON genericLiteral + ; + +stringLiteral + : EmptyStringLiteral + | NonEmptyStringLiteral + ; + +stringNullableLiteral + : EmptyStringLiteral + | NonEmptyStringLiteral + | K_NULL + ; + +integerLiteral + : IntegerLiteral + ; + +floatLiteral + : FloatingPointLiteral + | infLiteral + | nanLiteral + ; + +numericLiteral + : integerLiteral + | floatLiteral + ; + +booleanLiteral + : K_TRUE + | K_FALSE + ; + +dateLiteral + : K_DATETIME LPAREN stringArgument RPAREN + | K_DATETIME LPAREN RPAREN + | K_DATETIMEU LPAREN stringArgument RPAREN + | K_DATETIMEU LPAREN RPAREN + ; + +nullLiteral + : K_NULL + ; + +nanLiteral + : K_NAN + ; + +infLiteral + : K_INFINITY + | SignedInfLiteral + ; + +uuidLiteral + : K_UUID LPAREN RPAREN + | K_UUID LPAREN stringLiteral RPAREN + ; + + +nakedKey + : Identifier + ; + +classType + : Identifier + ; + +variable + : Identifier + ; + +// every Gremlin keyword must be listed here or else these words will not be able to be used as +// Map/Configuration keys as naked identifiers like [all: 123]. without having that definition +// here that sort of Map definition will get a syntax error. +keyword + : TRAVERSAL_ROOT // g - __ is not an allowable key in this context + | K_ADDALL + | K_ADDE + | K_ADDV + | K_AGGREGATE + | K_ALL + | K_AND + | K_ANY + | K_AS + | K_ASC + | K_ASDATE + | K_ASSTRING + | K_ASSIGN + | K_BARRIER + | K_BARRIERU + | K_BEGIN + | K_BETWEEN + | K_BOTH + | K_BOTHU + | K_BOTHE + | K_BOTHV + | K_BRANCH + | K_BY + | K_CALL + | K_CAP + | K_CARDINALITY + | K_CHOOSE + | K_COALESCE + | K_COIN + | K_COLUMN + | K_COMBINE + | K_CONCAT + | K_COMMIT + | K_COMPONENT + | K_CONJOIN + | K_CONNECTEDCOMPONENT + | K_CONNECTEDCOMPONENTU + | K_CONSTANT + | K_CONTAINING + | K_COUNT + | K_CYCLICPATH + | K_DAY + | K_DATEADD + | K_DATEDIFF + | K_DATETIME + | K_DATETIMEU + | K_DECR + | K_DEDUP + | K_DESC + | K_DIFFERENCE + | K_DIRECTION + | K_DISJUNCT + | K_DISTANCE + | K_DIV + | K_DROP + | K_DT + | K_E + | K_EDGES + | K_ELEMENTMAP + | K_ELEMENT + | K_EMIT + | K_ENDINGWITH + | K_EQ + | K_EXPLAIN + | K_FAIL + | K_FALSE + | K_FILTER + | K_FIRST + | K_FLATMAP + | K_FOLD + | K_FORMAT + | K_FROM + | K_GLOBAL + | K_GT + | K_GTE + | K_GRAPHML + | K_GRAPHSON + | K_GROUP + | K_GROUPCOUNT + | K_GRYO + | K_HAS + | K_HASID + | K_HASKEY + | K_HASLABEL + | K_HASNEXT + | K_HASNOT + | K_HASVALUE + | K_HOUR + | K_ID + | K_IDENTITY + | K_IDS + | K_IN + | K_INU + | K_INCLUDEEDGES + | K_INCR + | K_INDEXER + | K_INE + | K_INDEX + | K_INFINITY + | K_INJECT + | K_INSIDE + | K_INTERSECT + | K_INV + | K_IO + | K_IOU + | K_IS + | K_ITERATE + | K_KEY + | K_KEYS + | K_LABELS + | K_LABEL + | K_LAST + | K_LENGTH + | K_LIMIT + | K_LIST + | K_LOCAL + | K_LOOPS + | K_LT + | K_LTE + | K_LTRIM + | K_MAP + | K_MATCH + | K_MATH + | K_MAX + | K_MAXDISTANCE + | K_MEAN + | K_MERGE + | K_MERGEU + | K_MERGEE + | K_MERGEV + | K_MIN + | K_MINUTE + | K_MINUS + | K_MIXED + | K_MULT + | K_NAN + | K_NEGATE + | K_NEW + | K_NONE + | K_NOTCONTAINING + | K_NOTENDINGWITH + | K_NOTREGEX + | K_NOTSTARTINGWITH + | K_NOT + | K_NEQ + | K_NEXT + | K_NULL + | K_NORMSACK + | K_ONCREATE + | K_ONMATCH + | K_OPERATOR + | K_OPTION + | K_OPTIONAL + | K_ORDER + | K_ORDERU + | K_OR + | K_OTHERV + | K_OUT + | K_OUTU + | K_OUTE + | K_OUTSIDE + | K_OUTV + | K_P + | K_PAGERANK + | K_PAGERANKU + | K_PATH + | K_PEERPRESSURE + | K_PEERPRESSUREU + | K_PICK + | K_POP + | K_PROFILE + | K_PROJECT + | K_PROPERTIES + | K_PROPERTYMAP + | K_PROPERTYNAME + | K_PROPERTY + | K_PRODUCT + | K_RANGE + | K_READ + | K_READER + | K_REFERENCEVERTEX + | K_REGEX + | K_REPLACE + | K_REPEAT + | K_REVERSE + | K_ROLLBACK + | K_RTRIM + | K_SACK + | K_SAMPLE + | K_SCOPE + | K_SECOND + | K_SELECT + | K_SET + | K_SHORTESTPATH + | K_SHORTESTPATHU + | K_SHUFFLE + | K_SIDEEFFECT + | K_SIMPLEPATH + | K_SINGLE + | K_SKIP + | K_SPLIT + | K_STARTINGWITH + | K_STORE + | K_SUBGRAPH + | K_SUBSTRING + | K_SUM + | K_SUMLONG + | K_T + | K_TAIL + | K_TARGET + | K_TEXTP + | K_TIMELIMIT + | K_TIMES + | K_TO + | K_TOBULKSET + | K_TOKENS + | K_TOLIST + | K_TOLOWER + | K_TOSET + | K_TOSTRING + | K_TOUPPER + | K_TOE + | K_TOV + | K_TREE + | K_TRIM + | K_TRUE + | K_TRYNEXT + | K_TX + | K_UNFOLD + | K_UNION + | K_UNTIL + | K_UUID + | K_V + | K_VALUEMAP + | K_VALUES + | K_VALUE + | K_VERTEX + | K_WHERE + | K_WITH + | K_WITHBULK + | K_WITHIN + | K_WITHOPTOPTIONS + | K_WITHOUT + | K_WITHOUTSTRATEGIES + | K_WITHPATH + | K_WITHSACK + | K_WITHSIDEEFFECT + | K_WITHSTRATEGIES + | K_WRITE + | K_WRITER + ; + +/********************************************* + LEXER RULES +**********************************************/ + +// Lexer rules +// These rules are extracted from Java ANTLRv4 Grammar. +// Source: https://github.com/antlr/grammars-v4/blob/master/java8/Java8.g4 + +// §3.9 Keywords + +K_ADDALL: 'addAll'; +K_ADDE: 'addE'; +K_ADDV: 'addV'; +K_AGGREGATE: 'aggregate'; +K_ALL: 'all'; +K_AND: 'and'; +K_ANY: 'any'; +K_AS: 'as'; +K_ASC: 'asc'; +K_ASDATE: 'asDate'; +K_ASSTRING: 'asString'; +K_ASSIGN: 'assign'; +K_BARRIER: 'barrier'; +K_BARRIERU: 'Barrier'; +K_BEGIN: 'begin'; +K_BETWEEN: 'between'; +K_BOTH: 'both'; +K_BOTHU: 'BOTH'; +K_BOTHE: 'bothE'; +K_BOTHV: 'bothV'; +K_BRANCH: 'branch'; +K_BY: 'by'; +K_CALL: 'call'; +K_CAP: 'cap'; +K_CARDINALITY: 'Cardinality'; +K_CHOOSE: 'choose'; +K_COALESCE: 'coalesce'; +K_COIN: 'coin'; +K_COLUMN: 'Column'; +K_COMBINE: 'combine'; +K_COMMIT: 'commit'; +K_COMPONENT: 'component'; +K_CONCAT: 'concat'; +K_CONJOIN: 'conjoin'; +K_CONNECTEDCOMPONENT: 'connectedComponent'; +K_CONNECTEDCOMPONENTU: 'ConnectedComponent'; +K_CONSTANT: 'constant'; +K_CONTAINING: 'containing'; +K_COUNT: 'count'; +K_CYCLICPATH: 'cyclicPath'; +K_DAY: 'day'; +K_DATEADD: 'dateAdd'; +K_DATEDIFF: 'dateDiff'; +K_DATETIME: 'datetime'; +K_DATETIMEU: 'DateTime'; +K_DECR: 'decr'; +K_DEDUP: 'dedup'; +K_DESC: 'desc'; +K_DIFFERENCE: 'difference'; +K_DIRECTION: 'Direction'; +K_DISJUNCT: 'disjunct'; +K_DISTANCE: 'distance'; +K_DIV: 'div'; +K_DROP: 'drop'; +K_DT: 'DT'; +K_E: 'E'; +K_EDGES: 'edges'; +K_ELEMENTMAP: 'elementMap'; +K_ELEMENT: 'element'; +K_EMIT: 'emit'; +K_ENDINGWITH: 'endingWith'; +K_EQ: 'eq'; +K_EXPLAIN: 'explain'; +K_FAIL: 'fail'; +K_FALSE: 'false'; +K_FILTER: 'filter'; +K_FIRST: 'first'; +K_FLATMAP: 'flatMap'; +K_FOLD: 'fold'; +K_FORMAT: 'format'; +K_FROM: 'from'; +K_GLOBAL: 'global'; +K_GT: 'gt'; +K_GTE: 'gte'; +K_GRAPHML: 'graphml'; +K_GRAPHSON: 'graphson'; +K_GROUPCOUNT: 'groupCount'; +K_GROUP: 'group'; +K_GRYO: 'gryo'; +K_HAS: 'has'; +K_HASID: 'hasId'; +K_HASKEY: 'hasKey'; +K_HASLABEL: 'hasLabel'; +K_HASNEXT: 'hasNext'; +K_HASNOT: 'hasNot'; +K_HASVALUE: 'hasValue'; +K_HOUR: 'hour'; +K_ID: 'id'; +K_IDENTITY: 'identity'; +K_IDS: 'ids'; +K_IN: 'in'; +K_INU: 'IN'; +K_INE: 'inE'; +K_INCLUDEEDGES: 'includeEdges'; +K_INCR: 'incr'; +K_INDEXER: 'indexer'; +K_INDEX: 'index'; +K_INFINITY: 'Infinity'; +K_INJECT: 'inject'; +K_INSIDE: 'inside'; +K_INTERSECT: 'intersect'; +K_INV: 'inV'; +K_IOU: 'IO'; +K_IO: 'io'; +K_IS: 'is'; +K_ITERATE: 'iterate'; +K_KEY: 'key'; +K_KEYS: 'keys'; +K_LABELS: 'labels'; +K_LABEL: 'label'; +K_LAST: 'last'; +K_LENGTH: 'length'; +K_LIMIT: 'limit'; +K_LIST: 'list'; +K_LOCAL: 'local'; +K_LOOPS: 'loops'; +K_LT: 'lt'; +K_LTE: 'lte'; +K_LTRIM: 'lTrim'; +K_MAP: 'map'; +K_MATCH: 'match'; +K_MATH: 'math'; +K_MAX: 'max'; +K_MAXDISTANCE: 'maxDistance'; +K_MEAN: 'mean'; +K_MERGEU: 'Merge'; +K_MERGE: 'merge'; +K_MERGEE: 'mergeE'; +K_MERGEV: 'mergeV'; +K_MIN: 'min'; +K_MINUTE: 'minute'; +K_MINUS: 'minus'; +K_MIXED: 'mixed'; +K_MULT: 'mult'; +K_NAN: 'NaN'; +K_NEGATE: 'negate'; +K_NEXT: 'next'; +K_NONE: 'none'; +K_NOTREGEX: 'notRegex'; +K_NOTCONTAINING: 'notContaining'; +K_NOTENDINGWITH: 'notEndingWith'; +K_NOTSTARTINGWITH: 'notStartingWith'; +K_NOT: 'not'; +K_NEQ: 'neq'; +K_NEW: 'new'; +K_NORMSACK: 'normSack'; +K_NULL: 'null'; +K_ONCREATE: 'onCreate'; +K_ONMATCH: 'onMatch'; +K_OPERATOR: 'Operator'; +K_OPTION: 'option'; +K_OPTIONAL: 'optional'; +K_ORDERU: 'Order'; +K_ORDER: 'order'; +K_OR: 'or'; +K_OTHERV: 'otherV'; +K_OUTU: 'OUT'; +K_OUT: 'out'; +K_OUTE: 'outE'; +K_OUTSIDE: 'outside'; +K_OUTV: 'outV'; +K_P: 'P'; +K_PAGERANKU: 'PageRank'; +K_PAGERANK: 'pageRank'; +K_PATH: 'path'; +K_PEERPRESSUREU: 'PeerPressure'; +K_PEERPRESSURE: 'peerPressure'; +K_PICK: 'Pick'; +K_POP: 'Pop'; +K_PROFILE: 'profile'; +K_PROJECT: 'project'; +K_PROPERTIES: 'properties'; +K_PROPERTYMAP: 'propertyMap'; +K_PROPERTYNAME: 'propertyName'; +K_PROPERTY: 'property'; +K_PRODUCT: 'product'; +K_RANGE: 'range'; +K_READ: 'read'; +K_READER: 'reader'; +K_REFERENCEVERTEX: 'ReferenceVertex'; +K_REGEX: 'regex'; +K_REPLACE: 'replace'; +K_REPEAT: 'repeat'; +K_REVERSE: 'reverse'; +K_ROLLBACK: 'rollback'; +K_RTRIM: 'rTrim'; +K_SACK: 'sack'; +K_SAMPLE: 'sample'; +K_SCOPE: 'Scope'; +K_SECOND: 'second'; +K_SELECT: 'select'; +K_SET: 'set'; +K_SHORTESTPATHU: 'ShortestPath'; +K_SHORTESTPATH: 'shortestPath'; +K_SHUFFLE: 'shuffle'; +K_SIDEEFFECT: 'sideEffect'; +K_SIMPLEPATH: 'simplePath'; +K_SINGLE: 'single'; +K_SKIP: 'skip'; +K_SPLIT: 'split'; +K_STARTINGWITH: 'startingWith'; +K_STORE: 'store'; +K_SUBGRAPH: 'subgraph'; +K_SUBSTRING: 'substring'; +K_SUM: 'sum'; +K_SUMLONG: 'sumLong'; +K_T: 'T'; +K_TAIL: 'tail'; +K_TARGET: 'target'; +K_TEXTP: 'TextP'; +K_TIMELIMIT: 'timeLimit'; +K_TIMES: 'times'; +K_TO: 'to'; +K_TOBULKSET: 'toBulkSet'; +K_TOKENS: 'tokens'; +K_TOLIST: 'toList'; +K_TOLOWER: 'toLower'; +K_TOSET: 'toSet'; +K_TOSTRING: 'toString'; +K_TOUPPER: 'toUpper'; +K_TOE: 'toE'; +K_TOV: 'toV'; +K_TREE: 'tree'; +K_TRIM: 'trim'; +K_TRUE: 'true'; +K_TRYNEXT: 'tryNext'; +K_TX: 'tx'; +K_UNFOLD: 'unfold'; +K_UNION: 'union'; +K_UNTIL: 'until'; +K_UUID: 'UUID'; +K_V: 'V'; +K_VALUEMAP: 'valueMap'; +K_VALUES: 'values'; +K_VALUE: 'value'; +K_VERTEX: 'Vertex'; +K_WHERE: 'where'; +K_WITH: 'with'; +K_WITHBULK: 'withBulk'; +K_WITHIN: 'within'; +K_WITHOPTOPTIONS: 'WithOptions'; +K_WITHOUT: 'without'; +K_WITHOUTSTRATEGIES: 'withoutStrategies'; +K_WITHPATH: 'withPath'; +K_WITHSACK: 'withSack'; +K_WITHSIDEEFFECT: 'withSideEffect'; +K_WITHSTRATEGIES: 'withStrategies'; +K_WRITE: 'write'; +K_WRITER: 'writer'; + +// Integer Literals + +IntegerLiteral + : Sign? DecimalIntegerLiteral + | Sign? HexIntegerLiteral + | Sign? OctalIntegerLiteral + ; + +fragment +DecimalIntegerLiteral + : DecimalNumeral IntegerTypeSuffix? + ; + +fragment +HexIntegerLiteral + : HexNumeral IntegerTypeSuffix? + ; + +fragment +OctalIntegerLiteral + : OctalNumeral IntegerTypeSuffix? + ; + +fragment +IntegerTypeSuffix + : [bBsSnNiIlL] + ; + +fragment +DecimalNumeral + : '0' + | NonZeroDigit (Digits? | Underscores Digits) + ; + +fragment +Digits + : Digit (DigitsAndUnderscores? Digit)? + ; + +fragment +Digit + : '0' + | NonZeroDigit + ; + +fragment +NonZeroDigit + : [1-9] + ; + +fragment +DigitsAndUnderscores + : DigitOrUnderscore+ + ; + +fragment +DigitOrUnderscore + : Digit + | '_' + ; + +fragment +Underscores + : '_'+ + ; + +fragment +HexNumeral + : '0' [xX] HexDigits + ; + +fragment +HexDigits + : HexDigit (HexDigitsAndUnderscores? HexDigit)? + ; + +fragment +HexDigit + : [0-9a-fA-F] + ; + +fragment +HexDigitsAndUnderscores + : HexDigitOrUnderscore+ + ; + +fragment +HexDigitOrUnderscore + : HexDigit + | '_' + ; + +fragment +OctalNumeral + : '0' Underscores? OctalDigits + ; + +fragment +OctalDigits + : OctalDigit (OctalDigitsAndUnderscores? OctalDigit)? + ; + +fragment +OctalDigit + : [0-7] + ; + +fragment +OctalDigitsAndUnderscores + : OctalDigitOrUnderscore+ + ; + +fragment +OctalDigitOrUnderscore + : OctalDigit + | '_' + ; + +// Floating-Point Literals + +FloatingPointLiteral + : Sign? DecimalFloatingPointLiteral + ; + +fragment +DecimalFloatingPointLiteral + : Digits ('.' Digits ExponentPart? | ExponentPart) FloatTypeSuffix? + | Digits FloatTypeSuffix + ; + +fragment +ExponentPart + : ExponentIndicator SignedInteger + ; + +fragment +ExponentIndicator + : [eE] + ; + +fragment +SignedInteger + : Sign? Digits + ; + +fragment +Sign + : [+-] + ; + +fragment +FloatTypeSuffix + : [fFdDmM] + ; + +SignedInfLiteral + : Sign? K_INFINITY + ; + +// String Literals + +// String literal is customized since Java only allows double quoted strings where Groovy supports single quoted +// literals also. A side effect of this is ANTLR will not be able to parse single character string literals with +// single quoted so we instead remove char literal altogether and only have string literal in lexer tokens. +NonEmptyStringLiteral + : '"' DoubleQuotedStringCharacters '"' + | '\'' SingleQuotedStringCharacters '\'' + ; + +// We define NonEmptyStringLiteral and EmptyStringLiteral separately so that we can unambiguously handle empty queries +EmptyStringLiteral + : '""' + | '\'\'' + ; + +fragment +DoubleQuotedStringCharacters + : DoubleQuotedStringCharacter+ + ; + +fragment +DoubleQuotedStringCharacter + : ~('"' | '\\') + | JoinLineEscape + | EscapeSequence + ; + +fragment +SingleQuotedStringCharacters + : SingleQuotedStringCharacter+ + ; + +fragment +SingleQuotedStringCharacter + : ~('\'' | '\\') + | JoinLineEscape + | EscapeSequence + ; + +// Escape Sequences for Character and String Literals +fragment JoinLineEscape + : '\\' '\r'? '\n' + ; + +fragment +EscapeSequence + : '\\' [btnfr"'\\] + | OctalEscape + | UnicodeEscape // This is not in the spec but prevents having to preprocess the input + ; + +fragment +OctalEscape + : '\\' OctalDigit + | '\\' OctalDigit OctalDigit + | '\\' ZeroToThree OctalDigit OctalDigit + ; + +fragment +ZeroToThree + : [0-3] + ; + +// This is not in the spec but prevents having to preprocess the input +fragment +UnicodeEscape + : '\\' 'u'+ HexDigit HexDigit HexDigit HexDigit + ; + +// Separators + +LPAREN : '('; +RPAREN : ')'; +LBRACE : '{'; +RBRACE : '}'; +LBRACK : '['; +RBRACK : ']'; +SEMI : ';'; +COMMA : ','; +DOT : '.'; +COLON : ':'; + +TRAVERSAL_ROOT: 'g'; +ANON_TRAVERSAL_ROOT: '__'; + +// Trim whitespace and comments if present + +WS : [ \t\r\n\u000C]+ -> skip + ; + +LINE_COMMENT + : '//' ~[\r\n]* -> skip + ; + +Identifier + : IdentifierStart IdentifierPart* + ; + +// REFERENCE: https://github.com/antlr/grammars-v4/blob/master/java/java8/Java8Lexer.g4 +fragment +IdentifierStart + : [\u0024] + | [\u0041-\u005A] + | [\u005F] + | [\u0061-\u007A] + | [\u00A2-\u00A5] + | [\u00AA] + | [\u00B5] + | [\u00BA] + | [\u00C0-\u00D6] + | [\u00D8-\u00F6] + | [\u00F8-\u02C1] + | [\u02C6-\u02D1] + | [\u02E0-\u02E4] + | [\u02EC] + | [\u02EE] + | [\u0370-\u0374] + | [\u0376-\u0377] + | [\u037A-\u037D] + | [\u037F] + | [\u0386] + | [\u0388-\u038A] + | [\u038C] + | [\u038E-\u03A1] + | [\u03A3-\u03F5] + | [\u03F7-\u0481] + | [\u048A-\u052F] + | [\u0531-\u0556] + | [\u0559] + | [\u0561-\u0587] + | [\u058F] + | [\u05D0-\u05EA] + | [\u05F0-\u05F2] + | [\u060B] + | [\u0620-\u064A] + | [\u066E-\u066F] + | [\u0671-\u06D3] + | [\u06D5] + | [\u06E5-\u06E6] + | [\u06EE-\u06EF] + | [\u06FA-\u06FC] + | [\u06FF] + | [\u0710] + | [\u0712-\u072F] + | [\u074D-\u07A5] + | [\u07B1] + | [\u07CA-\u07EA] + | [\u07F4-\u07F5] + | [\u07FA] + | [\u0800-\u0815] + | [\u081A] + | [\u0824] + | [\u0828] + | [\u0840-\u0858] + | [\u0860-\u086A] + | [\u08A0-\u08B4] + | [\u08B6-\u08BD] + | [\u0904-\u0939] + | [\u093D] + | [\u0950] + | [\u0958-\u0961] + | [\u0971-\u0980] + | [\u0985-\u098C] + | [\u098F-\u0990] + | [\u0993-\u09A8] + | [\u09AA-\u09B0] + | [\u09B2] + | [\u09B6-\u09B9] + | [\u09BD] + | [\u09CE] + | [\u09DC-\u09DD] + | [\u09DF-\u09E1] + | [\u09F0-\u09F3] + | [\u09FB-\u09FC] + | [\u0A05-\u0A0A] + | [\u0A0F-\u0A10] + | [\u0A13-\u0A28] + | [\u0A2A-\u0A30] + | [\u0A32-\u0A33] + | [\u0A35-\u0A36] + | [\u0A38-\u0A39] + | [\u0A59-\u0A5C] + | [\u0A5E] + | [\u0A72-\u0A74] + | [\u0A85-\u0A8D] + | [\u0A8F-\u0A91] + | [\u0A93-\u0AA8] + | [\u0AAA-\u0AB0] + | [\u0AB2-\u0AB3] + | [\u0AB5-\u0AB9] + | [\u0ABD] + | [\u0AD0] + | [\u0AE0-\u0AE1] + | [\u0AF1] + | [\u0AF9] + | [\u0B05-\u0B0C] + | [\u0B0F-\u0B10] + | [\u0B13-\u0B28] + | [\u0B2A-\u0B30] + | [\u0B32-\u0B33] + | [\u0B35-\u0B39] + | [\u0B3D] + | [\u0B5C-\u0B5D] + | [\u0B5F-\u0B61] + | [\u0B71] + | [\u0B83] + | [\u0B85-\u0B8A] + | [\u0B8E-\u0B90] + | [\u0B92-\u0B95] + | [\u0B99-\u0B9A] + | [\u0B9C] + | [\u0B9E-\u0B9F] + | [\u0BA3-\u0BA4] + | [\u0BA8-\u0BAA] + | [\u0BAE-\u0BB9] + | [\u0BD0] + | [\u0BF9] + | [\u0C05-\u0C0C] + | [\u0C0E-\u0C10] + | [\u0C12-\u0C28] + | [\u0C2A-\u0C39] + | [\u0C3D] + | [\u0C58-\u0C5A] + | [\u0C60-\u0C61] + | [\u0C80] + | [\u0C85-\u0C8C] + | [\u0C8E-\u0C90] + | [\u0C92-\u0CA8] + | [\u0CAA-\u0CB3] + | [\u0CB5-\u0CB9] + | [\u0CBD] + | [\u0CDE] + | [\u0CE0-\u0CE1] + | [\u0CF1-\u0CF2] + | [\u0D05-\u0D0C] + | [\u0D0E-\u0D10] + | [\u0D12-\u0D3A] + | [\u0D3D] + | [\u0D4E] + | [\u0D54-\u0D56] + | [\u0D5F-\u0D61] + | [\u0D7A-\u0D7F] + | [\u0D85-\u0D96] + | [\u0D9A-\u0DB1] + | [\u0DB3-\u0DBB] + | [\u0DBD] + | [\u0DC0-\u0DC6] + | [\u0E01-\u0E30] + | [\u0E32-\u0E33] + | [\u0E3F-\u0E46] + | [\u0E81-\u0E82] + | [\u0E84] + | [\u0E87-\u0E88] + | [\u0E8A] + | [\u0E8D] + | [\u0E94-\u0E97] + | [\u0E99-\u0E9F] + | [\u0EA1-\u0EA3] + | [\u0EA5] + | [\u0EA7] + | [\u0EAA-\u0EAB] + | [\u0EAD-\u0EB0] + | [\u0EB2-\u0EB3] + | [\u0EBD] + | [\u0EC0-\u0EC4] + | [\u0EC6] + | [\u0EDC-\u0EDF] + | [\u0F00] + | [\u0F40-\u0F47] + | [\u0F49-\u0F6C] + | [\u0F88-\u0F8C] + | [\u1000-\u102A] + | [\u103F] + | [\u1050-\u1055] + | [\u105A-\u105D] + | [\u1061] + | [\u1065-\u1066] + | [\u106E-\u1070] + | [\u1075-\u1081] + | [\u108E] + | [\u10A0-\u10C5] + | [\u10C7] + | [\u10CD] + | [\u10D0-\u10FA] + | [\u10FC-\u1248] + | [\u124A-\u124D] + | [\u1250-\u1256] + | [\u1258] + | [\u125A-\u125D] + | [\u1260-\u1288] + | [\u128A-\u128D] + | [\u1290-\u12B0] + | [\u12B2-\u12B5] + | [\u12B8-\u12BE] + | [\u12C0] + | [\u12C2-\u12C5] + | [\u12C8-\u12D6] + | [\u12D8-\u1310] + | [\u1312-\u1315] + | [\u1318-\u135A] + | [\u1380-\u138F] + | [\u13A0-\u13F5] + | [\u13F8-\u13FD] + | [\u1401-\u166C] + | [\u166F-\u167F] + | [\u1681-\u169A] + | [\u16A0-\u16EA] + | [\u16EE-\u16F8] + | [\u1700-\u170C] + | [\u170E-\u1711] + | [\u1720-\u1731] + | [\u1740-\u1751] + | [\u1760-\u176C] + | [\u176E-\u1770] + | [\u1780-\u17B3] + | [\u17D7] + | [\u17DB-\u17DC] + | [\u1820-\u1877] + | [\u1880-\u1884] + | [\u1887-\u18A8] + | [\u18AA] + | [\u18B0-\u18F5] + | [\u1900-\u191E] + | [\u1950-\u196D] + | [\u1970-\u1974] + | [\u1980-\u19AB] + | [\u19B0-\u19C9] + | [\u1A00-\u1A16] + | [\u1A20-\u1A54] + | [\u1AA7] + | [\u1B05-\u1B33] + | [\u1B45-\u1B4B] + | [\u1B83-\u1BA0] + | [\u1BAE-\u1BAF] + | [\u1BBA-\u1BE5] + | [\u1C00-\u1C23] + | [\u1C4D-\u1C4F] + | [\u1C5A-\u1C7D] + | [\u1C80-\u1C88] + | [\u1CE9-\u1CEC] + | [\u1CEE-\u1CF1] + | [\u1CF5-\u1CF6] + | [\u1D00-\u1DBF] + | [\u1E00-\u1F15] + | [\u1F18-\u1F1D] + | [\u1F20-\u1F45] + | [\u1F48-\u1F4D] + | [\u1F50-\u1F57] + | [\u1F59] + | [\u1F5B] + | [\u1F5D] + | [\u1F5F-\u1F7D] + | [\u1F80-\u1FB4] + | [\u1FB6-\u1FBC] + | [\u1FBE] + | [\u1FC2-\u1FC4] + | [\u1FC6-\u1FCC] + | [\u1FD0-\u1FD3] + | [\u1FD6-\u1FDB] + | [\u1FE0-\u1FEC] + | [\u1FF2-\u1FF4] + | [\u1FF6-\u1FFC] + | [\u203F-\u2040] + | [\u2054] + | [\u2071] + | [\u207F] + | [\u2090-\u209C] + | [\u20A0-\u20BF] + | [\u2102] + | [\u2107] + | [\u210A-\u2113] + | [\u2115] + | [\u2119-\u211D] + | [\u2124] + | [\u2126] + | [\u2128] + | [\u212A-\u212D] + | [\u212F-\u2139] + | [\u213C-\u213F] + | [\u2145-\u2149] + | [\u214E] + | [\u2160-\u2188] + | [\u2C00-\u2C2E] + | [\u2C30-\u2C5E] + | [\u2C60-\u2CE4] + | [\u2CEB-\u2CEE] + | [\u2CF2-\u2CF3] + | [\u2D00-\u2D25] + | [\u2D27] + | [\u2D2D] + | [\u2D30-\u2D67] + | [\u2D6F] + | [\u2D80-\u2D96] + | [\u2DA0-\u2DA6] + | [\u2DA8-\u2DAE] + | [\u2DB0-\u2DB6] + | [\u2DB8-\u2DBE] + | [\u2DC0-\u2DC6] + | [\u2DC8-\u2DCE] + | [\u2DD0-\u2DD6] + | [\u2DD8-\u2DDE] + | [\u2E2F] + | [\u3005-\u3007] + | [\u3021-\u3029] + | [\u3031-\u3035] + | [\u3038-\u303C] + | [\u3041-\u3096] + | [\u309D-\u309F] + | [\u30A1-\u30FA] + | [\u30FC-\u30FF] + | [\u3105-\u312E] + | [\u3131-\u318E] + | [\u31A0-\u31BA] + | [\u31F0-\u31FF] + | [\u3400-\u4DB5] + | [\u4E00-\u9FEA] + | [\uA000-\uA48C] + | [\uA4D0-\uA4FD] + | [\uA500-\uA60C] + | [\uA610-\uA61F] + | [\uA62A-\uA62B] + | [\uA640-\uA66E] + | [\uA67F-\uA69D] + | [\uA6A0-\uA6EF] + | [\uA717-\uA71F] + | [\uA722-\uA788] + | [\uA78B-\uA7AE] + | [\uA7B0-\uA7B7] + | [\uA7F7-\uA801] + | [\uA803-\uA805] + | [\uA807-\uA80A] + | [\uA80C-\uA822] + | [\uA838] + | [\uA840-\uA873] + | [\uA882-\uA8B3] + | [\uA8F2-\uA8F7] + | [\uA8FB] + | [\uA8FD] + | [\uA90A-\uA925] + | [\uA930-\uA946] + | [\uA960-\uA97C] + | [\uA984-\uA9B2] + | [\uA9CF] + | [\uA9E0-\uA9E4] + | [\uA9E6-\uA9EF] + | [\uA9FA-\uA9FE] + | [\uAA00-\uAA28] + | [\uAA40-\uAA42] + | [\uAA44-\uAA4B] + | [\uAA60-\uAA76] + | [\uAA7A] + | [\uAA7E-\uAAAF] + | [\uAAB1] + | [\uAAB5-\uAAB6] + | [\uAAB9-\uAABD] + | [\uAAC0] + | [\uAAC2] + | [\uAADB-\uAADD] + | [\uAAE0-\uAAEA] + | [\uAAF2-\uAAF4] + | [\uAB01-\uAB06] + | [\uAB09-\uAB0E] + | [\uAB11-\uAB16] + | [\uAB20-\uAB26] + | [\uAB28-\uAB2E] + | [\uAB30-\uAB5A] + | [\uAB5C-\uAB65] + | [\uAB70-\uABE2] + | [\uAC00-\uD7A3] + | [\uD7B0-\uD7C6] + | [\uD7CB-\uD7FB] + | [\uF900-\uFA6D] + | [\uFA70-\uFAD9] + | [\uFB00-\uFB06] + | [\uFB13-\uFB17] + | [\uFB1D] + | [\uFB1F-\uFB28] + | [\uFB2A-\uFB36] + | [\uFB38-\uFB3C] + | [\uFB3E] + | [\uFB40-\uFB41] + | [\uFB43-\uFB44] + | [\uFB46-\uFBB1] + | [\uFBD3-\uFD3D] + | [\uFD50-\uFD8F] + | [\uFD92-\uFDC7] + | [\uFDF0-\uFDFC] + | [\uFE33-\uFE34] + | [\uFE4D-\uFE4F] + | [\uFE69] + | [\uFE70-\uFE74] + | [\uFE76-\uFEFC] + | [\uFF04] + | [\uFF21-\uFF3A] + | [\uFF3F] + | [\uFF41-\uFF5A] + | [\uFF66-\uFFBE] + | [\uFFC2-\uFFC7] + | [\uFFCA-\uFFCF] + | [\uFFD2-\uFFD7] + | [\uFFDA-\uFFDC] + | [\uFFE0-\uFFE1] + | [\uFFE5-\uFFE6] + ; + +fragment +IdentifierPart + : IdentifierStart + | [\u0030-\u0039] + | [\u007F-\u009F] + | [\u00AD] + | [\u0300-\u036F] + | [\u0483-\u0487] + | [\u0591-\u05BD] + | [\u05BF] + | [\u05C1-\u05C2] + | [\u05C4-\u05C5] + | [\u05C7] + | [\u0600-\u0605] + | [\u0610-\u061A] + | [\u061C] + | [\u064B-\u0669] + | [\u0670] + | [\u06D6-\u06DD] + | [\u06DF-\u06E4] + | [\u06E7-\u06E8] + | [\u06EA-\u06ED] + | [\u06F0-\u06F9] + | [\u070F] + | [\u0711] + | [\u0730-\u074A] + | [\u07A6-\u07B0] + | [\u07C0-\u07C9] + | [\u07EB-\u07F3] + | [\u0816-\u0819] + | [\u081B-\u0823] + | [\u0825-\u0827] + | [\u0829-\u082D] + | [\u0859-\u085B] + | [\u08D4-\u0903] + | [\u093A-\u093C] + | [\u093E-\u094F] + | [\u0951-\u0957] + | [\u0962-\u0963] + | [\u0966-\u096F] + | [\u0981-\u0983] + | [\u09BC] + | [\u09BE-\u09C4] + | [\u09C7-\u09C8] + | [\u09CB-\u09CD] + | [\u09D7] + | [\u09E2-\u09E3] + | [\u09E6-\u09EF] + | [\u0A01-\u0A03] + | [\u0A3C] + | [\u0A3E-\u0A42] + | [\u0A47-\u0A48] + | [\u0A4B-\u0A4D] + | [\u0A51] + | [\u0A66-\u0A71] + | [\u0A75] + | [\u0A81-\u0A83] + | [\u0ABC] + | [\u0ABE-\u0AC5] + | [\u0AC7-\u0AC9] + | [\u0ACB-\u0ACD] + | [\u0AE2-\u0AE3] + | [\u0AE6-\u0AEF] + | [\u0AFA-\u0AFF] + | [\u0B01-\u0B03] + | [\u0B3C] + | [\u0B3E-\u0B44] + | [\u0B47-\u0B48] + | [\u0B4B-\u0B4D] + | [\u0B56-\u0B57] + | [\u0B62-\u0B63] + | [\u0B66-\u0B6F] + | [\u0B82] + | [\u0BBE-\u0BC2] + | [\u0BC6-\u0BC8] + | [\u0BCA-\u0BCD] + | [\u0BD7] + | [\u0BE6-\u0BEF] + | [\u0C00-\u0C03] + | [\u0C3E-\u0C44] + | [\u0C46-\u0C48] + | [\u0C4A-\u0C4D] + | [\u0C55-\u0C56] + | [\u0C62-\u0C63] + | [\u0C66-\u0C6F] + | [\u0C81-\u0C83] + | [\u0CBC] + | [\u0CBE-\u0CC4] + | [\u0CC6-\u0CC8] + | [\u0CCA-\u0CCD] + | [\u0CD5-\u0CD6] + | [\u0CE2-\u0CE3] + | [\u0CE6-\u0CEF] + | [\u0D00-\u0D03] + | [\u0D3B-\u0D3C] + | [\u0D3E-\u0D44] + | [\u0D46-\u0D48] + | [\u0D4A-\u0D4D] + | [\u0D57] + | [\u0D62-\u0D63] + | [\u0D66-\u0D6F] + | [\u0D82-\u0D83] + | [\u0DCA] + | [\u0DCF-\u0DD4] + | [\u0DD6] + | [\u0DD8-\u0DDF] + | [\u0DE6-\u0DEF] + | [\u0DF2-\u0DF3] + | [\u0E31] + | [\u0E34-\u0E3A] + | [\u0E47-\u0E4E] + | [\u0E50-\u0E59] + | [\u0EB1] + | [\u0EB4-\u0EB9] + | [\u0EBB-\u0EBC] + | [\u0EC8-\u0ECD] + | [\u0ED0-\u0ED9] + | [\u0F18-\u0F19] + | [\u0F20-\u0F29] + | [\u0F35] + | [\u0F37] + | [\u0F39] + | [\u0F3E-\u0F3F] + | [\u0F71-\u0F84] + | [\u0F86-\u0F87] + | [\u0F8D-\u0F97] + | [\u0F99-\u0FBC] + | [\u0FC6] + | [\u102B-\u103E] + | [\u1040-\u1049] + | [\u1056-\u1059] + | [\u105E-\u1060] + | [\u1062-\u1064] + | [\u1067-\u106D] + | [\u1071-\u1074] + | [\u1082-\u108D] + | [\u108F-\u109D] + | [\u135D-\u135F] + | [\u1712-\u1714] + | [\u1732-\u1734] + | [\u1752-\u1753] + | [\u1772-\u1773] + | [\u17B4-\u17D3] + | [\u17DD] + | [\u17E0-\u17E9] + | [\u180B-\u180E] + | [\u1810-\u1819] + | [\u1885-\u1886] + | [\u18A9] + | [\u1920-\u192B] + | [\u1930-\u193B] + | [\u1946-\u194F] + | [\u19D0-\u19D9] + | [\u1A17-\u1A1B] + | [\u1A55-\u1A5E] + | [\u1A60-\u1A7C] + | [\u1A7F-\u1A89] + | [\u1A90-\u1A99] + | [\u1AB0-\u1ABD] + | [\u1B00-\u1B04] + | [\u1B34-\u1B44] + | [\u1B50-\u1B59] + | [\u1B6B-\u1B73] + | [\u1B80-\u1B82] + | [\u1BA1-\u1BAD] + | [\u1BB0-\u1BB9] + | [\u1BE6-\u1BF3] + | [\u1C24-\u1C37] + | [\u1C40-\u1C49] + | [\u1C50-\u1C59] + | [\u1CD0-\u1CD2] + | [\u1CD4-\u1CE8] + | [\u1CED] + | [\u1CF2-\u1CF4] + | [\u1CF7-\u1CF9] + | [\u1DC0-\u1DF9] + | [\u1DFB-\u1DFF] + | [\u200B-\u200F] + | [\u202A-\u202E] + | [\u2060-\u2064] + | [\u2066-\u206F] + | [\u20D0-\u20DC] + | [\u20E1] + | [\u20E5-\u20F0] + | [\u2CEF-\u2CF1] + | [\u2D7F] + | [\u2DE0-\u2DFF] + | [\u302A-\u302F] + | [\u3099-\u309A] + | [\uA620-\uA629] + | [\uA66F] + | [\uA674-\uA67D] + | [\uA69E-\uA69F] + | [\uA6F0-\uA6F1] + | [\uA802] + | [\uA806] + | [\uA80B] + | [\uA823-\uA827] + | [\uA880-\uA881] + | [\uA8B4-\uA8C5] + | [\uA8D0-\uA8D9] + | [\uA8E0-\uA8F1] + | [\uA900-\uA909] + | [\uA926-\uA92D] + | [\uA947-\uA953] + | [\uA980-\uA983] + | [\uA9B3-\uA9C0] + | [\uA9D0-\uA9D9] + | [\uA9E5] + | [\uA9F0-\uA9F9] + | [\uAA29-\uAA36] + | [\uAA43] + | [\uAA4C-\uAA4D] + | [\uAA50-\uAA59] + | [\uAA7B-\uAA7D] + | [\uAAB0] + | [\uAAB2-\uAAB4] + | [\uAAB7-\uAAB8] + | [\uAABE-\uAABF] + | [\uAAC1] + | [\uAAEB-\uAAEF] + | [\uAAF5-\uAAF6] + | [\uABE3-\uABEA] + | [\uABEC-\uABED] + | [\uABF0-\uABF9] + | [\uFB1E] + | [\uFE00-\uFE0F] + | [\uFE20-\uFE2F] + | [\uFEFF] + | [\uFF10-\uFF19] + | [\uFFF9-\uFFFB] + ; + diff --git a/text2gremlin/AST_Text2Gremlin/base/gremlin/Gremlin.interp b/text2gremlin/AST_Text2Gremlin/base/gremlin/Gremlin.interp new file mode 100644 index 000000000..ef5807b86 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/gremlin/Gremlin.interp @@ -0,0 +1,855 @@ +token literal names: +null +'discard' +'addAll' +'addE' +'addV' +'aggregate' +'all' +'and' +'any' +'as' +'asc' +'asDate' +'asString' +'assign' +'barrier' +'Barrier' +'begin' +'between' +'both' +'BOTH' +'bothE' +'bothV' +'branch' +'by' +'call' +'cap' +'Cardinality' +'choose' +'coalesce' +'coin' +'Column' +'combine' +'commit' +'component' +'concat' +'conjoin' +'connectedComponent' +'ConnectedComponent' +'constant' +'containing' +'count' +'cyclicPath' +'day' +'dateAdd' +'dateDiff' +'datetime' +'DateTime' +'decr' +'dedup' +'desc' +'difference' +'Direction' +'disjunct' +'distance' +'div' +'drop' +'DT' +'E' +'edges' +'elementMap' +'element' +'emit' +'endingWith' +'eq' +'explain' +'fail' +'false' +'filter' +'first' +'flatMap' +'fold' +'format' +'from' +'global' +'gt' +'gte' +'graphml' +'graphson' +'groupCount' +'group' +'gryo' +'has' +'hasId' +'hasKey' +'hasLabel' +'hasNext' +'hasNot' +'hasValue' +'hour' +'id' +'identity' +'ids' +'in' +'IN' +'inE' +'includeEdges' +'incr' +'indexer' +'index' +'Infinity' +'inject' +'inside' +'intersect' +'inV' +'IO' +'io' +'is' +'iterate' +'key' +'keys' +'labels' +'label' +'last' +'length' +'limit' +'list' +'local' +'loops' +'lt' +'lte' +'lTrim' +'map' +'match' +'math' +'max' +'maxDistance' +'mean' +'Merge' +'merge' +'mergeE' +'mergeV' +'min' +'minute' +'minus' +'mixed' +'mult' +'NaN' +'negate' +'next' +'none' +'notRegex' +'notContaining' +'notEndingWith' +'notStartingWith' +'not' +'neq' +'new' +'normSack' +'null' +'onCreate' +'onMatch' +'Operator' +'option' +'optional' +'Order' +'order' +'or' +'otherV' +'OUT' +'out' +'outE' +'outside' +'outV' +'P' +'PageRank' +'pageRank' +'path' +'PeerPressure' +'peerPressure' +'Pick' +'Pop' +'profile' +'project' +'properties' +'propertyMap' +'propertyName' +'property' +'product' +'range' +'read' +'reader' +'ReferenceVertex' +'regex' +'replace' +'repeat' +'reverse' +'rollback' +'rTrim' +'sack' +'sample' +'Scope' +'second' +'select' +'set' +'ShortestPath' +'shortestPath' +'shuffle' +'sideEffect' +'simplePath' +'single' +'skip' +'split' +'startingWith' +'store' +'subgraph' +'substring' +'sum' +'sumLong' +'T' +'tail' +'target' +'TextP' +'timeLimit' +'times' +'to' +'toBulkSet' +'tokens' +'toList' +'toLower' +'toSet' +'toString' +'toUpper' +'toE' +'toV' +'tree' +'trim' +'true' +'tryNext' +'tx' +'unfold' +'union' +'until' +'UUID' +'V' +'valueMap' +'values' +'value' +'Vertex' +'where' +'with' +'withBulk' +'within' +'WithOptions' +'without' +'withoutStrategies' +'withPath' +'withSack' +'withSideEffect' +'withStrategies' +'write' +'writer' +null +null +null +null +null +'(' +')' +'{' +'}' +'[' +']' +';' +',' +'.' +':' +'g' +'__' +null +null +null + +token symbolic names: +null +null +K_ADDALL +K_ADDE +K_ADDV +K_AGGREGATE +K_ALL +K_AND +K_ANY +K_AS +K_ASC +K_ASDATE +K_ASSTRING +K_ASSIGN +K_BARRIER +K_BARRIERU +K_BEGIN +K_BETWEEN +K_BOTH +K_BOTHU +K_BOTHE +K_BOTHV +K_BRANCH +K_BY +K_CALL +K_CAP +K_CARDINALITY +K_CHOOSE +K_COALESCE +K_COIN +K_COLUMN +K_COMBINE +K_COMMIT +K_COMPONENT +K_CONCAT +K_CONJOIN +K_CONNECTEDCOMPONENT +K_CONNECTEDCOMPONENTU +K_CONSTANT +K_CONTAINING +K_COUNT +K_CYCLICPATH +K_DAY +K_DATEADD +K_DATEDIFF +K_DATETIME +K_DATETIMEU +K_DECR +K_DEDUP +K_DESC +K_DIFFERENCE +K_DIRECTION +K_DISJUNCT +K_DISTANCE +K_DIV +K_DROP +K_DT +K_E +K_EDGES +K_ELEMENTMAP +K_ELEMENT +K_EMIT +K_ENDINGWITH +K_EQ +K_EXPLAIN +K_FAIL +K_FALSE +K_FILTER +K_FIRST +K_FLATMAP +K_FOLD +K_FORMAT +K_FROM +K_GLOBAL +K_GT +K_GTE +K_GRAPHML +K_GRAPHSON +K_GROUPCOUNT +K_GROUP +K_GRYO +K_HAS +K_HASID +K_HASKEY +K_HASLABEL +K_HASNEXT +K_HASNOT +K_HASVALUE +K_HOUR +K_ID +K_IDENTITY +K_IDS +K_IN +K_INU +K_INE +K_INCLUDEEDGES +K_INCR +K_INDEXER +K_INDEX +K_INFINITY +K_INJECT +K_INSIDE +K_INTERSECT +K_INV +K_IOU +K_IO +K_IS +K_ITERATE +K_KEY +K_KEYS +K_LABELS +K_LABEL +K_LAST +K_LENGTH +K_LIMIT +K_LIST +K_LOCAL +K_LOOPS +K_LT +K_LTE +K_LTRIM +K_MAP +K_MATCH +K_MATH +K_MAX +K_MAXDISTANCE +K_MEAN +K_MERGEU +K_MERGE +K_MERGEE +K_MERGEV +K_MIN +K_MINUTE +K_MINUS +K_MIXED +K_MULT +K_NAN +K_NEGATE +K_NEXT +K_NONE +K_NOTREGEX +K_NOTCONTAINING +K_NOTENDINGWITH +K_NOTSTARTINGWITH +K_NOT +K_NEQ +K_NEW +K_NORMSACK +K_NULL +K_ONCREATE +K_ONMATCH +K_OPERATOR +K_OPTION +K_OPTIONAL +K_ORDERU +K_ORDER +K_OR +K_OTHERV +K_OUTU +K_OUT +K_OUTE +K_OUTSIDE +K_OUTV +K_P +K_PAGERANKU +K_PAGERANK +K_PATH +K_PEERPRESSUREU +K_PEERPRESSURE +K_PICK +K_POP +K_PROFILE +K_PROJECT +K_PROPERTIES +K_PROPERTYMAP +K_PROPERTYNAME +K_PROPERTY +K_PRODUCT +K_RANGE +K_READ +K_READER +K_REFERENCEVERTEX +K_REGEX +K_REPLACE +K_REPEAT +K_REVERSE +K_ROLLBACK +K_RTRIM +K_SACK +K_SAMPLE +K_SCOPE +K_SECOND +K_SELECT +K_SET +K_SHORTESTPATHU +K_SHORTESTPATH +K_SHUFFLE +K_SIDEEFFECT +K_SIMPLEPATH +K_SINGLE +K_SKIP +K_SPLIT +K_STARTINGWITH +K_STORE +K_SUBGRAPH +K_SUBSTRING +K_SUM +K_SUMLONG +K_T +K_TAIL +K_TARGET +K_TEXTP +K_TIMELIMIT +K_TIMES +K_TO +K_TOBULKSET +K_TOKENS +K_TOLIST +K_TOLOWER +K_TOSET +K_TOSTRING +K_TOUPPER +K_TOE +K_TOV +K_TREE +K_TRIM +K_TRUE +K_TRYNEXT +K_TX +K_UNFOLD +K_UNION +K_UNTIL +K_UUID +K_V +K_VALUEMAP +K_VALUES +K_VALUE +K_VERTEX +K_WHERE +K_WITH +K_WITHBULK +K_WITHIN +K_WITHOPTOPTIONS +K_WITHOUT +K_WITHOUTSTRATEGIES +K_WITHPATH +K_WITHSACK +K_WITHSIDEEFFECT +K_WITHSTRATEGIES +K_WRITE +K_WRITER +IntegerLiteral +FloatingPointLiteral +SignedInfLiteral +NonEmptyStringLiteral +EmptyStringLiteral +LPAREN +RPAREN +LBRACE +RBRACE +LBRACK +RBRACK +SEMI +COMMA +DOT +COLON +TRAVERSAL_ROOT +ANON_TRAVERSAL_ROOT +WS +LINE_COMMENT +Identifier + +rule names: +queryList +query +emptyQuery +traversalSource +transactionPart +rootTraversal +traversalSourceSelfMethod +traversalSourceSelfMethod_withBulk +traversalSourceSelfMethod_withPath +traversalSourceSelfMethod_withSack +traversalSourceSelfMethod_withSideEffect +traversalSourceSelfMethod_withStrategies +traversalSourceSelfMethod_withoutStrategies +traversalSourceSelfMethod_with +traversalSourceSpawnMethod +traversalSourceSpawnMethod_addE +traversalSourceSpawnMethod_addV +traversalSourceSpawnMethod_E +traversalSourceSpawnMethod_V +traversalSourceSpawnMethod_inject +traversalSourceSpawnMethod_io +traversalSourceSpawnMethod_mergeV +traversalSourceSpawnMethod_mergeE +traversalSourceSpawnMethod_call +traversalSourceSpawnMethod_union +chainedTraversal +nestedTraversal +terminatedTraversal +traversalMethod +traversalMethod_V +traversalMethod_E +traversalMethod_addE +traversalMethod_addV +traversalMethod_aggregate +traversalMethod_all +traversalMethod_and +traversalMethod_any +traversalMethod_as +traversalMethod_asDate +traversalMethod_asString +traversalMethod_barrier +traversalMethod_both +traversalMethod_bothE +traversalMethod_bothV +traversalMethod_branch +traversalMethod_by +traversalMethod_call +traversalMethod_cap +traversalMethod_choose +traversalMethod_coalesce +traversalMethod_coin +traversalMethod_combine +traversalMethod_concat +traversalMethod_conjoin +traversalMethod_connectedComponent +traversalMethod_constant +traversalMethod_count +traversalMethod_cyclicPath +traversalMethod_dateAdd +traversalMethod_dateDiff +traversalMethod_dedup +traversalMethod_difference +traversalMethod_discard +traversalMethod_disjunct +traversalMethod_drop +traversalMethod_element +traversalMethod_elementMap +traversalMethod_emit +traversalMethod_fail +traversalMethod_filter +traversalMethod_flatMap +traversalMethod_fold +traversalMethod_format +traversalMethod_from +traversalMethod_group +traversalMethod_groupCount +traversalMethod_has +traversalMethod_hasId +traversalMethod_hasKey +traversalMethod_hasLabel +traversalMethod_hasNot +traversalMethod_hasValue +traversalMethod_id +traversalMethod_identity +traversalMethod_in +traversalMethod_inE +traversalMethod_intersect +traversalMethod_inV +traversalMethod_index +traversalMethod_inject +traversalMethod_is +traversalMethod_key +traversalMethod_label +traversalMethod_length +traversalMethod_limit +traversalMethod_local +traversalMethod_loops +traversalMethod_lTrim +traversalMethod_map +traversalMethod_match +traversalMethod_math +traversalMethod_max +traversalMethod_mean +traversalMethod_merge +traversalMethod_mergeV +traversalMethod_mergeE +traversalMethod_min +traversalMethod_none +traversalMethod_not +traversalMethod_option +traversalMethod_optional +traversalMethod_or +traversalMethod_order +traversalMethod_otherV +traversalMethod_out +traversalMethod_outE +traversalMethod_outV +traversalMethod_pageRank +traversalMethod_path +traversalMethod_peerPressure +traversalMethod_product +traversalMethod_profile +traversalMethod_project +traversalMethod_properties +traversalMethod_property +traversalMethod_propertyMap +traversalMethod_range +traversalMethod_read +traversalMethod_repeat +traversalMethod_replace +traversalMethod_reverse +traversalMethod_rTrim +traversalMethod_sack +traversalMethod_sample +traversalMethod_select +traversalMethod_shortestPath +traversalMethod_sideEffect +traversalMethod_simplePath +traversalMethod_skip +traversalMethod_split +traversalMethod_store +traversalMethod_subgraph +traversalMethod_substring +traversalMethod_sum +traversalMethod_tail +traversalMethod_timeLimit +traversalMethod_times +traversalMethod_to +traversalMethod_toE +traversalMethod_toLower +traversalMethod_toUpper +traversalMethod_toV +traversalMethod_tree +traversalMethod_trim +traversalMethod_unfold +traversalMethod_union +traversalMethod_until +traversalMethod_value +traversalMethod_valueMap +traversalMethod_values +traversalMethod_where +traversalMethod_with +traversalMethod_write +structureVertexLiteral +traversalStrategy +configuration +traversalScope +traversalBarrier +traversalT +traversalTShort +traversalTLong +traversalMerge +traversalOrder +traversalDirection +traversalDirectionShort +traversalDirectionLong +traversalCardinality +traversalColumn +traversalPop +traversalOperator +traversalPick +traversalDT +traversalPredicate +traversalTerminalMethod +traversalSackMethod +traversalComparator +traversalFunction +traversalBiFunction +traversalPredicate_eq +traversalPredicate_neq +traversalPredicate_lt +traversalPredicate_lte +traversalPredicate_gt +traversalPredicate_gte +traversalPredicate_inside +traversalPredicate_outside +traversalPredicate_between +traversalPredicate_within +traversalPredicate_without +traversalPredicate_not +traversalPredicate_containing +traversalPredicate_notContaining +traversalPredicate_startingWith +traversalPredicate_notStartingWith +traversalPredicate_endingWith +traversalPredicate_notEndingWith +traversalPredicate_regex +traversalPredicate_notRegex +traversalTerminalMethod_explain +traversalTerminalMethod_hasNext +traversalTerminalMethod_iterate +traversalTerminalMethod_tryNext +traversalTerminalMethod_next +traversalTerminalMethod_toList +traversalTerminalMethod_toSet +traversalTerminalMethod_toBulkSet +withOptionKeys +connectedComponentConstants +pageRankConstants +peerPressureConstants +shortestPathConstants +withOptionsValues +ioOptionsKeys +ioOptionsValues +connectedComponentConstants_component +connectedComponentConstants_edges +connectedComponentConstants_propertyName +pageRankConstants_edges +pageRankConstants_times +pageRankConstants_propertyName +peerPressureConstants_edges +peerPressureConstants_times +peerPressureConstants_propertyName +shortestPathConstants_target +shortestPathConstants_edges +shortestPathConstants_distance +shortestPathConstants_maxDistance +shortestPathConstants_includeEdges +withOptionsConstants_tokens +withOptionsConstants_none +withOptionsConstants_ids +withOptionsConstants_labels +withOptionsConstants_keys +withOptionsConstants_values +withOptionsConstants_all +withOptionsConstants_indexer +withOptionsConstants_list +withOptionsConstants_map +ioOptionsConstants_reader +ioOptionsConstants_writer +ioOptionsConstants_gryo +ioOptionsConstants_graphson +ioOptionsConstants_graphml +connectedComponentStringConstant +pageRankStringConstant +peerPressureStringConstant +shortestPathStringConstant +withOptionsStringConstant +ioOptionsStringConstant +booleanArgument +integerArgument +floatArgument +stringArgument +stringNullableArgument +stringNullableArgumentVarargs +dateArgument +genericArgument +genericArgumentVarargs +genericMapArgument +genericMapNullableArgument +nullableGenericLiteralMap +structureVertexArgument +traversalStrategyVarargs +traversalStrategyExpr +classTypeList +classTypeExpr +nestedTraversalList +nestedTraversalExpr +genericCollectionLiteral +genericLiteralVarargs +genericLiteralExpr +genericMapNullableLiteral +genericRangeLiteral +genericSetLiteral +stringNullableLiteralVarargs +genericLiteral +genericMapLiteral +mapKey +mapEntry +stringLiteral +stringNullableLiteral +integerLiteral +floatLiteral +numericLiteral +booleanLiteral +dateLiteral +nullLiteral +nanLiteral +infLiteral +uuidLiteral +nakedKey +classType +variable +keyword + + +atn: +[4, 1, 270, 3582, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2, 302, 7, 302, 2, 303, 7, 303, 1, 0, 1, 0, 3, 0, 611, 8, 0, 1, 0, 5, 0, 614, 8, 0, 10, 0, 12, 0, 617, 9, 0, 1, 0, 3, 0, 620, 8, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 636, 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 643, 8, 1, 10, 1, 12, 1, 646, 9, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 655, 8, 3, 1, 3, 1, 3, 1, 3, 5, 3, 660, 8, 3, 10, 3, 12, 3, 663, 9, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 686, 8, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 698, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 707, 8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 730, 8, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 3, 10, 748, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 755, 8, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 764, 8, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 780, 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 792, 8, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 804, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 819, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 851, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 863, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 896, 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 5, 25, 909, 8, 25, 10, 25, 12, 25, 912, 9, 25, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 918, 8, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1058, 8, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 1080, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1095, 8, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 1109, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 1131, 8, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 1147, 8, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1162, 8, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 3, 45, 1237, 8, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1267, 8, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 1274, 8, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 1320, 8, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1342, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1351, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1375, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 3, 59, 1398, 8, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 1405, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 3, 60, 1414, 8, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 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, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 3, 67, 1456, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1466, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 1478, 8, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 3, 71, 1495, 8, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1517, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 1527, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1537, 8, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 3, 76, 1604, 8, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 1611, 8, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 1620, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1632, 8, 78, 1, 78, 1, 78, 3, 78, 1636, 8, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 3, 79, 1648, 8, 79, 1, 79, 1, 79, 3, 79, 1652, 8, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 1664, 8, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 1673, 8, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 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, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 3, 90, 1721, 8, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 3, 93, 1739, 8, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 3, 94, 1753, 8, 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, 3, 96, 1768, 8, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 1778, 8, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 3, 101, 1803, 8, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 1813, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 1833, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 3, 105, 1848, 8, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 1858, 8, 106, 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, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 3, 109, 1912, 8, 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, 112, 1, 112, 1, 112, 1, 112, 3, 112, 1932, 8, 112, 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, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 3, 117, 1960, 8, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 1983, 8, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 3, 122, 1990, 8, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2008, 8, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2026, 8, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 2035, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 2058, 8, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 2076, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 2094, 8, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 2108, 8, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 2118, 8, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 2132, 8, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 3, 134, 2155, 8, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 3, 134, 2178, 8, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 3, 134, 2187, 8, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 3, 138, 2214, 8, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 2228, 8, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 3, 142, 2268, 8, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 2278, 8, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 2300, 8, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 2317, 8, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, 147, 2336, 8, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 3, 148, 2343, 8, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 2355, 8, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 3, 150, 2365, 8, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 3, 152, 2380, 8, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, 2390, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 2411, 8, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 2427, 8, 158, 1, 158, 1, 158, 3, 158, 2431, 8, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 3, 160, 2455, 8, 160, 1, 161, 1, 161, 1, 161, 1, 161, 3, 161, 2461, 8, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 3, 161, 2469, 8, 161, 1, 161, 1, 161, 1, 161, 1, 161, 3, 161, 2475, 8, 161, 1, 161, 1, 161, 3, 161, 2479, 8, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, 3, 163, 2486, 8, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 164, 3, 164, 2496, 8, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 5, 164, 2503, 8, 164, 10, 164, 12, 164, 2506, 9, 164, 3, 164, 2508, 8, 164, 1, 164, 3, 164, 2511, 8, 164, 1, 165, 1, 165, 3, 165, 2515, 8, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 3, 166, 2528, 8, 166, 1, 167, 1, 167, 1, 167, 1, 167, 3, 167, 2534, 8, 167, 1, 168, 1, 168, 3, 168, 2538, 8, 168, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 2554, 8, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 3, 171, 2572, 8, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 2586, 8, 172, 1, 173, 1, 173, 3, 173, 2590, 8, 173, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 3, 175, 2609, 8, 175, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 2615, 8, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 2625, 8, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 2635, 8, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 2653, 8, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 3, 177, 2663, 8, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 2681, 8, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 3, 179, 2727, 8, 179, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 3, 180, 2737, 8, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 2755, 8, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 3, 182, 2778, 8, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 5, 182, 2799, 8, 182, 10, 182, 12, 182, 2802, 9, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 3, 183, 2812, 8, 183, 1, 184, 1, 184, 1, 185, 1, 185, 1, 186, 1, 186, 3, 186, 2820, 8, 186, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 3, 188, 2828, 8, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, 2838, 8, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 3, 190, 2848, 8, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 191, 1, 191, 1, 191, 1, 191, 3, 191, 2858, 8, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 3, 192, 2868, 8, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 3, 193, 2878, 8, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, 194, 3, 194, 2888, 8, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, 195, 1, 195, 3, 195, 2900, 8, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 3, 196, 2912, 8, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 3, 197, 2924, 8, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 3, 197, 2932, 8, 197, 1, 197, 1, 197, 1, 197, 1, 197, 3, 197, 2938, 8, 197, 1, 198, 1, 198, 1, 198, 1, 198, 3, 198, 2944, 8, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 3, 198, 2952, 8, 198, 1, 198, 1, 198, 1, 198, 1, 198, 3, 198, 2958, 8, 198, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 2964, 8, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 200, 1, 200, 3, 200, 2974, 8, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 201, 3, 201, 2984, 8, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 2994, 8, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 1, 203, 3, 203, 3004, 8, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 3014, 8, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 205, 1, 205, 1, 205, 1, 205, 3, 205, 3024, 8, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 206, 3, 206, 3034, 8, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 207, 1, 207, 3, 207, 3044, 8, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 3, 212, 3074, 8, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 3, 216, 3095, 8, 216, 1, 217, 1, 217, 1, 217, 3, 217, 3100, 8, 217, 1, 218, 1, 218, 1, 218, 3, 218, 3105, 8, 218, 1, 219, 1, 219, 1, 219, 3, 219, 3110, 8, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 3, 220, 3117, 8, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 3, 221, 3128, 8, 221, 1, 222, 1, 222, 3, 222, 3132, 8, 222, 1, 223, 1, 223, 1, 223, 3, 223, 3137, 8, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 232, 1, 232, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 1, 233, 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, 1, 237, 1, 238, 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, 1, 240, 1, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 250, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 252, 1, 252, 1, 252, 1, 252, 1, 253, 1, 253, 1, 254, 1, 254, 1, 255, 1, 255, 1, 256, 1, 256, 1, 257, 1, 257, 1, 258, 1, 258, 1, 259, 1, 259, 3, 259, 3269, 8, 259, 1, 260, 1, 260, 3, 260, 3273, 8, 260, 1, 261, 1, 261, 3, 261, 3277, 8, 261, 1, 262, 1, 262, 3, 262, 3281, 8, 262, 1, 263, 1, 263, 3, 263, 3285, 8, 263, 1, 264, 1, 264, 1, 264, 5, 264, 3290, 8, 264, 10, 264, 12, 264, 3293, 9, 264, 3, 264, 3295, 8, 264, 1, 265, 1, 265, 3, 265, 3299, 8, 265, 1, 266, 1, 266, 3, 266, 3303, 8, 266, 1, 267, 1, 267, 1, 267, 5, 267, 3308, 8, 267, 10, 267, 12, 267, 3311, 9, 267, 3, 267, 3313, 8, 267, 1, 268, 1, 268, 3, 268, 3317, 8, 268, 1, 269, 1, 269, 3, 269, 3321, 8, 269, 1, 270, 1, 270, 3, 270, 3325, 8, 270, 1, 271, 1, 271, 3, 271, 3329, 8, 271, 1, 272, 3, 272, 3332, 8, 272, 1, 273, 1, 273, 1, 273, 5, 273, 3337, 8, 273, 10, 273, 12, 273, 3340, 9, 273, 1, 274, 3, 274, 3343, 8, 274, 1, 275, 1, 275, 1, 275, 5, 275, 3348, 8, 275, 10, 275, 12, 275, 3351, 9, 275, 1, 276, 3, 276, 3354, 8, 276, 1, 277, 1, 277, 1, 277, 5, 277, 3359, 8, 277, 10, 277, 12, 277, 3362, 9, 277, 1, 278, 1, 278, 1, 278, 1, 278, 5, 278, 3368, 8, 278, 10, 278, 12, 278, 3371, 9, 278, 3, 278, 3373, 8, 278, 1, 278, 1, 278, 1, 279, 3, 279, 3378, 8, 279, 1, 280, 1, 280, 1, 280, 5, 280, 3383, 8, 280, 10, 280, 12, 280, 3386, 9, 280, 1, 281, 1, 281, 3, 281, 3390, 8, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 3, 282, 3402, 8, 282, 1, 283, 1, 283, 1, 283, 1, 283, 5, 283, 3408, 8, 283, 10, 283, 12, 283, 3411, 9, 283, 3, 283, 3413, 8, 283, 1, 283, 1, 283, 1, 284, 1, 284, 1, 284, 5, 284, 3420, 8, 284, 10, 284, 12, 284, 3423, 9, 284, 3, 284, 3425, 8, 284, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 3, 285, 3446, 8, 285, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 5, 286, 3455, 8, 286, 10, 286, 12, 286, 3458, 9, 286, 1, 286, 1, 286, 3, 286, 3462, 8, 286, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 3469, 8, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 3476, 8, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 3483, 8, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 3490, 8, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 3497, 8, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 3504, 8, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 3511, 8, 287, 1, 287, 1, 287, 3, 287, 3515, 8, 287, 3, 287, 3517, 8, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 1, 290, 1, 290, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 3, 292, 3532, 8, 292, 1, 293, 1, 293, 3, 293, 3536, 8, 293, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 3, 295, 3556, 8, 295, 1, 296, 1, 296, 1, 297, 1, 297, 1, 298, 1, 298, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 3, 299, 3572, 8, 299, 1, 300, 1, 300, 1, 301, 1, 301, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 0, 4, 2, 6, 50, 364, 304, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 0, 8, 2, 0, 181, 181, 237, 237, 4, 0, 89, 89, 108, 108, 111, 111, 236, 236, 5, 0, 19, 19, 72, 72, 93, 93, 158, 158, 214, 214, 1, 0, 254, 255, 2, 0, 148, 148, 254, 255, 2, 0, 66, 66, 226, 226, 2, 0, 99, 99, 253, 253, 2, 0, 2, 250, 266, 266, 3817, 0, 608, 1, 0, 0, 0, 2, 635, 1, 0, 0, 0, 4, 647, 1, 0, 0, 0, 6, 654, 1, 0, 0, 0, 8, 685, 1, 0, 0, 0, 10, 697, 1, 0, 0, 0, 12, 706, 1, 0, 0, 0, 14, 708, 1, 0, 0, 0, 16, 713, 1, 0, 0, 0, 18, 729, 1, 0, 0, 0, 20, 747, 1, 0, 0, 0, 22, 749, 1, 0, 0, 0, 24, 758, 1, 0, 0, 0, 26, 779, 1, 0, 0, 0, 28, 791, 1, 0, 0, 0, 30, 803, 1, 0, 0, 0, 32, 818, 1, 0, 0, 0, 34, 820, 1, 0, 0, 0, 36, 825, 1, 0, 0, 0, 38, 830, 1, 0, 0, 0, 40, 835, 1, 0, 0, 0, 42, 850, 1, 0, 0, 0, 44, 862, 1, 0, 0, 0, 46, 895, 1, 0, 0, 0, 48, 897, 1, 0, 0, 0, 50, 902, 1, 0, 0, 0, 52, 917, 1, 0, 0, 0, 54, 919, 1, 0, 0, 0, 56, 1057, 1, 0, 0, 0, 58, 1059, 1, 0, 0, 0, 60, 1064, 1, 0, 0, 0, 62, 1079, 1, 0, 0, 0, 64, 1094, 1, 0, 0, 0, 66, 1108, 1, 0, 0, 0, 68, 1110, 1, 0, 0, 0, 70, 1115, 1, 0, 0, 0, 72, 1120, 1, 0, 0, 0, 74, 1125, 1, 0, 0, 0, 76, 1134, 1, 0, 0, 0, 78, 1146, 1, 0, 0, 0, 80, 1161, 1, 0, 0, 0, 82, 1163, 1, 0, 0, 0, 84, 1168, 1, 0, 0, 0, 86, 1173, 1, 0, 0, 0, 88, 1177, 1, 0, 0, 0, 90, 1236, 1, 0, 0, 0, 92, 1266, 1, 0, 0, 0, 94, 1268, 1, 0, 0, 0, 96, 1319, 1, 0, 0, 0, 98, 1321, 1, 0, 0, 0, 100, 1326, 1, 0, 0, 0, 102, 1331, 1, 0, 0, 0, 104, 1350, 1, 0, 0, 0, 106, 1352, 1, 0, 0, 0, 108, 1357, 1, 0, 0, 0, 110, 1361, 1, 0, 0, 0, 112, 1374, 1, 0, 0, 0, 114, 1376, 1, 0, 0, 0, 116, 1380, 1, 0, 0, 0, 118, 1397, 1, 0, 0, 0, 120, 1413, 1, 0, 0, 0, 122, 1415, 1, 0, 0, 0, 124, 1420, 1, 0, 0, 0, 126, 1424, 1, 0, 0, 0, 128, 1429, 1, 0, 0, 0, 130, 1433, 1, 0, 0, 0, 132, 1437, 1, 0, 0, 0, 134, 1455, 1, 0, 0, 0, 136, 1465, 1, 0, 0, 0, 138, 1477, 1, 0, 0, 0, 140, 1479, 1, 0, 0, 0, 142, 1494, 1, 0, 0, 0, 144, 1496, 1, 0, 0, 0, 146, 1516, 1, 0, 0, 0, 148, 1526, 1, 0, 0, 0, 150, 1536, 1, 0, 0, 0, 152, 1603, 1, 0, 0, 0, 154, 1619, 1, 0, 0, 0, 156, 1635, 1, 0, 0, 0, 158, 1651, 1, 0, 0, 0, 160, 1653, 1, 0, 0, 0, 162, 1672, 1, 0, 0, 0, 164, 1674, 1, 0, 0, 0, 166, 1678, 1, 0, 0, 0, 168, 1682, 1, 0, 0, 0, 170, 1687, 1, 0, 0, 0, 172, 1692, 1, 0, 0, 0, 174, 1697, 1, 0, 0, 0, 176, 1701, 1, 0, 0, 0, 178, 1705, 1, 0, 0, 0, 180, 1720, 1, 0, 0, 0, 182, 1722, 1, 0, 0, 0, 184, 1726, 1, 0, 0, 0, 186, 1738, 1, 0, 0, 0, 188, 1752, 1, 0, 0, 0, 190, 1754, 1, 0, 0, 0, 192, 1767, 1, 0, 0, 0, 194, 1777, 1, 0, 0, 0, 196, 1779, 1, 0, 0, 0, 198, 1784, 1, 0, 0, 0, 200, 1789, 1, 0, 0, 0, 202, 1802, 1, 0, 0, 0, 204, 1812, 1, 0, 0, 0, 206, 1814, 1, 0, 0, 0, 208, 1832, 1, 0, 0, 0, 210, 1847, 1, 0, 0, 0, 212, 1857, 1, 0, 0, 0, 214, 1859, 1, 0, 0, 0, 216, 1864, 1, 0, 0, 0, 218, 1911, 1, 0, 0, 0, 220, 1913, 1, 0, 0, 0, 222, 1918, 1, 0, 0, 0, 224, 1931, 1, 0, 0, 0, 226, 1933, 1, 0, 0, 0, 228, 1937, 1, 0, 0, 0, 230, 1942, 1, 0, 0, 0, 232, 1947, 1, 0, 0, 0, 234, 1959, 1, 0, 0, 0, 236, 1961, 1, 0, 0, 0, 238, 1965, 1, 0, 0, 0, 240, 1969, 1, 0, 0, 0, 242, 1982, 1, 0, 0, 0, 244, 1984, 1, 0, 0, 0, 246, 1993, 1, 0, 0, 0, 248, 2034, 1, 0, 0, 0, 250, 2036, 1, 0, 0, 0, 252, 2057, 1, 0, 0, 0, 254, 2059, 1, 0, 0, 0, 256, 2075, 1, 0, 0, 0, 258, 2093, 1, 0, 0, 0, 260, 2095, 1, 0, 0, 0, 262, 2107, 1, 0, 0, 0, 264, 2117, 1, 0, 0, 0, 266, 2131, 1, 0, 0, 0, 268, 2186, 1, 0, 0, 0, 270, 2188, 1, 0, 0, 0, 272, 2192, 1, 0, 0, 0, 274, 2197, 1, 0, 0, 0, 276, 2213, 1, 0, 0, 0, 278, 2227, 1, 0, 0, 0, 280, 2229, 1, 0, 0, 0, 282, 2234, 1, 0, 0, 0, 284, 2267, 1, 0, 0, 0, 286, 2277, 1, 0, 0, 0, 288, 2299, 1, 0, 0, 0, 290, 2301, 1, 0, 0, 0, 292, 2306, 1, 0, 0, 0, 294, 2335, 1, 0, 0, 0, 296, 2337, 1, 0, 0, 0, 298, 2354, 1, 0, 0, 0, 300, 2364, 1, 0, 0, 0, 302, 2366, 1, 0, 0, 0, 304, 2379, 1, 0, 0, 0, 306, 2389, 1, 0, 0, 0, 308, 2391, 1, 0, 0, 0, 310, 2395, 1, 0, 0, 0, 312, 2410, 1, 0, 0, 0, 314, 2412, 1, 0, 0, 0, 316, 2430, 1, 0, 0, 0, 318, 2432, 1, 0, 0, 0, 320, 2454, 1, 0, 0, 0, 322, 2478, 1, 0, 0, 0, 324, 2480, 1, 0, 0, 0, 326, 2485, 1, 0, 0, 0, 328, 2495, 1, 0, 0, 0, 330, 2514, 1, 0, 0, 0, 332, 2527, 1, 0, 0, 0, 334, 2533, 1, 0, 0, 0, 336, 2537, 1, 0, 0, 0, 338, 2539, 1, 0, 0, 0, 340, 2553, 1, 0, 0, 0, 342, 2571, 1, 0, 0, 0, 344, 2585, 1, 0, 0, 0, 346, 2589, 1, 0, 0, 0, 348, 2591, 1, 0, 0, 0, 350, 2608, 1, 0, 0, 0, 352, 2652, 1, 0, 0, 0, 354, 2662, 1, 0, 0, 0, 356, 2680, 1, 0, 0, 0, 358, 2726, 1, 0, 0, 0, 360, 2736, 1, 0, 0, 0, 362, 2754, 1, 0, 0, 0, 364, 2777, 1, 0, 0, 0, 366, 2811, 1, 0, 0, 0, 368, 2813, 1, 0, 0, 0, 370, 2815, 1, 0, 0, 0, 372, 2819, 1, 0, 0, 0, 374, 2821, 1, 0, 0, 0, 376, 2827, 1, 0, 0, 0, 378, 2837, 1, 0, 0, 0, 380, 2847, 1, 0, 0, 0, 382, 2857, 1, 0, 0, 0, 384, 2867, 1, 0, 0, 0, 386, 2877, 1, 0, 0, 0, 388, 2887, 1, 0, 0, 0, 390, 2899, 1, 0, 0, 0, 392, 2911, 1, 0, 0, 0, 394, 2937, 1, 0, 0, 0, 396, 2957, 1, 0, 0, 0, 398, 2963, 1, 0, 0, 0, 400, 2973, 1, 0, 0, 0, 402, 2983, 1, 0, 0, 0, 404, 2993, 1, 0, 0, 0, 406, 3003, 1, 0, 0, 0, 408, 3013, 1, 0, 0, 0, 410, 3023, 1, 0, 0, 0, 412, 3033, 1, 0, 0, 0, 414, 3043, 1, 0, 0, 0, 416, 3049, 1, 0, 0, 0, 418, 3053, 1, 0, 0, 0, 420, 3057, 1, 0, 0, 0, 422, 3061, 1, 0, 0, 0, 424, 3073, 1, 0, 0, 0, 426, 3075, 1, 0, 0, 0, 428, 3079, 1, 0, 0, 0, 430, 3083, 1, 0, 0, 0, 432, 3094, 1, 0, 0, 0, 434, 3099, 1, 0, 0, 0, 436, 3104, 1, 0, 0, 0, 438, 3109, 1, 0, 0, 0, 440, 3116, 1, 0, 0, 0, 442, 3127, 1, 0, 0, 0, 444, 3131, 1, 0, 0, 0, 446, 3136, 1, 0, 0, 0, 448, 3138, 1, 0, 0, 0, 450, 3142, 1, 0, 0, 0, 452, 3146, 1, 0, 0, 0, 454, 3150, 1, 0, 0, 0, 456, 3154, 1, 0, 0, 0, 458, 3158, 1, 0, 0, 0, 460, 3162, 1, 0, 0, 0, 462, 3166, 1, 0, 0, 0, 464, 3170, 1, 0, 0, 0, 466, 3174, 1, 0, 0, 0, 468, 3178, 1, 0, 0, 0, 470, 3182, 1, 0, 0, 0, 472, 3186, 1, 0, 0, 0, 474, 3190, 1, 0, 0, 0, 476, 3194, 1, 0, 0, 0, 478, 3198, 1, 0, 0, 0, 480, 3202, 1, 0, 0, 0, 482, 3206, 1, 0, 0, 0, 484, 3210, 1, 0, 0, 0, 486, 3214, 1, 0, 0, 0, 488, 3218, 1, 0, 0, 0, 490, 3222, 1, 0, 0, 0, 492, 3226, 1, 0, 0, 0, 494, 3230, 1, 0, 0, 0, 496, 3234, 1, 0, 0, 0, 498, 3238, 1, 0, 0, 0, 500, 3242, 1, 0, 0, 0, 502, 3246, 1, 0, 0, 0, 504, 3250, 1, 0, 0, 0, 506, 3254, 1, 0, 0, 0, 508, 3256, 1, 0, 0, 0, 510, 3258, 1, 0, 0, 0, 512, 3260, 1, 0, 0, 0, 514, 3262, 1, 0, 0, 0, 516, 3264, 1, 0, 0, 0, 518, 3268, 1, 0, 0, 0, 520, 3272, 1, 0, 0, 0, 522, 3276, 1, 0, 0, 0, 524, 3280, 1, 0, 0, 0, 526, 3284, 1, 0, 0, 0, 528, 3294, 1, 0, 0, 0, 530, 3298, 1, 0, 0, 0, 532, 3302, 1, 0, 0, 0, 534, 3312, 1, 0, 0, 0, 536, 3316, 1, 0, 0, 0, 538, 3320, 1, 0, 0, 0, 540, 3324, 1, 0, 0, 0, 542, 3328, 1, 0, 0, 0, 544, 3331, 1, 0, 0, 0, 546, 3333, 1, 0, 0, 0, 548, 3342, 1, 0, 0, 0, 550, 3344, 1, 0, 0, 0, 552, 3353, 1, 0, 0, 0, 554, 3355, 1, 0, 0, 0, 556, 3363, 1, 0, 0, 0, 558, 3377, 1, 0, 0, 0, 560, 3379, 1, 0, 0, 0, 562, 3389, 1, 0, 0, 0, 564, 3401, 1, 0, 0, 0, 566, 3403, 1, 0, 0, 0, 568, 3424, 1, 0, 0, 0, 570, 3445, 1, 0, 0, 0, 572, 3461, 1, 0, 0, 0, 574, 3516, 1, 0, 0, 0, 576, 3518, 1, 0, 0, 0, 578, 3522, 1, 0, 0, 0, 580, 3524, 1, 0, 0, 0, 582, 3526, 1, 0, 0, 0, 584, 3531, 1, 0, 0, 0, 586, 3535, 1, 0, 0, 0, 588, 3537, 1, 0, 0, 0, 590, 3555, 1, 0, 0, 0, 592, 3557, 1, 0, 0, 0, 594, 3559, 1, 0, 0, 0, 596, 3561, 1, 0, 0, 0, 598, 3571, 1, 0, 0, 0, 600, 3573, 1, 0, 0, 0, 602, 3575, 1, 0, 0, 0, 604, 3577, 1, 0, 0, 0, 606, 3579, 1, 0, 0, 0, 608, 615, 3, 2, 1, 0, 609, 611, 5, 262, 0, 0, 610, 609, 1, 0, 0, 0, 610, 611, 1, 0, 0, 0, 611, 612, 1, 0, 0, 0, 612, 614, 3, 2, 1, 0, 613, 610, 1, 0, 0, 0, 614, 617, 1, 0, 0, 0, 615, 613, 1, 0, 0, 0, 615, 616, 1, 0, 0, 0, 616, 619, 1, 0, 0, 0, 617, 615, 1, 0, 0, 0, 618, 620, 5, 262, 0, 0, 619, 618, 1, 0, 0, 0, 619, 620, 1, 0, 0, 0, 620, 621, 1, 0, 0, 0, 621, 622, 5, 0, 0, 1, 622, 1, 1, 0, 0, 0, 623, 624, 6, 1, -1, 0, 624, 636, 3, 6, 3, 0, 625, 626, 3, 6, 3, 0, 626, 627, 5, 264, 0, 0, 627, 628, 3, 8, 4, 0, 628, 636, 1, 0, 0, 0, 629, 636, 3, 10, 5, 0, 630, 631, 3, 10, 5, 0, 631, 632, 5, 264, 0, 0, 632, 633, 3, 366, 183, 0, 633, 636, 1, 0, 0, 0, 634, 636, 3, 4, 2, 0, 635, 623, 1, 0, 0, 0, 635, 625, 1, 0, 0, 0, 635, 629, 1, 0, 0, 0, 635, 630, 1, 0, 0, 0, 635, 634, 1, 0, 0, 0, 636, 644, 1, 0, 0, 0, 637, 638, 10, 2, 0, 0, 638, 639, 5, 264, 0, 0, 639, 640, 5, 220, 0, 0, 640, 641, 5, 256, 0, 0, 641, 643, 5, 257, 0, 0, 642, 637, 1, 0, 0, 0, 643, 646, 1, 0, 0, 0, 644, 642, 1, 0, 0, 0, 644, 645, 1, 0, 0, 0, 645, 3, 1, 0, 0, 0, 646, 644, 1, 0, 0, 0, 647, 648, 5, 255, 0, 0, 648, 5, 1, 0, 0, 0, 649, 650, 6, 3, -1, 0, 650, 655, 5, 266, 0, 0, 651, 652, 5, 266, 0, 0, 652, 653, 5, 264, 0, 0, 653, 655, 3, 12, 6, 0, 654, 649, 1, 0, 0, 0, 654, 651, 1, 0, 0, 0, 655, 661, 1, 0, 0, 0, 656, 657, 10, 1, 0, 0, 657, 658, 5, 264, 0, 0, 658, 660, 3, 12, 6, 0, 659, 656, 1, 0, 0, 0, 660, 663, 1, 0, 0, 0, 661, 659, 1, 0, 0, 0, 661, 662, 1, 0, 0, 0, 662, 7, 1, 0, 0, 0, 663, 661, 1, 0, 0, 0, 664, 665, 5, 228, 0, 0, 665, 666, 5, 256, 0, 0, 666, 667, 5, 257, 0, 0, 667, 668, 5, 264, 0, 0, 668, 669, 5, 16, 0, 0, 669, 670, 5, 256, 0, 0, 670, 686, 5, 257, 0, 0, 671, 672, 5, 228, 0, 0, 672, 673, 5, 256, 0, 0, 673, 674, 5, 257, 0, 0, 674, 675, 5, 264, 0, 0, 675, 676, 5, 32, 0, 0, 676, 677, 5, 256, 0, 0, 677, 686, 5, 257, 0, 0, 678, 679, 5, 228, 0, 0, 679, 680, 5, 256, 0, 0, 680, 681, 5, 257, 0, 0, 681, 682, 5, 264, 0, 0, 682, 683, 5, 186, 0, 0, 683, 684, 5, 256, 0, 0, 684, 686, 5, 257, 0, 0, 685, 664, 1, 0, 0, 0, 685, 671, 1, 0, 0, 0, 685, 678, 1, 0, 0, 0, 686, 9, 1, 0, 0, 0, 687, 688, 3, 6, 3, 0, 688, 689, 5, 264, 0, 0, 689, 690, 3, 28, 14, 0, 690, 698, 1, 0, 0, 0, 691, 692, 3, 6, 3, 0, 692, 693, 5, 264, 0, 0, 693, 694, 3, 28, 14, 0, 694, 695, 5, 264, 0, 0, 695, 696, 3, 50, 25, 0, 696, 698, 1, 0, 0, 0, 697, 687, 1, 0, 0, 0, 697, 691, 1, 0, 0, 0, 698, 11, 1, 0, 0, 0, 699, 707, 3, 14, 7, 0, 700, 707, 3, 16, 8, 0, 701, 707, 3, 18, 9, 0, 702, 707, 3, 20, 10, 0, 703, 707, 3, 22, 11, 0, 704, 707, 3, 24, 12, 0, 705, 707, 3, 26, 13, 0, 706, 699, 1, 0, 0, 0, 706, 700, 1, 0, 0, 0, 706, 701, 1, 0, 0, 0, 706, 702, 1, 0, 0, 0, 706, 703, 1, 0, 0, 0, 706, 704, 1, 0, 0, 0, 706, 705, 1, 0, 0, 0, 707, 13, 1, 0, 0, 0, 708, 709, 5, 240, 0, 0, 709, 710, 5, 256, 0, 0, 710, 711, 3, 518, 259, 0, 711, 712, 5, 257, 0, 0, 712, 15, 1, 0, 0, 0, 713, 714, 5, 245, 0, 0, 714, 715, 5, 256, 0, 0, 715, 716, 5, 257, 0, 0, 716, 17, 1, 0, 0, 0, 717, 718, 5, 246, 0, 0, 718, 719, 5, 256, 0, 0, 719, 720, 3, 532, 266, 0, 720, 721, 5, 257, 0, 0, 721, 730, 1, 0, 0, 0, 722, 723, 5, 246, 0, 0, 723, 724, 5, 256, 0, 0, 724, 725, 3, 532, 266, 0, 725, 726, 5, 263, 0, 0, 726, 727, 3, 374, 187, 0, 727, 728, 5, 257, 0, 0, 728, 730, 1, 0, 0, 0, 729, 717, 1, 0, 0, 0, 729, 722, 1, 0, 0, 0, 730, 19, 1, 0, 0, 0, 731, 732, 5, 247, 0, 0, 732, 733, 5, 256, 0, 0, 733, 734, 3, 578, 289, 0, 734, 735, 5, 263, 0, 0, 735, 736, 3, 532, 266, 0, 736, 737, 5, 257, 0, 0, 737, 748, 1, 0, 0, 0, 738, 739, 5, 247, 0, 0, 739, 740, 5, 256, 0, 0, 740, 741, 3, 578, 289, 0, 741, 742, 5, 263, 0, 0, 742, 743, 3, 532, 266, 0, 743, 744, 5, 263, 0, 0, 744, 745, 3, 374, 187, 0, 745, 746, 5, 257, 0, 0, 746, 748, 1, 0, 0, 0, 747, 731, 1, 0, 0, 0, 747, 738, 1, 0, 0, 0, 748, 21, 1, 0, 0, 0, 749, 750, 5, 248, 0, 0, 750, 751, 5, 256, 0, 0, 751, 754, 3, 328, 164, 0, 752, 753, 5, 263, 0, 0, 753, 755, 3, 544, 272, 0, 754, 752, 1, 0, 0, 0, 754, 755, 1, 0, 0, 0, 755, 756, 1, 0, 0, 0, 756, 757, 5, 257, 0, 0, 757, 23, 1, 0, 0, 0, 758, 759, 5, 244, 0, 0, 759, 760, 5, 256, 0, 0, 760, 763, 3, 602, 301, 0, 761, 762, 5, 263, 0, 0, 762, 764, 3, 548, 274, 0, 763, 761, 1, 0, 0, 0, 763, 764, 1, 0, 0, 0, 764, 765, 1, 0, 0, 0, 765, 766, 5, 257, 0, 0, 766, 25, 1, 0, 0, 0, 767, 768, 5, 239, 0, 0, 768, 769, 5, 256, 0, 0, 769, 770, 3, 578, 289, 0, 770, 771, 5, 257, 0, 0, 771, 780, 1, 0, 0, 0, 772, 773, 5, 239, 0, 0, 773, 774, 5, 256, 0, 0, 774, 775, 3, 578, 289, 0, 775, 776, 5, 263, 0, 0, 776, 777, 3, 532, 266, 0, 777, 778, 5, 257, 0, 0, 778, 780, 1, 0, 0, 0, 779, 767, 1, 0, 0, 0, 779, 772, 1, 0, 0, 0, 780, 27, 1, 0, 0, 0, 781, 792, 3, 30, 15, 0, 782, 792, 3, 32, 16, 0, 783, 792, 3, 34, 17, 0, 784, 792, 3, 36, 18, 0, 785, 792, 3, 44, 22, 0, 786, 792, 3, 42, 21, 0, 787, 792, 3, 38, 19, 0, 788, 792, 3, 40, 20, 0, 789, 792, 3, 46, 23, 0, 790, 792, 3, 48, 24, 0, 791, 781, 1, 0, 0, 0, 791, 782, 1, 0, 0, 0, 791, 783, 1, 0, 0, 0, 791, 784, 1, 0, 0, 0, 791, 785, 1, 0, 0, 0, 791, 786, 1, 0, 0, 0, 791, 787, 1, 0, 0, 0, 791, 788, 1, 0, 0, 0, 791, 789, 1, 0, 0, 0, 791, 790, 1, 0, 0, 0, 792, 29, 1, 0, 0, 0, 793, 794, 5, 3, 0, 0, 794, 795, 5, 256, 0, 0, 795, 796, 3, 524, 262, 0, 796, 797, 5, 257, 0, 0, 797, 804, 1, 0, 0, 0, 798, 799, 5, 3, 0, 0, 799, 800, 5, 256, 0, 0, 800, 801, 3, 52, 26, 0, 801, 802, 5, 257, 0, 0, 802, 804, 1, 0, 0, 0, 803, 793, 1, 0, 0, 0, 803, 798, 1, 0, 0, 0, 804, 31, 1, 0, 0, 0, 805, 806, 5, 4, 0, 0, 806, 807, 5, 256, 0, 0, 807, 819, 5, 257, 0, 0, 808, 809, 5, 4, 0, 0, 809, 810, 5, 256, 0, 0, 810, 811, 3, 524, 262, 0, 811, 812, 5, 257, 0, 0, 812, 819, 1, 0, 0, 0, 813, 814, 5, 4, 0, 0, 814, 815, 5, 256, 0, 0, 815, 816, 3, 52, 26, 0, 816, 817, 5, 257, 0, 0, 817, 819, 1, 0, 0, 0, 818, 805, 1, 0, 0, 0, 818, 808, 1, 0, 0, 0, 818, 813, 1, 0, 0, 0, 819, 33, 1, 0, 0, 0, 820, 821, 5, 57, 0, 0, 821, 822, 5, 256, 0, 0, 822, 823, 3, 534, 267, 0, 823, 824, 5, 257, 0, 0, 824, 35, 1, 0, 0, 0, 825, 826, 5, 233, 0, 0, 826, 827, 5, 256, 0, 0, 827, 828, 3, 534, 267, 0, 828, 829, 5, 257, 0, 0, 829, 37, 1, 0, 0, 0, 830, 831, 5, 100, 0, 0, 831, 832, 5, 256, 0, 0, 832, 833, 3, 534, 267, 0, 833, 834, 5, 257, 0, 0, 834, 39, 1, 0, 0, 0, 835, 836, 5, 105, 0, 0, 836, 837, 5, 256, 0, 0, 837, 838, 3, 578, 289, 0, 838, 839, 5, 257, 0, 0, 839, 41, 1, 0, 0, 0, 840, 841, 5, 130, 0, 0, 841, 842, 5, 256, 0, 0, 842, 843, 3, 538, 269, 0, 843, 844, 5, 257, 0, 0, 844, 851, 1, 0, 0, 0, 845, 846, 5, 130, 0, 0, 846, 847, 5, 256, 0, 0, 847, 848, 3, 52, 26, 0, 848, 849, 5, 257, 0, 0, 849, 851, 1, 0, 0, 0, 850, 840, 1, 0, 0, 0, 850, 845, 1, 0, 0, 0, 851, 43, 1, 0, 0, 0, 852, 853, 5, 129, 0, 0, 853, 854, 5, 256, 0, 0, 854, 855, 3, 538, 269, 0, 855, 856, 5, 257, 0, 0, 856, 863, 1, 0, 0, 0, 857, 858, 5, 129, 0, 0, 858, 859, 5, 256, 0, 0, 859, 860, 3, 52, 26, 0, 860, 861, 5, 257, 0, 0, 861, 863, 1, 0, 0, 0, 862, 852, 1, 0, 0, 0, 862, 857, 1, 0, 0, 0, 863, 45, 1, 0, 0, 0, 864, 865, 5, 24, 0, 0, 865, 866, 5, 256, 0, 0, 866, 896, 5, 257, 0, 0, 867, 868, 5, 24, 0, 0, 868, 869, 5, 256, 0, 0, 869, 870, 3, 578, 289, 0, 870, 871, 5, 257, 0, 0, 871, 896, 1, 0, 0, 0, 872, 873, 5, 24, 0, 0, 873, 874, 5, 256, 0, 0, 874, 875, 3, 578, 289, 0, 875, 876, 5, 263, 0, 0, 876, 877, 3, 536, 268, 0, 877, 878, 5, 257, 0, 0, 878, 896, 1, 0, 0, 0, 879, 880, 5, 24, 0, 0, 880, 881, 5, 256, 0, 0, 881, 882, 3, 578, 289, 0, 882, 883, 5, 263, 0, 0, 883, 884, 3, 52, 26, 0, 884, 885, 5, 257, 0, 0, 885, 896, 1, 0, 0, 0, 886, 887, 5, 24, 0, 0, 887, 888, 5, 256, 0, 0, 888, 889, 3, 578, 289, 0, 889, 890, 5, 263, 0, 0, 890, 891, 3, 536, 268, 0, 891, 892, 5, 263, 0, 0, 892, 893, 3, 52, 26, 0, 893, 894, 5, 257, 0, 0, 894, 896, 1, 0, 0, 0, 895, 864, 1, 0, 0, 0, 895, 867, 1, 0, 0, 0, 895, 872, 1, 0, 0, 0, 895, 879, 1, 0, 0, 0, 895, 886, 1, 0, 0, 0, 896, 47, 1, 0, 0, 0, 897, 898, 5, 230, 0, 0, 898, 899, 5, 256, 0, 0, 899, 900, 3, 552, 276, 0, 900, 901, 5, 257, 0, 0, 901, 49, 1, 0, 0, 0, 902, 903, 6, 25, -1, 0, 903, 904, 3, 56, 28, 0, 904, 910, 1, 0, 0, 0, 905, 906, 10, 1, 0, 0, 906, 907, 5, 264, 0, 0, 907, 909, 3, 56, 28, 0, 908, 905, 1, 0, 0, 0, 909, 912, 1, 0, 0, 0, 910, 908, 1, 0, 0, 0, 910, 911, 1, 0, 0, 0, 911, 51, 1, 0, 0, 0, 912, 910, 1, 0, 0, 0, 913, 918, 3, 50, 25, 0, 914, 915, 5, 267, 0, 0, 915, 916, 5, 264, 0, 0, 916, 918, 3, 50, 25, 0, 917, 913, 1, 0, 0, 0, 917, 914, 1, 0, 0, 0, 918, 53, 1, 0, 0, 0, 919, 920, 3, 10, 5, 0, 920, 921, 5, 264, 0, 0, 921, 922, 3, 366, 183, 0, 922, 55, 1, 0, 0, 0, 923, 1058, 3, 58, 29, 0, 924, 1058, 3, 60, 30, 0, 925, 1058, 3, 62, 31, 0, 926, 1058, 3, 64, 32, 0, 927, 1058, 3, 210, 105, 0, 928, 1058, 3, 208, 104, 0, 929, 1058, 3, 66, 33, 0, 930, 1058, 3, 68, 34, 0, 931, 1058, 3, 70, 35, 0, 932, 1058, 3, 72, 36, 0, 933, 1058, 3, 74, 37, 0, 934, 1058, 3, 80, 40, 0, 935, 1058, 3, 82, 41, 0, 936, 1058, 3, 84, 42, 0, 937, 1058, 3, 86, 43, 0, 938, 1058, 3, 88, 44, 0, 939, 1058, 3, 90, 45, 0, 940, 1058, 3, 94, 47, 0, 941, 1058, 3, 96, 48, 0, 942, 1058, 3, 98, 49, 0, 943, 1058, 3, 100, 50, 0, 944, 1058, 3, 106, 53, 0, 945, 1058, 3, 108, 54, 0, 946, 1058, 3, 110, 55, 0, 947, 1058, 3, 112, 56, 0, 948, 1058, 3, 114, 57, 0, 949, 1058, 3, 120, 60, 0, 950, 1058, 3, 122, 61, 0, 951, 1058, 3, 124, 62, 0, 952, 1058, 3, 126, 63, 0, 953, 1058, 3, 128, 64, 0, 954, 1058, 3, 132, 66, 0, 955, 1058, 3, 134, 67, 0, 956, 1058, 3, 138, 69, 0, 957, 1058, 3, 140, 70, 0, 958, 1058, 3, 142, 71, 0, 959, 1058, 3, 146, 73, 0, 960, 1058, 3, 148, 74, 0, 961, 1058, 3, 150, 75, 0, 962, 1058, 3, 152, 76, 0, 963, 1058, 3, 154, 77, 0, 964, 1058, 3, 156, 78, 0, 965, 1058, 3, 158, 79, 0, 966, 1058, 3, 160, 80, 0, 967, 1058, 3, 162, 81, 0, 968, 1058, 3, 164, 82, 0, 969, 1058, 3, 166, 83, 0, 970, 1058, 3, 168, 84, 0, 971, 1058, 3, 170, 85, 0, 972, 1058, 3, 172, 86, 0, 973, 1058, 3, 174, 87, 0, 974, 1058, 3, 176, 88, 0, 975, 1058, 3, 178, 89, 0, 976, 1058, 3, 180, 90, 0, 977, 1058, 3, 182, 91, 0, 978, 1058, 3, 184, 92, 0, 979, 1058, 3, 188, 94, 0, 980, 1058, 3, 190, 95, 0, 981, 1058, 3, 192, 96, 0, 982, 1058, 3, 196, 98, 0, 983, 1058, 3, 198, 99, 0, 984, 1058, 3, 200, 100, 0, 985, 1058, 3, 202, 101, 0, 986, 1058, 3, 204, 102, 0, 987, 1058, 3, 212, 106, 0, 988, 1058, 3, 214, 107, 0, 989, 1058, 3, 216, 108, 0, 990, 1058, 3, 218, 109, 0, 991, 1058, 3, 220, 110, 0, 992, 1058, 3, 222, 111, 0, 993, 1058, 3, 224, 112, 0, 994, 1058, 3, 226, 113, 0, 995, 1058, 3, 228, 114, 0, 996, 1058, 3, 230, 115, 0, 997, 1058, 3, 232, 116, 0, 998, 1058, 3, 234, 117, 0, 999, 1058, 3, 236, 118, 0, 1000, 1058, 3, 238, 119, 0, 1001, 1058, 3, 242, 121, 0, 1002, 1058, 3, 244, 122, 0, 1003, 1058, 3, 246, 123, 0, 1004, 1058, 3, 248, 124, 0, 1005, 1058, 3, 250, 125, 0, 1006, 1058, 3, 252, 126, 0, 1007, 1058, 3, 254, 127, 0, 1008, 1058, 3, 256, 128, 0, 1009, 1058, 3, 264, 132, 0, 1010, 1058, 3, 266, 133, 0, 1011, 1058, 3, 268, 134, 0, 1012, 1058, 3, 102, 51, 0, 1013, 1058, 3, 240, 120, 0, 1014, 1058, 3, 206, 103, 0, 1015, 1058, 3, 270, 135, 0, 1016, 1058, 3, 272, 136, 0, 1017, 1058, 3, 274, 137, 0, 1018, 1058, 3, 276, 138, 0, 1019, 1058, 3, 280, 140, 0, 1020, 1058, 3, 282, 141, 0, 1021, 1058, 3, 286, 143, 0, 1022, 1058, 3, 288, 144, 0, 1023, 1058, 3, 136, 68, 0, 1024, 1058, 3, 290, 145, 0, 1025, 1058, 3, 292, 146, 0, 1026, 1058, 3, 294, 147, 0, 1027, 1058, 3, 296, 148, 0, 1028, 1058, 3, 302, 151, 0, 1029, 1058, 3, 304, 152, 0, 1030, 1058, 3, 308, 154, 0, 1031, 1058, 3, 310, 155, 0, 1032, 1058, 3, 312, 156, 0, 1033, 1058, 3, 314, 157, 0, 1034, 1058, 3, 316, 158, 0, 1035, 1058, 3, 318, 159, 0, 1036, 1058, 3, 320, 160, 0, 1037, 1058, 3, 322, 161, 0, 1038, 1058, 3, 324, 162, 0, 1039, 1058, 3, 130, 65, 0, 1040, 1058, 3, 92, 46, 0, 1041, 1058, 3, 104, 52, 0, 1042, 1058, 3, 78, 39, 0, 1043, 1058, 3, 144, 72, 0, 1044, 1058, 3, 300, 150, 0, 1045, 1058, 3, 298, 149, 0, 1046, 1058, 3, 186, 93, 0, 1047, 1058, 3, 306, 153, 0, 1048, 1058, 3, 194, 97, 0, 1049, 1058, 3, 262, 131, 0, 1050, 1058, 3, 260, 130, 0, 1051, 1058, 3, 258, 129, 0, 1052, 1058, 3, 278, 139, 0, 1053, 1058, 3, 284, 142, 0, 1054, 1058, 3, 76, 38, 0, 1055, 1058, 3, 116, 58, 0, 1056, 1058, 3, 118, 59, 0, 1057, 923, 1, 0, 0, 0, 1057, 924, 1, 0, 0, 0, 1057, 925, 1, 0, 0, 0, 1057, 926, 1, 0, 0, 0, 1057, 927, 1, 0, 0, 0, 1057, 928, 1, 0, 0, 0, 1057, 929, 1, 0, 0, 0, 1057, 930, 1, 0, 0, 0, 1057, 931, 1, 0, 0, 0, 1057, 932, 1, 0, 0, 0, 1057, 933, 1, 0, 0, 0, 1057, 934, 1, 0, 0, 0, 1057, 935, 1, 0, 0, 0, 1057, 936, 1, 0, 0, 0, 1057, 937, 1, 0, 0, 0, 1057, 938, 1, 0, 0, 0, 1057, 939, 1, 0, 0, 0, 1057, 940, 1, 0, 0, 0, 1057, 941, 1, 0, 0, 0, 1057, 942, 1, 0, 0, 0, 1057, 943, 1, 0, 0, 0, 1057, 944, 1, 0, 0, 0, 1057, 945, 1, 0, 0, 0, 1057, 946, 1, 0, 0, 0, 1057, 947, 1, 0, 0, 0, 1057, 948, 1, 0, 0, 0, 1057, 949, 1, 0, 0, 0, 1057, 950, 1, 0, 0, 0, 1057, 951, 1, 0, 0, 0, 1057, 952, 1, 0, 0, 0, 1057, 953, 1, 0, 0, 0, 1057, 954, 1, 0, 0, 0, 1057, 955, 1, 0, 0, 0, 1057, 956, 1, 0, 0, 0, 1057, 957, 1, 0, 0, 0, 1057, 958, 1, 0, 0, 0, 1057, 959, 1, 0, 0, 0, 1057, 960, 1, 0, 0, 0, 1057, 961, 1, 0, 0, 0, 1057, 962, 1, 0, 0, 0, 1057, 963, 1, 0, 0, 0, 1057, 964, 1, 0, 0, 0, 1057, 965, 1, 0, 0, 0, 1057, 966, 1, 0, 0, 0, 1057, 967, 1, 0, 0, 0, 1057, 968, 1, 0, 0, 0, 1057, 969, 1, 0, 0, 0, 1057, 970, 1, 0, 0, 0, 1057, 971, 1, 0, 0, 0, 1057, 972, 1, 0, 0, 0, 1057, 973, 1, 0, 0, 0, 1057, 974, 1, 0, 0, 0, 1057, 975, 1, 0, 0, 0, 1057, 976, 1, 0, 0, 0, 1057, 977, 1, 0, 0, 0, 1057, 978, 1, 0, 0, 0, 1057, 979, 1, 0, 0, 0, 1057, 980, 1, 0, 0, 0, 1057, 981, 1, 0, 0, 0, 1057, 982, 1, 0, 0, 0, 1057, 983, 1, 0, 0, 0, 1057, 984, 1, 0, 0, 0, 1057, 985, 1, 0, 0, 0, 1057, 986, 1, 0, 0, 0, 1057, 987, 1, 0, 0, 0, 1057, 988, 1, 0, 0, 0, 1057, 989, 1, 0, 0, 0, 1057, 990, 1, 0, 0, 0, 1057, 991, 1, 0, 0, 0, 1057, 992, 1, 0, 0, 0, 1057, 993, 1, 0, 0, 0, 1057, 994, 1, 0, 0, 0, 1057, 995, 1, 0, 0, 0, 1057, 996, 1, 0, 0, 0, 1057, 997, 1, 0, 0, 0, 1057, 998, 1, 0, 0, 0, 1057, 999, 1, 0, 0, 0, 1057, 1000, 1, 0, 0, 0, 1057, 1001, 1, 0, 0, 0, 1057, 1002, 1, 0, 0, 0, 1057, 1003, 1, 0, 0, 0, 1057, 1004, 1, 0, 0, 0, 1057, 1005, 1, 0, 0, 0, 1057, 1006, 1, 0, 0, 0, 1057, 1007, 1, 0, 0, 0, 1057, 1008, 1, 0, 0, 0, 1057, 1009, 1, 0, 0, 0, 1057, 1010, 1, 0, 0, 0, 1057, 1011, 1, 0, 0, 0, 1057, 1012, 1, 0, 0, 0, 1057, 1013, 1, 0, 0, 0, 1057, 1014, 1, 0, 0, 0, 1057, 1015, 1, 0, 0, 0, 1057, 1016, 1, 0, 0, 0, 1057, 1017, 1, 0, 0, 0, 1057, 1018, 1, 0, 0, 0, 1057, 1019, 1, 0, 0, 0, 1057, 1020, 1, 0, 0, 0, 1057, 1021, 1, 0, 0, 0, 1057, 1022, 1, 0, 0, 0, 1057, 1023, 1, 0, 0, 0, 1057, 1024, 1, 0, 0, 0, 1057, 1025, 1, 0, 0, 0, 1057, 1026, 1, 0, 0, 0, 1057, 1027, 1, 0, 0, 0, 1057, 1028, 1, 0, 0, 0, 1057, 1029, 1, 0, 0, 0, 1057, 1030, 1, 0, 0, 0, 1057, 1031, 1, 0, 0, 0, 1057, 1032, 1, 0, 0, 0, 1057, 1033, 1, 0, 0, 0, 1057, 1034, 1, 0, 0, 0, 1057, 1035, 1, 0, 0, 0, 1057, 1036, 1, 0, 0, 0, 1057, 1037, 1, 0, 0, 0, 1057, 1038, 1, 0, 0, 0, 1057, 1039, 1, 0, 0, 0, 1057, 1040, 1, 0, 0, 0, 1057, 1041, 1, 0, 0, 0, 1057, 1042, 1, 0, 0, 0, 1057, 1043, 1, 0, 0, 0, 1057, 1044, 1, 0, 0, 0, 1057, 1045, 1, 0, 0, 0, 1057, 1046, 1, 0, 0, 0, 1057, 1047, 1, 0, 0, 0, 1057, 1048, 1, 0, 0, 0, 1057, 1049, 1, 0, 0, 0, 1057, 1050, 1, 0, 0, 0, 1057, 1051, 1, 0, 0, 0, 1057, 1052, 1, 0, 0, 0, 1057, 1053, 1, 0, 0, 0, 1057, 1054, 1, 0, 0, 0, 1057, 1055, 1, 0, 0, 0, 1057, 1056, 1, 0, 0, 0, 1058, 57, 1, 0, 0, 0, 1059, 1060, 5, 233, 0, 0, 1060, 1061, 5, 256, 0, 0, 1061, 1062, 3, 534, 267, 0, 1062, 1063, 5, 257, 0, 0, 1063, 59, 1, 0, 0, 0, 1064, 1065, 5, 57, 0, 0, 1065, 1066, 5, 256, 0, 0, 1066, 1067, 3, 534, 267, 0, 1067, 1068, 5, 257, 0, 0, 1068, 61, 1, 0, 0, 0, 1069, 1070, 5, 3, 0, 0, 1070, 1071, 5, 256, 0, 0, 1071, 1072, 3, 524, 262, 0, 1072, 1073, 5, 257, 0, 0, 1073, 1080, 1, 0, 0, 0, 1074, 1075, 5, 3, 0, 0, 1075, 1076, 5, 256, 0, 0, 1076, 1077, 3, 52, 26, 0, 1077, 1078, 5, 257, 0, 0, 1078, 1080, 1, 0, 0, 0, 1079, 1069, 1, 0, 0, 0, 1079, 1074, 1, 0, 0, 0, 1080, 63, 1, 0, 0, 0, 1081, 1082, 5, 4, 0, 0, 1082, 1083, 5, 256, 0, 0, 1083, 1095, 5, 257, 0, 0, 1084, 1085, 5, 4, 0, 0, 1085, 1086, 5, 256, 0, 0, 1086, 1087, 3, 524, 262, 0, 1087, 1088, 5, 257, 0, 0, 1088, 1095, 1, 0, 0, 0, 1089, 1090, 5, 4, 0, 0, 1090, 1091, 5, 256, 0, 0, 1091, 1092, 3, 52, 26, 0, 1092, 1093, 5, 257, 0, 0, 1093, 1095, 1, 0, 0, 0, 1094, 1081, 1, 0, 0, 0, 1094, 1084, 1, 0, 0, 0, 1094, 1089, 1, 0, 0, 0, 1095, 65, 1, 0, 0, 0, 1096, 1097, 5, 5, 0, 0, 1097, 1098, 5, 256, 0, 0, 1098, 1099, 3, 332, 166, 0, 1099, 1100, 5, 263, 0, 0, 1100, 1101, 3, 578, 289, 0, 1101, 1102, 5, 257, 0, 0, 1102, 1109, 1, 0, 0, 0, 1103, 1104, 5, 5, 0, 0, 1104, 1105, 5, 256, 0, 0, 1105, 1106, 3, 578, 289, 0, 1106, 1107, 5, 257, 0, 0, 1107, 1109, 1, 0, 0, 0, 1108, 1096, 1, 0, 0, 0, 1108, 1103, 1, 0, 0, 0, 1109, 67, 1, 0, 0, 0, 1110, 1111, 5, 6, 0, 0, 1111, 1112, 5, 256, 0, 0, 1112, 1113, 3, 364, 182, 0, 1113, 1114, 5, 257, 0, 0, 1114, 69, 1, 0, 0, 0, 1115, 1116, 5, 7, 0, 0, 1116, 1117, 5, 256, 0, 0, 1117, 1118, 3, 552, 276, 0, 1118, 1119, 5, 257, 0, 0, 1119, 71, 1, 0, 0, 0, 1120, 1121, 5, 8, 0, 0, 1121, 1122, 5, 256, 0, 0, 1122, 1123, 3, 364, 182, 0, 1123, 1124, 5, 257, 0, 0, 1124, 73, 1, 0, 0, 0, 1125, 1126, 5, 9, 0, 0, 1126, 1127, 5, 256, 0, 0, 1127, 1130, 3, 578, 289, 0, 1128, 1129, 5, 263, 0, 0, 1129, 1131, 3, 568, 284, 0, 1130, 1128, 1, 0, 0, 0, 1130, 1131, 1, 0, 0, 0, 1131, 1132, 1, 0, 0, 0, 1132, 1133, 5, 257, 0, 0, 1133, 75, 1, 0, 0, 0, 1134, 1135, 5, 11, 0, 0, 1135, 1136, 5, 256, 0, 0, 1136, 1137, 5, 257, 0, 0, 1137, 77, 1, 0, 0, 0, 1138, 1139, 5, 12, 0, 0, 1139, 1140, 5, 256, 0, 0, 1140, 1147, 5, 257, 0, 0, 1141, 1142, 5, 12, 0, 0, 1142, 1143, 5, 256, 0, 0, 1143, 1144, 3, 332, 166, 0, 1144, 1145, 5, 257, 0, 0, 1145, 1147, 1, 0, 0, 0, 1146, 1138, 1, 0, 0, 0, 1146, 1141, 1, 0, 0, 0, 1147, 79, 1, 0, 0, 0, 1148, 1149, 5, 14, 0, 0, 1149, 1150, 5, 256, 0, 0, 1150, 1151, 3, 368, 184, 0, 1151, 1152, 5, 257, 0, 0, 1152, 1162, 1, 0, 0, 0, 1153, 1154, 5, 14, 0, 0, 1154, 1155, 5, 256, 0, 0, 1155, 1162, 5, 257, 0, 0, 1156, 1157, 5, 14, 0, 0, 1157, 1158, 5, 256, 0, 0, 1158, 1159, 3, 582, 291, 0, 1159, 1160, 5, 257, 0, 0, 1160, 1162, 1, 0, 0, 0, 1161, 1148, 1, 0, 0, 0, 1161, 1153, 1, 0, 0, 0, 1161, 1156, 1, 0, 0, 0, 1162, 81, 1, 0, 0, 0, 1163, 1164, 5, 18, 0, 0, 1164, 1165, 5, 256, 0, 0, 1165, 1166, 3, 528, 264, 0, 1166, 1167, 5, 257, 0, 0, 1167, 83, 1, 0, 0, 0, 1168, 1169, 5, 20, 0, 0, 1169, 1170, 5, 256, 0, 0, 1170, 1171, 3, 528, 264, 0, 1171, 1172, 5, 257, 0, 0, 1172, 85, 1, 0, 0, 0, 1173, 1174, 5, 21, 0, 0, 1174, 1175, 5, 256, 0, 0, 1175, 1176, 5, 257, 0, 0, 1176, 87, 1, 0, 0, 0, 1177, 1178, 5, 22, 0, 0, 1178, 1179, 5, 256, 0, 0, 1179, 1180, 3, 52, 26, 0, 1180, 1181, 5, 257, 0, 0, 1181, 89, 1, 0, 0, 0, 1182, 1183, 5, 23, 0, 0, 1183, 1184, 5, 256, 0, 0, 1184, 1185, 3, 370, 185, 0, 1185, 1186, 5, 257, 0, 0, 1186, 1237, 1, 0, 0, 0, 1187, 1188, 5, 23, 0, 0, 1188, 1189, 5, 256, 0, 0, 1189, 1237, 5, 257, 0, 0, 1190, 1191, 5, 23, 0, 0, 1191, 1192, 5, 256, 0, 0, 1192, 1193, 3, 372, 186, 0, 1193, 1194, 5, 257, 0, 0, 1194, 1237, 1, 0, 0, 0, 1195, 1196, 5, 23, 0, 0, 1196, 1197, 5, 256, 0, 0, 1197, 1198, 3, 372, 186, 0, 1198, 1199, 5, 263, 0, 0, 1199, 1200, 3, 370, 185, 0, 1200, 1201, 5, 257, 0, 0, 1201, 1237, 1, 0, 0, 0, 1202, 1203, 5, 23, 0, 0, 1203, 1204, 5, 256, 0, 0, 1204, 1205, 3, 344, 172, 0, 1205, 1206, 5, 257, 0, 0, 1206, 1237, 1, 0, 0, 0, 1207, 1208, 5, 23, 0, 0, 1208, 1209, 5, 256, 0, 0, 1209, 1210, 3, 578, 289, 0, 1210, 1211, 5, 257, 0, 0, 1211, 1237, 1, 0, 0, 0, 1212, 1213, 5, 23, 0, 0, 1213, 1214, 5, 256, 0, 0, 1214, 1215, 3, 578, 289, 0, 1215, 1216, 5, 263, 0, 0, 1216, 1217, 3, 370, 185, 0, 1217, 1218, 5, 257, 0, 0, 1218, 1237, 1, 0, 0, 0, 1219, 1220, 5, 23, 0, 0, 1220, 1221, 5, 256, 0, 0, 1221, 1222, 3, 336, 168, 0, 1222, 1223, 5, 257, 0, 0, 1223, 1237, 1, 0, 0, 0, 1224, 1225, 5, 23, 0, 0, 1225, 1226, 5, 256, 0, 0, 1226, 1227, 3, 52, 26, 0, 1227, 1228, 5, 257, 0, 0, 1228, 1237, 1, 0, 0, 0, 1229, 1230, 5, 23, 0, 0, 1230, 1231, 5, 256, 0, 0, 1231, 1232, 3, 52, 26, 0, 1232, 1233, 5, 263, 0, 0, 1233, 1234, 3, 370, 185, 0, 1234, 1235, 5, 257, 0, 0, 1235, 1237, 1, 0, 0, 0, 1236, 1182, 1, 0, 0, 0, 1236, 1187, 1, 0, 0, 0, 1236, 1190, 1, 0, 0, 0, 1236, 1195, 1, 0, 0, 0, 1236, 1202, 1, 0, 0, 0, 1236, 1207, 1, 0, 0, 0, 1236, 1212, 1, 0, 0, 0, 1236, 1219, 1, 0, 0, 0, 1236, 1224, 1, 0, 0, 0, 1236, 1229, 1, 0, 0, 0, 1237, 91, 1, 0, 0, 0, 1238, 1239, 5, 24, 0, 0, 1239, 1240, 5, 256, 0, 0, 1240, 1241, 3, 578, 289, 0, 1241, 1242, 5, 257, 0, 0, 1242, 1267, 1, 0, 0, 0, 1243, 1244, 5, 24, 0, 0, 1244, 1245, 5, 256, 0, 0, 1245, 1246, 3, 578, 289, 0, 1246, 1247, 5, 263, 0, 0, 1247, 1248, 3, 536, 268, 0, 1248, 1249, 5, 257, 0, 0, 1249, 1267, 1, 0, 0, 0, 1250, 1251, 5, 24, 0, 0, 1251, 1252, 5, 256, 0, 0, 1252, 1253, 3, 578, 289, 0, 1253, 1254, 5, 263, 0, 0, 1254, 1255, 3, 52, 26, 0, 1255, 1256, 5, 257, 0, 0, 1256, 1267, 1, 0, 0, 0, 1257, 1258, 5, 24, 0, 0, 1258, 1259, 5, 256, 0, 0, 1259, 1260, 3, 578, 289, 0, 1260, 1261, 5, 263, 0, 0, 1261, 1262, 3, 536, 268, 0, 1262, 1263, 5, 263, 0, 0, 1263, 1264, 3, 52, 26, 0, 1264, 1265, 5, 257, 0, 0, 1265, 1267, 1, 0, 0, 0, 1266, 1238, 1, 0, 0, 0, 1266, 1243, 1, 0, 0, 0, 1266, 1250, 1, 0, 0, 0, 1266, 1257, 1, 0, 0, 0, 1267, 93, 1, 0, 0, 0, 1268, 1269, 5, 25, 0, 0, 1269, 1270, 5, 256, 0, 0, 1270, 1273, 3, 578, 289, 0, 1271, 1272, 5, 263, 0, 0, 1272, 1274, 3, 568, 284, 0, 1273, 1271, 1, 0, 0, 0, 1273, 1274, 1, 0, 0, 0, 1274, 1275, 1, 0, 0, 0, 1275, 1276, 5, 257, 0, 0, 1276, 95, 1, 0, 0, 0, 1277, 1278, 5, 27, 0, 0, 1278, 1279, 5, 256, 0, 0, 1279, 1280, 3, 372, 186, 0, 1280, 1281, 5, 257, 0, 0, 1281, 1320, 1, 0, 0, 0, 1282, 1283, 5, 27, 0, 0, 1283, 1284, 5, 256, 0, 0, 1284, 1285, 3, 364, 182, 0, 1285, 1286, 5, 263, 0, 0, 1286, 1287, 3, 52, 26, 0, 1287, 1288, 5, 257, 0, 0, 1288, 1320, 1, 0, 0, 0, 1289, 1290, 5, 27, 0, 0, 1290, 1291, 5, 256, 0, 0, 1291, 1292, 3, 364, 182, 0, 1292, 1293, 5, 263, 0, 0, 1293, 1294, 3, 52, 26, 0, 1294, 1295, 5, 263, 0, 0, 1295, 1296, 3, 52, 26, 0, 1296, 1297, 5, 257, 0, 0, 1297, 1320, 1, 0, 0, 0, 1298, 1299, 5, 27, 0, 0, 1299, 1300, 5, 256, 0, 0, 1300, 1301, 3, 52, 26, 0, 1301, 1302, 5, 257, 0, 0, 1302, 1320, 1, 0, 0, 0, 1303, 1304, 5, 27, 0, 0, 1304, 1305, 5, 256, 0, 0, 1305, 1306, 3, 52, 26, 0, 1306, 1307, 5, 263, 0, 0, 1307, 1308, 3, 52, 26, 0, 1308, 1309, 5, 257, 0, 0, 1309, 1320, 1, 0, 0, 0, 1310, 1311, 5, 27, 0, 0, 1311, 1312, 5, 256, 0, 0, 1312, 1313, 3, 52, 26, 0, 1313, 1314, 5, 263, 0, 0, 1314, 1315, 3, 52, 26, 0, 1315, 1316, 5, 263, 0, 0, 1316, 1317, 3, 52, 26, 0, 1317, 1318, 5, 257, 0, 0, 1318, 1320, 1, 0, 0, 0, 1319, 1277, 1, 0, 0, 0, 1319, 1282, 1, 0, 0, 0, 1319, 1289, 1, 0, 0, 0, 1319, 1298, 1, 0, 0, 0, 1319, 1303, 1, 0, 0, 0, 1319, 1310, 1, 0, 0, 0, 1320, 97, 1, 0, 0, 0, 1321, 1322, 5, 28, 0, 0, 1322, 1323, 5, 256, 0, 0, 1323, 1324, 3, 552, 276, 0, 1324, 1325, 5, 257, 0, 0, 1325, 99, 1, 0, 0, 0, 1326, 1327, 5, 29, 0, 0, 1327, 1328, 5, 256, 0, 0, 1328, 1329, 3, 522, 261, 0, 1329, 1330, 5, 257, 0, 0, 1330, 101, 1, 0, 0, 0, 1331, 1332, 5, 31, 0, 0, 1332, 1333, 5, 256, 0, 0, 1333, 1334, 3, 532, 266, 0, 1334, 1335, 5, 257, 0, 0, 1335, 103, 1, 0, 0, 0, 1336, 1337, 5, 34, 0, 0, 1337, 1338, 5, 256, 0, 0, 1338, 1341, 3, 52, 26, 0, 1339, 1340, 5, 263, 0, 0, 1340, 1342, 3, 552, 276, 0, 1341, 1339, 1, 0, 0, 0, 1341, 1342, 1, 0, 0, 0, 1342, 1343, 1, 0, 0, 0, 1343, 1344, 5, 257, 0, 0, 1344, 1351, 1, 0, 0, 0, 1345, 1346, 5, 34, 0, 0, 1346, 1347, 5, 256, 0, 0, 1347, 1348, 3, 568, 284, 0, 1348, 1349, 5, 257, 0, 0, 1349, 1351, 1, 0, 0, 0, 1350, 1336, 1, 0, 0, 0, 1350, 1345, 1, 0, 0, 0, 1351, 105, 1, 0, 0, 0, 1352, 1353, 5, 35, 0, 0, 1353, 1354, 5, 256, 0, 0, 1354, 1355, 3, 524, 262, 0, 1355, 1356, 5, 257, 0, 0, 1356, 107, 1, 0, 0, 0, 1357, 1358, 5, 36, 0, 0, 1358, 1359, 5, 256, 0, 0, 1359, 1360, 5, 257, 0, 0, 1360, 109, 1, 0, 0, 0, 1361, 1362, 5, 38, 0, 0, 1362, 1363, 5, 256, 0, 0, 1363, 1364, 3, 532, 266, 0, 1364, 1365, 5, 257, 0, 0, 1365, 111, 1, 0, 0, 0, 1366, 1367, 5, 40, 0, 0, 1367, 1368, 5, 256, 0, 0, 1368, 1375, 5, 257, 0, 0, 1369, 1370, 5, 40, 0, 0, 1370, 1371, 5, 256, 0, 0, 1371, 1372, 3, 332, 166, 0, 1372, 1373, 5, 257, 0, 0, 1373, 1375, 1, 0, 0, 0, 1374, 1366, 1, 0, 0, 0, 1374, 1369, 1, 0, 0, 0, 1375, 113, 1, 0, 0, 0, 1376, 1377, 5, 41, 0, 0, 1377, 1378, 5, 256, 0, 0, 1378, 1379, 5, 257, 0, 0, 1379, 115, 1, 0, 0, 0, 1380, 1381, 5, 43, 0, 0, 1381, 1382, 5, 256, 0, 0, 1382, 1383, 3, 362, 181, 0, 1383, 1384, 5, 263, 0, 0, 1384, 1385, 3, 582, 291, 0, 1385, 1386, 5, 257, 0, 0, 1386, 117, 1, 0, 0, 0, 1387, 1388, 5, 44, 0, 0, 1388, 1389, 5, 256, 0, 0, 1389, 1390, 3, 52, 26, 0, 1390, 1391, 5, 257, 0, 0, 1391, 1398, 1, 0, 0, 0, 1392, 1393, 5, 44, 0, 0, 1393, 1394, 5, 256, 0, 0, 1394, 1395, 3, 590, 295, 0, 1395, 1396, 5, 257, 0, 0, 1396, 1398, 1, 0, 0, 0, 1397, 1387, 1, 0, 0, 0, 1397, 1392, 1, 0, 0, 0, 1398, 119, 1, 0, 0, 0, 1399, 1400, 5, 48, 0, 0, 1400, 1401, 5, 256, 0, 0, 1401, 1404, 3, 332, 166, 0, 1402, 1403, 5, 263, 0, 0, 1403, 1405, 3, 568, 284, 0, 1404, 1402, 1, 0, 0, 0, 1404, 1405, 1, 0, 0, 0, 1405, 1406, 1, 0, 0, 0, 1406, 1407, 5, 257, 0, 0, 1407, 1414, 1, 0, 0, 0, 1408, 1409, 5, 48, 0, 0, 1409, 1410, 5, 256, 0, 0, 1410, 1411, 3, 568, 284, 0, 1411, 1412, 5, 257, 0, 0, 1412, 1414, 1, 0, 0, 0, 1413, 1399, 1, 0, 0, 0, 1413, 1408, 1, 0, 0, 0, 1414, 121, 1, 0, 0, 0, 1415, 1416, 5, 50, 0, 0, 1416, 1417, 5, 256, 0, 0, 1417, 1418, 3, 532, 266, 0, 1418, 1419, 5, 257, 0, 0, 1419, 123, 1, 0, 0, 0, 1420, 1421, 5, 1, 0, 0, 1421, 1422, 5, 256, 0, 0, 1422, 1423, 5, 257, 0, 0, 1423, 125, 1, 0, 0, 0, 1424, 1425, 5, 52, 0, 0, 1425, 1426, 5, 256, 0, 0, 1426, 1427, 3, 532, 266, 0, 1427, 1428, 5, 257, 0, 0, 1428, 127, 1, 0, 0, 0, 1429, 1430, 5, 55, 0, 0, 1430, 1431, 5, 256, 0, 0, 1431, 1432, 5, 257, 0, 0, 1432, 129, 1, 0, 0, 0, 1433, 1434, 5, 60, 0, 0, 1434, 1435, 5, 256, 0, 0, 1435, 1436, 5, 257, 0, 0, 1436, 131, 1, 0, 0, 0, 1437, 1438, 5, 59, 0, 0, 1438, 1439, 5, 256, 0, 0, 1439, 1440, 3, 568, 284, 0, 1440, 1441, 5, 257, 0, 0, 1441, 133, 1, 0, 0, 0, 1442, 1443, 5, 61, 0, 0, 1443, 1444, 5, 256, 0, 0, 1444, 1456, 5, 257, 0, 0, 1445, 1446, 5, 61, 0, 0, 1446, 1447, 5, 256, 0, 0, 1447, 1448, 3, 364, 182, 0, 1448, 1449, 5, 257, 0, 0, 1449, 1456, 1, 0, 0, 0, 1450, 1451, 5, 61, 0, 0, 1451, 1452, 5, 256, 0, 0, 1452, 1453, 3, 52, 26, 0, 1453, 1454, 5, 257, 0, 0, 1454, 1456, 1, 0, 0, 0, 1455, 1442, 1, 0, 0, 0, 1455, 1445, 1, 0, 0, 0, 1455, 1450, 1, 0, 0, 0, 1456, 135, 1, 0, 0, 0, 1457, 1458, 5, 65, 0, 0, 1458, 1459, 5, 256, 0, 0, 1459, 1466, 5, 257, 0, 0, 1460, 1461, 5, 65, 0, 0, 1461, 1462, 5, 256, 0, 0, 1462, 1463, 3, 578, 289, 0, 1463, 1464, 5, 257, 0, 0, 1464, 1466, 1, 0, 0, 0, 1465, 1457, 1, 0, 0, 0, 1465, 1460, 1, 0, 0, 0, 1466, 137, 1, 0, 0, 0, 1467, 1468, 5, 67, 0, 0, 1468, 1469, 5, 256, 0, 0, 1469, 1470, 3, 364, 182, 0, 1470, 1471, 5, 257, 0, 0, 1471, 1478, 1, 0, 0, 0, 1472, 1473, 5, 67, 0, 0, 1473, 1474, 5, 256, 0, 0, 1474, 1475, 3, 52, 26, 0, 1475, 1476, 5, 257, 0, 0, 1476, 1478, 1, 0, 0, 0, 1477, 1467, 1, 0, 0, 0, 1477, 1472, 1, 0, 0, 0, 1478, 139, 1, 0, 0, 0, 1479, 1480, 5, 69, 0, 0, 1480, 1481, 5, 256, 0, 0, 1481, 1482, 3, 52, 26, 0, 1482, 1483, 5, 257, 0, 0, 1483, 141, 1, 0, 0, 0, 1484, 1485, 5, 70, 0, 0, 1485, 1486, 5, 256, 0, 0, 1486, 1495, 5, 257, 0, 0, 1487, 1488, 5, 70, 0, 0, 1488, 1489, 5, 256, 0, 0, 1489, 1490, 3, 532, 266, 0, 1490, 1491, 5, 263, 0, 0, 1491, 1492, 3, 374, 187, 0, 1492, 1493, 5, 257, 0, 0, 1493, 1495, 1, 0, 0, 0, 1494, 1484, 1, 0, 0, 0, 1494, 1487, 1, 0, 0, 0, 1495, 143, 1, 0, 0, 0, 1496, 1497, 5, 71, 0, 0, 1497, 1498, 5, 256, 0, 0, 1498, 1499, 3, 578, 289, 0, 1499, 1500, 5, 257, 0, 0, 1500, 145, 1, 0, 0, 0, 1501, 1502, 5, 72, 0, 0, 1502, 1503, 5, 256, 0, 0, 1503, 1504, 3, 578, 289, 0, 1504, 1505, 5, 257, 0, 0, 1505, 1517, 1, 0, 0, 0, 1506, 1507, 5, 72, 0, 0, 1507, 1508, 5, 256, 0, 0, 1508, 1509, 3, 542, 271, 0, 1509, 1510, 5, 257, 0, 0, 1510, 1517, 1, 0, 0, 0, 1511, 1512, 5, 72, 0, 0, 1512, 1513, 5, 256, 0, 0, 1513, 1514, 3, 52, 26, 0, 1514, 1515, 5, 257, 0, 0, 1515, 1517, 1, 0, 0, 0, 1516, 1501, 1, 0, 0, 0, 1516, 1506, 1, 0, 0, 0, 1516, 1511, 1, 0, 0, 0, 1517, 147, 1, 0, 0, 0, 1518, 1519, 5, 79, 0, 0, 1519, 1520, 5, 256, 0, 0, 1520, 1527, 5, 257, 0, 0, 1521, 1522, 5, 79, 0, 0, 1522, 1523, 5, 256, 0, 0, 1523, 1524, 3, 578, 289, 0, 1524, 1525, 5, 257, 0, 0, 1525, 1527, 1, 0, 0, 0, 1526, 1518, 1, 0, 0, 0, 1526, 1521, 1, 0, 0, 0, 1527, 149, 1, 0, 0, 0, 1528, 1529, 5, 78, 0, 0, 1529, 1530, 5, 256, 0, 0, 1530, 1537, 5, 257, 0, 0, 1531, 1532, 5, 78, 0, 0, 1532, 1533, 5, 256, 0, 0, 1533, 1534, 3, 578, 289, 0, 1534, 1535, 5, 257, 0, 0, 1535, 1537, 1, 0, 0, 0, 1536, 1528, 1, 0, 0, 0, 1536, 1531, 1, 0, 0, 0, 1537, 151, 1, 0, 0, 0, 1538, 1539, 5, 81, 0, 0, 1539, 1540, 5, 256, 0, 0, 1540, 1541, 3, 580, 290, 0, 1541, 1542, 5, 257, 0, 0, 1542, 1604, 1, 0, 0, 0, 1543, 1544, 5, 81, 0, 0, 1544, 1545, 5, 256, 0, 0, 1545, 1546, 3, 580, 290, 0, 1546, 1547, 5, 263, 0, 0, 1547, 1548, 3, 532, 266, 0, 1548, 1549, 5, 257, 0, 0, 1549, 1604, 1, 0, 0, 0, 1550, 1551, 5, 81, 0, 0, 1551, 1552, 5, 256, 0, 0, 1552, 1553, 3, 580, 290, 0, 1553, 1554, 5, 263, 0, 0, 1554, 1555, 3, 364, 182, 0, 1555, 1556, 5, 257, 0, 0, 1556, 1604, 1, 0, 0, 0, 1557, 1558, 5, 81, 0, 0, 1558, 1559, 5, 256, 0, 0, 1559, 1560, 3, 526, 263, 0, 1560, 1561, 5, 263, 0, 0, 1561, 1562, 3, 580, 290, 0, 1562, 1563, 5, 263, 0, 0, 1563, 1564, 3, 532, 266, 0, 1564, 1565, 5, 257, 0, 0, 1565, 1604, 1, 0, 0, 0, 1566, 1567, 5, 81, 0, 0, 1567, 1568, 5, 256, 0, 0, 1568, 1569, 3, 526, 263, 0, 1569, 1570, 5, 263, 0, 0, 1570, 1571, 3, 580, 290, 0, 1571, 1572, 5, 263, 0, 0, 1572, 1573, 3, 364, 182, 0, 1573, 1574, 5, 257, 0, 0, 1574, 1604, 1, 0, 0, 0, 1575, 1576, 5, 81, 0, 0, 1576, 1577, 5, 256, 0, 0, 1577, 1578, 3, 580, 290, 0, 1578, 1579, 5, 263, 0, 0, 1579, 1580, 3, 52, 26, 0, 1580, 1581, 5, 257, 0, 0, 1581, 1604, 1, 0, 0, 0, 1582, 1583, 5, 81, 0, 0, 1583, 1584, 5, 256, 0, 0, 1584, 1585, 3, 336, 168, 0, 1585, 1586, 5, 263, 0, 0, 1586, 1587, 3, 532, 266, 0, 1587, 1588, 5, 257, 0, 0, 1588, 1604, 1, 0, 0, 0, 1589, 1590, 5, 81, 0, 0, 1590, 1591, 5, 256, 0, 0, 1591, 1592, 3, 336, 168, 0, 1592, 1593, 5, 263, 0, 0, 1593, 1594, 3, 364, 182, 0, 1594, 1595, 5, 257, 0, 0, 1595, 1604, 1, 0, 0, 0, 1596, 1597, 5, 81, 0, 0, 1597, 1598, 5, 256, 0, 0, 1598, 1599, 3, 336, 168, 0, 1599, 1600, 5, 263, 0, 0, 1600, 1601, 3, 52, 26, 0, 1601, 1602, 5, 257, 0, 0, 1602, 1604, 1, 0, 0, 0, 1603, 1538, 1, 0, 0, 0, 1603, 1543, 1, 0, 0, 0, 1603, 1550, 1, 0, 0, 0, 1603, 1557, 1, 0, 0, 0, 1603, 1566, 1, 0, 0, 0, 1603, 1575, 1, 0, 0, 0, 1603, 1582, 1, 0, 0, 0, 1603, 1589, 1, 0, 0, 0, 1603, 1596, 1, 0, 0, 0, 1604, 153, 1, 0, 0, 0, 1605, 1606, 5, 82, 0, 0, 1606, 1607, 5, 256, 0, 0, 1607, 1610, 3, 532, 266, 0, 1608, 1609, 5, 263, 0, 0, 1609, 1611, 3, 534, 267, 0, 1610, 1608, 1, 0, 0, 0, 1610, 1611, 1, 0, 0, 0, 1611, 1612, 1, 0, 0, 0, 1612, 1613, 5, 257, 0, 0, 1613, 1620, 1, 0, 0, 0, 1614, 1615, 5, 82, 0, 0, 1615, 1616, 5, 256, 0, 0, 1616, 1617, 3, 364, 182, 0, 1617, 1618, 5, 257, 0, 0, 1618, 1620, 1, 0, 0, 0, 1619, 1605, 1, 0, 0, 0, 1619, 1614, 1, 0, 0, 0, 1620, 155, 1, 0, 0, 0, 1621, 1622, 5, 83, 0, 0, 1622, 1623, 5, 256, 0, 0, 1623, 1624, 3, 364, 182, 0, 1624, 1625, 5, 257, 0, 0, 1625, 1636, 1, 0, 0, 0, 1626, 1627, 5, 83, 0, 0, 1627, 1628, 5, 256, 0, 0, 1628, 1631, 3, 580, 290, 0, 1629, 1630, 5, 263, 0, 0, 1630, 1632, 3, 568, 284, 0, 1631, 1629, 1, 0, 0, 0, 1631, 1632, 1, 0, 0, 0, 1632, 1633, 1, 0, 0, 0, 1633, 1634, 5, 257, 0, 0, 1634, 1636, 1, 0, 0, 0, 1635, 1621, 1, 0, 0, 0, 1635, 1626, 1, 0, 0, 0, 1636, 157, 1, 0, 0, 0, 1637, 1638, 5, 84, 0, 0, 1638, 1639, 5, 256, 0, 0, 1639, 1640, 3, 364, 182, 0, 1640, 1641, 5, 257, 0, 0, 1641, 1652, 1, 0, 0, 0, 1642, 1643, 5, 84, 0, 0, 1643, 1644, 5, 256, 0, 0, 1644, 1647, 3, 526, 263, 0, 1645, 1646, 5, 263, 0, 0, 1646, 1648, 3, 528, 264, 0, 1647, 1645, 1, 0, 0, 0, 1647, 1648, 1, 0, 0, 0, 1648, 1649, 1, 0, 0, 0, 1649, 1650, 5, 257, 0, 0, 1650, 1652, 1, 0, 0, 0, 1651, 1637, 1, 0, 0, 0, 1651, 1642, 1, 0, 0, 0, 1652, 159, 1, 0, 0, 0, 1653, 1654, 5, 86, 0, 0, 1654, 1655, 5, 256, 0, 0, 1655, 1656, 3, 580, 290, 0, 1656, 1657, 5, 257, 0, 0, 1657, 161, 1, 0, 0, 0, 1658, 1659, 5, 87, 0, 0, 1659, 1660, 5, 256, 0, 0, 1660, 1663, 3, 532, 266, 0, 1661, 1662, 5, 263, 0, 0, 1662, 1664, 3, 534, 267, 0, 1663, 1661, 1, 0, 0, 0, 1663, 1664, 1, 0, 0, 0, 1664, 1665, 1, 0, 0, 0, 1665, 1666, 5, 257, 0, 0, 1666, 1673, 1, 0, 0, 0, 1667, 1668, 5, 87, 0, 0, 1668, 1669, 5, 256, 0, 0, 1669, 1670, 3, 364, 182, 0, 1670, 1671, 5, 257, 0, 0, 1671, 1673, 1, 0, 0, 0, 1672, 1658, 1, 0, 0, 0, 1672, 1667, 1, 0, 0, 0, 1673, 163, 1, 0, 0, 0, 1674, 1675, 5, 89, 0, 0, 1675, 1676, 5, 256, 0, 0, 1676, 1677, 5, 257, 0, 0, 1677, 165, 1, 0, 0, 0, 1678, 1679, 5, 90, 0, 0, 1679, 1680, 5, 256, 0, 0, 1680, 1681, 5, 257, 0, 0, 1681, 167, 1, 0, 0, 0, 1682, 1683, 5, 92, 0, 0, 1683, 1684, 5, 256, 0, 0, 1684, 1685, 3, 528, 264, 0, 1685, 1686, 5, 257, 0, 0, 1686, 169, 1, 0, 0, 0, 1687, 1688, 5, 94, 0, 0, 1688, 1689, 5, 256, 0, 0, 1689, 1690, 3, 528, 264, 0, 1690, 1691, 5, 257, 0, 0, 1691, 171, 1, 0, 0, 0, 1692, 1693, 5, 102, 0, 0, 1693, 1694, 5, 256, 0, 0, 1694, 1695, 3, 532, 266, 0, 1695, 1696, 5, 257, 0, 0, 1696, 173, 1, 0, 0, 0, 1697, 1698, 5, 103, 0, 0, 1698, 1699, 5, 256, 0, 0, 1699, 1700, 5, 257, 0, 0, 1700, 175, 1, 0, 0, 0, 1701, 1702, 5, 98, 0, 0, 1702, 1703, 5, 256, 0, 0, 1703, 1704, 5, 257, 0, 0, 1704, 177, 1, 0, 0, 0, 1705, 1706, 5, 100, 0, 0, 1706, 1707, 5, 256, 0, 0, 1707, 1708, 3, 534, 267, 0, 1708, 1709, 5, 257, 0, 0, 1709, 179, 1, 0, 0, 0, 1710, 1711, 5, 106, 0, 0, 1711, 1712, 5, 256, 0, 0, 1712, 1713, 3, 532, 266, 0, 1713, 1714, 5, 257, 0, 0, 1714, 1721, 1, 0, 0, 0, 1715, 1716, 5, 106, 0, 0, 1716, 1717, 5, 256, 0, 0, 1717, 1718, 3, 364, 182, 0, 1718, 1719, 5, 257, 0, 0, 1719, 1721, 1, 0, 0, 0, 1720, 1710, 1, 0, 0, 0, 1720, 1715, 1, 0, 0, 0, 1721, 181, 1, 0, 0, 0, 1722, 1723, 5, 108, 0, 0, 1723, 1724, 5, 256, 0, 0, 1724, 1725, 5, 257, 0, 0, 1725, 183, 1, 0, 0, 0, 1726, 1727, 5, 111, 0, 0, 1727, 1728, 5, 256, 0, 0, 1728, 1729, 5, 257, 0, 0, 1729, 185, 1, 0, 0, 0, 1730, 1731, 5, 113, 0, 0, 1731, 1732, 5, 256, 0, 0, 1732, 1739, 5, 257, 0, 0, 1733, 1734, 5, 113, 0, 0, 1734, 1735, 5, 256, 0, 0, 1735, 1736, 3, 332, 166, 0, 1736, 1737, 5, 257, 0, 0, 1737, 1739, 1, 0, 0, 0, 1738, 1730, 1, 0, 0, 0, 1738, 1733, 1, 0, 0, 0, 1739, 187, 1, 0, 0, 0, 1740, 1741, 5, 114, 0, 0, 1741, 1742, 5, 256, 0, 0, 1742, 1743, 3, 332, 166, 0, 1743, 1744, 5, 263, 0, 0, 1744, 1745, 3, 520, 260, 0, 1745, 1746, 5, 257, 0, 0, 1746, 1753, 1, 0, 0, 0, 1747, 1748, 5, 114, 0, 0, 1748, 1749, 5, 256, 0, 0, 1749, 1750, 3, 520, 260, 0, 1750, 1751, 5, 257, 0, 0, 1751, 1753, 1, 0, 0, 0, 1752, 1740, 1, 0, 0, 0, 1752, 1747, 1, 0, 0, 0, 1753, 189, 1, 0, 0, 0, 1754, 1755, 5, 116, 0, 0, 1755, 1756, 5, 256, 0, 0, 1756, 1757, 3, 52, 26, 0, 1757, 1758, 5, 257, 0, 0, 1758, 191, 1, 0, 0, 0, 1759, 1760, 5, 117, 0, 0, 1760, 1761, 5, 256, 0, 0, 1761, 1768, 5, 257, 0, 0, 1762, 1763, 5, 117, 0, 0, 1763, 1764, 5, 256, 0, 0, 1764, 1765, 3, 578, 289, 0, 1765, 1766, 5, 257, 0, 0, 1766, 1768, 1, 0, 0, 0, 1767, 1759, 1, 0, 0, 0, 1767, 1762, 1, 0, 0, 0, 1768, 193, 1, 0, 0, 0, 1769, 1770, 5, 120, 0, 0, 1770, 1771, 5, 256, 0, 0, 1771, 1778, 5, 257, 0, 0, 1772, 1773, 5, 120, 0, 0, 1773, 1774, 5, 256, 0, 0, 1774, 1775, 3, 332, 166, 0, 1775, 1776, 5, 257, 0, 0, 1776, 1778, 1, 0, 0, 0, 1777, 1769, 1, 0, 0, 0, 1777, 1772, 1, 0, 0, 0, 1778, 195, 1, 0, 0, 0, 1779, 1780, 5, 121, 0, 0, 1780, 1781, 5, 256, 0, 0, 1781, 1782, 3, 52, 26, 0, 1782, 1783, 5, 257, 0, 0, 1783, 197, 1, 0, 0, 0, 1784, 1785, 5, 122, 0, 0, 1785, 1786, 5, 256, 0, 0, 1786, 1787, 3, 552, 276, 0, 1787, 1788, 5, 257, 0, 0, 1788, 199, 1, 0, 0, 0, 1789, 1790, 5, 123, 0, 0, 1790, 1791, 5, 256, 0, 0, 1791, 1792, 3, 578, 289, 0, 1792, 1793, 5, 257, 0, 0, 1793, 201, 1, 0, 0, 0, 1794, 1795, 5, 124, 0, 0, 1795, 1796, 5, 256, 0, 0, 1796, 1803, 5, 257, 0, 0, 1797, 1798, 5, 124, 0, 0, 1798, 1799, 5, 256, 0, 0, 1799, 1800, 3, 332, 166, 0, 1800, 1801, 5, 257, 0, 0, 1801, 1803, 1, 0, 0, 0, 1802, 1794, 1, 0, 0, 0, 1802, 1797, 1, 0, 0, 0, 1803, 203, 1, 0, 0, 0, 1804, 1805, 5, 126, 0, 0, 1805, 1806, 5, 256, 0, 0, 1806, 1813, 5, 257, 0, 0, 1807, 1808, 5, 126, 0, 0, 1808, 1809, 5, 256, 0, 0, 1809, 1810, 3, 332, 166, 0, 1810, 1811, 5, 257, 0, 0, 1811, 1813, 1, 0, 0, 0, 1812, 1804, 1, 0, 0, 0, 1812, 1807, 1, 0, 0, 0, 1813, 205, 1, 0, 0, 0, 1814, 1815, 5, 128, 0, 0, 1815, 1816, 5, 256, 0, 0, 1816, 1817, 3, 532, 266, 0, 1817, 1818, 5, 257, 0, 0, 1818, 207, 1, 0, 0, 0, 1819, 1820, 5, 130, 0, 0, 1820, 1821, 5, 256, 0, 0, 1821, 1833, 5, 257, 0, 0, 1822, 1823, 5, 130, 0, 0, 1823, 1824, 5, 256, 0, 0, 1824, 1825, 3, 538, 269, 0, 1825, 1826, 5, 257, 0, 0, 1826, 1833, 1, 0, 0, 0, 1827, 1828, 5, 130, 0, 0, 1828, 1829, 5, 256, 0, 0, 1829, 1830, 3, 52, 26, 0, 1830, 1831, 5, 257, 0, 0, 1831, 1833, 1, 0, 0, 0, 1832, 1819, 1, 0, 0, 0, 1832, 1822, 1, 0, 0, 0, 1832, 1827, 1, 0, 0, 0, 1833, 209, 1, 0, 0, 0, 1834, 1835, 5, 129, 0, 0, 1835, 1836, 5, 256, 0, 0, 1836, 1848, 5, 257, 0, 0, 1837, 1838, 5, 129, 0, 0, 1838, 1839, 5, 256, 0, 0, 1839, 1840, 3, 538, 269, 0, 1840, 1841, 5, 257, 0, 0, 1841, 1848, 1, 0, 0, 0, 1842, 1843, 5, 129, 0, 0, 1843, 1844, 5, 256, 0, 0, 1844, 1845, 3, 52, 26, 0, 1845, 1846, 5, 257, 0, 0, 1846, 1848, 1, 0, 0, 0, 1847, 1834, 1, 0, 0, 0, 1847, 1837, 1, 0, 0, 0, 1847, 1842, 1, 0, 0, 0, 1848, 211, 1, 0, 0, 0, 1849, 1850, 5, 131, 0, 0, 1850, 1851, 5, 256, 0, 0, 1851, 1858, 5, 257, 0, 0, 1852, 1853, 5, 131, 0, 0, 1853, 1854, 5, 256, 0, 0, 1854, 1855, 3, 332, 166, 0, 1855, 1856, 5, 257, 0, 0, 1856, 1858, 1, 0, 0, 0, 1857, 1849, 1, 0, 0, 0, 1857, 1852, 1, 0, 0, 0, 1858, 213, 1, 0, 0, 0, 1859, 1860, 5, 139, 0, 0, 1860, 1861, 5, 256, 0, 0, 1861, 1862, 3, 364, 182, 0, 1862, 1863, 5, 257, 0, 0, 1863, 215, 1, 0, 0, 0, 1864, 1865, 5, 144, 0, 0, 1865, 1866, 5, 256, 0, 0, 1866, 1867, 3, 52, 26, 0, 1867, 1868, 5, 257, 0, 0, 1868, 217, 1, 0, 0, 0, 1869, 1870, 5, 152, 0, 0, 1870, 1871, 5, 256, 0, 0, 1871, 1872, 3, 364, 182, 0, 1872, 1873, 5, 263, 0, 0, 1873, 1874, 3, 52, 26, 0, 1874, 1875, 5, 257, 0, 0, 1875, 1912, 1, 0, 0, 0, 1876, 1877, 5, 152, 0, 0, 1877, 1878, 5, 256, 0, 0, 1878, 1879, 3, 342, 171, 0, 1879, 1880, 5, 263, 0, 0, 1880, 1881, 3, 538, 269, 0, 1881, 1882, 5, 257, 0, 0, 1882, 1912, 1, 0, 0, 0, 1883, 1884, 5, 152, 0, 0, 1884, 1885, 5, 256, 0, 0, 1885, 1886, 3, 342, 171, 0, 1886, 1887, 5, 263, 0, 0, 1887, 1888, 3, 538, 269, 0, 1888, 1889, 5, 263, 0, 0, 1889, 1890, 3, 352, 176, 0, 1890, 1891, 5, 257, 0, 0, 1891, 1912, 1, 0, 0, 0, 1892, 1893, 5, 152, 0, 0, 1893, 1894, 5, 256, 0, 0, 1894, 1895, 3, 342, 171, 0, 1895, 1896, 5, 263, 0, 0, 1896, 1897, 3, 52, 26, 0, 1897, 1898, 5, 257, 0, 0, 1898, 1912, 1, 0, 0, 0, 1899, 1900, 5, 152, 0, 0, 1900, 1901, 5, 256, 0, 0, 1901, 1902, 3, 532, 266, 0, 1902, 1903, 5, 263, 0, 0, 1903, 1904, 3, 52, 26, 0, 1904, 1905, 5, 257, 0, 0, 1905, 1912, 1, 0, 0, 0, 1906, 1907, 5, 152, 0, 0, 1907, 1908, 5, 256, 0, 0, 1908, 1909, 3, 52, 26, 0, 1909, 1910, 5, 257, 0, 0, 1910, 1912, 1, 0, 0, 0, 1911, 1869, 1, 0, 0, 0, 1911, 1876, 1, 0, 0, 0, 1911, 1883, 1, 0, 0, 0, 1911, 1892, 1, 0, 0, 0, 1911, 1899, 1, 0, 0, 0, 1911, 1906, 1, 0, 0, 0, 1912, 219, 1, 0, 0, 0, 1913, 1914, 5, 153, 0, 0, 1914, 1915, 5, 256, 0, 0, 1915, 1916, 3, 52, 26, 0, 1916, 1917, 5, 257, 0, 0, 1917, 221, 1, 0, 0, 0, 1918, 1919, 5, 156, 0, 0, 1919, 1920, 5, 256, 0, 0, 1920, 1921, 3, 552, 276, 0, 1921, 1922, 5, 257, 0, 0, 1922, 223, 1, 0, 0, 0, 1923, 1924, 5, 155, 0, 0, 1924, 1925, 5, 256, 0, 0, 1925, 1932, 5, 257, 0, 0, 1926, 1927, 5, 155, 0, 0, 1927, 1928, 5, 256, 0, 0, 1928, 1929, 3, 332, 166, 0, 1929, 1930, 5, 257, 0, 0, 1930, 1932, 1, 0, 0, 0, 1931, 1923, 1, 0, 0, 0, 1931, 1926, 1, 0, 0, 0, 1932, 225, 1, 0, 0, 0, 1933, 1934, 5, 157, 0, 0, 1934, 1935, 5, 256, 0, 0, 1935, 1936, 5, 257, 0, 0, 1936, 227, 1, 0, 0, 0, 1937, 1938, 5, 159, 0, 0, 1938, 1939, 5, 256, 0, 0, 1939, 1940, 3, 528, 264, 0, 1940, 1941, 5, 257, 0, 0, 1941, 229, 1, 0, 0, 0, 1942, 1943, 5, 160, 0, 0, 1943, 1944, 5, 256, 0, 0, 1944, 1945, 3, 528, 264, 0, 1945, 1946, 5, 257, 0, 0, 1946, 231, 1, 0, 0, 0, 1947, 1948, 5, 162, 0, 0, 1948, 1949, 5, 256, 0, 0, 1949, 1950, 5, 257, 0, 0, 1950, 233, 1, 0, 0, 0, 1951, 1952, 5, 165, 0, 0, 1952, 1953, 5, 256, 0, 0, 1953, 1960, 5, 257, 0, 0, 1954, 1955, 5, 165, 0, 0, 1955, 1956, 5, 256, 0, 0, 1956, 1957, 3, 522, 261, 0, 1957, 1958, 5, 257, 0, 0, 1958, 1960, 1, 0, 0, 0, 1959, 1951, 1, 0, 0, 0, 1959, 1954, 1, 0, 0, 0, 1960, 235, 1, 0, 0, 0, 1961, 1962, 5, 166, 0, 0, 1962, 1963, 5, 256, 0, 0, 1963, 1964, 5, 257, 0, 0, 1964, 237, 1, 0, 0, 0, 1965, 1966, 5, 168, 0, 0, 1966, 1967, 5, 256, 0, 0, 1967, 1968, 5, 257, 0, 0, 1968, 239, 1, 0, 0, 0, 1969, 1970, 5, 177, 0, 0, 1970, 1971, 5, 256, 0, 0, 1971, 1972, 3, 532, 266, 0, 1972, 1973, 5, 257, 0, 0, 1973, 241, 1, 0, 0, 0, 1974, 1975, 5, 171, 0, 0, 1975, 1976, 5, 256, 0, 0, 1976, 1983, 5, 257, 0, 0, 1977, 1978, 5, 171, 0, 0, 1978, 1979, 5, 256, 0, 0, 1979, 1980, 3, 578, 289, 0, 1980, 1981, 5, 257, 0, 0, 1981, 1983, 1, 0, 0, 0, 1982, 1974, 1, 0, 0, 0, 1982, 1977, 1, 0, 0, 0, 1983, 243, 1, 0, 0, 0, 1984, 1985, 5, 172, 0, 0, 1985, 1986, 5, 256, 0, 0, 1986, 1989, 3, 578, 289, 0, 1987, 1988, 5, 263, 0, 0, 1988, 1990, 3, 568, 284, 0, 1989, 1987, 1, 0, 0, 0, 1989, 1990, 1, 0, 0, 0, 1990, 1991, 1, 0, 0, 0, 1991, 1992, 5, 257, 0, 0, 1992, 245, 1, 0, 0, 0, 1993, 1994, 5, 173, 0, 0, 1994, 1995, 5, 256, 0, 0, 1995, 1996, 3, 568, 284, 0, 1996, 1997, 5, 257, 0, 0, 1997, 247, 1, 0, 0, 0, 1998, 1999, 5, 176, 0, 0, 1999, 2000, 5, 256, 0, 0, 2000, 2001, 3, 352, 176, 0, 2001, 2002, 5, 263, 0, 0, 2002, 2003, 3, 532, 266, 0, 2003, 2004, 5, 263, 0, 0, 2004, 2007, 3, 532, 266, 0, 2005, 2006, 5, 263, 0, 0, 2006, 2008, 3, 534, 267, 0, 2007, 2005, 1, 0, 0, 0, 2007, 2008, 1, 0, 0, 0, 2008, 2009, 1, 0, 0, 0, 2009, 2010, 5, 257, 0, 0, 2010, 2035, 1, 0, 0, 0, 2011, 2012, 5, 176, 0, 0, 2012, 2013, 5, 256, 0, 0, 2013, 2014, 3, 352, 176, 0, 2014, 2015, 5, 263, 0, 0, 2015, 2016, 3, 538, 269, 0, 2016, 2017, 5, 257, 0, 0, 2017, 2035, 1, 0, 0, 0, 2018, 2019, 5, 176, 0, 0, 2019, 2020, 5, 256, 0, 0, 2020, 2021, 3, 532, 266, 0, 2021, 2022, 5, 263, 0, 0, 2022, 2025, 3, 532, 266, 0, 2023, 2024, 5, 263, 0, 0, 2024, 2026, 3, 534, 267, 0, 2025, 2023, 1, 0, 0, 0, 2025, 2026, 1, 0, 0, 0, 2026, 2027, 1, 0, 0, 0, 2027, 2028, 5, 257, 0, 0, 2028, 2035, 1, 0, 0, 0, 2029, 2030, 5, 176, 0, 0, 2030, 2031, 5, 256, 0, 0, 2031, 2032, 3, 538, 269, 0, 2032, 2033, 5, 257, 0, 0, 2033, 2035, 1, 0, 0, 0, 2034, 1998, 1, 0, 0, 0, 2034, 2011, 1, 0, 0, 0, 2034, 2018, 1, 0, 0, 0, 2034, 2029, 1, 0, 0, 0, 2035, 249, 1, 0, 0, 0, 2036, 2037, 5, 174, 0, 0, 2037, 2038, 5, 256, 0, 0, 2038, 2039, 3, 568, 284, 0, 2039, 2040, 5, 257, 0, 0, 2040, 251, 1, 0, 0, 0, 2041, 2042, 5, 178, 0, 0, 2042, 2043, 5, 256, 0, 0, 2043, 2044, 3, 332, 166, 0, 2044, 2045, 5, 263, 0, 0, 2045, 2046, 3, 520, 260, 0, 2046, 2047, 5, 263, 0, 0, 2047, 2048, 3, 520, 260, 0, 2048, 2049, 5, 257, 0, 0, 2049, 2058, 1, 0, 0, 0, 2050, 2051, 5, 178, 0, 0, 2051, 2052, 5, 256, 0, 0, 2052, 2053, 3, 520, 260, 0, 2053, 2054, 5, 263, 0, 0, 2054, 2055, 3, 520, 260, 0, 2055, 2056, 5, 257, 0, 0, 2056, 2058, 1, 0, 0, 0, 2057, 2041, 1, 0, 0, 0, 2057, 2050, 1, 0, 0, 0, 2058, 253, 1, 0, 0, 0, 2059, 2060, 5, 179, 0, 0, 2060, 2061, 5, 256, 0, 0, 2061, 2062, 5, 257, 0, 0, 2062, 255, 1, 0, 0, 0, 2063, 2064, 5, 184, 0, 0, 2064, 2065, 5, 256, 0, 0, 2065, 2066, 3, 578, 289, 0, 2066, 2067, 5, 263, 0, 0, 2067, 2068, 3, 52, 26, 0, 2068, 2069, 5, 257, 0, 0, 2069, 2076, 1, 0, 0, 0, 2070, 2071, 5, 184, 0, 0, 2071, 2072, 5, 256, 0, 0, 2072, 2073, 3, 52, 26, 0, 2073, 2074, 5, 257, 0, 0, 2074, 2076, 1, 0, 0, 0, 2075, 2063, 1, 0, 0, 0, 2075, 2070, 1, 0, 0, 0, 2076, 257, 1, 0, 0, 0, 2077, 2078, 5, 183, 0, 0, 2078, 2079, 5, 256, 0, 0, 2079, 2080, 3, 580, 290, 0, 2080, 2081, 5, 263, 0, 0, 2081, 2082, 3, 580, 290, 0, 2082, 2083, 5, 257, 0, 0, 2083, 2094, 1, 0, 0, 0, 2084, 2085, 5, 183, 0, 0, 2085, 2086, 5, 256, 0, 0, 2086, 2087, 3, 332, 166, 0, 2087, 2088, 5, 263, 0, 0, 2088, 2089, 3, 580, 290, 0, 2089, 2090, 5, 263, 0, 0, 2090, 2091, 3, 580, 290, 0, 2091, 2092, 5, 257, 0, 0, 2092, 2094, 1, 0, 0, 0, 2093, 2077, 1, 0, 0, 0, 2093, 2084, 1, 0, 0, 0, 2094, 259, 1, 0, 0, 0, 2095, 2096, 5, 185, 0, 0, 2096, 2097, 5, 256, 0, 0, 2097, 2098, 5, 257, 0, 0, 2098, 261, 1, 0, 0, 0, 2099, 2100, 5, 187, 0, 0, 2100, 2101, 5, 256, 0, 0, 2101, 2108, 5, 257, 0, 0, 2102, 2103, 5, 187, 0, 0, 2103, 2104, 5, 256, 0, 0, 2104, 2105, 3, 332, 166, 0, 2105, 2106, 5, 257, 0, 0, 2106, 2108, 1, 0, 0, 0, 2107, 2099, 1, 0, 0, 0, 2107, 2102, 1, 0, 0, 0, 2108, 263, 1, 0, 0, 0, 2109, 2110, 5, 188, 0, 0, 2110, 2111, 5, 256, 0, 0, 2111, 2112, 3, 374, 187, 0, 2112, 2113, 5, 257, 0, 0, 2113, 2118, 1, 0, 0, 0, 2114, 2115, 5, 188, 0, 0, 2115, 2116, 5, 256, 0, 0, 2116, 2118, 5, 257, 0, 0, 2117, 2109, 1, 0, 0, 0, 2117, 2114, 1, 0, 0, 0, 2118, 265, 1, 0, 0, 0, 2119, 2120, 5, 189, 0, 0, 2120, 2121, 5, 256, 0, 0, 2121, 2122, 3, 332, 166, 0, 2122, 2123, 5, 263, 0, 0, 2123, 2124, 3, 582, 291, 0, 2124, 2125, 5, 257, 0, 0, 2125, 2132, 1, 0, 0, 0, 2126, 2127, 5, 189, 0, 0, 2127, 2128, 5, 256, 0, 0, 2128, 2129, 3, 582, 291, 0, 2129, 2130, 5, 257, 0, 0, 2130, 2132, 1, 0, 0, 0, 2131, 2119, 1, 0, 0, 0, 2131, 2126, 1, 0, 0, 0, 2132, 267, 1, 0, 0, 0, 2133, 2134, 5, 192, 0, 0, 2134, 2135, 5, 256, 0, 0, 2135, 2136, 3, 354, 177, 0, 2136, 2137, 5, 257, 0, 0, 2137, 2187, 1, 0, 0, 0, 2138, 2139, 5, 192, 0, 0, 2139, 2140, 5, 256, 0, 0, 2140, 2141, 3, 356, 178, 0, 2141, 2142, 5, 263, 0, 0, 2142, 2143, 3, 578, 289, 0, 2143, 2144, 5, 257, 0, 0, 2144, 2187, 1, 0, 0, 0, 2145, 2146, 5, 192, 0, 0, 2146, 2147, 5, 256, 0, 0, 2147, 2148, 3, 356, 178, 0, 2148, 2149, 5, 263, 0, 0, 2149, 2150, 3, 578, 289, 0, 2150, 2151, 5, 263, 0, 0, 2151, 2154, 3, 578, 289, 0, 2152, 2153, 5, 263, 0, 0, 2153, 2155, 3, 568, 284, 0, 2154, 2152, 1, 0, 0, 0, 2154, 2155, 1, 0, 0, 0, 2155, 2156, 1, 0, 0, 0, 2156, 2157, 5, 257, 0, 0, 2157, 2187, 1, 0, 0, 0, 2158, 2159, 5, 192, 0, 0, 2159, 2160, 5, 256, 0, 0, 2160, 2161, 3, 356, 178, 0, 2161, 2162, 5, 263, 0, 0, 2162, 2163, 3, 52, 26, 0, 2163, 2164, 5, 257, 0, 0, 2164, 2187, 1, 0, 0, 0, 2165, 2166, 5, 192, 0, 0, 2166, 2167, 5, 256, 0, 0, 2167, 2168, 3, 578, 289, 0, 2168, 2169, 5, 257, 0, 0, 2169, 2187, 1, 0, 0, 0, 2170, 2171, 5, 192, 0, 0, 2171, 2172, 5, 256, 0, 0, 2172, 2173, 3, 578, 289, 0, 2173, 2174, 5, 263, 0, 0, 2174, 2177, 3, 578, 289, 0, 2175, 2176, 5, 263, 0, 0, 2176, 2178, 3, 568, 284, 0, 2177, 2175, 1, 0, 0, 0, 2177, 2178, 1, 0, 0, 0, 2178, 2179, 1, 0, 0, 0, 2179, 2180, 5, 257, 0, 0, 2180, 2187, 1, 0, 0, 0, 2181, 2182, 5, 192, 0, 0, 2182, 2183, 5, 256, 0, 0, 2183, 2184, 3, 52, 26, 0, 2184, 2185, 5, 257, 0, 0, 2185, 2187, 1, 0, 0, 0, 2186, 2133, 1, 0, 0, 0, 2186, 2138, 1, 0, 0, 0, 2186, 2145, 1, 0, 0, 0, 2186, 2158, 1, 0, 0, 0, 2186, 2165, 1, 0, 0, 0, 2186, 2170, 1, 0, 0, 0, 2186, 2181, 1, 0, 0, 0, 2187, 269, 1, 0, 0, 0, 2188, 2189, 5, 195, 0, 0, 2189, 2190, 5, 256, 0, 0, 2190, 2191, 5, 257, 0, 0, 2191, 271, 1, 0, 0, 0, 2192, 2193, 5, 197, 0, 0, 2193, 2194, 5, 256, 0, 0, 2194, 2195, 3, 52, 26, 0, 2195, 2196, 5, 257, 0, 0, 2196, 273, 1, 0, 0, 0, 2197, 2198, 5, 198, 0, 0, 2198, 2199, 5, 256, 0, 0, 2199, 2200, 5, 257, 0, 0, 2200, 275, 1, 0, 0, 0, 2201, 2202, 5, 200, 0, 0, 2202, 2203, 5, 256, 0, 0, 2203, 2204, 3, 332, 166, 0, 2204, 2205, 5, 263, 0, 0, 2205, 2206, 3, 520, 260, 0, 2206, 2207, 5, 257, 0, 0, 2207, 2214, 1, 0, 0, 0, 2208, 2209, 5, 200, 0, 0, 2209, 2210, 5, 256, 0, 0, 2210, 2211, 3, 520, 260, 0, 2211, 2212, 5, 257, 0, 0, 2212, 2214, 1, 0, 0, 0, 2213, 2201, 1, 0, 0, 0, 2213, 2208, 1, 0, 0, 0, 2214, 277, 1, 0, 0, 0, 2215, 2216, 5, 201, 0, 0, 2216, 2217, 5, 256, 0, 0, 2217, 2218, 3, 580, 290, 0, 2218, 2219, 5, 257, 0, 0, 2219, 2228, 1, 0, 0, 0, 2220, 2221, 5, 201, 0, 0, 2221, 2222, 5, 256, 0, 0, 2222, 2223, 3, 332, 166, 0, 2223, 2224, 5, 263, 0, 0, 2224, 2225, 3, 580, 290, 0, 2225, 2226, 5, 257, 0, 0, 2226, 2228, 1, 0, 0, 0, 2227, 2215, 1, 0, 0, 0, 2227, 2220, 1, 0, 0, 0, 2228, 279, 1, 0, 0, 0, 2229, 2230, 5, 203, 0, 0, 2230, 2231, 5, 256, 0, 0, 2231, 2232, 3, 578, 289, 0, 2232, 2233, 5, 257, 0, 0, 2233, 281, 1, 0, 0, 0, 2234, 2235, 5, 204, 0, 0, 2235, 2236, 5, 256, 0, 0, 2236, 2237, 3, 578, 289, 0, 2237, 2238, 5, 257, 0, 0, 2238, 283, 1, 0, 0, 0, 2239, 2240, 5, 205, 0, 0, 2240, 2241, 5, 256, 0, 0, 2241, 2242, 3, 582, 291, 0, 2242, 2243, 5, 257, 0, 0, 2243, 2268, 1, 0, 0, 0, 2244, 2245, 5, 205, 0, 0, 2245, 2246, 5, 256, 0, 0, 2246, 2247, 3, 332, 166, 0, 2247, 2248, 5, 263, 0, 0, 2248, 2249, 3, 582, 291, 0, 2249, 2250, 5, 257, 0, 0, 2250, 2268, 1, 0, 0, 0, 2251, 2252, 5, 205, 0, 0, 2252, 2253, 5, 256, 0, 0, 2253, 2254, 3, 582, 291, 0, 2254, 2255, 5, 263, 0, 0, 2255, 2256, 3, 582, 291, 0, 2256, 2257, 5, 257, 0, 0, 2257, 2268, 1, 0, 0, 0, 2258, 2259, 5, 205, 0, 0, 2259, 2260, 5, 256, 0, 0, 2260, 2261, 3, 332, 166, 0, 2261, 2262, 5, 263, 0, 0, 2262, 2263, 3, 582, 291, 0, 2263, 2264, 5, 263, 0, 0, 2264, 2265, 3, 582, 291, 0, 2265, 2266, 5, 257, 0, 0, 2266, 2268, 1, 0, 0, 0, 2267, 2239, 1, 0, 0, 0, 2267, 2244, 1, 0, 0, 0, 2267, 2251, 1, 0, 0, 0, 2267, 2258, 1, 0, 0, 0, 2268, 285, 1, 0, 0, 0, 2269, 2270, 5, 206, 0, 0, 2270, 2271, 5, 256, 0, 0, 2271, 2278, 5, 257, 0, 0, 2272, 2273, 5, 206, 0, 0, 2273, 2274, 5, 256, 0, 0, 2274, 2275, 3, 332, 166, 0, 2275, 2276, 5, 257, 0, 0, 2276, 2278, 1, 0, 0, 0, 2277, 2269, 1, 0, 0, 0, 2277, 2272, 1, 0, 0, 0, 2278, 287, 1, 0, 0, 0, 2279, 2280, 5, 209, 0, 0, 2280, 2281, 5, 256, 0, 0, 2281, 2300, 5, 257, 0, 0, 2282, 2283, 5, 209, 0, 0, 2283, 2284, 5, 256, 0, 0, 2284, 2285, 3, 332, 166, 0, 2285, 2286, 5, 257, 0, 0, 2286, 2300, 1, 0, 0, 0, 2287, 2288, 5, 209, 0, 0, 2288, 2289, 5, 256, 0, 0, 2289, 2290, 3, 332, 166, 0, 2290, 2291, 5, 263, 0, 0, 2291, 2292, 3, 520, 260, 0, 2292, 2293, 5, 257, 0, 0, 2293, 2300, 1, 0, 0, 0, 2294, 2295, 5, 209, 0, 0, 2295, 2296, 5, 256, 0, 0, 2296, 2297, 3, 520, 260, 0, 2297, 2298, 5, 257, 0, 0, 2298, 2300, 1, 0, 0, 0, 2299, 2279, 1, 0, 0, 0, 2299, 2282, 1, 0, 0, 0, 2299, 2287, 1, 0, 0, 0, 2299, 2294, 1, 0, 0, 0, 2300, 289, 1, 0, 0, 0, 2301, 2302, 5, 212, 0, 0, 2302, 2303, 5, 256, 0, 0, 2303, 2304, 3, 582, 291, 0, 2304, 2305, 5, 257, 0, 0, 2305, 291, 1, 0, 0, 0, 2306, 2307, 5, 213, 0, 0, 2307, 2308, 5, 256, 0, 0, 2308, 2309, 3, 582, 291, 0, 2309, 2310, 5, 257, 0, 0, 2310, 293, 1, 0, 0, 0, 2311, 2312, 5, 214, 0, 0, 2312, 2313, 5, 256, 0, 0, 2313, 2316, 3, 346, 173, 0, 2314, 2315, 5, 263, 0, 0, 2315, 2317, 3, 568, 284, 0, 2316, 2314, 1, 0, 0, 0, 2316, 2317, 1, 0, 0, 0, 2317, 2318, 1, 0, 0, 0, 2318, 2319, 5, 257, 0, 0, 2319, 2336, 1, 0, 0, 0, 2320, 2321, 5, 214, 0, 0, 2321, 2322, 5, 256, 0, 0, 2322, 2323, 3, 578, 289, 0, 2323, 2324, 5, 257, 0, 0, 2324, 2336, 1, 0, 0, 0, 2325, 2326, 5, 214, 0, 0, 2326, 2327, 5, 256, 0, 0, 2327, 2328, 3, 542, 271, 0, 2328, 2329, 5, 257, 0, 0, 2329, 2336, 1, 0, 0, 0, 2330, 2331, 5, 214, 0, 0, 2331, 2332, 5, 256, 0, 0, 2332, 2333, 3, 52, 26, 0, 2333, 2334, 5, 257, 0, 0, 2334, 2336, 1, 0, 0, 0, 2335, 2311, 1, 0, 0, 0, 2335, 2320, 1, 0, 0, 0, 2335, 2325, 1, 0, 0, 0, 2335, 2330, 1, 0, 0, 0, 2336, 295, 1, 0, 0, 0, 2337, 2338, 5, 222, 0, 0, 2338, 2339, 5, 256, 0, 0, 2339, 2342, 3, 346, 173, 0, 2340, 2341, 5, 263, 0, 0, 2341, 2343, 3, 528, 264, 0, 2342, 2340, 1, 0, 0, 0, 2342, 2343, 1, 0, 0, 0, 2343, 2344, 1, 0, 0, 0, 2344, 2345, 5, 257, 0, 0, 2345, 297, 1, 0, 0, 0, 2346, 2347, 5, 218, 0, 0, 2347, 2348, 5, 256, 0, 0, 2348, 2355, 5, 257, 0, 0, 2349, 2350, 5, 218, 0, 0, 2350, 2351, 5, 256, 0, 0, 2351, 2352, 3, 332, 166, 0, 2352, 2353, 5, 257, 0, 0, 2353, 2355, 1, 0, 0, 0, 2354, 2346, 1, 0, 0, 0, 2354, 2349, 1, 0, 0, 0, 2355, 299, 1, 0, 0, 0, 2356, 2357, 5, 221, 0, 0, 2357, 2358, 5, 256, 0, 0, 2358, 2365, 5, 257, 0, 0, 2359, 2360, 5, 221, 0, 0, 2360, 2361, 5, 256, 0, 0, 2361, 2362, 3, 332, 166, 0, 2362, 2363, 5, 257, 0, 0, 2363, 2365, 1, 0, 0, 0, 2364, 2356, 1, 0, 0, 0, 2364, 2359, 1, 0, 0, 0, 2365, 301, 1, 0, 0, 0, 2366, 2367, 5, 223, 0, 0, 2367, 2368, 5, 256, 0, 0, 2368, 2369, 3, 346, 173, 0, 2369, 2370, 5, 257, 0, 0, 2370, 303, 1, 0, 0, 0, 2371, 2372, 5, 224, 0, 0, 2372, 2373, 5, 256, 0, 0, 2373, 2380, 5, 257, 0, 0, 2374, 2375, 5, 224, 0, 0, 2375, 2376, 5, 256, 0, 0, 2376, 2377, 3, 578, 289, 0, 2377, 2378, 5, 257, 0, 0, 2378, 2380, 1, 0, 0, 0, 2379, 2371, 1, 0, 0, 0, 2379, 2374, 1, 0, 0, 0, 2380, 305, 1, 0, 0, 0, 2381, 2382, 5, 225, 0, 0, 2382, 2383, 5, 256, 0, 0, 2383, 2390, 5, 257, 0, 0, 2384, 2385, 5, 225, 0, 0, 2385, 2386, 5, 256, 0, 0, 2386, 2387, 3, 332, 166, 0, 2387, 2388, 5, 257, 0, 0, 2388, 2390, 1, 0, 0, 0, 2389, 2381, 1, 0, 0, 0, 2389, 2384, 1, 0, 0, 0, 2390, 307, 1, 0, 0, 0, 2391, 2392, 5, 229, 0, 0, 2392, 2393, 5, 256, 0, 0, 2393, 2394, 5, 257, 0, 0, 2394, 309, 1, 0, 0, 0, 2395, 2396, 5, 230, 0, 0, 2396, 2397, 5, 256, 0, 0, 2397, 2398, 3, 552, 276, 0, 2398, 2399, 5, 257, 0, 0, 2399, 311, 1, 0, 0, 0, 2400, 2401, 5, 231, 0, 0, 2401, 2402, 5, 256, 0, 0, 2402, 2403, 3, 364, 182, 0, 2403, 2404, 5, 257, 0, 0, 2404, 2411, 1, 0, 0, 0, 2405, 2406, 5, 231, 0, 0, 2406, 2407, 5, 256, 0, 0, 2407, 2408, 3, 52, 26, 0, 2408, 2409, 5, 257, 0, 0, 2409, 2411, 1, 0, 0, 0, 2410, 2400, 1, 0, 0, 0, 2410, 2405, 1, 0, 0, 0, 2411, 313, 1, 0, 0, 0, 2412, 2413, 5, 236, 0, 0, 2413, 2414, 5, 256, 0, 0, 2414, 2415, 5, 257, 0, 0, 2415, 315, 1, 0, 0, 0, 2416, 2417, 5, 234, 0, 0, 2417, 2418, 5, 256, 0, 0, 2418, 2419, 3, 568, 284, 0, 2419, 2420, 5, 257, 0, 0, 2420, 2431, 1, 0, 0, 0, 2421, 2422, 5, 234, 0, 0, 2422, 2423, 5, 256, 0, 0, 2423, 2426, 3, 588, 294, 0, 2424, 2425, 5, 263, 0, 0, 2425, 2427, 3, 568, 284, 0, 2426, 2424, 1, 0, 0, 0, 2426, 2427, 1, 0, 0, 0, 2427, 2428, 1, 0, 0, 0, 2428, 2429, 5, 257, 0, 0, 2429, 2431, 1, 0, 0, 0, 2430, 2416, 1, 0, 0, 0, 2430, 2421, 1, 0, 0, 0, 2431, 317, 1, 0, 0, 0, 2432, 2433, 5, 235, 0, 0, 2433, 2434, 5, 256, 0, 0, 2434, 2435, 3, 568, 284, 0, 2435, 2436, 5, 257, 0, 0, 2436, 319, 1, 0, 0, 0, 2437, 2438, 5, 238, 0, 0, 2438, 2439, 5, 256, 0, 0, 2439, 2440, 3, 364, 182, 0, 2440, 2441, 5, 257, 0, 0, 2441, 2455, 1, 0, 0, 0, 2442, 2443, 5, 238, 0, 0, 2443, 2444, 5, 256, 0, 0, 2444, 2445, 3, 578, 289, 0, 2445, 2446, 5, 263, 0, 0, 2446, 2447, 3, 364, 182, 0, 2447, 2448, 5, 257, 0, 0, 2448, 2455, 1, 0, 0, 0, 2449, 2450, 5, 238, 0, 0, 2450, 2451, 5, 256, 0, 0, 2451, 2452, 3, 52, 26, 0, 2452, 2453, 5, 257, 0, 0, 2453, 2455, 1, 0, 0, 0, 2454, 2437, 1, 0, 0, 0, 2454, 2442, 1, 0, 0, 0, 2454, 2449, 1, 0, 0, 0, 2455, 321, 1, 0, 0, 0, 2456, 2457, 5, 239, 0, 0, 2457, 2460, 5, 256, 0, 0, 2458, 2461, 3, 432, 216, 0, 2459, 2461, 3, 578, 289, 0, 2460, 2458, 1, 0, 0, 0, 2460, 2459, 1, 0, 0, 0, 2461, 2462, 1, 0, 0, 0, 2462, 2463, 5, 257, 0, 0, 2463, 2479, 1, 0, 0, 0, 2464, 2465, 5, 239, 0, 0, 2465, 2468, 5, 256, 0, 0, 2466, 2469, 3, 432, 216, 0, 2467, 2469, 3, 578, 289, 0, 2468, 2466, 1, 0, 0, 0, 2468, 2467, 1, 0, 0, 0, 2469, 2470, 1, 0, 0, 0, 2470, 2474, 5, 263, 0, 0, 2471, 2475, 3, 442, 221, 0, 2472, 2475, 3, 446, 223, 0, 2473, 2475, 3, 532, 266, 0, 2474, 2471, 1, 0, 0, 0, 2474, 2472, 1, 0, 0, 0, 2474, 2473, 1, 0, 0, 0, 2475, 2476, 1, 0, 0, 0, 2476, 2477, 5, 257, 0, 0, 2477, 2479, 1, 0, 0, 0, 2478, 2456, 1, 0, 0, 0, 2478, 2464, 1, 0, 0, 0, 2479, 323, 1, 0, 0, 0, 2480, 2481, 5, 249, 0, 0, 2481, 2482, 5, 256, 0, 0, 2482, 2483, 5, 257, 0, 0, 2483, 325, 1, 0, 0, 0, 2484, 2486, 5, 146, 0, 0, 2485, 2484, 1, 0, 0, 0, 2485, 2486, 1, 0, 0, 0, 2486, 2487, 1, 0, 0, 0, 2487, 2488, 7, 0, 0, 0, 2488, 2489, 5, 256, 0, 0, 2489, 2490, 3, 532, 266, 0, 2490, 2491, 5, 263, 0, 0, 2491, 2492, 3, 524, 262, 0, 2492, 2493, 5, 257, 0, 0, 2493, 327, 1, 0, 0, 0, 2494, 2496, 5, 146, 0, 0, 2495, 2494, 1, 0, 0, 0, 2495, 2496, 1, 0, 0, 0, 2496, 2497, 1, 0, 0, 0, 2497, 2510, 3, 602, 301, 0, 2498, 2507, 5, 256, 0, 0, 2499, 2504, 3, 330, 165, 0, 2500, 2501, 5, 263, 0, 0, 2501, 2503, 3, 330, 165, 0, 2502, 2500, 1, 0, 0, 0, 2503, 2506, 1, 0, 0, 0, 2504, 2502, 1, 0, 0, 0, 2504, 2505, 1, 0, 0, 0, 2505, 2508, 1, 0, 0, 0, 2506, 2504, 1, 0, 0, 0, 2507, 2499, 1, 0, 0, 0, 2507, 2508, 1, 0, 0, 0, 2508, 2509, 1, 0, 0, 0, 2509, 2511, 5, 257, 0, 0, 2510, 2498, 1, 0, 0, 0, 2510, 2511, 1, 0, 0, 0, 2511, 329, 1, 0, 0, 0, 2512, 2515, 3, 606, 303, 0, 2513, 2515, 3, 600, 300, 0, 2514, 2512, 1, 0, 0, 0, 2514, 2513, 1, 0, 0, 0, 2515, 2516, 1, 0, 0, 0, 2516, 2517, 5, 265, 0, 0, 2517, 2518, 3, 532, 266, 0, 2518, 331, 1, 0, 0, 0, 2519, 2528, 5, 116, 0, 0, 2520, 2521, 5, 190, 0, 0, 2521, 2522, 5, 264, 0, 0, 2522, 2528, 5, 116, 0, 0, 2523, 2528, 5, 73, 0, 0, 2524, 2525, 5, 190, 0, 0, 2525, 2526, 5, 264, 0, 0, 2526, 2528, 5, 73, 0, 0, 2527, 2519, 1, 0, 0, 0, 2527, 2520, 1, 0, 0, 0, 2527, 2523, 1, 0, 0, 0, 2527, 2524, 1, 0, 0, 0, 2528, 333, 1, 0, 0, 0, 2529, 2534, 5, 147, 0, 0, 2530, 2531, 5, 15, 0, 0, 2531, 2532, 5, 264, 0, 0, 2532, 2534, 5, 147, 0, 0, 2533, 2529, 1, 0, 0, 0, 2533, 2530, 1, 0, 0, 0, 2534, 335, 1, 0, 0, 0, 2535, 2538, 3, 338, 169, 0, 2536, 2538, 3, 340, 170, 0, 2537, 2535, 1, 0, 0, 0, 2537, 2536, 1, 0, 0, 0, 2538, 337, 1, 0, 0, 0, 2539, 2540, 7, 1, 0, 0, 2540, 339, 1, 0, 0, 0, 2541, 2542, 5, 208, 0, 0, 2542, 2543, 5, 264, 0, 0, 2543, 2554, 5, 89, 0, 0, 2544, 2545, 5, 208, 0, 0, 2545, 2546, 5, 264, 0, 0, 2546, 2554, 5, 111, 0, 0, 2547, 2548, 5, 208, 0, 0, 2548, 2549, 5, 264, 0, 0, 2549, 2554, 5, 108, 0, 0, 2550, 2551, 5, 208, 0, 0, 2551, 2552, 5, 264, 0, 0, 2552, 2554, 5, 236, 0, 0, 2553, 2541, 1, 0, 0, 0, 2553, 2544, 1, 0, 0, 0, 2553, 2547, 1, 0, 0, 0, 2553, 2550, 1, 0, 0, 0, 2554, 341, 1, 0, 0, 0, 2555, 2572, 5, 149, 0, 0, 2556, 2557, 5, 127, 0, 0, 2557, 2558, 5, 264, 0, 0, 2558, 2572, 5, 149, 0, 0, 2559, 2572, 5, 150, 0, 0, 2560, 2561, 5, 127, 0, 0, 2561, 2562, 5, 264, 0, 0, 2562, 2572, 5, 150, 0, 0, 2563, 2572, 5, 162, 0, 0, 2564, 2565, 5, 127, 0, 0, 2565, 2566, 5, 264, 0, 0, 2566, 2572, 5, 162, 0, 0, 2567, 2572, 5, 103, 0, 0, 2568, 2569, 5, 127, 0, 0, 2569, 2570, 5, 264, 0, 0, 2570, 2572, 5, 103, 0, 0, 2571, 2555, 1, 0, 0, 0, 2571, 2556, 1, 0, 0, 0, 2571, 2559, 1, 0, 0, 0, 2571, 2560, 1, 0, 0, 0, 2571, 2563, 1, 0, 0, 0, 2571, 2564, 1, 0, 0, 0, 2571, 2567, 1, 0, 0, 0, 2571, 2568, 1, 0, 0, 0, 2572, 343, 1, 0, 0, 0, 2573, 2586, 5, 10, 0, 0, 2574, 2575, 5, 154, 0, 0, 2575, 2576, 5, 264, 0, 0, 2576, 2586, 5, 10, 0, 0, 2577, 2586, 5, 49, 0, 0, 2578, 2579, 5, 154, 0, 0, 2579, 2580, 5, 264, 0, 0, 2580, 2586, 5, 49, 0, 0, 2581, 2586, 5, 196, 0, 0, 2582, 2583, 5, 154, 0, 0, 2583, 2584, 5, 264, 0, 0, 2584, 2586, 5, 196, 0, 0, 2585, 2573, 1, 0, 0, 0, 2585, 2574, 1, 0, 0, 0, 2585, 2577, 1, 0, 0, 0, 2585, 2578, 1, 0, 0, 0, 2585, 2581, 1, 0, 0, 0, 2585, 2582, 1, 0, 0, 0, 2586, 345, 1, 0, 0, 0, 2587, 2590, 3, 348, 174, 0, 2588, 2590, 3, 350, 175, 0, 2589, 2587, 1, 0, 0, 0, 2589, 2588, 1, 0, 0, 0, 2590, 347, 1, 0, 0, 0, 2591, 2592, 7, 2, 0, 0, 2592, 349, 1, 0, 0, 0, 2593, 2594, 5, 51, 0, 0, 2594, 2595, 5, 264, 0, 0, 2595, 2609, 5, 93, 0, 0, 2596, 2597, 5, 51, 0, 0, 2597, 2598, 5, 264, 0, 0, 2598, 2609, 5, 72, 0, 0, 2599, 2600, 5, 51, 0, 0, 2600, 2601, 5, 264, 0, 0, 2601, 2609, 5, 158, 0, 0, 2602, 2603, 5, 51, 0, 0, 2603, 2604, 5, 264, 0, 0, 2604, 2609, 5, 214, 0, 0, 2605, 2606, 5, 51, 0, 0, 2606, 2607, 5, 264, 0, 0, 2607, 2609, 5, 19, 0, 0, 2608, 2593, 1, 0, 0, 0, 2608, 2596, 1, 0, 0, 0, 2608, 2599, 1, 0, 0, 0, 2608, 2602, 1, 0, 0, 0, 2608, 2605, 1, 0, 0, 0, 2609, 351, 1, 0, 0, 0, 2610, 2611, 5, 26, 0, 0, 2611, 2612, 5, 264, 0, 0, 2612, 2615, 5, 199, 0, 0, 2613, 2615, 5, 199, 0, 0, 2614, 2610, 1, 0, 0, 0, 2614, 2613, 1, 0, 0, 0, 2615, 2616, 1, 0, 0, 0, 2616, 2617, 5, 256, 0, 0, 2617, 2618, 3, 570, 285, 0, 2618, 2619, 5, 257, 0, 0, 2619, 2653, 1, 0, 0, 0, 2620, 2621, 5, 26, 0, 0, 2621, 2622, 5, 264, 0, 0, 2622, 2625, 5, 193, 0, 0, 2623, 2625, 5, 193, 0, 0, 2624, 2620, 1, 0, 0, 0, 2624, 2623, 1, 0, 0, 0, 2625, 2626, 1, 0, 0, 0, 2626, 2627, 5, 256, 0, 0, 2627, 2628, 3, 570, 285, 0, 2628, 2629, 5, 257, 0, 0, 2629, 2653, 1, 0, 0, 0, 2630, 2631, 5, 26, 0, 0, 2631, 2632, 5, 264, 0, 0, 2632, 2635, 5, 115, 0, 0, 2633, 2635, 5, 115, 0, 0, 2634, 2630, 1, 0, 0, 0, 2634, 2633, 1, 0, 0, 0, 2635, 2636, 1, 0, 0, 0, 2636, 2637, 5, 256, 0, 0, 2637, 2638, 3, 570, 285, 0, 2638, 2639, 5, 257, 0, 0, 2639, 2653, 1, 0, 0, 0, 2640, 2653, 5, 199, 0, 0, 2641, 2642, 5, 26, 0, 0, 2642, 2643, 5, 264, 0, 0, 2643, 2653, 5, 199, 0, 0, 2644, 2653, 5, 193, 0, 0, 2645, 2646, 5, 26, 0, 0, 2646, 2647, 5, 264, 0, 0, 2647, 2653, 5, 193, 0, 0, 2648, 2653, 5, 115, 0, 0, 2649, 2650, 5, 26, 0, 0, 2650, 2651, 5, 264, 0, 0, 2651, 2653, 5, 115, 0, 0, 2652, 2614, 1, 0, 0, 0, 2652, 2624, 1, 0, 0, 0, 2652, 2634, 1, 0, 0, 0, 2652, 2640, 1, 0, 0, 0, 2652, 2641, 1, 0, 0, 0, 2652, 2644, 1, 0, 0, 0, 2652, 2645, 1, 0, 0, 0, 2652, 2648, 1, 0, 0, 0, 2652, 2649, 1, 0, 0, 0, 2653, 353, 1, 0, 0, 0, 2654, 2663, 5, 109, 0, 0, 2655, 2656, 5, 30, 0, 0, 2656, 2657, 5, 264, 0, 0, 2657, 2663, 5, 109, 0, 0, 2658, 2663, 5, 235, 0, 0, 2659, 2660, 5, 30, 0, 0, 2660, 2661, 5, 264, 0, 0, 2661, 2663, 5, 235, 0, 0, 2662, 2654, 1, 0, 0, 0, 2662, 2655, 1, 0, 0, 0, 2662, 2658, 1, 0, 0, 0, 2662, 2659, 1, 0, 0, 0, 2663, 355, 1, 0, 0, 0, 2664, 2681, 5, 68, 0, 0, 2665, 2666, 5, 170, 0, 0, 2666, 2667, 5, 264, 0, 0, 2667, 2681, 5, 68, 0, 0, 2668, 2681, 5, 112, 0, 0, 2669, 2670, 5, 170, 0, 0, 2670, 2671, 5, 264, 0, 0, 2671, 2681, 5, 112, 0, 0, 2672, 2681, 5, 6, 0, 0, 2673, 2674, 5, 170, 0, 0, 2674, 2675, 5, 264, 0, 0, 2675, 2681, 5, 6, 0, 0, 2676, 2681, 5, 134, 0, 0, 2677, 2678, 5, 170, 0, 0, 2678, 2679, 5, 264, 0, 0, 2679, 2681, 5, 134, 0, 0, 2680, 2664, 1, 0, 0, 0, 2680, 2665, 1, 0, 0, 0, 2680, 2668, 1, 0, 0, 0, 2680, 2669, 1, 0, 0, 0, 2680, 2672, 1, 0, 0, 0, 2680, 2673, 1, 0, 0, 0, 2680, 2676, 1, 0, 0, 0, 2680, 2677, 1, 0, 0, 0, 2681, 357, 1, 0, 0, 0, 2682, 2727, 5, 2, 0, 0, 2683, 2684, 5, 151, 0, 0, 2684, 2685, 5, 264, 0, 0, 2685, 2727, 5, 2, 0, 0, 2686, 2727, 5, 7, 0, 0, 2687, 2688, 5, 151, 0, 0, 2688, 2689, 5, 264, 0, 0, 2689, 2727, 5, 7, 0, 0, 2690, 2727, 5, 13, 0, 0, 2691, 2692, 5, 151, 0, 0, 2692, 2693, 5, 264, 0, 0, 2693, 2727, 5, 13, 0, 0, 2694, 2727, 5, 54, 0, 0, 2695, 2696, 5, 151, 0, 0, 2696, 2697, 5, 264, 0, 0, 2697, 2727, 5, 54, 0, 0, 2698, 2727, 5, 124, 0, 0, 2699, 2700, 5, 151, 0, 0, 2700, 2701, 5, 264, 0, 0, 2701, 2727, 5, 124, 0, 0, 2702, 2727, 5, 131, 0, 0, 2703, 2704, 5, 151, 0, 0, 2704, 2705, 5, 264, 0, 0, 2705, 2727, 5, 131, 0, 0, 2706, 2727, 5, 133, 0, 0, 2707, 2708, 5, 151, 0, 0, 2708, 2709, 5, 264, 0, 0, 2709, 2727, 5, 133, 0, 0, 2710, 2727, 5, 135, 0, 0, 2711, 2712, 5, 151, 0, 0, 2712, 2713, 5, 264, 0, 0, 2713, 2727, 5, 135, 0, 0, 2714, 2727, 5, 156, 0, 0, 2715, 2716, 5, 151, 0, 0, 2716, 2717, 5, 264, 0, 0, 2717, 2727, 5, 156, 0, 0, 2718, 2727, 5, 206, 0, 0, 2719, 2720, 5, 151, 0, 0, 2720, 2721, 5, 264, 0, 0, 2721, 2727, 5, 206, 0, 0, 2722, 2727, 5, 207, 0, 0, 2723, 2724, 5, 151, 0, 0, 2724, 2725, 5, 264, 0, 0, 2725, 2727, 5, 207, 0, 0, 2726, 2682, 1, 0, 0, 0, 2726, 2683, 1, 0, 0, 0, 2726, 2686, 1, 0, 0, 0, 2726, 2687, 1, 0, 0, 0, 2726, 2690, 1, 0, 0, 0, 2726, 2691, 1, 0, 0, 0, 2726, 2694, 1, 0, 0, 0, 2726, 2695, 1, 0, 0, 0, 2726, 2698, 1, 0, 0, 0, 2726, 2699, 1, 0, 0, 0, 2726, 2702, 1, 0, 0, 0, 2726, 2703, 1, 0, 0, 0, 2726, 2706, 1, 0, 0, 0, 2726, 2707, 1, 0, 0, 0, 2726, 2710, 1, 0, 0, 0, 2726, 2711, 1, 0, 0, 0, 2726, 2714, 1, 0, 0, 0, 2726, 2715, 1, 0, 0, 0, 2726, 2718, 1, 0, 0, 0, 2726, 2719, 1, 0, 0, 0, 2726, 2722, 1, 0, 0, 0, 2726, 2723, 1, 0, 0, 0, 2727, 359, 1, 0, 0, 0, 2728, 2737, 5, 8, 0, 0, 2729, 2730, 5, 169, 0, 0, 2730, 2731, 5, 264, 0, 0, 2731, 2737, 5, 8, 0, 0, 2732, 2737, 5, 139, 0, 0, 2733, 2734, 5, 169, 0, 0, 2734, 2735, 5, 264, 0, 0, 2735, 2737, 5, 139, 0, 0, 2736, 2728, 1, 0, 0, 0, 2736, 2729, 1, 0, 0, 0, 2736, 2732, 1, 0, 0, 0, 2736, 2733, 1, 0, 0, 0, 2737, 361, 1, 0, 0, 0, 2738, 2755, 5, 191, 0, 0, 2739, 2740, 5, 56, 0, 0, 2740, 2741, 5, 264, 0, 0, 2741, 2755, 5, 191, 0, 0, 2742, 2755, 5, 132, 0, 0, 2743, 2744, 5, 56, 0, 0, 2744, 2745, 5, 264, 0, 0, 2745, 2755, 5, 132, 0, 0, 2746, 2755, 5, 88, 0, 0, 2747, 2748, 5, 56, 0, 0, 2748, 2749, 5, 264, 0, 0, 2749, 2755, 5, 88, 0, 0, 2750, 2755, 5, 42, 0, 0, 2751, 2752, 5, 56, 0, 0, 2752, 2753, 5, 264, 0, 0, 2753, 2755, 5, 42, 0, 0, 2754, 2738, 1, 0, 0, 0, 2754, 2739, 1, 0, 0, 0, 2754, 2742, 1, 0, 0, 0, 2754, 2743, 1, 0, 0, 0, 2754, 2746, 1, 0, 0, 0, 2754, 2747, 1, 0, 0, 0, 2754, 2750, 1, 0, 0, 0, 2754, 2751, 1, 0, 0, 0, 2755, 363, 1, 0, 0, 0, 2756, 2757, 6, 182, -1, 0, 2757, 2778, 3, 376, 188, 0, 2758, 2778, 3, 378, 189, 0, 2759, 2778, 3, 380, 190, 0, 2760, 2778, 3, 382, 191, 0, 2761, 2778, 3, 384, 192, 0, 2762, 2778, 3, 386, 193, 0, 2763, 2778, 3, 388, 194, 0, 2764, 2778, 3, 390, 195, 0, 2765, 2778, 3, 392, 196, 0, 2766, 2778, 3, 394, 197, 0, 2767, 2778, 3, 396, 198, 0, 2768, 2778, 3, 398, 199, 0, 2769, 2778, 3, 404, 202, 0, 2770, 2778, 3, 406, 203, 0, 2771, 2778, 3, 408, 204, 0, 2772, 2778, 3, 410, 205, 0, 2773, 2778, 3, 400, 200, 0, 2774, 2778, 3, 402, 201, 0, 2775, 2778, 3, 412, 206, 0, 2776, 2778, 3, 414, 207, 0, 2777, 2756, 1, 0, 0, 0, 2777, 2758, 1, 0, 0, 0, 2777, 2759, 1, 0, 0, 0, 2777, 2760, 1, 0, 0, 0, 2777, 2761, 1, 0, 0, 0, 2777, 2762, 1, 0, 0, 0, 2777, 2763, 1, 0, 0, 0, 2777, 2764, 1, 0, 0, 0, 2777, 2765, 1, 0, 0, 0, 2777, 2766, 1, 0, 0, 0, 2777, 2767, 1, 0, 0, 0, 2777, 2768, 1, 0, 0, 0, 2777, 2769, 1, 0, 0, 0, 2777, 2770, 1, 0, 0, 0, 2777, 2771, 1, 0, 0, 0, 2777, 2772, 1, 0, 0, 0, 2777, 2773, 1, 0, 0, 0, 2777, 2774, 1, 0, 0, 0, 2777, 2775, 1, 0, 0, 0, 2777, 2776, 1, 0, 0, 0, 2778, 2800, 1, 0, 0, 0, 2779, 2780, 10, 3, 0, 0, 2780, 2781, 5, 264, 0, 0, 2781, 2782, 5, 7, 0, 0, 2782, 2783, 5, 256, 0, 0, 2783, 2784, 3, 364, 182, 0, 2784, 2785, 5, 257, 0, 0, 2785, 2799, 1, 0, 0, 0, 2786, 2787, 10, 2, 0, 0, 2787, 2788, 5, 264, 0, 0, 2788, 2789, 5, 156, 0, 0, 2789, 2790, 5, 256, 0, 0, 2790, 2791, 3, 364, 182, 0, 2791, 2792, 5, 257, 0, 0, 2792, 2799, 1, 0, 0, 0, 2793, 2794, 10, 1, 0, 0, 2794, 2795, 5, 264, 0, 0, 2795, 2796, 5, 137, 0, 0, 2796, 2797, 5, 256, 0, 0, 2797, 2799, 5, 257, 0, 0, 2798, 2779, 1, 0, 0, 0, 2798, 2786, 1, 0, 0, 0, 2798, 2793, 1, 0, 0, 0, 2799, 2802, 1, 0, 0, 0, 2800, 2798, 1, 0, 0, 0, 2800, 2801, 1, 0, 0, 0, 2801, 365, 1, 0, 0, 0, 2802, 2800, 1, 0, 0, 0, 2803, 2812, 3, 416, 208, 0, 2804, 2812, 3, 420, 210, 0, 2805, 2812, 3, 418, 209, 0, 2806, 2812, 3, 422, 211, 0, 2807, 2812, 3, 424, 212, 0, 2808, 2812, 3, 426, 213, 0, 2809, 2812, 3, 428, 214, 0, 2810, 2812, 3, 430, 215, 0, 2811, 2803, 1, 0, 0, 0, 2811, 2804, 1, 0, 0, 0, 2811, 2805, 1, 0, 0, 0, 2811, 2806, 1, 0, 0, 0, 2811, 2807, 1, 0, 0, 0, 2811, 2808, 1, 0, 0, 0, 2811, 2809, 1, 0, 0, 0, 2811, 2810, 1, 0, 0, 0, 2812, 367, 1, 0, 0, 0, 2813, 2814, 3, 334, 167, 0, 2814, 369, 1, 0, 0, 0, 2815, 2816, 3, 344, 172, 0, 2816, 371, 1, 0, 0, 0, 2817, 2820, 3, 336, 168, 0, 2818, 2820, 3, 354, 177, 0, 2819, 2817, 1, 0, 0, 0, 2819, 2818, 1, 0, 0, 0, 2820, 373, 1, 0, 0, 0, 2821, 2822, 3, 358, 179, 0, 2822, 375, 1, 0, 0, 0, 2823, 2824, 5, 163, 0, 0, 2824, 2825, 5, 264, 0, 0, 2825, 2828, 5, 63, 0, 0, 2826, 2828, 5, 63, 0, 0, 2827, 2823, 1, 0, 0, 0, 2827, 2826, 1, 0, 0, 0, 2828, 2829, 1, 0, 0, 0, 2829, 2830, 5, 256, 0, 0, 2830, 2831, 3, 532, 266, 0, 2831, 2832, 5, 257, 0, 0, 2832, 377, 1, 0, 0, 0, 2833, 2834, 5, 163, 0, 0, 2834, 2835, 5, 264, 0, 0, 2835, 2838, 5, 145, 0, 0, 2836, 2838, 5, 145, 0, 0, 2837, 2833, 1, 0, 0, 0, 2837, 2836, 1, 0, 0, 0, 2838, 2839, 1, 0, 0, 0, 2839, 2840, 5, 256, 0, 0, 2840, 2841, 3, 532, 266, 0, 2841, 2842, 5, 257, 0, 0, 2842, 379, 1, 0, 0, 0, 2843, 2844, 5, 163, 0, 0, 2844, 2845, 5, 264, 0, 0, 2845, 2848, 5, 118, 0, 0, 2846, 2848, 5, 118, 0, 0, 2847, 2843, 1, 0, 0, 0, 2847, 2846, 1, 0, 0, 0, 2848, 2849, 1, 0, 0, 0, 2849, 2850, 5, 256, 0, 0, 2850, 2851, 3, 532, 266, 0, 2851, 2852, 5, 257, 0, 0, 2852, 381, 1, 0, 0, 0, 2853, 2854, 5, 163, 0, 0, 2854, 2855, 5, 264, 0, 0, 2855, 2858, 5, 119, 0, 0, 2856, 2858, 5, 119, 0, 0, 2857, 2853, 1, 0, 0, 0, 2857, 2856, 1, 0, 0, 0, 2858, 2859, 1, 0, 0, 0, 2859, 2860, 5, 256, 0, 0, 2860, 2861, 3, 532, 266, 0, 2861, 2862, 5, 257, 0, 0, 2862, 383, 1, 0, 0, 0, 2863, 2864, 5, 163, 0, 0, 2864, 2865, 5, 264, 0, 0, 2865, 2868, 5, 74, 0, 0, 2866, 2868, 5, 74, 0, 0, 2867, 2863, 1, 0, 0, 0, 2867, 2866, 1, 0, 0, 0, 2868, 2869, 1, 0, 0, 0, 2869, 2870, 5, 256, 0, 0, 2870, 2871, 3, 532, 266, 0, 2871, 2872, 5, 257, 0, 0, 2872, 385, 1, 0, 0, 0, 2873, 2874, 5, 163, 0, 0, 2874, 2875, 5, 264, 0, 0, 2875, 2878, 5, 75, 0, 0, 2876, 2878, 5, 75, 0, 0, 2877, 2873, 1, 0, 0, 0, 2877, 2876, 1, 0, 0, 0, 2878, 2879, 1, 0, 0, 0, 2879, 2880, 5, 256, 0, 0, 2880, 2881, 3, 532, 266, 0, 2881, 2882, 5, 257, 0, 0, 2882, 387, 1, 0, 0, 0, 2883, 2884, 5, 163, 0, 0, 2884, 2885, 5, 264, 0, 0, 2885, 2888, 5, 101, 0, 0, 2886, 2888, 5, 101, 0, 0, 2887, 2883, 1, 0, 0, 0, 2887, 2886, 1, 0, 0, 0, 2888, 2889, 1, 0, 0, 0, 2889, 2890, 5, 256, 0, 0, 2890, 2891, 3, 532, 266, 0, 2891, 2892, 5, 263, 0, 0, 2892, 2893, 3, 532, 266, 0, 2893, 2894, 5, 257, 0, 0, 2894, 389, 1, 0, 0, 0, 2895, 2896, 5, 163, 0, 0, 2896, 2897, 5, 264, 0, 0, 2897, 2900, 5, 161, 0, 0, 2898, 2900, 5, 161, 0, 0, 2899, 2895, 1, 0, 0, 0, 2899, 2898, 1, 0, 0, 0, 2900, 2901, 1, 0, 0, 0, 2901, 2902, 5, 256, 0, 0, 2902, 2903, 3, 532, 266, 0, 2903, 2904, 5, 263, 0, 0, 2904, 2905, 3, 532, 266, 0, 2905, 2906, 5, 257, 0, 0, 2906, 391, 1, 0, 0, 0, 2907, 2908, 5, 163, 0, 0, 2908, 2909, 5, 264, 0, 0, 2909, 2912, 5, 17, 0, 0, 2910, 2912, 5, 17, 0, 0, 2911, 2907, 1, 0, 0, 0, 2911, 2910, 1, 0, 0, 0, 2912, 2913, 1, 0, 0, 0, 2913, 2914, 5, 256, 0, 0, 2914, 2915, 3, 532, 266, 0, 2915, 2916, 5, 263, 0, 0, 2916, 2917, 3, 532, 266, 0, 2917, 2918, 5, 257, 0, 0, 2918, 393, 1, 0, 0, 0, 2919, 2920, 5, 163, 0, 0, 2920, 2921, 5, 264, 0, 0, 2921, 2924, 5, 241, 0, 0, 2922, 2924, 5, 241, 0, 0, 2923, 2919, 1, 0, 0, 0, 2923, 2922, 1, 0, 0, 0, 2924, 2925, 1, 0, 0, 0, 2925, 2926, 5, 256, 0, 0, 2926, 2938, 5, 257, 0, 0, 2927, 2928, 5, 163, 0, 0, 2928, 2929, 5, 264, 0, 0, 2929, 2932, 5, 241, 0, 0, 2930, 2932, 5, 241, 0, 0, 2931, 2927, 1, 0, 0, 0, 2931, 2930, 1, 0, 0, 0, 2932, 2933, 1, 0, 0, 0, 2933, 2934, 5, 256, 0, 0, 2934, 2935, 3, 534, 267, 0, 2935, 2936, 5, 257, 0, 0, 2936, 2938, 1, 0, 0, 0, 2937, 2923, 1, 0, 0, 0, 2937, 2931, 1, 0, 0, 0, 2938, 395, 1, 0, 0, 0, 2939, 2940, 5, 163, 0, 0, 2940, 2941, 5, 264, 0, 0, 2941, 2944, 5, 243, 0, 0, 2942, 2944, 5, 243, 0, 0, 2943, 2939, 1, 0, 0, 0, 2943, 2942, 1, 0, 0, 0, 2944, 2945, 1, 0, 0, 0, 2945, 2946, 5, 256, 0, 0, 2946, 2958, 5, 257, 0, 0, 2947, 2948, 5, 163, 0, 0, 2948, 2949, 5, 264, 0, 0, 2949, 2952, 5, 243, 0, 0, 2950, 2952, 5, 243, 0, 0, 2951, 2947, 1, 0, 0, 0, 2951, 2950, 1, 0, 0, 0, 2952, 2953, 1, 0, 0, 0, 2953, 2954, 5, 256, 0, 0, 2954, 2955, 3, 534, 267, 0, 2955, 2956, 5, 257, 0, 0, 2956, 2958, 1, 0, 0, 0, 2957, 2943, 1, 0, 0, 0, 2957, 2951, 1, 0, 0, 0, 2958, 397, 1, 0, 0, 0, 2959, 2960, 5, 163, 0, 0, 2960, 2961, 5, 264, 0, 0, 2961, 2964, 5, 144, 0, 0, 2962, 2964, 5, 144, 0, 0, 2963, 2959, 1, 0, 0, 0, 2963, 2962, 1, 0, 0, 0, 2964, 2965, 1, 0, 0, 0, 2965, 2966, 5, 256, 0, 0, 2966, 2967, 3, 364, 182, 0, 2967, 2968, 5, 257, 0, 0, 2968, 399, 1, 0, 0, 0, 2969, 2970, 5, 211, 0, 0, 2970, 2971, 5, 264, 0, 0, 2971, 2974, 5, 39, 0, 0, 2972, 2974, 5, 39, 0, 0, 2973, 2969, 1, 0, 0, 0, 2973, 2972, 1, 0, 0, 0, 2974, 2975, 1, 0, 0, 0, 2975, 2976, 5, 256, 0, 0, 2976, 2977, 3, 524, 262, 0, 2977, 2978, 5, 257, 0, 0, 2978, 401, 1, 0, 0, 0, 2979, 2980, 5, 211, 0, 0, 2980, 2981, 5, 264, 0, 0, 2981, 2984, 5, 141, 0, 0, 2982, 2984, 5, 141, 0, 0, 2983, 2979, 1, 0, 0, 0, 2983, 2982, 1, 0, 0, 0, 2984, 2985, 1, 0, 0, 0, 2985, 2986, 5, 256, 0, 0, 2986, 2987, 3, 524, 262, 0, 2987, 2988, 5, 257, 0, 0, 2988, 403, 1, 0, 0, 0, 2989, 2990, 5, 211, 0, 0, 2990, 2991, 5, 264, 0, 0, 2991, 2994, 5, 202, 0, 0, 2992, 2994, 5, 202, 0, 0, 2993, 2989, 1, 0, 0, 0, 2993, 2992, 1, 0, 0, 0, 2994, 2995, 1, 0, 0, 0, 2995, 2996, 5, 256, 0, 0, 2996, 2997, 3, 524, 262, 0, 2997, 2998, 5, 257, 0, 0, 2998, 405, 1, 0, 0, 0, 2999, 3000, 5, 211, 0, 0, 3000, 3001, 5, 264, 0, 0, 3001, 3004, 5, 143, 0, 0, 3002, 3004, 5, 143, 0, 0, 3003, 2999, 1, 0, 0, 0, 3003, 3002, 1, 0, 0, 0, 3004, 3005, 1, 0, 0, 0, 3005, 3006, 5, 256, 0, 0, 3006, 3007, 3, 524, 262, 0, 3007, 3008, 5, 257, 0, 0, 3008, 407, 1, 0, 0, 0, 3009, 3010, 5, 211, 0, 0, 3010, 3011, 5, 264, 0, 0, 3011, 3014, 5, 62, 0, 0, 3012, 3014, 5, 62, 0, 0, 3013, 3009, 1, 0, 0, 0, 3013, 3012, 1, 0, 0, 0, 3014, 3015, 1, 0, 0, 0, 3015, 3016, 5, 256, 0, 0, 3016, 3017, 3, 524, 262, 0, 3017, 3018, 5, 257, 0, 0, 3018, 409, 1, 0, 0, 0, 3019, 3020, 5, 211, 0, 0, 3020, 3021, 5, 264, 0, 0, 3021, 3024, 5, 142, 0, 0, 3022, 3024, 5, 142, 0, 0, 3023, 3019, 1, 0, 0, 0, 3023, 3022, 1, 0, 0, 0, 3024, 3025, 1, 0, 0, 0, 3025, 3026, 5, 256, 0, 0, 3026, 3027, 3, 524, 262, 0, 3027, 3028, 5, 257, 0, 0, 3028, 411, 1, 0, 0, 0, 3029, 3030, 5, 211, 0, 0, 3030, 3031, 5, 264, 0, 0, 3031, 3034, 5, 182, 0, 0, 3032, 3034, 5, 182, 0, 0, 3033, 3029, 1, 0, 0, 0, 3033, 3032, 1, 0, 0, 0, 3034, 3035, 1, 0, 0, 0, 3035, 3036, 5, 256, 0, 0, 3036, 3037, 3, 524, 262, 0, 3037, 3038, 5, 257, 0, 0, 3038, 413, 1, 0, 0, 0, 3039, 3040, 5, 211, 0, 0, 3040, 3041, 5, 264, 0, 0, 3041, 3044, 5, 140, 0, 0, 3042, 3044, 5, 140, 0, 0, 3043, 3039, 1, 0, 0, 0, 3043, 3042, 1, 0, 0, 0, 3044, 3045, 1, 0, 0, 0, 3045, 3046, 5, 256, 0, 0, 3046, 3047, 3, 524, 262, 0, 3047, 3048, 5, 257, 0, 0, 3048, 415, 1, 0, 0, 0, 3049, 3050, 5, 64, 0, 0, 3050, 3051, 5, 256, 0, 0, 3051, 3052, 5, 257, 0, 0, 3052, 417, 1, 0, 0, 0, 3053, 3054, 5, 85, 0, 0, 3054, 3055, 5, 256, 0, 0, 3055, 3056, 5, 257, 0, 0, 3056, 419, 1, 0, 0, 0, 3057, 3058, 5, 107, 0, 0, 3058, 3059, 5, 256, 0, 0, 3059, 3060, 5, 257, 0, 0, 3060, 421, 1, 0, 0, 0, 3061, 3062, 5, 227, 0, 0, 3062, 3063, 5, 256, 0, 0, 3063, 3064, 5, 257, 0, 0, 3064, 423, 1, 0, 0, 0, 3065, 3066, 5, 138, 0, 0, 3066, 3067, 5, 256, 0, 0, 3067, 3074, 5, 257, 0, 0, 3068, 3069, 5, 138, 0, 0, 3069, 3070, 5, 256, 0, 0, 3070, 3071, 3, 582, 291, 0, 3071, 3072, 5, 257, 0, 0, 3072, 3074, 1, 0, 0, 0, 3073, 3065, 1, 0, 0, 0, 3073, 3068, 1, 0, 0, 0, 3074, 425, 1, 0, 0, 0, 3075, 3076, 5, 217, 0, 0, 3076, 3077, 5, 256, 0, 0, 3077, 3078, 5, 257, 0, 0, 3078, 427, 1, 0, 0, 0, 3079, 3080, 5, 219, 0, 0, 3080, 3081, 5, 256, 0, 0, 3081, 3082, 5, 257, 0, 0, 3082, 429, 1, 0, 0, 0, 3083, 3084, 5, 215, 0, 0, 3084, 3085, 5, 256, 0, 0, 3085, 3086, 5, 257, 0, 0, 3086, 431, 1, 0, 0, 0, 3087, 3095, 3, 440, 220, 0, 3088, 3095, 3, 434, 217, 0, 3089, 3095, 3, 436, 218, 0, 3090, 3095, 3, 438, 219, 0, 3091, 3095, 3, 444, 222, 0, 3092, 3095, 3, 476, 238, 0, 3093, 3095, 3, 490, 245, 0, 3094, 3087, 1, 0, 0, 0, 3094, 3088, 1, 0, 0, 0, 3094, 3089, 1, 0, 0, 0, 3094, 3090, 1, 0, 0, 0, 3094, 3091, 1, 0, 0, 0, 3094, 3092, 1, 0, 0, 0, 3094, 3093, 1, 0, 0, 0, 3095, 433, 1, 0, 0, 0, 3096, 3100, 3, 448, 224, 0, 3097, 3100, 3, 450, 225, 0, 3098, 3100, 3, 452, 226, 0, 3099, 3096, 1, 0, 0, 0, 3099, 3097, 1, 0, 0, 0, 3099, 3098, 1, 0, 0, 0, 3100, 435, 1, 0, 0, 0, 3101, 3105, 3, 454, 227, 0, 3102, 3105, 3, 456, 228, 0, 3103, 3105, 3, 458, 229, 0, 3104, 3101, 1, 0, 0, 0, 3104, 3102, 1, 0, 0, 0, 3104, 3103, 1, 0, 0, 0, 3105, 437, 1, 0, 0, 0, 3106, 3110, 3, 460, 230, 0, 3107, 3110, 3, 462, 231, 0, 3108, 3110, 3, 464, 232, 0, 3109, 3106, 1, 0, 0, 0, 3109, 3107, 1, 0, 0, 0, 3109, 3108, 1, 0, 0, 0, 3110, 439, 1, 0, 0, 0, 3111, 3117, 3, 466, 233, 0, 3112, 3117, 3, 468, 234, 0, 3113, 3117, 3, 470, 235, 0, 3114, 3117, 3, 472, 236, 0, 3115, 3117, 3, 474, 237, 0, 3116, 3111, 1, 0, 0, 0, 3116, 3112, 1, 0, 0, 0, 3116, 3113, 1, 0, 0, 0, 3116, 3114, 1, 0, 0, 0, 3116, 3115, 1, 0, 0, 0, 3117, 441, 1, 0, 0, 0, 3118, 3128, 3, 476, 238, 0, 3119, 3128, 3, 478, 239, 0, 3120, 3128, 3, 480, 240, 0, 3121, 3128, 3, 482, 241, 0, 3122, 3128, 3, 484, 242, 0, 3123, 3128, 3, 486, 243, 0, 3124, 3128, 3, 488, 244, 0, 3125, 3128, 3, 492, 246, 0, 3126, 3128, 3, 494, 247, 0, 3127, 3118, 1, 0, 0, 0, 3127, 3119, 1, 0, 0, 0, 3127, 3120, 1, 0, 0, 0, 3127, 3121, 1, 0, 0, 0, 3127, 3122, 1, 0, 0, 0, 3127, 3123, 1, 0, 0, 0, 3127, 3124, 1, 0, 0, 0, 3127, 3125, 1, 0, 0, 0, 3127, 3126, 1, 0, 0, 0, 3128, 443, 1, 0, 0, 0, 3129, 3132, 3, 496, 248, 0, 3130, 3132, 3, 498, 249, 0, 3131, 3129, 1, 0, 0, 0, 3131, 3130, 1, 0, 0, 0, 3132, 445, 1, 0, 0, 0, 3133, 3137, 3, 500, 250, 0, 3134, 3137, 3, 502, 251, 0, 3135, 3137, 3, 504, 252, 0, 3136, 3133, 1, 0, 0, 0, 3136, 3134, 1, 0, 0, 0, 3136, 3135, 1, 0, 0, 0, 3137, 447, 1, 0, 0, 0, 3138, 3139, 3, 506, 253, 0, 3139, 3140, 5, 264, 0, 0, 3140, 3141, 5, 33, 0, 0, 3141, 449, 1, 0, 0, 0, 3142, 3143, 3, 506, 253, 0, 3143, 3144, 5, 264, 0, 0, 3144, 3145, 5, 58, 0, 0, 3145, 451, 1, 0, 0, 0, 3146, 3147, 3, 506, 253, 0, 3147, 3148, 5, 264, 0, 0, 3148, 3149, 5, 175, 0, 0, 3149, 453, 1, 0, 0, 0, 3150, 3151, 3, 508, 254, 0, 3151, 3152, 5, 264, 0, 0, 3152, 3153, 5, 58, 0, 0, 3153, 455, 1, 0, 0, 0, 3154, 3155, 3, 508, 254, 0, 3155, 3156, 5, 264, 0, 0, 3156, 3157, 5, 213, 0, 0, 3157, 457, 1, 0, 0, 0, 3158, 3159, 3, 508, 254, 0, 3159, 3160, 5, 264, 0, 0, 3160, 3161, 5, 175, 0, 0, 3161, 459, 1, 0, 0, 0, 3162, 3163, 3, 510, 255, 0, 3163, 3164, 5, 264, 0, 0, 3164, 3165, 5, 58, 0, 0, 3165, 461, 1, 0, 0, 0, 3166, 3167, 3, 510, 255, 0, 3167, 3168, 5, 264, 0, 0, 3168, 3169, 5, 213, 0, 0, 3169, 463, 1, 0, 0, 0, 3170, 3171, 3, 510, 255, 0, 3171, 3172, 5, 264, 0, 0, 3172, 3173, 5, 175, 0, 0, 3173, 465, 1, 0, 0, 0, 3174, 3175, 3, 512, 256, 0, 3175, 3176, 5, 264, 0, 0, 3176, 3177, 5, 210, 0, 0, 3177, 467, 1, 0, 0, 0, 3178, 3179, 3, 512, 256, 0, 3179, 3180, 5, 264, 0, 0, 3180, 3181, 5, 58, 0, 0, 3181, 469, 1, 0, 0, 0, 3182, 3183, 3, 512, 256, 0, 3183, 3184, 5, 264, 0, 0, 3184, 3185, 5, 53, 0, 0, 3185, 471, 1, 0, 0, 0, 3186, 3187, 3, 512, 256, 0, 3187, 3188, 5, 264, 0, 0, 3188, 3189, 5, 125, 0, 0, 3189, 473, 1, 0, 0, 0, 3190, 3191, 3, 512, 256, 0, 3191, 3192, 5, 264, 0, 0, 3192, 3193, 5, 95, 0, 0, 3193, 475, 1, 0, 0, 0, 3194, 3195, 3, 514, 257, 0, 3195, 3196, 5, 264, 0, 0, 3196, 3197, 5, 216, 0, 0, 3197, 477, 1, 0, 0, 0, 3198, 3199, 3, 514, 257, 0, 3199, 3200, 5, 264, 0, 0, 3200, 3201, 5, 139, 0, 0, 3201, 479, 1, 0, 0, 0, 3202, 3203, 3, 514, 257, 0, 3203, 3204, 5, 264, 0, 0, 3204, 3205, 5, 91, 0, 0, 3205, 481, 1, 0, 0, 0, 3206, 3207, 3, 514, 257, 0, 3207, 3208, 5, 264, 0, 0, 3208, 3209, 5, 110, 0, 0, 3209, 483, 1, 0, 0, 0, 3210, 3211, 3, 514, 257, 0, 3211, 3212, 5, 264, 0, 0, 3212, 3213, 5, 109, 0, 0, 3213, 485, 1, 0, 0, 0, 3214, 3215, 3, 514, 257, 0, 3215, 3216, 5, 264, 0, 0, 3216, 3217, 5, 235, 0, 0, 3217, 487, 1, 0, 0, 0, 3218, 3219, 3, 514, 257, 0, 3219, 3220, 5, 264, 0, 0, 3220, 3221, 5, 6, 0, 0, 3221, 489, 1, 0, 0, 0, 3222, 3223, 3, 514, 257, 0, 3223, 3224, 5, 264, 0, 0, 3224, 3225, 5, 97, 0, 0, 3225, 491, 1, 0, 0, 0, 3226, 3227, 3, 514, 257, 0, 3227, 3228, 5, 264, 0, 0, 3228, 3229, 5, 115, 0, 0, 3229, 493, 1, 0, 0, 0, 3230, 3231, 3, 514, 257, 0, 3231, 3232, 5, 264, 0, 0, 3232, 3233, 5, 121, 0, 0, 3233, 495, 1, 0, 0, 0, 3234, 3235, 3, 516, 258, 0, 3235, 3236, 5, 264, 0, 0, 3236, 3237, 5, 180, 0, 0, 3237, 497, 1, 0, 0, 0, 3238, 3239, 3, 516, 258, 0, 3239, 3240, 5, 264, 0, 0, 3240, 3241, 5, 250, 0, 0, 3241, 499, 1, 0, 0, 0, 3242, 3243, 3, 516, 258, 0, 3243, 3244, 5, 264, 0, 0, 3244, 3245, 5, 80, 0, 0, 3245, 501, 1, 0, 0, 0, 3246, 3247, 3, 516, 258, 0, 3247, 3248, 5, 264, 0, 0, 3248, 3249, 5, 77, 0, 0, 3249, 503, 1, 0, 0, 0, 3250, 3251, 3, 516, 258, 0, 3251, 3252, 5, 264, 0, 0, 3252, 3253, 5, 76, 0, 0, 3253, 505, 1, 0, 0, 0, 3254, 3255, 5, 37, 0, 0, 3255, 507, 1, 0, 0, 0, 3256, 3257, 5, 164, 0, 0, 3257, 509, 1, 0, 0, 0, 3258, 3259, 5, 167, 0, 0, 3259, 511, 1, 0, 0, 0, 3260, 3261, 5, 194, 0, 0, 3261, 513, 1, 0, 0, 0, 3262, 3263, 5, 242, 0, 0, 3263, 515, 1, 0, 0, 0, 3264, 3265, 5, 104, 0, 0, 3265, 517, 1, 0, 0, 0, 3266, 3269, 3, 588, 294, 0, 3267, 3269, 3, 604, 302, 0, 3268, 3266, 1, 0, 0, 0, 3268, 3267, 1, 0, 0, 0, 3269, 519, 1, 0, 0, 0, 3270, 3273, 3, 582, 291, 0, 3271, 3273, 3, 604, 302, 0, 3272, 3270, 1, 0, 0, 0, 3272, 3271, 1, 0, 0, 0, 3273, 521, 1, 0, 0, 0, 3274, 3277, 3, 584, 292, 0, 3275, 3277, 3, 604, 302, 0, 3276, 3274, 1, 0, 0, 0, 3276, 3275, 1, 0, 0, 0, 3277, 523, 1, 0, 0, 0, 3278, 3281, 3, 578, 289, 0, 3279, 3281, 3, 604, 302, 0, 3280, 3278, 1, 0, 0, 0, 3280, 3279, 1, 0, 0, 0, 3281, 525, 1, 0, 0, 0, 3282, 3285, 3, 580, 290, 0, 3283, 3285, 3, 604, 302, 0, 3284, 3282, 1, 0, 0, 0, 3284, 3283, 1, 0, 0, 0, 3285, 527, 1, 0, 0, 0, 3286, 3291, 3, 526, 263, 0, 3287, 3288, 5, 263, 0, 0, 3288, 3290, 3, 526, 263, 0, 3289, 3287, 1, 0, 0, 0, 3290, 3293, 1, 0, 0, 0, 3291, 3289, 1, 0, 0, 0, 3291, 3292, 1, 0, 0, 0, 3292, 3295, 1, 0, 0, 0, 3293, 3291, 1, 0, 0, 0, 3294, 3286, 1, 0, 0, 0, 3294, 3295, 1, 0, 0, 0, 3295, 529, 1, 0, 0, 0, 3296, 3299, 3, 590, 295, 0, 3297, 3299, 3, 604, 302, 0, 3298, 3296, 1, 0, 0, 0, 3298, 3297, 1, 0, 0, 0, 3299, 531, 1, 0, 0, 0, 3300, 3303, 3, 570, 285, 0, 3301, 3303, 3, 604, 302, 0, 3302, 3300, 1, 0, 0, 0, 3302, 3301, 1, 0, 0, 0, 3303, 533, 1, 0, 0, 0, 3304, 3309, 3, 532, 266, 0, 3305, 3306, 5, 263, 0, 0, 3306, 3308, 3, 532, 266, 0, 3307, 3305, 1, 0, 0, 0, 3308, 3311, 1, 0, 0, 0, 3309, 3307, 1, 0, 0, 0, 3309, 3310, 1, 0, 0, 0, 3310, 3313, 1, 0, 0, 0, 3311, 3309, 1, 0, 0, 0, 3312, 3304, 1, 0, 0, 0, 3312, 3313, 1, 0, 0, 0, 3313, 535, 1, 0, 0, 0, 3314, 3317, 3, 572, 286, 0, 3315, 3317, 3, 604, 302, 0, 3316, 3314, 1, 0, 0, 0, 3316, 3315, 1, 0, 0, 0, 3317, 537, 1, 0, 0, 0, 3318, 3321, 3, 562, 281, 0, 3319, 3321, 3, 604, 302, 0, 3320, 3318, 1, 0, 0, 0, 3320, 3319, 1, 0, 0, 0, 3321, 539, 1, 0, 0, 0, 3322, 3325, 3, 572, 286, 0, 3323, 3325, 3, 592, 296, 0, 3324, 3322, 1, 0, 0, 0, 3324, 3323, 1, 0, 0, 0, 3325, 541, 1, 0, 0, 0, 3326, 3329, 3, 326, 163, 0, 3327, 3329, 3, 604, 302, 0, 3328, 3326, 1, 0, 0, 0, 3328, 3327, 1, 0, 0, 0, 3329, 543, 1, 0, 0, 0, 3330, 3332, 3, 546, 273, 0, 3331, 3330, 1, 0, 0, 0, 3331, 3332, 1, 0, 0, 0, 3332, 545, 1, 0, 0, 0, 3333, 3338, 3, 328, 164, 0, 3334, 3335, 5, 263, 0, 0, 3335, 3337, 3, 328, 164, 0, 3336, 3334, 1, 0, 0, 0, 3337, 3340, 1, 0, 0, 0, 3338, 3336, 1, 0, 0, 0, 3338, 3339, 1, 0, 0, 0, 3339, 547, 1, 0, 0, 0, 3340, 3338, 1, 0, 0, 0, 3341, 3343, 3, 550, 275, 0, 3342, 3341, 1, 0, 0, 0, 3342, 3343, 1, 0, 0, 0, 3343, 549, 1, 0, 0, 0, 3344, 3349, 3, 602, 301, 0, 3345, 3346, 5, 263, 0, 0, 3346, 3348, 3, 602, 301, 0, 3347, 3345, 1, 0, 0, 0, 3348, 3351, 1, 0, 0, 0, 3349, 3347, 1, 0, 0, 0, 3349, 3350, 1, 0, 0, 0, 3350, 551, 1, 0, 0, 0, 3351, 3349, 1, 0, 0, 0, 3352, 3354, 3, 554, 277, 0, 3353, 3352, 1, 0, 0, 0, 3353, 3354, 1, 0, 0, 0, 3354, 553, 1, 0, 0, 0, 3355, 3360, 3, 52, 26, 0, 3356, 3357, 5, 263, 0, 0, 3357, 3359, 3, 52, 26, 0, 3358, 3356, 1, 0, 0, 0, 3359, 3362, 1, 0, 0, 0, 3360, 3358, 1, 0, 0, 0, 3360, 3361, 1, 0, 0, 0, 3361, 555, 1, 0, 0, 0, 3362, 3360, 1, 0, 0, 0, 3363, 3372, 5, 260, 0, 0, 3364, 3369, 3, 570, 285, 0, 3365, 3366, 5, 263, 0, 0, 3366, 3368, 3, 570, 285, 0, 3367, 3365, 1, 0, 0, 0, 3368, 3371, 1, 0, 0, 0, 3369, 3367, 1, 0, 0, 0, 3369, 3370, 1, 0, 0, 0, 3370, 3373, 1, 0, 0, 0, 3371, 3369, 1, 0, 0, 0, 3372, 3364, 1, 0, 0, 0, 3372, 3373, 1, 0, 0, 0, 3373, 3374, 1, 0, 0, 0, 3374, 3375, 5, 261, 0, 0, 3375, 557, 1, 0, 0, 0, 3376, 3378, 3, 560, 280, 0, 3377, 3376, 1, 0, 0, 0, 3377, 3378, 1, 0, 0, 0, 3378, 559, 1, 0, 0, 0, 3379, 3384, 3, 570, 285, 0, 3380, 3381, 5, 263, 0, 0, 3381, 3383, 3, 570, 285, 0, 3382, 3380, 1, 0, 0, 0, 3383, 3386, 1, 0, 0, 0, 3384, 3382, 1, 0, 0, 0, 3384, 3385, 1, 0, 0, 0, 3385, 561, 1, 0, 0, 0, 3386, 3384, 1, 0, 0, 0, 3387, 3390, 3, 572, 286, 0, 3388, 3390, 3, 592, 296, 0, 3389, 3387, 1, 0, 0, 0, 3389, 3388, 1, 0, 0, 0, 3390, 563, 1, 0, 0, 0, 3391, 3392, 3, 582, 291, 0, 3392, 3393, 5, 264, 0, 0, 3393, 3394, 5, 264, 0, 0, 3394, 3395, 3, 582, 291, 0, 3395, 3402, 1, 0, 0, 0, 3396, 3397, 3, 578, 289, 0, 3397, 3398, 5, 264, 0, 0, 3398, 3399, 5, 264, 0, 0, 3399, 3400, 3, 578, 289, 0, 3400, 3402, 1, 0, 0, 0, 3401, 3391, 1, 0, 0, 0, 3401, 3396, 1, 0, 0, 0, 3402, 565, 1, 0, 0, 0, 3403, 3412, 5, 258, 0, 0, 3404, 3409, 3, 570, 285, 0, 3405, 3406, 5, 263, 0, 0, 3406, 3408, 3, 570, 285, 0, 3407, 3405, 1, 0, 0, 0, 3408, 3411, 1, 0, 0, 0, 3409, 3407, 1, 0, 0, 0, 3409, 3410, 1, 0, 0, 0, 3410, 3413, 1, 0, 0, 0, 3411, 3409, 1, 0, 0, 0, 3412, 3404, 1, 0, 0, 0, 3412, 3413, 1, 0, 0, 0, 3413, 3414, 1, 0, 0, 0, 3414, 3415, 5, 259, 0, 0, 3415, 567, 1, 0, 0, 0, 3416, 3421, 3, 580, 290, 0, 3417, 3418, 5, 263, 0, 0, 3418, 3420, 3, 580, 290, 0, 3419, 3417, 1, 0, 0, 0, 3420, 3423, 1, 0, 0, 0, 3421, 3419, 1, 0, 0, 0, 3421, 3422, 1, 0, 0, 0, 3422, 3425, 1, 0, 0, 0, 3423, 3421, 1, 0, 0, 0, 3424, 3416, 1, 0, 0, 0, 3424, 3425, 1, 0, 0, 0, 3425, 569, 1, 0, 0, 0, 3426, 3446, 3, 586, 293, 0, 3427, 3446, 3, 588, 294, 0, 3428, 3446, 3, 578, 289, 0, 3429, 3446, 3, 590, 295, 0, 3430, 3446, 3, 592, 296, 0, 3431, 3446, 3, 336, 168, 0, 3432, 3446, 3, 352, 176, 0, 3433, 3446, 3, 346, 173, 0, 3434, 3446, 3, 342, 171, 0, 3435, 3446, 3, 360, 180, 0, 3436, 3446, 3, 362, 181, 0, 3437, 3446, 3, 326, 163, 0, 3438, 3446, 3, 566, 283, 0, 3439, 3446, 3, 556, 278, 0, 3440, 3446, 3, 564, 282, 0, 3441, 3446, 3, 52, 26, 0, 3442, 3446, 3, 54, 27, 0, 3443, 3446, 3, 598, 299, 0, 3444, 3446, 3, 572, 286, 0, 3445, 3426, 1, 0, 0, 0, 3445, 3427, 1, 0, 0, 0, 3445, 3428, 1, 0, 0, 0, 3445, 3429, 1, 0, 0, 0, 3445, 3430, 1, 0, 0, 0, 3445, 3431, 1, 0, 0, 0, 3445, 3432, 1, 0, 0, 0, 3445, 3433, 1, 0, 0, 0, 3445, 3434, 1, 0, 0, 0, 3445, 3435, 1, 0, 0, 0, 3445, 3436, 1, 0, 0, 0, 3445, 3437, 1, 0, 0, 0, 3445, 3438, 1, 0, 0, 0, 3445, 3439, 1, 0, 0, 0, 3445, 3440, 1, 0, 0, 0, 3445, 3441, 1, 0, 0, 0, 3445, 3442, 1, 0, 0, 0, 3445, 3443, 1, 0, 0, 0, 3445, 3444, 1, 0, 0, 0, 3446, 571, 1, 0, 0, 0, 3447, 3448, 5, 260, 0, 0, 3448, 3449, 5, 265, 0, 0, 3449, 3462, 5, 261, 0, 0, 3450, 3451, 5, 260, 0, 0, 3451, 3456, 3, 576, 288, 0, 3452, 3453, 5, 263, 0, 0, 3453, 3455, 3, 576, 288, 0, 3454, 3452, 1, 0, 0, 0, 3455, 3458, 1, 0, 0, 0, 3456, 3454, 1, 0, 0, 0, 3456, 3457, 1, 0, 0, 0, 3457, 3459, 1, 0, 0, 0, 3458, 3456, 1, 0, 0, 0, 3459, 3460, 5, 261, 0, 0, 3460, 3462, 1, 0, 0, 0, 3461, 3447, 1, 0, 0, 0, 3461, 3450, 1, 0, 0, 0, 3462, 573, 1, 0, 0, 0, 3463, 3464, 5, 256, 0, 0, 3464, 3465, 3, 336, 168, 0, 3465, 3466, 5, 257, 0, 0, 3466, 3469, 1, 0, 0, 0, 3467, 3469, 3, 340, 170, 0, 3468, 3463, 1, 0, 0, 0, 3468, 3467, 1, 0, 0, 0, 3469, 3517, 1, 0, 0, 0, 3470, 3471, 5, 256, 0, 0, 3471, 3472, 3, 346, 173, 0, 3472, 3473, 5, 257, 0, 0, 3473, 3476, 1, 0, 0, 0, 3474, 3476, 3, 350, 175, 0, 3475, 3470, 1, 0, 0, 0, 3475, 3474, 1, 0, 0, 0, 3476, 3517, 1, 0, 0, 0, 3477, 3478, 5, 256, 0, 0, 3478, 3479, 3, 566, 283, 0, 3479, 3480, 5, 257, 0, 0, 3480, 3483, 1, 0, 0, 0, 3481, 3483, 3, 566, 283, 0, 3482, 3477, 1, 0, 0, 0, 3482, 3481, 1, 0, 0, 0, 3483, 3517, 1, 0, 0, 0, 3484, 3485, 5, 256, 0, 0, 3485, 3486, 3, 556, 278, 0, 3486, 3487, 5, 257, 0, 0, 3487, 3490, 1, 0, 0, 0, 3488, 3490, 3, 556, 278, 0, 3489, 3484, 1, 0, 0, 0, 3489, 3488, 1, 0, 0, 0, 3490, 3517, 1, 0, 0, 0, 3491, 3492, 5, 256, 0, 0, 3492, 3493, 3, 572, 286, 0, 3493, 3494, 5, 257, 0, 0, 3494, 3497, 1, 0, 0, 0, 3495, 3497, 3, 572, 286, 0, 3496, 3491, 1, 0, 0, 0, 3496, 3495, 1, 0, 0, 0, 3497, 3517, 1, 0, 0, 0, 3498, 3499, 5, 256, 0, 0, 3499, 3500, 3, 578, 289, 0, 3500, 3501, 5, 257, 0, 0, 3501, 3504, 1, 0, 0, 0, 3502, 3504, 3, 578, 289, 0, 3503, 3498, 1, 0, 0, 0, 3503, 3502, 1, 0, 0, 0, 3504, 3517, 1, 0, 0, 0, 3505, 3506, 5, 256, 0, 0, 3506, 3507, 3, 586, 293, 0, 3507, 3508, 5, 257, 0, 0, 3508, 3511, 1, 0, 0, 0, 3509, 3511, 3, 586, 293, 0, 3510, 3505, 1, 0, 0, 0, 3510, 3509, 1, 0, 0, 0, 3511, 3517, 1, 0, 0, 0, 3512, 3515, 3, 606, 303, 0, 3513, 3515, 3, 600, 300, 0, 3514, 3512, 1, 0, 0, 0, 3514, 3513, 1, 0, 0, 0, 3515, 3517, 1, 0, 0, 0, 3516, 3468, 1, 0, 0, 0, 3516, 3475, 1, 0, 0, 0, 3516, 3482, 1, 0, 0, 0, 3516, 3489, 1, 0, 0, 0, 3516, 3496, 1, 0, 0, 0, 3516, 3503, 1, 0, 0, 0, 3516, 3510, 1, 0, 0, 0, 3516, 3514, 1, 0, 0, 0, 3517, 575, 1, 0, 0, 0, 3518, 3519, 3, 574, 287, 0, 3519, 3520, 5, 265, 0, 0, 3520, 3521, 3, 570, 285, 0, 3521, 577, 1, 0, 0, 0, 3522, 3523, 7, 3, 0, 0, 3523, 579, 1, 0, 0, 0, 3524, 3525, 7, 4, 0, 0, 3525, 581, 1, 0, 0, 0, 3526, 3527, 5, 251, 0, 0, 3527, 583, 1, 0, 0, 0, 3528, 3532, 5, 252, 0, 0, 3529, 3532, 3, 596, 298, 0, 3530, 3532, 3, 594, 297, 0, 3531, 3528, 1, 0, 0, 0, 3531, 3529, 1, 0, 0, 0, 3531, 3530, 1, 0, 0, 0, 3532, 585, 1, 0, 0, 0, 3533, 3536, 3, 582, 291, 0, 3534, 3536, 3, 584, 292, 0, 3535, 3533, 1, 0, 0, 0, 3535, 3534, 1, 0, 0, 0, 3536, 587, 1, 0, 0, 0, 3537, 3538, 7, 5, 0, 0, 3538, 589, 1, 0, 0, 0, 3539, 3540, 5, 45, 0, 0, 3540, 3541, 5, 256, 0, 0, 3541, 3542, 3, 524, 262, 0, 3542, 3543, 5, 257, 0, 0, 3543, 3556, 1, 0, 0, 0, 3544, 3545, 5, 45, 0, 0, 3545, 3546, 5, 256, 0, 0, 3546, 3556, 5, 257, 0, 0, 3547, 3548, 5, 46, 0, 0, 3548, 3549, 5, 256, 0, 0, 3549, 3550, 3, 524, 262, 0, 3550, 3551, 5, 257, 0, 0, 3551, 3556, 1, 0, 0, 0, 3552, 3553, 5, 46, 0, 0, 3553, 3554, 5, 256, 0, 0, 3554, 3556, 5, 257, 0, 0, 3555, 3539, 1, 0, 0, 0, 3555, 3544, 1, 0, 0, 0, 3555, 3547, 1, 0, 0, 0, 3555, 3552, 1, 0, 0, 0, 3556, 591, 1, 0, 0, 0, 3557, 3558, 5, 148, 0, 0, 3558, 593, 1, 0, 0, 0, 3559, 3560, 5, 136, 0, 0, 3560, 595, 1, 0, 0, 0, 3561, 3562, 7, 6, 0, 0, 3562, 597, 1, 0, 0, 0, 3563, 3564, 5, 232, 0, 0, 3564, 3565, 5, 256, 0, 0, 3565, 3572, 5, 257, 0, 0, 3566, 3567, 5, 232, 0, 0, 3567, 3568, 5, 256, 0, 0, 3568, 3569, 3, 578, 289, 0, 3569, 3570, 5, 257, 0, 0, 3570, 3572, 1, 0, 0, 0, 3571, 3563, 1, 0, 0, 0, 3571, 3566, 1, 0, 0, 0, 3572, 599, 1, 0, 0, 0, 3573, 3574, 5, 270, 0, 0, 3574, 601, 1, 0, 0, 0, 3575, 3576, 5, 270, 0, 0, 3576, 603, 1, 0, 0, 0, 3577, 3578, 5, 270, 0, 0, 3578, 605, 1, 0, 0, 0, 3579, 3580, 7, 7, 0, 0, 3580, 607, 1, 0, 0, 0, 211, 610, 615, 619, 635, 644, 654, 661, 685, 697, 706, 729, 747, 754, 763, 779, 791, 803, 818, 850, 862, 895, 910, 917, 1057, 1079, 1094, 1108, 1130, 1146, 1161, 1236, 1266, 1273, 1319, 1341, 1350, 1374, 1397, 1404, 1413, 1455, 1465, 1477, 1494, 1516, 1526, 1536, 1603, 1610, 1619, 1631, 1635, 1647, 1651, 1663, 1672, 1720, 1738, 1752, 1767, 1777, 1802, 1812, 1832, 1847, 1857, 1911, 1931, 1959, 1982, 1989, 2007, 2025, 2034, 2057, 2075, 2093, 2107, 2117, 2131, 2154, 2177, 2186, 2213, 2227, 2267, 2277, 2299, 2316, 2335, 2342, 2354, 2364, 2379, 2389, 2410, 2426, 2430, 2454, 2460, 2468, 2474, 2478, 2485, 2495, 2504, 2507, 2510, 2514, 2527, 2533, 2537, 2553, 2571, 2585, 2589, 2608, 2614, 2624, 2634, 2652, 2662, 2680, 2726, 2736, 2754, 2777, 2798, 2800, 2811, 2819, 2827, 2837, 2847, 2857, 2867, 2877, 2887, 2899, 2911, 2923, 2931, 2937, 2943, 2951, 2957, 2963, 2973, 2983, 2993, 3003, 3013, 3023, 3033, 3043, 3073, 3094, 3099, 3104, 3109, 3116, 3127, 3131, 3136, 3268, 3272, 3276, 3280, 3284, 3291, 3294, 3298, 3302, 3309, 3312, 3316, 3320, 3324, 3328, 3331, 3338, 3342, 3349, 3353, 3360, 3369, 3372, 3377, 3384, 3389, 3401, 3409, 3412, 3421, 3424, 3445, 3456, 3461, 3468, 3475, 3482, 3489, 3496, 3503, 3510, 3514, 3516, 3531, 3535, 3555, 3571] \ No newline at end of file diff --git a/text2gremlin/AST_Text2Gremlin/base/gremlin/Gremlin.tokens b/text2gremlin/AST_Text2Gremlin/base/gremlin/Gremlin.tokens new file mode 100644 index 000000000..0b40f3f1c --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/gremlin/Gremlin.tokens @@ -0,0 +1,532 @@ +T__0=1 +K_ADDALL=2 +K_ADDE=3 +K_ADDV=4 +K_AGGREGATE=5 +K_ALL=6 +K_AND=7 +K_ANY=8 +K_AS=9 +K_ASC=10 +K_ASDATE=11 +K_ASSTRING=12 +K_ASSIGN=13 +K_BARRIER=14 +K_BARRIERU=15 +K_BEGIN=16 +K_BETWEEN=17 +K_BOTH=18 +K_BOTHU=19 +K_BOTHE=20 +K_BOTHV=21 +K_BRANCH=22 +K_BY=23 +K_CALL=24 +K_CAP=25 +K_CARDINALITY=26 +K_CHOOSE=27 +K_COALESCE=28 +K_COIN=29 +K_COLUMN=30 +K_COMBINE=31 +K_COMMIT=32 +K_COMPONENT=33 +K_CONCAT=34 +K_CONJOIN=35 +K_CONNECTEDCOMPONENT=36 +K_CONNECTEDCOMPONENTU=37 +K_CONSTANT=38 +K_CONTAINING=39 +K_COUNT=40 +K_CYCLICPATH=41 +K_DAY=42 +K_DATEADD=43 +K_DATEDIFF=44 +K_DATETIME=45 +K_DATETIMEU=46 +K_DECR=47 +K_DEDUP=48 +K_DESC=49 +K_DIFFERENCE=50 +K_DIRECTION=51 +K_DISJUNCT=52 +K_DISTANCE=53 +K_DIV=54 +K_DROP=55 +K_DT=56 +K_E=57 +K_EDGES=58 +K_ELEMENTMAP=59 +K_ELEMENT=60 +K_EMIT=61 +K_ENDINGWITH=62 +K_EQ=63 +K_EXPLAIN=64 +K_FAIL=65 +K_FALSE=66 +K_FILTER=67 +K_FIRST=68 +K_FLATMAP=69 +K_FOLD=70 +K_FORMAT=71 +K_FROM=72 +K_GLOBAL=73 +K_GT=74 +K_GTE=75 +K_GRAPHML=76 +K_GRAPHSON=77 +K_GROUPCOUNT=78 +K_GROUP=79 +K_GRYO=80 +K_HAS=81 +K_HASID=82 +K_HASKEY=83 +K_HASLABEL=84 +K_HASNEXT=85 +K_HASNOT=86 +K_HASVALUE=87 +K_HOUR=88 +K_ID=89 +K_IDENTITY=90 +K_IDS=91 +K_IN=92 +K_INU=93 +K_INE=94 +K_INCLUDEEDGES=95 +K_INCR=96 +K_INDEXER=97 +K_INDEX=98 +K_INFINITY=99 +K_INJECT=100 +K_INSIDE=101 +K_INTERSECT=102 +K_INV=103 +K_IOU=104 +K_IO=105 +K_IS=106 +K_ITERATE=107 +K_KEY=108 +K_KEYS=109 +K_LABELS=110 +K_LABEL=111 +K_LAST=112 +K_LENGTH=113 +K_LIMIT=114 +K_LIST=115 +K_LOCAL=116 +K_LOOPS=117 +K_LT=118 +K_LTE=119 +K_LTRIM=120 +K_MAP=121 +K_MATCH=122 +K_MATH=123 +K_MAX=124 +K_MAXDISTANCE=125 +K_MEAN=126 +K_MERGEU=127 +K_MERGE=128 +K_MERGEE=129 +K_MERGEV=130 +K_MIN=131 +K_MINUTE=132 +K_MINUS=133 +K_MIXED=134 +K_MULT=135 +K_NAN=136 +K_NEGATE=137 +K_NEXT=138 +K_NONE=139 +K_NOTREGEX=140 +K_NOTCONTAINING=141 +K_NOTENDINGWITH=142 +K_NOTSTARTINGWITH=143 +K_NOT=144 +K_NEQ=145 +K_NEW=146 +K_NORMSACK=147 +K_NULL=148 +K_ONCREATE=149 +K_ONMATCH=150 +K_OPERATOR=151 +K_OPTION=152 +K_OPTIONAL=153 +K_ORDERU=154 +K_ORDER=155 +K_OR=156 +K_OTHERV=157 +K_OUTU=158 +K_OUT=159 +K_OUTE=160 +K_OUTSIDE=161 +K_OUTV=162 +K_P=163 +K_PAGERANKU=164 +K_PAGERANK=165 +K_PATH=166 +K_PEERPRESSUREU=167 +K_PEERPRESSURE=168 +K_PICK=169 +K_POP=170 +K_PROFILE=171 +K_PROJECT=172 +K_PROPERTIES=173 +K_PROPERTYMAP=174 +K_PROPERTYNAME=175 +K_PROPERTY=176 +K_PRODUCT=177 +K_RANGE=178 +K_READ=179 +K_READER=180 +K_REFERENCEVERTEX=181 +K_REGEX=182 +K_REPLACE=183 +K_REPEAT=184 +K_REVERSE=185 +K_ROLLBACK=186 +K_RTRIM=187 +K_SACK=188 +K_SAMPLE=189 +K_SCOPE=190 +K_SECOND=191 +K_SELECT=192 +K_SET=193 +K_SHORTESTPATHU=194 +K_SHORTESTPATH=195 +K_SHUFFLE=196 +K_SIDEEFFECT=197 +K_SIMPLEPATH=198 +K_SINGLE=199 +K_SKIP=200 +K_SPLIT=201 +K_STARTINGWITH=202 +K_STORE=203 +K_SUBGRAPH=204 +K_SUBSTRING=205 +K_SUM=206 +K_SUMLONG=207 +K_T=208 +K_TAIL=209 +K_TARGET=210 +K_TEXTP=211 +K_TIMELIMIT=212 +K_TIMES=213 +K_TO=214 +K_TOBULKSET=215 +K_TOKENS=216 +K_TOLIST=217 +K_TOLOWER=218 +K_TOSET=219 +K_TOSTRING=220 +K_TOUPPER=221 +K_TOE=222 +K_TOV=223 +K_TREE=224 +K_TRIM=225 +K_TRUE=226 +K_TRYNEXT=227 +K_TX=228 +K_UNFOLD=229 +K_UNION=230 +K_UNTIL=231 +K_UUID=232 +K_V=233 +K_VALUEMAP=234 +K_VALUES=235 +K_VALUE=236 +K_VERTEX=237 +K_WHERE=238 +K_WITH=239 +K_WITHBULK=240 +K_WITHIN=241 +K_WITHOPTOPTIONS=242 +K_WITHOUT=243 +K_WITHOUTSTRATEGIES=244 +K_WITHPATH=245 +K_WITHSACK=246 +K_WITHSIDEEFFECT=247 +K_WITHSTRATEGIES=248 +K_WRITE=249 +K_WRITER=250 +IntegerLiteral=251 +FloatingPointLiteral=252 +SignedInfLiteral=253 +NonEmptyStringLiteral=254 +EmptyStringLiteral=255 +LPAREN=256 +RPAREN=257 +LBRACE=258 +RBRACE=259 +LBRACK=260 +RBRACK=261 +SEMI=262 +COMMA=263 +DOT=264 +COLON=265 +TRAVERSAL_ROOT=266 +ANON_TRAVERSAL_ROOT=267 +WS=268 +LINE_COMMENT=269 +Identifier=270 +'discard'=1 +'addAll'=2 +'addE'=3 +'addV'=4 +'aggregate'=5 +'all'=6 +'and'=7 +'any'=8 +'as'=9 +'asc'=10 +'asDate'=11 +'asString'=12 +'assign'=13 +'barrier'=14 +'Barrier'=15 +'begin'=16 +'between'=17 +'both'=18 +'BOTH'=19 +'bothE'=20 +'bothV'=21 +'branch'=22 +'by'=23 +'call'=24 +'cap'=25 +'Cardinality'=26 +'choose'=27 +'coalesce'=28 +'coin'=29 +'Column'=30 +'combine'=31 +'commit'=32 +'component'=33 +'concat'=34 +'conjoin'=35 +'connectedComponent'=36 +'ConnectedComponent'=37 +'constant'=38 +'containing'=39 +'count'=40 +'cyclicPath'=41 +'day'=42 +'dateAdd'=43 +'dateDiff'=44 +'datetime'=45 +'DateTime'=46 +'decr'=47 +'dedup'=48 +'desc'=49 +'difference'=50 +'Direction'=51 +'disjunct'=52 +'distance'=53 +'div'=54 +'drop'=55 +'DT'=56 +'E'=57 +'edges'=58 +'elementMap'=59 +'element'=60 +'emit'=61 +'endingWith'=62 +'eq'=63 +'explain'=64 +'fail'=65 +'false'=66 +'filter'=67 +'first'=68 +'flatMap'=69 +'fold'=70 +'format'=71 +'from'=72 +'global'=73 +'gt'=74 +'gte'=75 +'graphml'=76 +'graphson'=77 +'groupCount'=78 +'group'=79 +'gryo'=80 +'has'=81 +'hasId'=82 +'hasKey'=83 +'hasLabel'=84 +'hasNext'=85 +'hasNot'=86 +'hasValue'=87 +'hour'=88 +'id'=89 +'identity'=90 +'ids'=91 +'in'=92 +'IN'=93 +'inE'=94 +'includeEdges'=95 +'incr'=96 +'indexer'=97 +'index'=98 +'Infinity'=99 +'inject'=100 +'inside'=101 +'intersect'=102 +'inV'=103 +'IO'=104 +'io'=105 +'is'=106 +'iterate'=107 +'key'=108 +'keys'=109 +'labels'=110 +'label'=111 +'last'=112 +'length'=113 +'limit'=114 +'list'=115 +'local'=116 +'loops'=117 +'lt'=118 +'lte'=119 +'lTrim'=120 +'map'=121 +'match'=122 +'math'=123 +'max'=124 +'maxDistance'=125 +'mean'=126 +'Merge'=127 +'merge'=128 +'mergeE'=129 +'mergeV'=130 +'min'=131 +'minute'=132 +'minus'=133 +'mixed'=134 +'mult'=135 +'NaN'=136 +'negate'=137 +'next'=138 +'none'=139 +'notRegex'=140 +'notContaining'=141 +'notEndingWith'=142 +'notStartingWith'=143 +'not'=144 +'neq'=145 +'new'=146 +'normSack'=147 +'null'=148 +'onCreate'=149 +'onMatch'=150 +'Operator'=151 +'option'=152 +'optional'=153 +'Order'=154 +'order'=155 +'or'=156 +'otherV'=157 +'OUT'=158 +'out'=159 +'outE'=160 +'outside'=161 +'outV'=162 +'P'=163 +'PageRank'=164 +'pageRank'=165 +'path'=166 +'PeerPressure'=167 +'peerPressure'=168 +'Pick'=169 +'Pop'=170 +'profile'=171 +'project'=172 +'properties'=173 +'propertyMap'=174 +'propertyName'=175 +'property'=176 +'product'=177 +'range'=178 +'read'=179 +'reader'=180 +'ReferenceVertex'=181 +'regex'=182 +'replace'=183 +'repeat'=184 +'reverse'=185 +'rollback'=186 +'rTrim'=187 +'sack'=188 +'sample'=189 +'Scope'=190 +'second'=191 +'select'=192 +'set'=193 +'ShortestPath'=194 +'shortestPath'=195 +'shuffle'=196 +'sideEffect'=197 +'simplePath'=198 +'single'=199 +'skip'=200 +'split'=201 +'startingWith'=202 +'store'=203 +'subgraph'=204 +'substring'=205 +'sum'=206 +'sumLong'=207 +'T'=208 +'tail'=209 +'target'=210 +'TextP'=211 +'timeLimit'=212 +'times'=213 +'to'=214 +'toBulkSet'=215 +'tokens'=216 +'toList'=217 +'toLower'=218 +'toSet'=219 +'toString'=220 +'toUpper'=221 +'toE'=222 +'toV'=223 +'tree'=224 +'trim'=225 +'true'=226 +'tryNext'=227 +'tx'=228 +'unfold'=229 +'union'=230 +'until'=231 +'UUID'=232 +'V'=233 +'valueMap'=234 +'values'=235 +'value'=236 +'Vertex'=237 +'where'=238 +'with'=239 +'withBulk'=240 +'within'=241 +'WithOptions'=242 +'without'=243 +'withoutStrategies'=244 +'withPath'=245 +'withSack'=246 +'withSideEffect'=247 +'withStrategies'=248 +'write'=249 +'writer'=250 +'('=256 +')'=257 +'{'=258 +'}'=259 +'['=260 +']'=261 +';'=262 +','=263 +'.'=264 +':'=265 +'g'=266 +'__'=267 diff --git a/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinLexer.interp b/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinLexer.interp new file mode 100644 index 000000000..9e9f13af1 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinLexer.interp @@ -0,0 +1,865 @@ +token literal names: +null +'discard' +'addAll' +'addE' +'addV' +'aggregate' +'all' +'and' +'any' +'as' +'asc' +'asDate' +'asString' +'assign' +'barrier' +'Barrier' +'begin' +'between' +'both' +'BOTH' +'bothE' +'bothV' +'branch' +'by' +'call' +'cap' +'Cardinality' +'choose' +'coalesce' +'coin' +'Column' +'combine' +'commit' +'component' +'concat' +'conjoin' +'connectedComponent' +'ConnectedComponent' +'constant' +'containing' +'count' +'cyclicPath' +'day' +'dateAdd' +'dateDiff' +'datetime' +'DateTime' +'decr' +'dedup' +'desc' +'difference' +'Direction' +'disjunct' +'distance' +'div' +'drop' +'DT' +'E' +'edges' +'elementMap' +'element' +'emit' +'endingWith' +'eq' +'explain' +'fail' +'false' +'filter' +'first' +'flatMap' +'fold' +'format' +'from' +'global' +'gt' +'gte' +'graphml' +'graphson' +'groupCount' +'group' +'gryo' +'has' +'hasId' +'hasKey' +'hasLabel' +'hasNext' +'hasNot' +'hasValue' +'hour' +'id' +'identity' +'ids' +'in' +'IN' +'inE' +'includeEdges' +'incr' +'indexer' +'index' +'Infinity' +'inject' +'inside' +'intersect' +'inV' +'IO' +'io' +'is' +'iterate' +'key' +'keys' +'labels' +'label' +'last' +'length' +'limit' +'list' +'local' +'loops' +'lt' +'lte' +'lTrim' +'map' +'match' +'math' +'max' +'maxDistance' +'mean' +'Merge' +'merge' +'mergeE' +'mergeV' +'min' +'minute' +'minus' +'mixed' +'mult' +'NaN' +'negate' +'next' +'none' +'notRegex' +'notContaining' +'notEndingWith' +'notStartingWith' +'not' +'neq' +'new' +'normSack' +'null' +'onCreate' +'onMatch' +'Operator' +'option' +'optional' +'Order' +'order' +'or' +'otherV' +'OUT' +'out' +'outE' +'outside' +'outV' +'P' +'PageRank' +'pageRank' +'path' +'PeerPressure' +'peerPressure' +'Pick' +'Pop' +'profile' +'project' +'properties' +'propertyMap' +'propertyName' +'property' +'product' +'range' +'read' +'reader' +'ReferenceVertex' +'regex' +'replace' +'repeat' +'reverse' +'rollback' +'rTrim' +'sack' +'sample' +'Scope' +'second' +'select' +'set' +'ShortestPath' +'shortestPath' +'shuffle' +'sideEffect' +'simplePath' +'single' +'skip' +'split' +'startingWith' +'store' +'subgraph' +'substring' +'sum' +'sumLong' +'T' +'tail' +'target' +'TextP' +'timeLimit' +'times' +'to' +'toBulkSet' +'tokens' +'toList' +'toLower' +'toSet' +'toString' +'toUpper' +'toE' +'toV' +'tree' +'trim' +'true' +'tryNext' +'tx' +'unfold' +'union' +'until' +'UUID' +'V' +'valueMap' +'values' +'value' +'Vertex' +'where' +'with' +'withBulk' +'within' +'WithOptions' +'without' +'withoutStrategies' +'withPath' +'withSack' +'withSideEffect' +'withStrategies' +'write' +'writer' +null +null +null +null +null +'(' +')' +'{' +'}' +'[' +']' +';' +',' +'.' +':' +'g' +'__' +null +null +null + +token symbolic names: +null +null +K_ADDALL +K_ADDE +K_ADDV +K_AGGREGATE +K_ALL +K_AND +K_ANY +K_AS +K_ASC +K_ASDATE +K_ASSTRING +K_ASSIGN +K_BARRIER +K_BARRIERU +K_BEGIN +K_BETWEEN +K_BOTH +K_BOTHU +K_BOTHE +K_BOTHV +K_BRANCH +K_BY +K_CALL +K_CAP +K_CARDINALITY +K_CHOOSE +K_COALESCE +K_COIN +K_COLUMN +K_COMBINE +K_COMMIT +K_COMPONENT +K_CONCAT +K_CONJOIN +K_CONNECTEDCOMPONENT +K_CONNECTEDCOMPONENTU +K_CONSTANT +K_CONTAINING +K_COUNT +K_CYCLICPATH +K_DAY +K_DATEADD +K_DATEDIFF +K_DATETIME +K_DATETIMEU +K_DECR +K_DEDUP +K_DESC +K_DIFFERENCE +K_DIRECTION +K_DISJUNCT +K_DISTANCE +K_DIV +K_DROP +K_DT +K_E +K_EDGES +K_ELEMENTMAP +K_ELEMENT +K_EMIT +K_ENDINGWITH +K_EQ +K_EXPLAIN +K_FAIL +K_FALSE +K_FILTER +K_FIRST +K_FLATMAP +K_FOLD +K_FORMAT +K_FROM +K_GLOBAL +K_GT +K_GTE +K_GRAPHML +K_GRAPHSON +K_GROUPCOUNT +K_GROUP +K_GRYO +K_HAS +K_HASID +K_HASKEY +K_HASLABEL +K_HASNEXT +K_HASNOT +K_HASVALUE +K_HOUR +K_ID +K_IDENTITY +K_IDS +K_IN +K_INU +K_INE +K_INCLUDEEDGES +K_INCR +K_INDEXER +K_INDEX +K_INFINITY +K_INJECT +K_INSIDE +K_INTERSECT +K_INV +K_IOU +K_IO +K_IS +K_ITERATE +K_KEY +K_KEYS +K_LABELS +K_LABEL +K_LAST +K_LENGTH +K_LIMIT +K_LIST +K_LOCAL +K_LOOPS +K_LT +K_LTE +K_LTRIM +K_MAP +K_MATCH +K_MATH +K_MAX +K_MAXDISTANCE +K_MEAN +K_MERGEU +K_MERGE +K_MERGEE +K_MERGEV +K_MIN +K_MINUTE +K_MINUS +K_MIXED +K_MULT +K_NAN +K_NEGATE +K_NEXT +K_NONE +K_NOTREGEX +K_NOTCONTAINING +K_NOTENDINGWITH +K_NOTSTARTINGWITH +K_NOT +K_NEQ +K_NEW +K_NORMSACK +K_NULL +K_ONCREATE +K_ONMATCH +K_OPERATOR +K_OPTION +K_OPTIONAL +K_ORDERU +K_ORDER +K_OR +K_OTHERV +K_OUTU +K_OUT +K_OUTE +K_OUTSIDE +K_OUTV +K_P +K_PAGERANKU +K_PAGERANK +K_PATH +K_PEERPRESSUREU +K_PEERPRESSURE +K_PICK +K_POP +K_PROFILE +K_PROJECT +K_PROPERTIES +K_PROPERTYMAP +K_PROPERTYNAME +K_PROPERTY +K_PRODUCT +K_RANGE +K_READ +K_READER +K_REFERENCEVERTEX +K_REGEX +K_REPLACE +K_REPEAT +K_REVERSE +K_ROLLBACK +K_RTRIM +K_SACK +K_SAMPLE +K_SCOPE +K_SECOND +K_SELECT +K_SET +K_SHORTESTPATHU +K_SHORTESTPATH +K_SHUFFLE +K_SIDEEFFECT +K_SIMPLEPATH +K_SINGLE +K_SKIP +K_SPLIT +K_STARTINGWITH +K_STORE +K_SUBGRAPH +K_SUBSTRING +K_SUM +K_SUMLONG +K_T +K_TAIL +K_TARGET +K_TEXTP +K_TIMELIMIT +K_TIMES +K_TO +K_TOBULKSET +K_TOKENS +K_TOLIST +K_TOLOWER +K_TOSET +K_TOSTRING +K_TOUPPER +K_TOE +K_TOV +K_TREE +K_TRIM +K_TRUE +K_TRYNEXT +K_TX +K_UNFOLD +K_UNION +K_UNTIL +K_UUID +K_V +K_VALUEMAP +K_VALUES +K_VALUE +K_VERTEX +K_WHERE +K_WITH +K_WITHBULK +K_WITHIN +K_WITHOPTOPTIONS +K_WITHOUT +K_WITHOUTSTRATEGIES +K_WITHPATH +K_WITHSACK +K_WITHSIDEEFFECT +K_WITHSTRATEGIES +K_WRITE +K_WRITER +IntegerLiteral +FloatingPointLiteral +SignedInfLiteral +NonEmptyStringLiteral +EmptyStringLiteral +LPAREN +RPAREN +LBRACE +RBRACE +LBRACK +RBRACK +SEMI +COMMA +DOT +COLON +TRAVERSAL_ROOT +ANON_TRAVERSAL_ROOT +WS +LINE_COMMENT +Identifier + +rule names: +T__0 +K_ADDALL +K_ADDE +K_ADDV +K_AGGREGATE +K_ALL +K_AND +K_ANY +K_AS +K_ASC +K_ASDATE +K_ASSTRING +K_ASSIGN +K_BARRIER +K_BARRIERU +K_BEGIN +K_BETWEEN +K_BOTH +K_BOTHU +K_BOTHE +K_BOTHV +K_BRANCH +K_BY +K_CALL +K_CAP +K_CARDINALITY +K_CHOOSE +K_COALESCE +K_COIN +K_COLUMN +K_COMBINE +K_COMMIT +K_COMPONENT +K_CONCAT +K_CONJOIN +K_CONNECTEDCOMPONENT +K_CONNECTEDCOMPONENTU +K_CONSTANT +K_CONTAINING +K_COUNT +K_CYCLICPATH +K_DAY +K_DATEADD +K_DATEDIFF +K_DATETIME +K_DATETIMEU +K_DECR +K_DEDUP +K_DESC +K_DIFFERENCE +K_DIRECTION +K_DISJUNCT +K_DISTANCE +K_DIV +K_DROP +K_DT +K_E +K_EDGES +K_ELEMENTMAP +K_ELEMENT +K_EMIT +K_ENDINGWITH +K_EQ +K_EXPLAIN +K_FAIL +K_FALSE +K_FILTER +K_FIRST +K_FLATMAP +K_FOLD +K_FORMAT +K_FROM +K_GLOBAL +K_GT +K_GTE +K_GRAPHML +K_GRAPHSON +K_GROUPCOUNT +K_GROUP +K_GRYO +K_HAS +K_HASID +K_HASKEY +K_HASLABEL +K_HASNEXT +K_HASNOT +K_HASVALUE +K_HOUR +K_ID +K_IDENTITY +K_IDS +K_IN +K_INU +K_INE +K_INCLUDEEDGES +K_INCR +K_INDEXER +K_INDEX +K_INFINITY +K_INJECT +K_INSIDE +K_INTERSECT +K_INV +K_IOU +K_IO +K_IS +K_ITERATE +K_KEY +K_KEYS +K_LABELS +K_LABEL +K_LAST +K_LENGTH +K_LIMIT +K_LIST +K_LOCAL +K_LOOPS +K_LT +K_LTE +K_LTRIM +K_MAP +K_MATCH +K_MATH +K_MAX +K_MAXDISTANCE +K_MEAN +K_MERGEU +K_MERGE +K_MERGEE +K_MERGEV +K_MIN +K_MINUTE +K_MINUS +K_MIXED +K_MULT +K_NAN +K_NEGATE +K_NEXT +K_NONE +K_NOTREGEX +K_NOTCONTAINING +K_NOTENDINGWITH +K_NOTSTARTINGWITH +K_NOT +K_NEQ +K_NEW +K_NORMSACK +K_NULL +K_ONCREATE +K_ONMATCH +K_OPERATOR +K_OPTION +K_OPTIONAL +K_ORDERU +K_ORDER +K_OR +K_OTHERV +K_OUTU +K_OUT +K_OUTE +K_OUTSIDE +K_OUTV +K_P +K_PAGERANKU +K_PAGERANK +K_PATH +K_PEERPRESSUREU +K_PEERPRESSURE +K_PICK +K_POP +K_PROFILE +K_PROJECT +K_PROPERTIES +K_PROPERTYMAP +K_PROPERTYNAME +K_PROPERTY +K_PRODUCT +K_RANGE +K_READ +K_READER +K_REFERENCEVERTEX +K_REGEX +K_REPLACE +K_REPEAT +K_REVERSE +K_ROLLBACK +K_RTRIM +K_SACK +K_SAMPLE +K_SCOPE +K_SECOND +K_SELECT +K_SET +K_SHORTESTPATHU +K_SHORTESTPATH +K_SHUFFLE +K_SIDEEFFECT +K_SIMPLEPATH +K_SINGLE +K_SKIP +K_SPLIT +K_STARTINGWITH +K_STORE +K_SUBGRAPH +K_SUBSTRING +K_SUM +K_SUMLONG +K_T +K_TAIL +K_TARGET +K_TEXTP +K_TIMELIMIT +K_TIMES +K_TO +K_TOBULKSET +K_TOKENS +K_TOLIST +K_TOLOWER +K_TOSET +K_TOSTRING +K_TOUPPER +K_TOE +K_TOV +K_TREE +K_TRIM +K_TRUE +K_TRYNEXT +K_TX +K_UNFOLD +K_UNION +K_UNTIL +K_UUID +K_V +K_VALUEMAP +K_VALUES +K_VALUE +K_VERTEX +K_WHERE +K_WITH +K_WITHBULK +K_WITHIN +K_WITHOPTOPTIONS +K_WITHOUT +K_WITHOUTSTRATEGIES +K_WITHPATH +K_WITHSACK +K_WITHSIDEEFFECT +K_WITHSTRATEGIES +K_WRITE +K_WRITER +IntegerLiteral +DecimalIntegerLiteral +HexIntegerLiteral +OctalIntegerLiteral +IntegerTypeSuffix +DecimalNumeral +Digits +Digit +NonZeroDigit +DigitsAndUnderscores +DigitOrUnderscore +Underscores +HexNumeral +HexDigits +HexDigit +HexDigitsAndUnderscores +HexDigitOrUnderscore +OctalNumeral +OctalDigits +OctalDigit +OctalDigitsAndUnderscores +OctalDigitOrUnderscore +FloatingPointLiteral +DecimalFloatingPointLiteral +ExponentPart +ExponentIndicator +SignedInteger +Sign +FloatTypeSuffix +SignedInfLiteral +NonEmptyStringLiteral +EmptyStringLiteral +DoubleQuotedStringCharacters +DoubleQuotedStringCharacter +SingleQuotedStringCharacters +SingleQuotedStringCharacter +JoinLineEscape +EscapeSequence +OctalEscape +ZeroToThree +UnicodeEscape +LPAREN +RPAREN +LBRACE +RBRACE +LBRACK +RBRACK +SEMI +COMMA +DOT +COLON +TRAVERSAL_ROOT +ANON_TRAVERSAL_ROOT +WS +LINE_COMMENT +Identifier +IdentifierStart +IdentifierPart + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 270, 2660, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, 7, 306, 2, 307, 7, 307, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 23, 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, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 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, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 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, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 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, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 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, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 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, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 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, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 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, 139, 1, 140, 1, 140, 1, 140, 1, 140, 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, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 250, 3, 250, 2377, 8, 250, 1, 250, 1, 250, 3, 250, 2381, 8, 250, 1, 250, 1, 250, 3, 250, 2385, 8, 250, 1, 250, 3, 250, 2388, 8, 250, 1, 251, 1, 251, 3, 251, 2392, 8, 251, 1, 252, 1, 252, 3, 252, 2396, 8, 252, 1, 253, 1, 253, 3, 253, 2400, 8, 253, 1, 254, 1, 254, 1, 255, 1, 255, 1, 255, 3, 255, 2407, 8, 255, 1, 255, 1, 255, 1, 255, 3, 255, 2412, 8, 255, 3, 255, 2414, 8, 255, 1, 256, 1, 256, 3, 256, 2418, 8, 256, 1, 256, 3, 256, 2421, 8, 256, 1, 257, 1, 257, 3, 257, 2425, 8, 257, 1, 258, 1, 258, 1, 259, 4, 259, 2430, 8, 259, 11, 259, 12, 259, 2431, 1, 260, 1, 260, 3, 260, 2436, 8, 260, 1, 261, 4, 261, 2439, 8, 261, 11, 261, 12, 261, 2440, 1, 262, 1, 262, 1, 262, 1, 262, 1, 263, 1, 263, 3, 263, 2449, 8, 263, 1, 263, 3, 263, 2452, 8, 263, 1, 264, 1, 264, 1, 265, 4, 265, 2457, 8, 265, 11, 265, 12, 265, 2458, 1, 266, 1, 266, 3, 266, 2463, 8, 266, 1, 267, 1, 267, 3, 267, 2467, 8, 267, 1, 267, 1, 267, 1, 268, 1, 268, 3, 268, 2473, 8, 268, 1, 268, 3, 268, 2476, 8, 268, 1, 269, 1, 269, 1, 270, 4, 270, 2481, 8, 270, 11, 270, 12, 270, 2482, 1, 271, 1, 271, 3, 271, 2487, 8, 271, 1, 272, 3, 272, 2490, 8, 272, 1, 272, 1, 272, 1, 273, 1, 273, 1, 273, 1, 273, 3, 273, 2498, 8, 273, 1, 273, 3, 273, 2501, 8, 273, 1, 273, 3, 273, 2504, 8, 273, 1, 273, 1, 273, 1, 273, 3, 273, 2509, 8, 273, 1, 274, 1, 274, 1, 274, 1, 275, 1, 275, 1, 276, 3, 276, 2517, 8, 276, 1, 276, 1, 276, 1, 277, 1, 277, 1, 278, 1, 278, 1, 279, 3, 279, 2526, 8, 279, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 3, 280, 2538, 8, 280, 1, 281, 1, 281, 1, 281, 1, 281, 3, 281, 2544, 8, 281, 1, 282, 4, 282, 2547, 8, 282, 11, 282, 12, 282, 2548, 1, 283, 1, 283, 1, 283, 3, 283, 2554, 8, 283, 1, 284, 4, 284, 2557, 8, 284, 11, 284, 12, 284, 2558, 1, 285, 1, 285, 1, 285, 3, 285, 2564, 8, 285, 1, 286, 1, 286, 3, 286, 2568, 8, 286, 1, 286, 1, 286, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 2576, 8, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 3, 288, 2589, 8, 288, 1, 289, 1, 289, 1, 290, 1, 290, 4, 290, 2595, 8, 290, 11, 290, 12, 290, 2596, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 291, 1, 291, 1, 292, 1, 292, 1, 293, 1, 293, 1, 294, 1, 294, 1, 295, 1, 295, 1, 296, 1, 296, 1, 297, 1, 297, 1, 298, 1, 298, 1, 299, 1, 299, 1, 300, 1, 300, 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, 1, 303, 4, 303, 2630, 8, 303, 11, 303, 12, 303, 2631, 1, 303, 1, 303, 1, 304, 1, 304, 1, 304, 1, 304, 5, 304, 2640, 8, 304, 10, 304, 12, 304, 2643, 9, 304, 1, 304, 1, 304, 1, 305, 1, 305, 5, 305, 2649, 8, 305, 10, 305, 12, 305, 2652, 9, 305, 1, 306, 3, 306, 2655, 8, 306, 1, 307, 1, 307, 3, 307, 2659, 8, 307, 0, 0, 308, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, 57, 115, 58, 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, 65, 131, 66, 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72, 145, 73, 147, 74, 149, 75, 151, 76, 153, 77, 155, 78, 157, 79, 159, 80, 161, 81, 163, 82, 165, 83, 167, 84, 169, 85, 171, 86, 173, 87, 175, 88, 177, 89, 179, 90, 181, 91, 183, 92, 185, 93, 187, 94, 189, 95, 191, 96, 193, 97, 195, 98, 197, 99, 199, 100, 201, 101, 203, 102, 205, 103, 207, 104, 209, 105, 211, 106, 213, 107, 215, 108, 217, 109, 219, 110, 221, 111, 223, 112, 225, 113, 227, 114, 229, 115, 231, 116, 233, 117, 235, 118, 237, 119, 239, 120, 241, 121, 243, 122, 245, 123, 247, 124, 249, 125, 251, 126, 253, 127, 255, 128, 257, 129, 259, 130, 261, 131, 263, 132, 265, 133, 267, 134, 269, 135, 271, 136, 273, 137, 275, 138, 277, 139, 279, 140, 281, 141, 283, 142, 285, 143, 287, 144, 289, 145, 291, 146, 293, 147, 295, 148, 297, 149, 299, 150, 301, 151, 303, 152, 305, 153, 307, 154, 309, 155, 311, 156, 313, 157, 315, 158, 317, 159, 319, 160, 321, 161, 323, 162, 325, 163, 327, 164, 329, 165, 331, 166, 333, 167, 335, 168, 337, 169, 339, 170, 341, 171, 343, 172, 345, 173, 347, 174, 349, 175, 351, 176, 353, 177, 355, 178, 357, 179, 359, 180, 361, 181, 363, 182, 365, 183, 367, 184, 369, 185, 371, 186, 373, 187, 375, 188, 377, 189, 379, 190, 381, 191, 383, 192, 385, 193, 387, 194, 389, 195, 391, 196, 393, 197, 395, 198, 397, 199, 399, 200, 401, 201, 403, 202, 405, 203, 407, 204, 409, 205, 411, 206, 413, 207, 415, 208, 417, 209, 419, 210, 421, 211, 423, 212, 425, 213, 427, 214, 429, 215, 431, 216, 433, 217, 435, 218, 437, 219, 439, 220, 441, 221, 443, 222, 445, 223, 447, 224, 449, 225, 451, 226, 453, 227, 455, 228, 457, 229, 459, 230, 461, 231, 463, 232, 465, 233, 467, 234, 469, 235, 471, 236, 473, 237, 475, 238, 477, 239, 479, 240, 481, 241, 483, 242, 485, 243, 487, 244, 489, 245, 491, 246, 493, 247, 495, 248, 497, 249, 499, 250, 501, 251, 503, 0, 505, 0, 507, 0, 509, 0, 511, 0, 513, 0, 515, 0, 517, 0, 519, 0, 521, 0, 523, 0, 525, 0, 527, 0, 529, 0, 531, 0, 533, 0, 535, 0, 537, 0, 539, 0, 541, 0, 543, 0, 545, 252, 547, 0, 549, 0, 551, 0, 553, 0, 555, 0, 557, 0, 559, 253, 561, 254, 563, 255, 565, 0, 567, 0, 569, 0, 571, 0, 573, 0, 575, 0, 577, 0, 579, 0, 581, 0, 583, 256, 585, 257, 587, 258, 589, 259, 591, 260, 593, 261, 595, 262, 597, 263, 599, 264, 601, 265, 603, 266, 605, 267, 607, 268, 609, 269, 611, 270, 613, 0, 615, 0, 1, 0, 16, 10, 0, 66, 66, 73, 73, 76, 76, 78, 78, 83, 83, 98, 98, 105, 105, 108, 108, 110, 110, 115, 115, 1, 0, 49, 57, 2, 0, 88, 88, 120, 120, 3, 0, 48, 57, 65, 70, 97, 102, 1, 0, 48, 55, 2, 0, 69, 69, 101, 101, 2, 0, 43, 43, 45, 45, 6, 0, 68, 68, 70, 70, 77, 77, 100, 100, 102, 102, 109, 109, 2, 0, 34, 34, 92, 92, 2, 0, 39, 39, 92, 92, 8, 0, 34, 34, 39, 39, 92, 92, 98, 98, 102, 102, 110, 110, 114, 114, 116, 116, 1, 0, 48, 51, 3, 0, 9, 10, 12, 13, 32, 32, 2, 0, 10, 10, 13, 13, 402, 0, 36, 36, 65, 90, 95, 95, 97, 122, 162, 165, 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, 1377, 1415, 1423, 1423, 1488, 1514, 1520, 1522, 1547, 1547, 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, 2208, 2228, 2230, 2237, 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, 2547, 2555, 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, 2801, 2801, 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, 3065, 3065, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3133, 3160, 3162, 3168, 3169, 3200, 3200, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 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, 3647, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 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, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6107, 6108, 6176, 6263, 6272, 6276, 6279, 6312, 6314, 6314, 6320, 6389, 6400, 6430, 6480, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7296, 7304, 7401, 7404, 7406, 7409, 7413, 7414, 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, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8352, 8383, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12590, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40938, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42653, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42926, 42928, 42935, 42999, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43064, 43064, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43261, 43261, 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, 43877, 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, 65020, 65075, 65076, 65101, 65103, 65129, 65129, 65136, 65140, 65142, 65276, 65284, 65284, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65504, 65505, 65509, 65510, 228, 0, 48, 57, 127, 159, 173, 173, 768, 879, 1155, 1159, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1536, 1541, 1552, 1562, 1564, 1564, 1611, 1641, 1648, 1648, 1750, 1757, 1759, 1764, 1767, 1768, 1770, 1773, 1776, 1785, 1807, 1807, 1809, 1809, 1840, 1866, 1958, 1968, 1984, 1993, 2027, 2035, 2070, 2073, 2075, 2083, 2085, 2087, 2089, 2093, 2137, 2139, 2260, 2307, 2362, 2364, 2366, 2383, 2385, 2391, 2402, 2403, 2406, 2415, 2433, 2435, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2530, 2531, 2534, 2543, 2561, 2563, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2662, 2673, 2677, 2677, 2689, 2691, 2748, 2748, 2750, 2757, 2759, 2761, 2763, 2765, 2786, 2787, 2790, 2799, 2810, 2815, 2817, 2819, 2876, 2876, 2878, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2914, 2915, 2918, 2927, 2946, 2946, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3046, 3055, 3072, 3075, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3170, 3171, 3174, 3183, 3201, 3203, 3260, 3260, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3298, 3299, 3302, 3311, 3328, 3331, 3387, 3388, 3390, 3396, 3398, 3400, 3402, 3405, 3415, 3415, 3426, 3427, 3430, 3439, 3458, 3459, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3558, 3567, 3570, 3571, 3633, 3633, 3636, 3642, 3655, 3662, 3664, 3673, 3761, 3761, 3764, 3769, 3771, 3772, 3784, 3789, 3792, 3801, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3903, 3953, 3972, 3974, 3975, 3981, 3991, 3993, 4028, 4038, 4038, 4139, 4158, 4160, 4169, 4182, 4185, 4190, 4192, 4194, 4196, 4199, 4205, 4209, 4212, 4226, 4237, 4239, 4253, 4957, 4959, 5906, 5908, 5938, 5940, 5970, 5971, 6002, 6003, 6068, 6099, 6109, 6109, 6112, 6121, 6155, 6158, 6160, 6169, 6277, 6278, 6313, 6313, 6432, 6443, 6448, 6459, 6470, 6479, 6608, 6617, 6679, 6683, 6741, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6832, 6845, 6912, 6916, 6964, 6980, 6992, 7001, 7019, 7027, 7040, 7042, 7073, 7085, 7088, 7097, 7142, 7155, 7204, 7223, 7232, 7241, 7248, 7257, 7376, 7378, 7380, 7400, 7405, 7405, 7410, 7412, 7415, 7417, 7616, 7673, 7675, 7679, 8203, 8207, 8234, 8238, 8288, 8292, 8294, 8303, 8400, 8412, 8417, 8417, 8421, 8432, 11503, 11505, 11647, 11647, 11744, 11775, 12330, 12335, 12441, 12442, 42528, 42537, 42607, 42607, 42612, 42621, 42654, 42655, 42736, 42737, 43010, 43010, 43014, 43014, 43019, 43019, 43043, 43047, 43136, 43137, 43188, 43205, 43216, 43225, 43232, 43249, 43264, 43273, 43302, 43309, 43335, 43347, 43392, 43395, 43443, 43456, 43472, 43481, 43493, 43493, 43504, 43513, 43561, 43574, 43587, 43587, 43596, 43597, 43600, 43609, 43643, 43645, 43696, 43696, 43698, 43700, 43703, 43704, 43710, 43711, 43713, 43713, 43755, 43759, 43765, 43766, 44003, 44010, 44012, 44013, 44016, 44025, 64286, 64286, 65024, 65039, 65056, 65071, 65279, 65279, 65296, 65305, 65529, 65531, 2672, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, 0, 0, 0, 0, 253, 1, 0, 0, 0, 0, 255, 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, 0, 259, 1, 0, 0, 0, 0, 261, 1, 0, 0, 0, 0, 263, 1, 0, 0, 0, 0, 265, 1, 0, 0, 0, 0, 267, 1, 0, 0, 0, 0, 269, 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 273, 1, 0, 0, 0, 0, 275, 1, 0, 0, 0, 0, 277, 1, 0, 0, 0, 0, 279, 1, 0, 0, 0, 0, 281, 1, 0, 0, 0, 0, 283, 1, 0, 0, 0, 0, 285, 1, 0, 0, 0, 0, 287, 1, 0, 0, 0, 0, 289, 1, 0, 0, 0, 0, 291, 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, 0, 295, 1, 0, 0, 0, 0, 297, 1, 0, 0, 0, 0, 299, 1, 0, 0, 0, 0, 301, 1, 0, 0, 0, 0, 303, 1, 0, 0, 0, 0, 305, 1, 0, 0, 0, 0, 307, 1, 0, 0, 0, 0, 309, 1, 0, 0, 0, 0, 311, 1, 0, 0, 0, 0, 313, 1, 0, 0, 0, 0, 315, 1, 0, 0, 0, 0, 317, 1, 0, 0, 0, 0, 319, 1, 0, 0, 0, 0, 321, 1, 0, 0, 0, 0, 323, 1, 0, 0, 0, 0, 325, 1, 0, 0, 0, 0, 327, 1, 0, 0, 0, 0, 329, 1, 0, 0, 0, 0, 331, 1, 0, 0, 0, 0, 333, 1, 0, 0, 0, 0, 335, 1, 0, 0, 0, 0, 337, 1, 0, 0, 0, 0, 339, 1, 0, 0, 0, 0, 341, 1, 0, 0, 0, 0, 343, 1, 0, 0, 0, 0, 345, 1, 0, 0, 0, 0, 347, 1, 0, 0, 0, 0, 349, 1, 0, 0, 0, 0, 351, 1, 0, 0, 0, 0, 353, 1, 0, 0, 0, 0, 355, 1, 0, 0, 0, 0, 357, 1, 0, 0, 0, 0, 359, 1, 0, 0, 0, 0, 361, 1, 0, 0, 0, 0, 363, 1, 0, 0, 0, 0, 365, 1, 0, 0, 0, 0, 367, 1, 0, 0, 0, 0, 369, 1, 0, 0, 0, 0, 371, 1, 0, 0, 0, 0, 373, 1, 0, 0, 0, 0, 375, 1, 0, 0, 0, 0, 377, 1, 0, 0, 0, 0, 379, 1, 0, 0, 0, 0, 381, 1, 0, 0, 0, 0, 383, 1, 0, 0, 0, 0, 385, 1, 0, 0, 0, 0, 387, 1, 0, 0, 0, 0, 389, 1, 0, 0, 0, 0, 391, 1, 0, 0, 0, 0, 393, 1, 0, 0, 0, 0, 395, 1, 0, 0, 0, 0, 397, 1, 0, 0, 0, 0, 399, 1, 0, 0, 0, 0, 401, 1, 0, 0, 0, 0, 403, 1, 0, 0, 0, 0, 405, 1, 0, 0, 0, 0, 407, 1, 0, 0, 0, 0, 409, 1, 0, 0, 0, 0, 411, 1, 0, 0, 0, 0, 413, 1, 0, 0, 0, 0, 415, 1, 0, 0, 0, 0, 417, 1, 0, 0, 0, 0, 419, 1, 0, 0, 0, 0, 421, 1, 0, 0, 0, 0, 423, 1, 0, 0, 0, 0, 425, 1, 0, 0, 0, 0, 427, 1, 0, 0, 0, 0, 429, 1, 0, 0, 0, 0, 431, 1, 0, 0, 0, 0, 433, 1, 0, 0, 0, 0, 435, 1, 0, 0, 0, 0, 437, 1, 0, 0, 0, 0, 439, 1, 0, 0, 0, 0, 441, 1, 0, 0, 0, 0, 443, 1, 0, 0, 0, 0, 445, 1, 0, 0, 0, 0, 447, 1, 0, 0, 0, 0, 449, 1, 0, 0, 0, 0, 451, 1, 0, 0, 0, 0, 453, 1, 0, 0, 0, 0, 455, 1, 0, 0, 0, 0, 457, 1, 0, 0, 0, 0, 459, 1, 0, 0, 0, 0, 461, 1, 0, 0, 0, 0, 463, 1, 0, 0, 0, 0, 465, 1, 0, 0, 0, 0, 467, 1, 0, 0, 0, 0, 469, 1, 0, 0, 0, 0, 471, 1, 0, 0, 0, 0, 473, 1, 0, 0, 0, 0, 475, 1, 0, 0, 0, 0, 477, 1, 0, 0, 0, 0, 479, 1, 0, 0, 0, 0, 481, 1, 0, 0, 0, 0, 483, 1, 0, 0, 0, 0, 485, 1, 0, 0, 0, 0, 487, 1, 0, 0, 0, 0, 489, 1, 0, 0, 0, 0, 491, 1, 0, 0, 0, 0, 493, 1, 0, 0, 0, 0, 495, 1, 0, 0, 0, 0, 497, 1, 0, 0, 0, 0, 499, 1, 0, 0, 0, 0, 501, 1, 0, 0, 0, 0, 545, 1, 0, 0, 0, 0, 559, 1, 0, 0, 0, 0, 561, 1, 0, 0, 0, 0, 563, 1, 0, 0, 0, 0, 583, 1, 0, 0, 0, 0, 585, 1, 0, 0, 0, 0, 587, 1, 0, 0, 0, 0, 589, 1, 0, 0, 0, 0, 591, 1, 0, 0, 0, 0, 593, 1, 0, 0, 0, 0, 595, 1, 0, 0, 0, 0, 597, 1, 0, 0, 0, 0, 599, 1, 0, 0, 0, 0, 601, 1, 0, 0, 0, 0, 603, 1, 0, 0, 0, 0, 605, 1, 0, 0, 0, 0, 607, 1, 0, 0, 0, 0, 609, 1, 0, 0, 0, 0, 611, 1, 0, 0, 0, 1, 617, 1, 0, 0, 0, 3, 625, 1, 0, 0, 0, 5, 632, 1, 0, 0, 0, 7, 637, 1, 0, 0, 0, 9, 642, 1, 0, 0, 0, 11, 652, 1, 0, 0, 0, 13, 656, 1, 0, 0, 0, 15, 660, 1, 0, 0, 0, 17, 664, 1, 0, 0, 0, 19, 667, 1, 0, 0, 0, 21, 671, 1, 0, 0, 0, 23, 678, 1, 0, 0, 0, 25, 687, 1, 0, 0, 0, 27, 694, 1, 0, 0, 0, 29, 702, 1, 0, 0, 0, 31, 710, 1, 0, 0, 0, 33, 716, 1, 0, 0, 0, 35, 724, 1, 0, 0, 0, 37, 729, 1, 0, 0, 0, 39, 734, 1, 0, 0, 0, 41, 740, 1, 0, 0, 0, 43, 746, 1, 0, 0, 0, 45, 753, 1, 0, 0, 0, 47, 756, 1, 0, 0, 0, 49, 761, 1, 0, 0, 0, 51, 765, 1, 0, 0, 0, 53, 777, 1, 0, 0, 0, 55, 784, 1, 0, 0, 0, 57, 793, 1, 0, 0, 0, 59, 798, 1, 0, 0, 0, 61, 805, 1, 0, 0, 0, 63, 813, 1, 0, 0, 0, 65, 820, 1, 0, 0, 0, 67, 830, 1, 0, 0, 0, 69, 837, 1, 0, 0, 0, 71, 845, 1, 0, 0, 0, 73, 864, 1, 0, 0, 0, 75, 883, 1, 0, 0, 0, 77, 892, 1, 0, 0, 0, 79, 903, 1, 0, 0, 0, 81, 909, 1, 0, 0, 0, 83, 920, 1, 0, 0, 0, 85, 924, 1, 0, 0, 0, 87, 932, 1, 0, 0, 0, 89, 941, 1, 0, 0, 0, 91, 950, 1, 0, 0, 0, 93, 959, 1, 0, 0, 0, 95, 964, 1, 0, 0, 0, 97, 970, 1, 0, 0, 0, 99, 975, 1, 0, 0, 0, 101, 986, 1, 0, 0, 0, 103, 996, 1, 0, 0, 0, 105, 1005, 1, 0, 0, 0, 107, 1014, 1, 0, 0, 0, 109, 1018, 1, 0, 0, 0, 111, 1023, 1, 0, 0, 0, 113, 1026, 1, 0, 0, 0, 115, 1028, 1, 0, 0, 0, 117, 1034, 1, 0, 0, 0, 119, 1045, 1, 0, 0, 0, 121, 1053, 1, 0, 0, 0, 123, 1058, 1, 0, 0, 0, 125, 1069, 1, 0, 0, 0, 127, 1072, 1, 0, 0, 0, 129, 1080, 1, 0, 0, 0, 131, 1085, 1, 0, 0, 0, 133, 1091, 1, 0, 0, 0, 135, 1098, 1, 0, 0, 0, 137, 1104, 1, 0, 0, 0, 139, 1112, 1, 0, 0, 0, 141, 1117, 1, 0, 0, 0, 143, 1124, 1, 0, 0, 0, 145, 1129, 1, 0, 0, 0, 147, 1136, 1, 0, 0, 0, 149, 1139, 1, 0, 0, 0, 151, 1143, 1, 0, 0, 0, 153, 1151, 1, 0, 0, 0, 155, 1160, 1, 0, 0, 0, 157, 1171, 1, 0, 0, 0, 159, 1177, 1, 0, 0, 0, 161, 1182, 1, 0, 0, 0, 163, 1186, 1, 0, 0, 0, 165, 1192, 1, 0, 0, 0, 167, 1199, 1, 0, 0, 0, 169, 1208, 1, 0, 0, 0, 171, 1216, 1, 0, 0, 0, 173, 1223, 1, 0, 0, 0, 175, 1232, 1, 0, 0, 0, 177, 1237, 1, 0, 0, 0, 179, 1240, 1, 0, 0, 0, 181, 1249, 1, 0, 0, 0, 183, 1253, 1, 0, 0, 0, 185, 1256, 1, 0, 0, 0, 187, 1259, 1, 0, 0, 0, 189, 1263, 1, 0, 0, 0, 191, 1276, 1, 0, 0, 0, 193, 1281, 1, 0, 0, 0, 195, 1289, 1, 0, 0, 0, 197, 1295, 1, 0, 0, 0, 199, 1304, 1, 0, 0, 0, 201, 1311, 1, 0, 0, 0, 203, 1318, 1, 0, 0, 0, 205, 1328, 1, 0, 0, 0, 207, 1332, 1, 0, 0, 0, 209, 1335, 1, 0, 0, 0, 211, 1338, 1, 0, 0, 0, 213, 1341, 1, 0, 0, 0, 215, 1349, 1, 0, 0, 0, 217, 1353, 1, 0, 0, 0, 219, 1358, 1, 0, 0, 0, 221, 1365, 1, 0, 0, 0, 223, 1371, 1, 0, 0, 0, 225, 1376, 1, 0, 0, 0, 227, 1383, 1, 0, 0, 0, 229, 1389, 1, 0, 0, 0, 231, 1394, 1, 0, 0, 0, 233, 1400, 1, 0, 0, 0, 235, 1406, 1, 0, 0, 0, 237, 1409, 1, 0, 0, 0, 239, 1413, 1, 0, 0, 0, 241, 1419, 1, 0, 0, 0, 243, 1423, 1, 0, 0, 0, 245, 1429, 1, 0, 0, 0, 247, 1434, 1, 0, 0, 0, 249, 1438, 1, 0, 0, 0, 251, 1450, 1, 0, 0, 0, 253, 1455, 1, 0, 0, 0, 255, 1461, 1, 0, 0, 0, 257, 1467, 1, 0, 0, 0, 259, 1474, 1, 0, 0, 0, 261, 1481, 1, 0, 0, 0, 263, 1485, 1, 0, 0, 0, 265, 1492, 1, 0, 0, 0, 267, 1498, 1, 0, 0, 0, 269, 1504, 1, 0, 0, 0, 271, 1509, 1, 0, 0, 0, 273, 1513, 1, 0, 0, 0, 275, 1520, 1, 0, 0, 0, 277, 1525, 1, 0, 0, 0, 279, 1530, 1, 0, 0, 0, 281, 1539, 1, 0, 0, 0, 283, 1553, 1, 0, 0, 0, 285, 1567, 1, 0, 0, 0, 287, 1583, 1, 0, 0, 0, 289, 1587, 1, 0, 0, 0, 291, 1591, 1, 0, 0, 0, 293, 1595, 1, 0, 0, 0, 295, 1604, 1, 0, 0, 0, 297, 1609, 1, 0, 0, 0, 299, 1618, 1, 0, 0, 0, 301, 1626, 1, 0, 0, 0, 303, 1635, 1, 0, 0, 0, 305, 1642, 1, 0, 0, 0, 307, 1651, 1, 0, 0, 0, 309, 1657, 1, 0, 0, 0, 311, 1663, 1, 0, 0, 0, 313, 1666, 1, 0, 0, 0, 315, 1673, 1, 0, 0, 0, 317, 1677, 1, 0, 0, 0, 319, 1681, 1, 0, 0, 0, 321, 1686, 1, 0, 0, 0, 323, 1694, 1, 0, 0, 0, 325, 1699, 1, 0, 0, 0, 327, 1701, 1, 0, 0, 0, 329, 1710, 1, 0, 0, 0, 331, 1719, 1, 0, 0, 0, 333, 1724, 1, 0, 0, 0, 335, 1737, 1, 0, 0, 0, 337, 1750, 1, 0, 0, 0, 339, 1755, 1, 0, 0, 0, 341, 1759, 1, 0, 0, 0, 343, 1767, 1, 0, 0, 0, 345, 1775, 1, 0, 0, 0, 347, 1786, 1, 0, 0, 0, 349, 1798, 1, 0, 0, 0, 351, 1811, 1, 0, 0, 0, 353, 1820, 1, 0, 0, 0, 355, 1828, 1, 0, 0, 0, 357, 1834, 1, 0, 0, 0, 359, 1839, 1, 0, 0, 0, 361, 1846, 1, 0, 0, 0, 363, 1862, 1, 0, 0, 0, 365, 1868, 1, 0, 0, 0, 367, 1876, 1, 0, 0, 0, 369, 1883, 1, 0, 0, 0, 371, 1891, 1, 0, 0, 0, 373, 1900, 1, 0, 0, 0, 375, 1906, 1, 0, 0, 0, 377, 1911, 1, 0, 0, 0, 379, 1918, 1, 0, 0, 0, 381, 1924, 1, 0, 0, 0, 383, 1931, 1, 0, 0, 0, 385, 1938, 1, 0, 0, 0, 387, 1942, 1, 0, 0, 0, 389, 1955, 1, 0, 0, 0, 391, 1968, 1, 0, 0, 0, 393, 1976, 1, 0, 0, 0, 395, 1987, 1, 0, 0, 0, 397, 1998, 1, 0, 0, 0, 399, 2005, 1, 0, 0, 0, 401, 2010, 1, 0, 0, 0, 403, 2016, 1, 0, 0, 0, 405, 2029, 1, 0, 0, 0, 407, 2035, 1, 0, 0, 0, 409, 2044, 1, 0, 0, 0, 411, 2054, 1, 0, 0, 0, 413, 2058, 1, 0, 0, 0, 415, 2066, 1, 0, 0, 0, 417, 2068, 1, 0, 0, 0, 419, 2073, 1, 0, 0, 0, 421, 2080, 1, 0, 0, 0, 423, 2086, 1, 0, 0, 0, 425, 2096, 1, 0, 0, 0, 427, 2102, 1, 0, 0, 0, 429, 2105, 1, 0, 0, 0, 431, 2115, 1, 0, 0, 0, 433, 2122, 1, 0, 0, 0, 435, 2129, 1, 0, 0, 0, 437, 2137, 1, 0, 0, 0, 439, 2143, 1, 0, 0, 0, 441, 2152, 1, 0, 0, 0, 443, 2160, 1, 0, 0, 0, 445, 2164, 1, 0, 0, 0, 447, 2168, 1, 0, 0, 0, 449, 2173, 1, 0, 0, 0, 451, 2178, 1, 0, 0, 0, 453, 2183, 1, 0, 0, 0, 455, 2191, 1, 0, 0, 0, 457, 2194, 1, 0, 0, 0, 459, 2201, 1, 0, 0, 0, 461, 2207, 1, 0, 0, 0, 463, 2213, 1, 0, 0, 0, 465, 2218, 1, 0, 0, 0, 467, 2220, 1, 0, 0, 0, 469, 2229, 1, 0, 0, 0, 471, 2236, 1, 0, 0, 0, 473, 2242, 1, 0, 0, 0, 475, 2249, 1, 0, 0, 0, 477, 2255, 1, 0, 0, 0, 479, 2260, 1, 0, 0, 0, 481, 2269, 1, 0, 0, 0, 483, 2276, 1, 0, 0, 0, 485, 2288, 1, 0, 0, 0, 487, 2296, 1, 0, 0, 0, 489, 2314, 1, 0, 0, 0, 491, 2323, 1, 0, 0, 0, 493, 2332, 1, 0, 0, 0, 495, 2347, 1, 0, 0, 0, 497, 2362, 1, 0, 0, 0, 499, 2368, 1, 0, 0, 0, 501, 2387, 1, 0, 0, 0, 503, 2389, 1, 0, 0, 0, 505, 2393, 1, 0, 0, 0, 507, 2397, 1, 0, 0, 0, 509, 2401, 1, 0, 0, 0, 511, 2413, 1, 0, 0, 0, 513, 2415, 1, 0, 0, 0, 515, 2424, 1, 0, 0, 0, 517, 2426, 1, 0, 0, 0, 519, 2429, 1, 0, 0, 0, 521, 2435, 1, 0, 0, 0, 523, 2438, 1, 0, 0, 0, 525, 2442, 1, 0, 0, 0, 527, 2446, 1, 0, 0, 0, 529, 2453, 1, 0, 0, 0, 531, 2456, 1, 0, 0, 0, 533, 2462, 1, 0, 0, 0, 535, 2464, 1, 0, 0, 0, 537, 2470, 1, 0, 0, 0, 539, 2477, 1, 0, 0, 0, 541, 2480, 1, 0, 0, 0, 543, 2486, 1, 0, 0, 0, 545, 2489, 1, 0, 0, 0, 547, 2508, 1, 0, 0, 0, 549, 2510, 1, 0, 0, 0, 551, 2513, 1, 0, 0, 0, 553, 2516, 1, 0, 0, 0, 555, 2520, 1, 0, 0, 0, 557, 2522, 1, 0, 0, 0, 559, 2525, 1, 0, 0, 0, 561, 2537, 1, 0, 0, 0, 563, 2543, 1, 0, 0, 0, 565, 2546, 1, 0, 0, 0, 567, 2553, 1, 0, 0, 0, 569, 2556, 1, 0, 0, 0, 571, 2563, 1, 0, 0, 0, 573, 2565, 1, 0, 0, 0, 575, 2575, 1, 0, 0, 0, 577, 2588, 1, 0, 0, 0, 579, 2590, 1, 0, 0, 0, 581, 2592, 1, 0, 0, 0, 583, 2603, 1, 0, 0, 0, 585, 2605, 1, 0, 0, 0, 587, 2607, 1, 0, 0, 0, 589, 2609, 1, 0, 0, 0, 591, 2611, 1, 0, 0, 0, 593, 2613, 1, 0, 0, 0, 595, 2615, 1, 0, 0, 0, 597, 2617, 1, 0, 0, 0, 599, 2619, 1, 0, 0, 0, 601, 2621, 1, 0, 0, 0, 603, 2623, 1, 0, 0, 0, 605, 2625, 1, 0, 0, 0, 607, 2629, 1, 0, 0, 0, 609, 2635, 1, 0, 0, 0, 611, 2646, 1, 0, 0, 0, 613, 2654, 1, 0, 0, 0, 615, 2658, 1, 0, 0, 0, 617, 618, 5, 100, 0, 0, 618, 619, 5, 105, 0, 0, 619, 620, 5, 115, 0, 0, 620, 621, 5, 99, 0, 0, 621, 622, 5, 97, 0, 0, 622, 623, 5, 114, 0, 0, 623, 624, 5, 100, 0, 0, 624, 2, 1, 0, 0, 0, 625, 626, 5, 97, 0, 0, 626, 627, 5, 100, 0, 0, 627, 628, 5, 100, 0, 0, 628, 629, 5, 65, 0, 0, 629, 630, 5, 108, 0, 0, 630, 631, 5, 108, 0, 0, 631, 4, 1, 0, 0, 0, 632, 633, 5, 97, 0, 0, 633, 634, 5, 100, 0, 0, 634, 635, 5, 100, 0, 0, 635, 636, 5, 69, 0, 0, 636, 6, 1, 0, 0, 0, 637, 638, 5, 97, 0, 0, 638, 639, 5, 100, 0, 0, 639, 640, 5, 100, 0, 0, 640, 641, 5, 86, 0, 0, 641, 8, 1, 0, 0, 0, 642, 643, 5, 97, 0, 0, 643, 644, 5, 103, 0, 0, 644, 645, 5, 103, 0, 0, 645, 646, 5, 114, 0, 0, 646, 647, 5, 101, 0, 0, 647, 648, 5, 103, 0, 0, 648, 649, 5, 97, 0, 0, 649, 650, 5, 116, 0, 0, 650, 651, 5, 101, 0, 0, 651, 10, 1, 0, 0, 0, 652, 653, 5, 97, 0, 0, 653, 654, 5, 108, 0, 0, 654, 655, 5, 108, 0, 0, 655, 12, 1, 0, 0, 0, 656, 657, 5, 97, 0, 0, 657, 658, 5, 110, 0, 0, 658, 659, 5, 100, 0, 0, 659, 14, 1, 0, 0, 0, 660, 661, 5, 97, 0, 0, 661, 662, 5, 110, 0, 0, 662, 663, 5, 121, 0, 0, 663, 16, 1, 0, 0, 0, 664, 665, 5, 97, 0, 0, 665, 666, 5, 115, 0, 0, 666, 18, 1, 0, 0, 0, 667, 668, 5, 97, 0, 0, 668, 669, 5, 115, 0, 0, 669, 670, 5, 99, 0, 0, 670, 20, 1, 0, 0, 0, 671, 672, 5, 97, 0, 0, 672, 673, 5, 115, 0, 0, 673, 674, 5, 68, 0, 0, 674, 675, 5, 97, 0, 0, 675, 676, 5, 116, 0, 0, 676, 677, 5, 101, 0, 0, 677, 22, 1, 0, 0, 0, 678, 679, 5, 97, 0, 0, 679, 680, 5, 115, 0, 0, 680, 681, 5, 83, 0, 0, 681, 682, 5, 116, 0, 0, 682, 683, 5, 114, 0, 0, 683, 684, 5, 105, 0, 0, 684, 685, 5, 110, 0, 0, 685, 686, 5, 103, 0, 0, 686, 24, 1, 0, 0, 0, 687, 688, 5, 97, 0, 0, 688, 689, 5, 115, 0, 0, 689, 690, 5, 115, 0, 0, 690, 691, 5, 105, 0, 0, 691, 692, 5, 103, 0, 0, 692, 693, 5, 110, 0, 0, 693, 26, 1, 0, 0, 0, 694, 695, 5, 98, 0, 0, 695, 696, 5, 97, 0, 0, 696, 697, 5, 114, 0, 0, 697, 698, 5, 114, 0, 0, 698, 699, 5, 105, 0, 0, 699, 700, 5, 101, 0, 0, 700, 701, 5, 114, 0, 0, 701, 28, 1, 0, 0, 0, 702, 703, 5, 66, 0, 0, 703, 704, 5, 97, 0, 0, 704, 705, 5, 114, 0, 0, 705, 706, 5, 114, 0, 0, 706, 707, 5, 105, 0, 0, 707, 708, 5, 101, 0, 0, 708, 709, 5, 114, 0, 0, 709, 30, 1, 0, 0, 0, 710, 711, 5, 98, 0, 0, 711, 712, 5, 101, 0, 0, 712, 713, 5, 103, 0, 0, 713, 714, 5, 105, 0, 0, 714, 715, 5, 110, 0, 0, 715, 32, 1, 0, 0, 0, 716, 717, 5, 98, 0, 0, 717, 718, 5, 101, 0, 0, 718, 719, 5, 116, 0, 0, 719, 720, 5, 119, 0, 0, 720, 721, 5, 101, 0, 0, 721, 722, 5, 101, 0, 0, 722, 723, 5, 110, 0, 0, 723, 34, 1, 0, 0, 0, 724, 725, 5, 98, 0, 0, 725, 726, 5, 111, 0, 0, 726, 727, 5, 116, 0, 0, 727, 728, 5, 104, 0, 0, 728, 36, 1, 0, 0, 0, 729, 730, 5, 66, 0, 0, 730, 731, 5, 79, 0, 0, 731, 732, 5, 84, 0, 0, 732, 733, 5, 72, 0, 0, 733, 38, 1, 0, 0, 0, 734, 735, 5, 98, 0, 0, 735, 736, 5, 111, 0, 0, 736, 737, 5, 116, 0, 0, 737, 738, 5, 104, 0, 0, 738, 739, 5, 69, 0, 0, 739, 40, 1, 0, 0, 0, 740, 741, 5, 98, 0, 0, 741, 742, 5, 111, 0, 0, 742, 743, 5, 116, 0, 0, 743, 744, 5, 104, 0, 0, 744, 745, 5, 86, 0, 0, 745, 42, 1, 0, 0, 0, 746, 747, 5, 98, 0, 0, 747, 748, 5, 114, 0, 0, 748, 749, 5, 97, 0, 0, 749, 750, 5, 110, 0, 0, 750, 751, 5, 99, 0, 0, 751, 752, 5, 104, 0, 0, 752, 44, 1, 0, 0, 0, 753, 754, 5, 98, 0, 0, 754, 755, 5, 121, 0, 0, 755, 46, 1, 0, 0, 0, 756, 757, 5, 99, 0, 0, 757, 758, 5, 97, 0, 0, 758, 759, 5, 108, 0, 0, 759, 760, 5, 108, 0, 0, 760, 48, 1, 0, 0, 0, 761, 762, 5, 99, 0, 0, 762, 763, 5, 97, 0, 0, 763, 764, 5, 112, 0, 0, 764, 50, 1, 0, 0, 0, 765, 766, 5, 67, 0, 0, 766, 767, 5, 97, 0, 0, 767, 768, 5, 114, 0, 0, 768, 769, 5, 100, 0, 0, 769, 770, 5, 105, 0, 0, 770, 771, 5, 110, 0, 0, 771, 772, 5, 97, 0, 0, 772, 773, 5, 108, 0, 0, 773, 774, 5, 105, 0, 0, 774, 775, 5, 116, 0, 0, 775, 776, 5, 121, 0, 0, 776, 52, 1, 0, 0, 0, 777, 778, 5, 99, 0, 0, 778, 779, 5, 104, 0, 0, 779, 780, 5, 111, 0, 0, 780, 781, 5, 111, 0, 0, 781, 782, 5, 115, 0, 0, 782, 783, 5, 101, 0, 0, 783, 54, 1, 0, 0, 0, 784, 785, 5, 99, 0, 0, 785, 786, 5, 111, 0, 0, 786, 787, 5, 97, 0, 0, 787, 788, 5, 108, 0, 0, 788, 789, 5, 101, 0, 0, 789, 790, 5, 115, 0, 0, 790, 791, 5, 99, 0, 0, 791, 792, 5, 101, 0, 0, 792, 56, 1, 0, 0, 0, 793, 794, 5, 99, 0, 0, 794, 795, 5, 111, 0, 0, 795, 796, 5, 105, 0, 0, 796, 797, 5, 110, 0, 0, 797, 58, 1, 0, 0, 0, 798, 799, 5, 67, 0, 0, 799, 800, 5, 111, 0, 0, 800, 801, 5, 108, 0, 0, 801, 802, 5, 117, 0, 0, 802, 803, 5, 109, 0, 0, 803, 804, 5, 110, 0, 0, 804, 60, 1, 0, 0, 0, 805, 806, 5, 99, 0, 0, 806, 807, 5, 111, 0, 0, 807, 808, 5, 109, 0, 0, 808, 809, 5, 98, 0, 0, 809, 810, 5, 105, 0, 0, 810, 811, 5, 110, 0, 0, 811, 812, 5, 101, 0, 0, 812, 62, 1, 0, 0, 0, 813, 814, 5, 99, 0, 0, 814, 815, 5, 111, 0, 0, 815, 816, 5, 109, 0, 0, 816, 817, 5, 109, 0, 0, 817, 818, 5, 105, 0, 0, 818, 819, 5, 116, 0, 0, 819, 64, 1, 0, 0, 0, 820, 821, 5, 99, 0, 0, 821, 822, 5, 111, 0, 0, 822, 823, 5, 109, 0, 0, 823, 824, 5, 112, 0, 0, 824, 825, 5, 111, 0, 0, 825, 826, 5, 110, 0, 0, 826, 827, 5, 101, 0, 0, 827, 828, 5, 110, 0, 0, 828, 829, 5, 116, 0, 0, 829, 66, 1, 0, 0, 0, 830, 831, 5, 99, 0, 0, 831, 832, 5, 111, 0, 0, 832, 833, 5, 110, 0, 0, 833, 834, 5, 99, 0, 0, 834, 835, 5, 97, 0, 0, 835, 836, 5, 116, 0, 0, 836, 68, 1, 0, 0, 0, 837, 838, 5, 99, 0, 0, 838, 839, 5, 111, 0, 0, 839, 840, 5, 110, 0, 0, 840, 841, 5, 106, 0, 0, 841, 842, 5, 111, 0, 0, 842, 843, 5, 105, 0, 0, 843, 844, 5, 110, 0, 0, 844, 70, 1, 0, 0, 0, 845, 846, 5, 99, 0, 0, 846, 847, 5, 111, 0, 0, 847, 848, 5, 110, 0, 0, 848, 849, 5, 110, 0, 0, 849, 850, 5, 101, 0, 0, 850, 851, 5, 99, 0, 0, 851, 852, 5, 116, 0, 0, 852, 853, 5, 101, 0, 0, 853, 854, 5, 100, 0, 0, 854, 855, 5, 67, 0, 0, 855, 856, 5, 111, 0, 0, 856, 857, 5, 109, 0, 0, 857, 858, 5, 112, 0, 0, 858, 859, 5, 111, 0, 0, 859, 860, 5, 110, 0, 0, 860, 861, 5, 101, 0, 0, 861, 862, 5, 110, 0, 0, 862, 863, 5, 116, 0, 0, 863, 72, 1, 0, 0, 0, 864, 865, 5, 67, 0, 0, 865, 866, 5, 111, 0, 0, 866, 867, 5, 110, 0, 0, 867, 868, 5, 110, 0, 0, 868, 869, 5, 101, 0, 0, 869, 870, 5, 99, 0, 0, 870, 871, 5, 116, 0, 0, 871, 872, 5, 101, 0, 0, 872, 873, 5, 100, 0, 0, 873, 874, 5, 67, 0, 0, 874, 875, 5, 111, 0, 0, 875, 876, 5, 109, 0, 0, 876, 877, 5, 112, 0, 0, 877, 878, 5, 111, 0, 0, 878, 879, 5, 110, 0, 0, 879, 880, 5, 101, 0, 0, 880, 881, 5, 110, 0, 0, 881, 882, 5, 116, 0, 0, 882, 74, 1, 0, 0, 0, 883, 884, 5, 99, 0, 0, 884, 885, 5, 111, 0, 0, 885, 886, 5, 110, 0, 0, 886, 887, 5, 115, 0, 0, 887, 888, 5, 116, 0, 0, 888, 889, 5, 97, 0, 0, 889, 890, 5, 110, 0, 0, 890, 891, 5, 116, 0, 0, 891, 76, 1, 0, 0, 0, 892, 893, 5, 99, 0, 0, 893, 894, 5, 111, 0, 0, 894, 895, 5, 110, 0, 0, 895, 896, 5, 116, 0, 0, 896, 897, 5, 97, 0, 0, 897, 898, 5, 105, 0, 0, 898, 899, 5, 110, 0, 0, 899, 900, 5, 105, 0, 0, 900, 901, 5, 110, 0, 0, 901, 902, 5, 103, 0, 0, 902, 78, 1, 0, 0, 0, 903, 904, 5, 99, 0, 0, 904, 905, 5, 111, 0, 0, 905, 906, 5, 117, 0, 0, 906, 907, 5, 110, 0, 0, 907, 908, 5, 116, 0, 0, 908, 80, 1, 0, 0, 0, 909, 910, 5, 99, 0, 0, 910, 911, 5, 121, 0, 0, 911, 912, 5, 99, 0, 0, 912, 913, 5, 108, 0, 0, 913, 914, 5, 105, 0, 0, 914, 915, 5, 99, 0, 0, 915, 916, 5, 80, 0, 0, 916, 917, 5, 97, 0, 0, 917, 918, 5, 116, 0, 0, 918, 919, 5, 104, 0, 0, 919, 82, 1, 0, 0, 0, 920, 921, 5, 100, 0, 0, 921, 922, 5, 97, 0, 0, 922, 923, 5, 121, 0, 0, 923, 84, 1, 0, 0, 0, 924, 925, 5, 100, 0, 0, 925, 926, 5, 97, 0, 0, 926, 927, 5, 116, 0, 0, 927, 928, 5, 101, 0, 0, 928, 929, 5, 65, 0, 0, 929, 930, 5, 100, 0, 0, 930, 931, 5, 100, 0, 0, 931, 86, 1, 0, 0, 0, 932, 933, 5, 100, 0, 0, 933, 934, 5, 97, 0, 0, 934, 935, 5, 116, 0, 0, 935, 936, 5, 101, 0, 0, 936, 937, 5, 68, 0, 0, 937, 938, 5, 105, 0, 0, 938, 939, 5, 102, 0, 0, 939, 940, 5, 102, 0, 0, 940, 88, 1, 0, 0, 0, 941, 942, 5, 100, 0, 0, 942, 943, 5, 97, 0, 0, 943, 944, 5, 116, 0, 0, 944, 945, 5, 101, 0, 0, 945, 946, 5, 116, 0, 0, 946, 947, 5, 105, 0, 0, 947, 948, 5, 109, 0, 0, 948, 949, 5, 101, 0, 0, 949, 90, 1, 0, 0, 0, 950, 951, 5, 68, 0, 0, 951, 952, 5, 97, 0, 0, 952, 953, 5, 116, 0, 0, 953, 954, 5, 101, 0, 0, 954, 955, 5, 84, 0, 0, 955, 956, 5, 105, 0, 0, 956, 957, 5, 109, 0, 0, 957, 958, 5, 101, 0, 0, 958, 92, 1, 0, 0, 0, 959, 960, 5, 100, 0, 0, 960, 961, 5, 101, 0, 0, 961, 962, 5, 99, 0, 0, 962, 963, 5, 114, 0, 0, 963, 94, 1, 0, 0, 0, 964, 965, 5, 100, 0, 0, 965, 966, 5, 101, 0, 0, 966, 967, 5, 100, 0, 0, 967, 968, 5, 117, 0, 0, 968, 969, 5, 112, 0, 0, 969, 96, 1, 0, 0, 0, 970, 971, 5, 100, 0, 0, 971, 972, 5, 101, 0, 0, 972, 973, 5, 115, 0, 0, 973, 974, 5, 99, 0, 0, 974, 98, 1, 0, 0, 0, 975, 976, 5, 100, 0, 0, 976, 977, 5, 105, 0, 0, 977, 978, 5, 102, 0, 0, 978, 979, 5, 102, 0, 0, 979, 980, 5, 101, 0, 0, 980, 981, 5, 114, 0, 0, 981, 982, 5, 101, 0, 0, 982, 983, 5, 110, 0, 0, 983, 984, 5, 99, 0, 0, 984, 985, 5, 101, 0, 0, 985, 100, 1, 0, 0, 0, 986, 987, 5, 68, 0, 0, 987, 988, 5, 105, 0, 0, 988, 989, 5, 114, 0, 0, 989, 990, 5, 101, 0, 0, 990, 991, 5, 99, 0, 0, 991, 992, 5, 116, 0, 0, 992, 993, 5, 105, 0, 0, 993, 994, 5, 111, 0, 0, 994, 995, 5, 110, 0, 0, 995, 102, 1, 0, 0, 0, 996, 997, 5, 100, 0, 0, 997, 998, 5, 105, 0, 0, 998, 999, 5, 115, 0, 0, 999, 1000, 5, 106, 0, 0, 1000, 1001, 5, 117, 0, 0, 1001, 1002, 5, 110, 0, 0, 1002, 1003, 5, 99, 0, 0, 1003, 1004, 5, 116, 0, 0, 1004, 104, 1, 0, 0, 0, 1005, 1006, 5, 100, 0, 0, 1006, 1007, 5, 105, 0, 0, 1007, 1008, 5, 115, 0, 0, 1008, 1009, 5, 116, 0, 0, 1009, 1010, 5, 97, 0, 0, 1010, 1011, 5, 110, 0, 0, 1011, 1012, 5, 99, 0, 0, 1012, 1013, 5, 101, 0, 0, 1013, 106, 1, 0, 0, 0, 1014, 1015, 5, 100, 0, 0, 1015, 1016, 5, 105, 0, 0, 1016, 1017, 5, 118, 0, 0, 1017, 108, 1, 0, 0, 0, 1018, 1019, 5, 100, 0, 0, 1019, 1020, 5, 114, 0, 0, 1020, 1021, 5, 111, 0, 0, 1021, 1022, 5, 112, 0, 0, 1022, 110, 1, 0, 0, 0, 1023, 1024, 5, 68, 0, 0, 1024, 1025, 5, 84, 0, 0, 1025, 112, 1, 0, 0, 0, 1026, 1027, 5, 69, 0, 0, 1027, 114, 1, 0, 0, 0, 1028, 1029, 5, 101, 0, 0, 1029, 1030, 5, 100, 0, 0, 1030, 1031, 5, 103, 0, 0, 1031, 1032, 5, 101, 0, 0, 1032, 1033, 5, 115, 0, 0, 1033, 116, 1, 0, 0, 0, 1034, 1035, 5, 101, 0, 0, 1035, 1036, 5, 108, 0, 0, 1036, 1037, 5, 101, 0, 0, 1037, 1038, 5, 109, 0, 0, 1038, 1039, 5, 101, 0, 0, 1039, 1040, 5, 110, 0, 0, 1040, 1041, 5, 116, 0, 0, 1041, 1042, 5, 77, 0, 0, 1042, 1043, 5, 97, 0, 0, 1043, 1044, 5, 112, 0, 0, 1044, 118, 1, 0, 0, 0, 1045, 1046, 5, 101, 0, 0, 1046, 1047, 5, 108, 0, 0, 1047, 1048, 5, 101, 0, 0, 1048, 1049, 5, 109, 0, 0, 1049, 1050, 5, 101, 0, 0, 1050, 1051, 5, 110, 0, 0, 1051, 1052, 5, 116, 0, 0, 1052, 120, 1, 0, 0, 0, 1053, 1054, 5, 101, 0, 0, 1054, 1055, 5, 109, 0, 0, 1055, 1056, 5, 105, 0, 0, 1056, 1057, 5, 116, 0, 0, 1057, 122, 1, 0, 0, 0, 1058, 1059, 5, 101, 0, 0, 1059, 1060, 5, 110, 0, 0, 1060, 1061, 5, 100, 0, 0, 1061, 1062, 5, 105, 0, 0, 1062, 1063, 5, 110, 0, 0, 1063, 1064, 5, 103, 0, 0, 1064, 1065, 5, 87, 0, 0, 1065, 1066, 5, 105, 0, 0, 1066, 1067, 5, 116, 0, 0, 1067, 1068, 5, 104, 0, 0, 1068, 124, 1, 0, 0, 0, 1069, 1070, 5, 101, 0, 0, 1070, 1071, 5, 113, 0, 0, 1071, 126, 1, 0, 0, 0, 1072, 1073, 5, 101, 0, 0, 1073, 1074, 5, 120, 0, 0, 1074, 1075, 5, 112, 0, 0, 1075, 1076, 5, 108, 0, 0, 1076, 1077, 5, 97, 0, 0, 1077, 1078, 5, 105, 0, 0, 1078, 1079, 5, 110, 0, 0, 1079, 128, 1, 0, 0, 0, 1080, 1081, 5, 102, 0, 0, 1081, 1082, 5, 97, 0, 0, 1082, 1083, 5, 105, 0, 0, 1083, 1084, 5, 108, 0, 0, 1084, 130, 1, 0, 0, 0, 1085, 1086, 5, 102, 0, 0, 1086, 1087, 5, 97, 0, 0, 1087, 1088, 5, 108, 0, 0, 1088, 1089, 5, 115, 0, 0, 1089, 1090, 5, 101, 0, 0, 1090, 132, 1, 0, 0, 0, 1091, 1092, 5, 102, 0, 0, 1092, 1093, 5, 105, 0, 0, 1093, 1094, 5, 108, 0, 0, 1094, 1095, 5, 116, 0, 0, 1095, 1096, 5, 101, 0, 0, 1096, 1097, 5, 114, 0, 0, 1097, 134, 1, 0, 0, 0, 1098, 1099, 5, 102, 0, 0, 1099, 1100, 5, 105, 0, 0, 1100, 1101, 5, 114, 0, 0, 1101, 1102, 5, 115, 0, 0, 1102, 1103, 5, 116, 0, 0, 1103, 136, 1, 0, 0, 0, 1104, 1105, 5, 102, 0, 0, 1105, 1106, 5, 108, 0, 0, 1106, 1107, 5, 97, 0, 0, 1107, 1108, 5, 116, 0, 0, 1108, 1109, 5, 77, 0, 0, 1109, 1110, 5, 97, 0, 0, 1110, 1111, 5, 112, 0, 0, 1111, 138, 1, 0, 0, 0, 1112, 1113, 5, 102, 0, 0, 1113, 1114, 5, 111, 0, 0, 1114, 1115, 5, 108, 0, 0, 1115, 1116, 5, 100, 0, 0, 1116, 140, 1, 0, 0, 0, 1117, 1118, 5, 102, 0, 0, 1118, 1119, 5, 111, 0, 0, 1119, 1120, 5, 114, 0, 0, 1120, 1121, 5, 109, 0, 0, 1121, 1122, 5, 97, 0, 0, 1122, 1123, 5, 116, 0, 0, 1123, 142, 1, 0, 0, 0, 1124, 1125, 5, 102, 0, 0, 1125, 1126, 5, 114, 0, 0, 1126, 1127, 5, 111, 0, 0, 1127, 1128, 5, 109, 0, 0, 1128, 144, 1, 0, 0, 0, 1129, 1130, 5, 103, 0, 0, 1130, 1131, 5, 108, 0, 0, 1131, 1132, 5, 111, 0, 0, 1132, 1133, 5, 98, 0, 0, 1133, 1134, 5, 97, 0, 0, 1134, 1135, 5, 108, 0, 0, 1135, 146, 1, 0, 0, 0, 1136, 1137, 5, 103, 0, 0, 1137, 1138, 5, 116, 0, 0, 1138, 148, 1, 0, 0, 0, 1139, 1140, 5, 103, 0, 0, 1140, 1141, 5, 116, 0, 0, 1141, 1142, 5, 101, 0, 0, 1142, 150, 1, 0, 0, 0, 1143, 1144, 5, 103, 0, 0, 1144, 1145, 5, 114, 0, 0, 1145, 1146, 5, 97, 0, 0, 1146, 1147, 5, 112, 0, 0, 1147, 1148, 5, 104, 0, 0, 1148, 1149, 5, 109, 0, 0, 1149, 1150, 5, 108, 0, 0, 1150, 152, 1, 0, 0, 0, 1151, 1152, 5, 103, 0, 0, 1152, 1153, 5, 114, 0, 0, 1153, 1154, 5, 97, 0, 0, 1154, 1155, 5, 112, 0, 0, 1155, 1156, 5, 104, 0, 0, 1156, 1157, 5, 115, 0, 0, 1157, 1158, 5, 111, 0, 0, 1158, 1159, 5, 110, 0, 0, 1159, 154, 1, 0, 0, 0, 1160, 1161, 5, 103, 0, 0, 1161, 1162, 5, 114, 0, 0, 1162, 1163, 5, 111, 0, 0, 1163, 1164, 5, 117, 0, 0, 1164, 1165, 5, 112, 0, 0, 1165, 1166, 5, 67, 0, 0, 1166, 1167, 5, 111, 0, 0, 1167, 1168, 5, 117, 0, 0, 1168, 1169, 5, 110, 0, 0, 1169, 1170, 5, 116, 0, 0, 1170, 156, 1, 0, 0, 0, 1171, 1172, 5, 103, 0, 0, 1172, 1173, 5, 114, 0, 0, 1173, 1174, 5, 111, 0, 0, 1174, 1175, 5, 117, 0, 0, 1175, 1176, 5, 112, 0, 0, 1176, 158, 1, 0, 0, 0, 1177, 1178, 5, 103, 0, 0, 1178, 1179, 5, 114, 0, 0, 1179, 1180, 5, 121, 0, 0, 1180, 1181, 5, 111, 0, 0, 1181, 160, 1, 0, 0, 0, 1182, 1183, 5, 104, 0, 0, 1183, 1184, 5, 97, 0, 0, 1184, 1185, 5, 115, 0, 0, 1185, 162, 1, 0, 0, 0, 1186, 1187, 5, 104, 0, 0, 1187, 1188, 5, 97, 0, 0, 1188, 1189, 5, 115, 0, 0, 1189, 1190, 5, 73, 0, 0, 1190, 1191, 5, 100, 0, 0, 1191, 164, 1, 0, 0, 0, 1192, 1193, 5, 104, 0, 0, 1193, 1194, 5, 97, 0, 0, 1194, 1195, 5, 115, 0, 0, 1195, 1196, 5, 75, 0, 0, 1196, 1197, 5, 101, 0, 0, 1197, 1198, 5, 121, 0, 0, 1198, 166, 1, 0, 0, 0, 1199, 1200, 5, 104, 0, 0, 1200, 1201, 5, 97, 0, 0, 1201, 1202, 5, 115, 0, 0, 1202, 1203, 5, 76, 0, 0, 1203, 1204, 5, 97, 0, 0, 1204, 1205, 5, 98, 0, 0, 1205, 1206, 5, 101, 0, 0, 1206, 1207, 5, 108, 0, 0, 1207, 168, 1, 0, 0, 0, 1208, 1209, 5, 104, 0, 0, 1209, 1210, 5, 97, 0, 0, 1210, 1211, 5, 115, 0, 0, 1211, 1212, 5, 78, 0, 0, 1212, 1213, 5, 101, 0, 0, 1213, 1214, 5, 120, 0, 0, 1214, 1215, 5, 116, 0, 0, 1215, 170, 1, 0, 0, 0, 1216, 1217, 5, 104, 0, 0, 1217, 1218, 5, 97, 0, 0, 1218, 1219, 5, 115, 0, 0, 1219, 1220, 5, 78, 0, 0, 1220, 1221, 5, 111, 0, 0, 1221, 1222, 5, 116, 0, 0, 1222, 172, 1, 0, 0, 0, 1223, 1224, 5, 104, 0, 0, 1224, 1225, 5, 97, 0, 0, 1225, 1226, 5, 115, 0, 0, 1226, 1227, 5, 86, 0, 0, 1227, 1228, 5, 97, 0, 0, 1228, 1229, 5, 108, 0, 0, 1229, 1230, 5, 117, 0, 0, 1230, 1231, 5, 101, 0, 0, 1231, 174, 1, 0, 0, 0, 1232, 1233, 5, 104, 0, 0, 1233, 1234, 5, 111, 0, 0, 1234, 1235, 5, 117, 0, 0, 1235, 1236, 5, 114, 0, 0, 1236, 176, 1, 0, 0, 0, 1237, 1238, 5, 105, 0, 0, 1238, 1239, 5, 100, 0, 0, 1239, 178, 1, 0, 0, 0, 1240, 1241, 5, 105, 0, 0, 1241, 1242, 5, 100, 0, 0, 1242, 1243, 5, 101, 0, 0, 1243, 1244, 5, 110, 0, 0, 1244, 1245, 5, 116, 0, 0, 1245, 1246, 5, 105, 0, 0, 1246, 1247, 5, 116, 0, 0, 1247, 1248, 5, 121, 0, 0, 1248, 180, 1, 0, 0, 0, 1249, 1250, 5, 105, 0, 0, 1250, 1251, 5, 100, 0, 0, 1251, 1252, 5, 115, 0, 0, 1252, 182, 1, 0, 0, 0, 1253, 1254, 5, 105, 0, 0, 1254, 1255, 5, 110, 0, 0, 1255, 184, 1, 0, 0, 0, 1256, 1257, 5, 73, 0, 0, 1257, 1258, 5, 78, 0, 0, 1258, 186, 1, 0, 0, 0, 1259, 1260, 5, 105, 0, 0, 1260, 1261, 5, 110, 0, 0, 1261, 1262, 5, 69, 0, 0, 1262, 188, 1, 0, 0, 0, 1263, 1264, 5, 105, 0, 0, 1264, 1265, 5, 110, 0, 0, 1265, 1266, 5, 99, 0, 0, 1266, 1267, 5, 108, 0, 0, 1267, 1268, 5, 117, 0, 0, 1268, 1269, 5, 100, 0, 0, 1269, 1270, 5, 101, 0, 0, 1270, 1271, 5, 69, 0, 0, 1271, 1272, 5, 100, 0, 0, 1272, 1273, 5, 103, 0, 0, 1273, 1274, 5, 101, 0, 0, 1274, 1275, 5, 115, 0, 0, 1275, 190, 1, 0, 0, 0, 1276, 1277, 5, 105, 0, 0, 1277, 1278, 5, 110, 0, 0, 1278, 1279, 5, 99, 0, 0, 1279, 1280, 5, 114, 0, 0, 1280, 192, 1, 0, 0, 0, 1281, 1282, 5, 105, 0, 0, 1282, 1283, 5, 110, 0, 0, 1283, 1284, 5, 100, 0, 0, 1284, 1285, 5, 101, 0, 0, 1285, 1286, 5, 120, 0, 0, 1286, 1287, 5, 101, 0, 0, 1287, 1288, 5, 114, 0, 0, 1288, 194, 1, 0, 0, 0, 1289, 1290, 5, 105, 0, 0, 1290, 1291, 5, 110, 0, 0, 1291, 1292, 5, 100, 0, 0, 1292, 1293, 5, 101, 0, 0, 1293, 1294, 5, 120, 0, 0, 1294, 196, 1, 0, 0, 0, 1295, 1296, 5, 73, 0, 0, 1296, 1297, 5, 110, 0, 0, 1297, 1298, 5, 102, 0, 0, 1298, 1299, 5, 105, 0, 0, 1299, 1300, 5, 110, 0, 0, 1300, 1301, 5, 105, 0, 0, 1301, 1302, 5, 116, 0, 0, 1302, 1303, 5, 121, 0, 0, 1303, 198, 1, 0, 0, 0, 1304, 1305, 5, 105, 0, 0, 1305, 1306, 5, 110, 0, 0, 1306, 1307, 5, 106, 0, 0, 1307, 1308, 5, 101, 0, 0, 1308, 1309, 5, 99, 0, 0, 1309, 1310, 5, 116, 0, 0, 1310, 200, 1, 0, 0, 0, 1311, 1312, 5, 105, 0, 0, 1312, 1313, 5, 110, 0, 0, 1313, 1314, 5, 115, 0, 0, 1314, 1315, 5, 105, 0, 0, 1315, 1316, 5, 100, 0, 0, 1316, 1317, 5, 101, 0, 0, 1317, 202, 1, 0, 0, 0, 1318, 1319, 5, 105, 0, 0, 1319, 1320, 5, 110, 0, 0, 1320, 1321, 5, 116, 0, 0, 1321, 1322, 5, 101, 0, 0, 1322, 1323, 5, 114, 0, 0, 1323, 1324, 5, 115, 0, 0, 1324, 1325, 5, 101, 0, 0, 1325, 1326, 5, 99, 0, 0, 1326, 1327, 5, 116, 0, 0, 1327, 204, 1, 0, 0, 0, 1328, 1329, 5, 105, 0, 0, 1329, 1330, 5, 110, 0, 0, 1330, 1331, 5, 86, 0, 0, 1331, 206, 1, 0, 0, 0, 1332, 1333, 5, 73, 0, 0, 1333, 1334, 5, 79, 0, 0, 1334, 208, 1, 0, 0, 0, 1335, 1336, 5, 105, 0, 0, 1336, 1337, 5, 111, 0, 0, 1337, 210, 1, 0, 0, 0, 1338, 1339, 5, 105, 0, 0, 1339, 1340, 5, 115, 0, 0, 1340, 212, 1, 0, 0, 0, 1341, 1342, 5, 105, 0, 0, 1342, 1343, 5, 116, 0, 0, 1343, 1344, 5, 101, 0, 0, 1344, 1345, 5, 114, 0, 0, 1345, 1346, 5, 97, 0, 0, 1346, 1347, 5, 116, 0, 0, 1347, 1348, 5, 101, 0, 0, 1348, 214, 1, 0, 0, 0, 1349, 1350, 5, 107, 0, 0, 1350, 1351, 5, 101, 0, 0, 1351, 1352, 5, 121, 0, 0, 1352, 216, 1, 0, 0, 0, 1353, 1354, 5, 107, 0, 0, 1354, 1355, 5, 101, 0, 0, 1355, 1356, 5, 121, 0, 0, 1356, 1357, 5, 115, 0, 0, 1357, 218, 1, 0, 0, 0, 1358, 1359, 5, 108, 0, 0, 1359, 1360, 5, 97, 0, 0, 1360, 1361, 5, 98, 0, 0, 1361, 1362, 5, 101, 0, 0, 1362, 1363, 5, 108, 0, 0, 1363, 1364, 5, 115, 0, 0, 1364, 220, 1, 0, 0, 0, 1365, 1366, 5, 108, 0, 0, 1366, 1367, 5, 97, 0, 0, 1367, 1368, 5, 98, 0, 0, 1368, 1369, 5, 101, 0, 0, 1369, 1370, 5, 108, 0, 0, 1370, 222, 1, 0, 0, 0, 1371, 1372, 5, 108, 0, 0, 1372, 1373, 5, 97, 0, 0, 1373, 1374, 5, 115, 0, 0, 1374, 1375, 5, 116, 0, 0, 1375, 224, 1, 0, 0, 0, 1376, 1377, 5, 108, 0, 0, 1377, 1378, 5, 101, 0, 0, 1378, 1379, 5, 110, 0, 0, 1379, 1380, 5, 103, 0, 0, 1380, 1381, 5, 116, 0, 0, 1381, 1382, 5, 104, 0, 0, 1382, 226, 1, 0, 0, 0, 1383, 1384, 5, 108, 0, 0, 1384, 1385, 5, 105, 0, 0, 1385, 1386, 5, 109, 0, 0, 1386, 1387, 5, 105, 0, 0, 1387, 1388, 5, 116, 0, 0, 1388, 228, 1, 0, 0, 0, 1389, 1390, 5, 108, 0, 0, 1390, 1391, 5, 105, 0, 0, 1391, 1392, 5, 115, 0, 0, 1392, 1393, 5, 116, 0, 0, 1393, 230, 1, 0, 0, 0, 1394, 1395, 5, 108, 0, 0, 1395, 1396, 5, 111, 0, 0, 1396, 1397, 5, 99, 0, 0, 1397, 1398, 5, 97, 0, 0, 1398, 1399, 5, 108, 0, 0, 1399, 232, 1, 0, 0, 0, 1400, 1401, 5, 108, 0, 0, 1401, 1402, 5, 111, 0, 0, 1402, 1403, 5, 111, 0, 0, 1403, 1404, 5, 112, 0, 0, 1404, 1405, 5, 115, 0, 0, 1405, 234, 1, 0, 0, 0, 1406, 1407, 5, 108, 0, 0, 1407, 1408, 5, 116, 0, 0, 1408, 236, 1, 0, 0, 0, 1409, 1410, 5, 108, 0, 0, 1410, 1411, 5, 116, 0, 0, 1411, 1412, 5, 101, 0, 0, 1412, 238, 1, 0, 0, 0, 1413, 1414, 5, 108, 0, 0, 1414, 1415, 5, 84, 0, 0, 1415, 1416, 5, 114, 0, 0, 1416, 1417, 5, 105, 0, 0, 1417, 1418, 5, 109, 0, 0, 1418, 240, 1, 0, 0, 0, 1419, 1420, 5, 109, 0, 0, 1420, 1421, 5, 97, 0, 0, 1421, 1422, 5, 112, 0, 0, 1422, 242, 1, 0, 0, 0, 1423, 1424, 5, 109, 0, 0, 1424, 1425, 5, 97, 0, 0, 1425, 1426, 5, 116, 0, 0, 1426, 1427, 5, 99, 0, 0, 1427, 1428, 5, 104, 0, 0, 1428, 244, 1, 0, 0, 0, 1429, 1430, 5, 109, 0, 0, 1430, 1431, 5, 97, 0, 0, 1431, 1432, 5, 116, 0, 0, 1432, 1433, 5, 104, 0, 0, 1433, 246, 1, 0, 0, 0, 1434, 1435, 5, 109, 0, 0, 1435, 1436, 5, 97, 0, 0, 1436, 1437, 5, 120, 0, 0, 1437, 248, 1, 0, 0, 0, 1438, 1439, 5, 109, 0, 0, 1439, 1440, 5, 97, 0, 0, 1440, 1441, 5, 120, 0, 0, 1441, 1442, 5, 68, 0, 0, 1442, 1443, 5, 105, 0, 0, 1443, 1444, 5, 115, 0, 0, 1444, 1445, 5, 116, 0, 0, 1445, 1446, 5, 97, 0, 0, 1446, 1447, 5, 110, 0, 0, 1447, 1448, 5, 99, 0, 0, 1448, 1449, 5, 101, 0, 0, 1449, 250, 1, 0, 0, 0, 1450, 1451, 5, 109, 0, 0, 1451, 1452, 5, 101, 0, 0, 1452, 1453, 5, 97, 0, 0, 1453, 1454, 5, 110, 0, 0, 1454, 252, 1, 0, 0, 0, 1455, 1456, 5, 77, 0, 0, 1456, 1457, 5, 101, 0, 0, 1457, 1458, 5, 114, 0, 0, 1458, 1459, 5, 103, 0, 0, 1459, 1460, 5, 101, 0, 0, 1460, 254, 1, 0, 0, 0, 1461, 1462, 5, 109, 0, 0, 1462, 1463, 5, 101, 0, 0, 1463, 1464, 5, 114, 0, 0, 1464, 1465, 5, 103, 0, 0, 1465, 1466, 5, 101, 0, 0, 1466, 256, 1, 0, 0, 0, 1467, 1468, 5, 109, 0, 0, 1468, 1469, 5, 101, 0, 0, 1469, 1470, 5, 114, 0, 0, 1470, 1471, 5, 103, 0, 0, 1471, 1472, 5, 101, 0, 0, 1472, 1473, 5, 69, 0, 0, 1473, 258, 1, 0, 0, 0, 1474, 1475, 5, 109, 0, 0, 1475, 1476, 5, 101, 0, 0, 1476, 1477, 5, 114, 0, 0, 1477, 1478, 5, 103, 0, 0, 1478, 1479, 5, 101, 0, 0, 1479, 1480, 5, 86, 0, 0, 1480, 260, 1, 0, 0, 0, 1481, 1482, 5, 109, 0, 0, 1482, 1483, 5, 105, 0, 0, 1483, 1484, 5, 110, 0, 0, 1484, 262, 1, 0, 0, 0, 1485, 1486, 5, 109, 0, 0, 1486, 1487, 5, 105, 0, 0, 1487, 1488, 5, 110, 0, 0, 1488, 1489, 5, 117, 0, 0, 1489, 1490, 5, 116, 0, 0, 1490, 1491, 5, 101, 0, 0, 1491, 264, 1, 0, 0, 0, 1492, 1493, 5, 109, 0, 0, 1493, 1494, 5, 105, 0, 0, 1494, 1495, 5, 110, 0, 0, 1495, 1496, 5, 117, 0, 0, 1496, 1497, 5, 115, 0, 0, 1497, 266, 1, 0, 0, 0, 1498, 1499, 5, 109, 0, 0, 1499, 1500, 5, 105, 0, 0, 1500, 1501, 5, 120, 0, 0, 1501, 1502, 5, 101, 0, 0, 1502, 1503, 5, 100, 0, 0, 1503, 268, 1, 0, 0, 0, 1504, 1505, 5, 109, 0, 0, 1505, 1506, 5, 117, 0, 0, 1506, 1507, 5, 108, 0, 0, 1507, 1508, 5, 116, 0, 0, 1508, 270, 1, 0, 0, 0, 1509, 1510, 5, 78, 0, 0, 1510, 1511, 5, 97, 0, 0, 1511, 1512, 5, 78, 0, 0, 1512, 272, 1, 0, 0, 0, 1513, 1514, 5, 110, 0, 0, 1514, 1515, 5, 101, 0, 0, 1515, 1516, 5, 103, 0, 0, 1516, 1517, 5, 97, 0, 0, 1517, 1518, 5, 116, 0, 0, 1518, 1519, 5, 101, 0, 0, 1519, 274, 1, 0, 0, 0, 1520, 1521, 5, 110, 0, 0, 1521, 1522, 5, 101, 0, 0, 1522, 1523, 5, 120, 0, 0, 1523, 1524, 5, 116, 0, 0, 1524, 276, 1, 0, 0, 0, 1525, 1526, 5, 110, 0, 0, 1526, 1527, 5, 111, 0, 0, 1527, 1528, 5, 110, 0, 0, 1528, 1529, 5, 101, 0, 0, 1529, 278, 1, 0, 0, 0, 1530, 1531, 5, 110, 0, 0, 1531, 1532, 5, 111, 0, 0, 1532, 1533, 5, 116, 0, 0, 1533, 1534, 5, 82, 0, 0, 1534, 1535, 5, 101, 0, 0, 1535, 1536, 5, 103, 0, 0, 1536, 1537, 5, 101, 0, 0, 1537, 1538, 5, 120, 0, 0, 1538, 280, 1, 0, 0, 0, 1539, 1540, 5, 110, 0, 0, 1540, 1541, 5, 111, 0, 0, 1541, 1542, 5, 116, 0, 0, 1542, 1543, 5, 67, 0, 0, 1543, 1544, 5, 111, 0, 0, 1544, 1545, 5, 110, 0, 0, 1545, 1546, 5, 116, 0, 0, 1546, 1547, 5, 97, 0, 0, 1547, 1548, 5, 105, 0, 0, 1548, 1549, 5, 110, 0, 0, 1549, 1550, 5, 105, 0, 0, 1550, 1551, 5, 110, 0, 0, 1551, 1552, 5, 103, 0, 0, 1552, 282, 1, 0, 0, 0, 1553, 1554, 5, 110, 0, 0, 1554, 1555, 5, 111, 0, 0, 1555, 1556, 5, 116, 0, 0, 1556, 1557, 5, 69, 0, 0, 1557, 1558, 5, 110, 0, 0, 1558, 1559, 5, 100, 0, 0, 1559, 1560, 5, 105, 0, 0, 1560, 1561, 5, 110, 0, 0, 1561, 1562, 5, 103, 0, 0, 1562, 1563, 5, 87, 0, 0, 1563, 1564, 5, 105, 0, 0, 1564, 1565, 5, 116, 0, 0, 1565, 1566, 5, 104, 0, 0, 1566, 284, 1, 0, 0, 0, 1567, 1568, 5, 110, 0, 0, 1568, 1569, 5, 111, 0, 0, 1569, 1570, 5, 116, 0, 0, 1570, 1571, 5, 83, 0, 0, 1571, 1572, 5, 116, 0, 0, 1572, 1573, 5, 97, 0, 0, 1573, 1574, 5, 114, 0, 0, 1574, 1575, 5, 116, 0, 0, 1575, 1576, 5, 105, 0, 0, 1576, 1577, 5, 110, 0, 0, 1577, 1578, 5, 103, 0, 0, 1578, 1579, 5, 87, 0, 0, 1579, 1580, 5, 105, 0, 0, 1580, 1581, 5, 116, 0, 0, 1581, 1582, 5, 104, 0, 0, 1582, 286, 1, 0, 0, 0, 1583, 1584, 5, 110, 0, 0, 1584, 1585, 5, 111, 0, 0, 1585, 1586, 5, 116, 0, 0, 1586, 288, 1, 0, 0, 0, 1587, 1588, 5, 110, 0, 0, 1588, 1589, 5, 101, 0, 0, 1589, 1590, 5, 113, 0, 0, 1590, 290, 1, 0, 0, 0, 1591, 1592, 5, 110, 0, 0, 1592, 1593, 5, 101, 0, 0, 1593, 1594, 5, 119, 0, 0, 1594, 292, 1, 0, 0, 0, 1595, 1596, 5, 110, 0, 0, 1596, 1597, 5, 111, 0, 0, 1597, 1598, 5, 114, 0, 0, 1598, 1599, 5, 109, 0, 0, 1599, 1600, 5, 83, 0, 0, 1600, 1601, 5, 97, 0, 0, 1601, 1602, 5, 99, 0, 0, 1602, 1603, 5, 107, 0, 0, 1603, 294, 1, 0, 0, 0, 1604, 1605, 5, 110, 0, 0, 1605, 1606, 5, 117, 0, 0, 1606, 1607, 5, 108, 0, 0, 1607, 1608, 5, 108, 0, 0, 1608, 296, 1, 0, 0, 0, 1609, 1610, 5, 111, 0, 0, 1610, 1611, 5, 110, 0, 0, 1611, 1612, 5, 67, 0, 0, 1612, 1613, 5, 114, 0, 0, 1613, 1614, 5, 101, 0, 0, 1614, 1615, 5, 97, 0, 0, 1615, 1616, 5, 116, 0, 0, 1616, 1617, 5, 101, 0, 0, 1617, 298, 1, 0, 0, 0, 1618, 1619, 5, 111, 0, 0, 1619, 1620, 5, 110, 0, 0, 1620, 1621, 5, 77, 0, 0, 1621, 1622, 5, 97, 0, 0, 1622, 1623, 5, 116, 0, 0, 1623, 1624, 5, 99, 0, 0, 1624, 1625, 5, 104, 0, 0, 1625, 300, 1, 0, 0, 0, 1626, 1627, 5, 79, 0, 0, 1627, 1628, 5, 112, 0, 0, 1628, 1629, 5, 101, 0, 0, 1629, 1630, 5, 114, 0, 0, 1630, 1631, 5, 97, 0, 0, 1631, 1632, 5, 116, 0, 0, 1632, 1633, 5, 111, 0, 0, 1633, 1634, 5, 114, 0, 0, 1634, 302, 1, 0, 0, 0, 1635, 1636, 5, 111, 0, 0, 1636, 1637, 5, 112, 0, 0, 1637, 1638, 5, 116, 0, 0, 1638, 1639, 5, 105, 0, 0, 1639, 1640, 5, 111, 0, 0, 1640, 1641, 5, 110, 0, 0, 1641, 304, 1, 0, 0, 0, 1642, 1643, 5, 111, 0, 0, 1643, 1644, 5, 112, 0, 0, 1644, 1645, 5, 116, 0, 0, 1645, 1646, 5, 105, 0, 0, 1646, 1647, 5, 111, 0, 0, 1647, 1648, 5, 110, 0, 0, 1648, 1649, 5, 97, 0, 0, 1649, 1650, 5, 108, 0, 0, 1650, 306, 1, 0, 0, 0, 1651, 1652, 5, 79, 0, 0, 1652, 1653, 5, 114, 0, 0, 1653, 1654, 5, 100, 0, 0, 1654, 1655, 5, 101, 0, 0, 1655, 1656, 5, 114, 0, 0, 1656, 308, 1, 0, 0, 0, 1657, 1658, 5, 111, 0, 0, 1658, 1659, 5, 114, 0, 0, 1659, 1660, 5, 100, 0, 0, 1660, 1661, 5, 101, 0, 0, 1661, 1662, 5, 114, 0, 0, 1662, 310, 1, 0, 0, 0, 1663, 1664, 5, 111, 0, 0, 1664, 1665, 5, 114, 0, 0, 1665, 312, 1, 0, 0, 0, 1666, 1667, 5, 111, 0, 0, 1667, 1668, 5, 116, 0, 0, 1668, 1669, 5, 104, 0, 0, 1669, 1670, 5, 101, 0, 0, 1670, 1671, 5, 114, 0, 0, 1671, 1672, 5, 86, 0, 0, 1672, 314, 1, 0, 0, 0, 1673, 1674, 5, 79, 0, 0, 1674, 1675, 5, 85, 0, 0, 1675, 1676, 5, 84, 0, 0, 1676, 316, 1, 0, 0, 0, 1677, 1678, 5, 111, 0, 0, 1678, 1679, 5, 117, 0, 0, 1679, 1680, 5, 116, 0, 0, 1680, 318, 1, 0, 0, 0, 1681, 1682, 5, 111, 0, 0, 1682, 1683, 5, 117, 0, 0, 1683, 1684, 5, 116, 0, 0, 1684, 1685, 5, 69, 0, 0, 1685, 320, 1, 0, 0, 0, 1686, 1687, 5, 111, 0, 0, 1687, 1688, 5, 117, 0, 0, 1688, 1689, 5, 116, 0, 0, 1689, 1690, 5, 115, 0, 0, 1690, 1691, 5, 105, 0, 0, 1691, 1692, 5, 100, 0, 0, 1692, 1693, 5, 101, 0, 0, 1693, 322, 1, 0, 0, 0, 1694, 1695, 5, 111, 0, 0, 1695, 1696, 5, 117, 0, 0, 1696, 1697, 5, 116, 0, 0, 1697, 1698, 5, 86, 0, 0, 1698, 324, 1, 0, 0, 0, 1699, 1700, 5, 80, 0, 0, 1700, 326, 1, 0, 0, 0, 1701, 1702, 5, 80, 0, 0, 1702, 1703, 5, 97, 0, 0, 1703, 1704, 5, 103, 0, 0, 1704, 1705, 5, 101, 0, 0, 1705, 1706, 5, 82, 0, 0, 1706, 1707, 5, 97, 0, 0, 1707, 1708, 5, 110, 0, 0, 1708, 1709, 5, 107, 0, 0, 1709, 328, 1, 0, 0, 0, 1710, 1711, 5, 112, 0, 0, 1711, 1712, 5, 97, 0, 0, 1712, 1713, 5, 103, 0, 0, 1713, 1714, 5, 101, 0, 0, 1714, 1715, 5, 82, 0, 0, 1715, 1716, 5, 97, 0, 0, 1716, 1717, 5, 110, 0, 0, 1717, 1718, 5, 107, 0, 0, 1718, 330, 1, 0, 0, 0, 1719, 1720, 5, 112, 0, 0, 1720, 1721, 5, 97, 0, 0, 1721, 1722, 5, 116, 0, 0, 1722, 1723, 5, 104, 0, 0, 1723, 332, 1, 0, 0, 0, 1724, 1725, 5, 80, 0, 0, 1725, 1726, 5, 101, 0, 0, 1726, 1727, 5, 101, 0, 0, 1727, 1728, 5, 114, 0, 0, 1728, 1729, 5, 80, 0, 0, 1729, 1730, 5, 114, 0, 0, 1730, 1731, 5, 101, 0, 0, 1731, 1732, 5, 115, 0, 0, 1732, 1733, 5, 115, 0, 0, 1733, 1734, 5, 117, 0, 0, 1734, 1735, 5, 114, 0, 0, 1735, 1736, 5, 101, 0, 0, 1736, 334, 1, 0, 0, 0, 1737, 1738, 5, 112, 0, 0, 1738, 1739, 5, 101, 0, 0, 1739, 1740, 5, 101, 0, 0, 1740, 1741, 5, 114, 0, 0, 1741, 1742, 5, 80, 0, 0, 1742, 1743, 5, 114, 0, 0, 1743, 1744, 5, 101, 0, 0, 1744, 1745, 5, 115, 0, 0, 1745, 1746, 5, 115, 0, 0, 1746, 1747, 5, 117, 0, 0, 1747, 1748, 5, 114, 0, 0, 1748, 1749, 5, 101, 0, 0, 1749, 336, 1, 0, 0, 0, 1750, 1751, 5, 80, 0, 0, 1751, 1752, 5, 105, 0, 0, 1752, 1753, 5, 99, 0, 0, 1753, 1754, 5, 107, 0, 0, 1754, 338, 1, 0, 0, 0, 1755, 1756, 5, 80, 0, 0, 1756, 1757, 5, 111, 0, 0, 1757, 1758, 5, 112, 0, 0, 1758, 340, 1, 0, 0, 0, 1759, 1760, 5, 112, 0, 0, 1760, 1761, 5, 114, 0, 0, 1761, 1762, 5, 111, 0, 0, 1762, 1763, 5, 102, 0, 0, 1763, 1764, 5, 105, 0, 0, 1764, 1765, 5, 108, 0, 0, 1765, 1766, 5, 101, 0, 0, 1766, 342, 1, 0, 0, 0, 1767, 1768, 5, 112, 0, 0, 1768, 1769, 5, 114, 0, 0, 1769, 1770, 5, 111, 0, 0, 1770, 1771, 5, 106, 0, 0, 1771, 1772, 5, 101, 0, 0, 1772, 1773, 5, 99, 0, 0, 1773, 1774, 5, 116, 0, 0, 1774, 344, 1, 0, 0, 0, 1775, 1776, 5, 112, 0, 0, 1776, 1777, 5, 114, 0, 0, 1777, 1778, 5, 111, 0, 0, 1778, 1779, 5, 112, 0, 0, 1779, 1780, 5, 101, 0, 0, 1780, 1781, 5, 114, 0, 0, 1781, 1782, 5, 116, 0, 0, 1782, 1783, 5, 105, 0, 0, 1783, 1784, 5, 101, 0, 0, 1784, 1785, 5, 115, 0, 0, 1785, 346, 1, 0, 0, 0, 1786, 1787, 5, 112, 0, 0, 1787, 1788, 5, 114, 0, 0, 1788, 1789, 5, 111, 0, 0, 1789, 1790, 5, 112, 0, 0, 1790, 1791, 5, 101, 0, 0, 1791, 1792, 5, 114, 0, 0, 1792, 1793, 5, 116, 0, 0, 1793, 1794, 5, 121, 0, 0, 1794, 1795, 5, 77, 0, 0, 1795, 1796, 5, 97, 0, 0, 1796, 1797, 5, 112, 0, 0, 1797, 348, 1, 0, 0, 0, 1798, 1799, 5, 112, 0, 0, 1799, 1800, 5, 114, 0, 0, 1800, 1801, 5, 111, 0, 0, 1801, 1802, 5, 112, 0, 0, 1802, 1803, 5, 101, 0, 0, 1803, 1804, 5, 114, 0, 0, 1804, 1805, 5, 116, 0, 0, 1805, 1806, 5, 121, 0, 0, 1806, 1807, 5, 78, 0, 0, 1807, 1808, 5, 97, 0, 0, 1808, 1809, 5, 109, 0, 0, 1809, 1810, 5, 101, 0, 0, 1810, 350, 1, 0, 0, 0, 1811, 1812, 5, 112, 0, 0, 1812, 1813, 5, 114, 0, 0, 1813, 1814, 5, 111, 0, 0, 1814, 1815, 5, 112, 0, 0, 1815, 1816, 5, 101, 0, 0, 1816, 1817, 5, 114, 0, 0, 1817, 1818, 5, 116, 0, 0, 1818, 1819, 5, 121, 0, 0, 1819, 352, 1, 0, 0, 0, 1820, 1821, 5, 112, 0, 0, 1821, 1822, 5, 114, 0, 0, 1822, 1823, 5, 111, 0, 0, 1823, 1824, 5, 100, 0, 0, 1824, 1825, 5, 117, 0, 0, 1825, 1826, 5, 99, 0, 0, 1826, 1827, 5, 116, 0, 0, 1827, 354, 1, 0, 0, 0, 1828, 1829, 5, 114, 0, 0, 1829, 1830, 5, 97, 0, 0, 1830, 1831, 5, 110, 0, 0, 1831, 1832, 5, 103, 0, 0, 1832, 1833, 5, 101, 0, 0, 1833, 356, 1, 0, 0, 0, 1834, 1835, 5, 114, 0, 0, 1835, 1836, 5, 101, 0, 0, 1836, 1837, 5, 97, 0, 0, 1837, 1838, 5, 100, 0, 0, 1838, 358, 1, 0, 0, 0, 1839, 1840, 5, 114, 0, 0, 1840, 1841, 5, 101, 0, 0, 1841, 1842, 5, 97, 0, 0, 1842, 1843, 5, 100, 0, 0, 1843, 1844, 5, 101, 0, 0, 1844, 1845, 5, 114, 0, 0, 1845, 360, 1, 0, 0, 0, 1846, 1847, 5, 82, 0, 0, 1847, 1848, 5, 101, 0, 0, 1848, 1849, 5, 102, 0, 0, 1849, 1850, 5, 101, 0, 0, 1850, 1851, 5, 114, 0, 0, 1851, 1852, 5, 101, 0, 0, 1852, 1853, 5, 110, 0, 0, 1853, 1854, 5, 99, 0, 0, 1854, 1855, 5, 101, 0, 0, 1855, 1856, 5, 86, 0, 0, 1856, 1857, 5, 101, 0, 0, 1857, 1858, 5, 114, 0, 0, 1858, 1859, 5, 116, 0, 0, 1859, 1860, 5, 101, 0, 0, 1860, 1861, 5, 120, 0, 0, 1861, 362, 1, 0, 0, 0, 1862, 1863, 5, 114, 0, 0, 1863, 1864, 5, 101, 0, 0, 1864, 1865, 5, 103, 0, 0, 1865, 1866, 5, 101, 0, 0, 1866, 1867, 5, 120, 0, 0, 1867, 364, 1, 0, 0, 0, 1868, 1869, 5, 114, 0, 0, 1869, 1870, 5, 101, 0, 0, 1870, 1871, 5, 112, 0, 0, 1871, 1872, 5, 108, 0, 0, 1872, 1873, 5, 97, 0, 0, 1873, 1874, 5, 99, 0, 0, 1874, 1875, 5, 101, 0, 0, 1875, 366, 1, 0, 0, 0, 1876, 1877, 5, 114, 0, 0, 1877, 1878, 5, 101, 0, 0, 1878, 1879, 5, 112, 0, 0, 1879, 1880, 5, 101, 0, 0, 1880, 1881, 5, 97, 0, 0, 1881, 1882, 5, 116, 0, 0, 1882, 368, 1, 0, 0, 0, 1883, 1884, 5, 114, 0, 0, 1884, 1885, 5, 101, 0, 0, 1885, 1886, 5, 118, 0, 0, 1886, 1887, 5, 101, 0, 0, 1887, 1888, 5, 114, 0, 0, 1888, 1889, 5, 115, 0, 0, 1889, 1890, 5, 101, 0, 0, 1890, 370, 1, 0, 0, 0, 1891, 1892, 5, 114, 0, 0, 1892, 1893, 5, 111, 0, 0, 1893, 1894, 5, 108, 0, 0, 1894, 1895, 5, 108, 0, 0, 1895, 1896, 5, 98, 0, 0, 1896, 1897, 5, 97, 0, 0, 1897, 1898, 5, 99, 0, 0, 1898, 1899, 5, 107, 0, 0, 1899, 372, 1, 0, 0, 0, 1900, 1901, 5, 114, 0, 0, 1901, 1902, 5, 84, 0, 0, 1902, 1903, 5, 114, 0, 0, 1903, 1904, 5, 105, 0, 0, 1904, 1905, 5, 109, 0, 0, 1905, 374, 1, 0, 0, 0, 1906, 1907, 5, 115, 0, 0, 1907, 1908, 5, 97, 0, 0, 1908, 1909, 5, 99, 0, 0, 1909, 1910, 5, 107, 0, 0, 1910, 376, 1, 0, 0, 0, 1911, 1912, 5, 115, 0, 0, 1912, 1913, 5, 97, 0, 0, 1913, 1914, 5, 109, 0, 0, 1914, 1915, 5, 112, 0, 0, 1915, 1916, 5, 108, 0, 0, 1916, 1917, 5, 101, 0, 0, 1917, 378, 1, 0, 0, 0, 1918, 1919, 5, 83, 0, 0, 1919, 1920, 5, 99, 0, 0, 1920, 1921, 5, 111, 0, 0, 1921, 1922, 5, 112, 0, 0, 1922, 1923, 5, 101, 0, 0, 1923, 380, 1, 0, 0, 0, 1924, 1925, 5, 115, 0, 0, 1925, 1926, 5, 101, 0, 0, 1926, 1927, 5, 99, 0, 0, 1927, 1928, 5, 111, 0, 0, 1928, 1929, 5, 110, 0, 0, 1929, 1930, 5, 100, 0, 0, 1930, 382, 1, 0, 0, 0, 1931, 1932, 5, 115, 0, 0, 1932, 1933, 5, 101, 0, 0, 1933, 1934, 5, 108, 0, 0, 1934, 1935, 5, 101, 0, 0, 1935, 1936, 5, 99, 0, 0, 1936, 1937, 5, 116, 0, 0, 1937, 384, 1, 0, 0, 0, 1938, 1939, 5, 115, 0, 0, 1939, 1940, 5, 101, 0, 0, 1940, 1941, 5, 116, 0, 0, 1941, 386, 1, 0, 0, 0, 1942, 1943, 5, 83, 0, 0, 1943, 1944, 5, 104, 0, 0, 1944, 1945, 5, 111, 0, 0, 1945, 1946, 5, 114, 0, 0, 1946, 1947, 5, 116, 0, 0, 1947, 1948, 5, 101, 0, 0, 1948, 1949, 5, 115, 0, 0, 1949, 1950, 5, 116, 0, 0, 1950, 1951, 5, 80, 0, 0, 1951, 1952, 5, 97, 0, 0, 1952, 1953, 5, 116, 0, 0, 1953, 1954, 5, 104, 0, 0, 1954, 388, 1, 0, 0, 0, 1955, 1956, 5, 115, 0, 0, 1956, 1957, 5, 104, 0, 0, 1957, 1958, 5, 111, 0, 0, 1958, 1959, 5, 114, 0, 0, 1959, 1960, 5, 116, 0, 0, 1960, 1961, 5, 101, 0, 0, 1961, 1962, 5, 115, 0, 0, 1962, 1963, 5, 116, 0, 0, 1963, 1964, 5, 80, 0, 0, 1964, 1965, 5, 97, 0, 0, 1965, 1966, 5, 116, 0, 0, 1966, 1967, 5, 104, 0, 0, 1967, 390, 1, 0, 0, 0, 1968, 1969, 5, 115, 0, 0, 1969, 1970, 5, 104, 0, 0, 1970, 1971, 5, 117, 0, 0, 1971, 1972, 5, 102, 0, 0, 1972, 1973, 5, 102, 0, 0, 1973, 1974, 5, 108, 0, 0, 1974, 1975, 5, 101, 0, 0, 1975, 392, 1, 0, 0, 0, 1976, 1977, 5, 115, 0, 0, 1977, 1978, 5, 105, 0, 0, 1978, 1979, 5, 100, 0, 0, 1979, 1980, 5, 101, 0, 0, 1980, 1981, 5, 69, 0, 0, 1981, 1982, 5, 102, 0, 0, 1982, 1983, 5, 102, 0, 0, 1983, 1984, 5, 101, 0, 0, 1984, 1985, 5, 99, 0, 0, 1985, 1986, 5, 116, 0, 0, 1986, 394, 1, 0, 0, 0, 1987, 1988, 5, 115, 0, 0, 1988, 1989, 5, 105, 0, 0, 1989, 1990, 5, 109, 0, 0, 1990, 1991, 5, 112, 0, 0, 1991, 1992, 5, 108, 0, 0, 1992, 1993, 5, 101, 0, 0, 1993, 1994, 5, 80, 0, 0, 1994, 1995, 5, 97, 0, 0, 1995, 1996, 5, 116, 0, 0, 1996, 1997, 5, 104, 0, 0, 1997, 396, 1, 0, 0, 0, 1998, 1999, 5, 115, 0, 0, 1999, 2000, 5, 105, 0, 0, 2000, 2001, 5, 110, 0, 0, 2001, 2002, 5, 103, 0, 0, 2002, 2003, 5, 108, 0, 0, 2003, 2004, 5, 101, 0, 0, 2004, 398, 1, 0, 0, 0, 2005, 2006, 5, 115, 0, 0, 2006, 2007, 5, 107, 0, 0, 2007, 2008, 5, 105, 0, 0, 2008, 2009, 5, 112, 0, 0, 2009, 400, 1, 0, 0, 0, 2010, 2011, 5, 115, 0, 0, 2011, 2012, 5, 112, 0, 0, 2012, 2013, 5, 108, 0, 0, 2013, 2014, 5, 105, 0, 0, 2014, 2015, 5, 116, 0, 0, 2015, 402, 1, 0, 0, 0, 2016, 2017, 5, 115, 0, 0, 2017, 2018, 5, 116, 0, 0, 2018, 2019, 5, 97, 0, 0, 2019, 2020, 5, 114, 0, 0, 2020, 2021, 5, 116, 0, 0, 2021, 2022, 5, 105, 0, 0, 2022, 2023, 5, 110, 0, 0, 2023, 2024, 5, 103, 0, 0, 2024, 2025, 5, 87, 0, 0, 2025, 2026, 5, 105, 0, 0, 2026, 2027, 5, 116, 0, 0, 2027, 2028, 5, 104, 0, 0, 2028, 404, 1, 0, 0, 0, 2029, 2030, 5, 115, 0, 0, 2030, 2031, 5, 116, 0, 0, 2031, 2032, 5, 111, 0, 0, 2032, 2033, 5, 114, 0, 0, 2033, 2034, 5, 101, 0, 0, 2034, 406, 1, 0, 0, 0, 2035, 2036, 5, 115, 0, 0, 2036, 2037, 5, 117, 0, 0, 2037, 2038, 5, 98, 0, 0, 2038, 2039, 5, 103, 0, 0, 2039, 2040, 5, 114, 0, 0, 2040, 2041, 5, 97, 0, 0, 2041, 2042, 5, 112, 0, 0, 2042, 2043, 5, 104, 0, 0, 2043, 408, 1, 0, 0, 0, 2044, 2045, 5, 115, 0, 0, 2045, 2046, 5, 117, 0, 0, 2046, 2047, 5, 98, 0, 0, 2047, 2048, 5, 115, 0, 0, 2048, 2049, 5, 116, 0, 0, 2049, 2050, 5, 114, 0, 0, 2050, 2051, 5, 105, 0, 0, 2051, 2052, 5, 110, 0, 0, 2052, 2053, 5, 103, 0, 0, 2053, 410, 1, 0, 0, 0, 2054, 2055, 5, 115, 0, 0, 2055, 2056, 5, 117, 0, 0, 2056, 2057, 5, 109, 0, 0, 2057, 412, 1, 0, 0, 0, 2058, 2059, 5, 115, 0, 0, 2059, 2060, 5, 117, 0, 0, 2060, 2061, 5, 109, 0, 0, 2061, 2062, 5, 76, 0, 0, 2062, 2063, 5, 111, 0, 0, 2063, 2064, 5, 110, 0, 0, 2064, 2065, 5, 103, 0, 0, 2065, 414, 1, 0, 0, 0, 2066, 2067, 5, 84, 0, 0, 2067, 416, 1, 0, 0, 0, 2068, 2069, 5, 116, 0, 0, 2069, 2070, 5, 97, 0, 0, 2070, 2071, 5, 105, 0, 0, 2071, 2072, 5, 108, 0, 0, 2072, 418, 1, 0, 0, 0, 2073, 2074, 5, 116, 0, 0, 2074, 2075, 5, 97, 0, 0, 2075, 2076, 5, 114, 0, 0, 2076, 2077, 5, 103, 0, 0, 2077, 2078, 5, 101, 0, 0, 2078, 2079, 5, 116, 0, 0, 2079, 420, 1, 0, 0, 0, 2080, 2081, 5, 84, 0, 0, 2081, 2082, 5, 101, 0, 0, 2082, 2083, 5, 120, 0, 0, 2083, 2084, 5, 116, 0, 0, 2084, 2085, 5, 80, 0, 0, 2085, 422, 1, 0, 0, 0, 2086, 2087, 5, 116, 0, 0, 2087, 2088, 5, 105, 0, 0, 2088, 2089, 5, 109, 0, 0, 2089, 2090, 5, 101, 0, 0, 2090, 2091, 5, 76, 0, 0, 2091, 2092, 5, 105, 0, 0, 2092, 2093, 5, 109, 0, 0, 2093, 2094, 5, 105, 0, 0, 2094, 2095, 5, 116, 0, 0, 2095, 424, 1, 0, 0, 0, 2096, 2097, 5, 116, 0, 0, 2097, 2098, 5, 105, 0, 0, 2098, 2099, 5, 109, 0, 0, 2099, 2100, 5, 101, 0, 0, 2100, 2101, 5, 115, 0, 0, 2101, 426, 1, 0, 0, 0, 2102, 2103, 5, 116, 0, 0, 2103, 2104, 5, 111, 0, 0, 2104, 428, 1, 0, 0, 0, 2105, 2106, 5, 116, 0, 0, 2106, 2107, 5, 111, 0, 0, 2107, 2108, 5, 66, 0, 0, 2108, 2109, 5, 117, 0, 0, 2109, 2110, 5, 108, 0, 0, 2110, 2111, 5, 107, 0, 0, 2111, 2112, 5, 83, 0, 0, 2112, 2113, 5, 101, 0, 0, 2113, 2114, 5, 116, 0, 0, 2114, 430, 1, 0, 0, 0, 2115, 2116, 5, 116, 0, 0, 2116, 2117, 5, 111, 0, 0, 2117, 2118, 5, 107, 0, 0, 2118, 2119, 5, 101, 0, 0, 2119, 2120, 5, 110, 0, 0, 2120, 2121, 5, 115, 0, 0, 2121, 432, 1, 0, 0, 0, 2122, 2123, 5, 116, 0, 0, 2123, 2124, 5, 111, 0, 0, 2124, 2125, 5, 76, 0, 0, 2125, 2126, 5, 105, 0, 0, 2126, 2127, 5, 115, 0, 0, 2127, 2128, 5, 116, 0, 0, 2128, 434, 1, 0, 0, 0, 2129, 2130, 5, 116, 0, 0, 2130, 2131, 5, 111, 0, 0, 2131, 2132, 5, 76, 0, 0, 2132, 2133, 5, 111, 0, 0, 2133, 2134, 5, 119, 0, 0, 2134, 2135, 5, 101, 0, 0, 2135, 2136, 5, 114, 0, 0, 2136, 436, 1, 0, 0, 0, 2137, 2138, 5, 116, 0, 0, 2138, 2139, 5, 111, 0, 0, 2139, 2140, 5, 83, 0, 0, 2140, 2141, 5, 101, 0, 0, 2141, 2142, 5, 116, 0, 0, 2142, 438, 1, 0, 0, 0, 2143, 2144, 5, 116, 0, 0, 2144, 2145, 5, 111, 0, 0, 2145, 2146, 5, 83, 0, 0, 2146, 2147, 5, 116, 0, 0, 2147, 2148, 5, 114, 0, 0, 2148, 2149, 5, 105, 0, 0, 2149, 2150, 5, 110, 0, 0, 2150, 2151, 5, 103, 0, 0, 2151, 440, 1, 0, 0, 0, 2152, 2153, 5, 116, 0, 0, 2153, 2154, 5, 111, 0, 0, 2154, 2155, 5, 85, 0, 0, 2155, 2156, 5, 112, 0, 0, 2156, 2157, 5, 112, 0, 0, 2157, 2158, 5, 101, 0, 0, 2158, 2159, 5, 114, 0, 0, 2159, 442, 1, 0, 0, 0, 2160, 2161, 5, 116, 0, 0, 2161, 2162, 5, 111, 0, 0, 2162, 2163, 5, 69, 0, 0, 2163, 444, 1, 0, 0, 0, 2164, 2165, 5, 116, 0, 0, 2165, 2166, 5, 111, 0, 0, 2166, 2167, 5, 86, 0, 0, 2167, 446, 1, 0, 0, 0, 2168, 2169, 5, 116, 0, 0, 2169, 2170, 5, 114, 0, 0, 2170, 2171, 5, 101, 0, 0, 2171, 2172, 5, 101, 0, 0, 2172, 448, 1, 0, 0, 0, 2173, 2174, 5, 116, 0, 0, 2174, 2175, 5, 114, 0, 0, 2175, 2176, 5, 105, 0, 0, 2176, 2177, 5, 109, 0, 0, 2177, 450, 1, 0, 0, 0, 2178, 2179, 5, 116, 0, 0, 2179, 2180, 5, 114, 0, 0, 2180, 2181, 5, 117, 0, 0, 2181, 2182, 5, 101, 0, 0, 2182, 452, 1, 0, 0, 0, 2183, 2184, 5, 116, 0, 0, 2184, 2185, 5, 114, 0, 0, 2185, 2186, 5, 121, 0, 0, 2186, 2187, 5, 78, 0, 0, 2187, 2188, 5, 101, 0, 0, 2188, 2189, 5, 120, 0, 0, 2189, 2190, 5, 116, 0, 0, 2190, 454, 1, 0, 0, 0, 2191, 2192, 5, 116, 0, 0, 2192, 2193, 5, 120, 0, 0, 2193, 456, 1, 0, 0, 0, 2194, 2195, 5, 117, 0, 0, 2195, 2196, 5, 110, 0, 0, 2196, 2197, 5, 102, 0, 0, 2197, 2198, 5, 111, 0, 0, 2198, 2199, 5, 108, 0, 0, 2199, 2200, 5, 100, 0, 0, 2200, 458, 1, 0, 0, 0, 2201, 2202, 5, 117, 0, 0, 2202, 2203, 5, 110, 0, 0, 2203, 2204, 5, 105, 0, 0, 2204, 2205, 5, 111, 0, 0, 2205, 2206, 5, 110, 0, 0, 2206, 460, 1, 0, 0, 0, 2207, 2208, 5, 117, 0, 0, 2208, 2209, 5, 110, 0, 0, 2209, 2210, 5, 116, 0, 0, 2210, 2211, 5, 105, 0, 0, 2211, 2212, 5, 108, 0, 0, 2212, 462, 1, 0, 0, 0, 2213, 2214, 5, 85, 0, 0, 2214, 2215, 5, 85, 0, 0, 2215, 2216, 5, 73, 0, 0, 2216, 2217, 5, 68, 0, 0, 2217, 464, 1, 0, 0, 0, 2218, 2219, 5, 86, 0, 0, 2219, 466, 1, 0, 0, 0, 2220, 2221, 5, 118, 0, 0, 2221, 2222, 5, 97, 0, 0, 2222, 2223, 5, 108, 0, 0, 2223, 2224, 5, 117, 0, 0, 2224, 2225, 5, 101, 0, 0, 2225, 2226, 5, 77, 0, 0, 2226, 2227, 5, 97, 0, 0, 2227, 2228, 5, 112, 0, 0, 2228, 468, 1, 0, 0, 0, 2229, 2230, 5, 118, 0, 0, 2230, 2231, 5, 97, 0, 0, 2231, 2232, 5, 108, 0, 0, 2232, 2233, 5, 117, 0, 0, 2233, 2234, 5, 101, 0, 0, 2234, 2235, 5, 115, 0, 0, 2235, 470, 1, 0, 0, 0, 2236, 2237, 5, 118, 0, 0, 2237, 2238, 5, 97, 0, 0, 2238, 2239, 5, 108, 0, 0, 2239, 2240, 5, 117, 0, 0, 2240, 2241, 5, 101, 0, 0, 2241, 472, 1, 0, 0, 0, 2242, 2243, 5, 86, 0, 0, 2243, 2244, 5, 101, 0, 0, 2244, 2245, 5, 114, 0, 0, 2245, 2246, 5, 116, 0, 0, 2246, 2247, 5, 101, 0, 0, 2247, 2248, 5, 120, 0, 0, 2248, 474, 1, 0, 0, 0, 2249, 2250, 5, 119, 0, 0, 2250, 2251, 5, 104, 0, 0, 2251, 2252, 5, 101, 0, 0, 2252, 2253, 5, 114, 0, 0, 2253, 2254, 5, 101, 0, 0, 2254, 476, 1, 0, 0, 0, 2255, 2256, 5, 119, 0, 0, 2256, 2257, 5, 105, 0, 0, 2257, 2258, 5, 116, 0, 0, 2258, 2259, 5, 104, 0, 0, 2259, 478, 1, 0, 0, 0, 2260, 2261, 5, 119, 0, 0, 2261, 2262, 5, 105, 0, 0, 2262, 2263, 5, 116, 0, 0, 2263, 2264, 5, 104, 0, 0, 2264, 2265, 5, 66, 0, 0, 2265, 2266, 5, 117, 0, 0, 2266, 2267, 5, 108, 0, 0, 2267, 2268, 5, 107, 0, 0, 2268, 480, 1, 0, 0, 0, 2269, 2270, 5, 119, 0, 0, 2270, 2271, 5, 105, 0, 0, 2271, 2272, 5, 116, 0, 0, 2272, 2273, 5, 104, 0, 0, 2273, 2274, 5, 105, 0, 0, 2274, 2275, 5, 110, 0, 0, 2275, 482, 1, 0, 0, 0, 2276, 2277, 5, 87, 0, 0, 2277, 2278, 5, 105, 0, 0, 2278, 2279, 5, 116, 0, 0, 2279, 2280, 5, 104, 0, 0, 2280, 2281, 5, 79, 0, 0, 2281, 2282, 5, 112, 0, 0, 2282, 2283, 5, 116, 0, 0, 2283, 2284, 5, 105, 0, 0, 2284, 2285, 5, 111, 0, 0, 2285, 2286, 5, 110, 0, 0, 2286, 2287, 5, 115, 0, 0, 2287, 484, 1, 0, 0, 0, 2288, 2289, 5, 119, 0, 0, 2289, 2290, 5, 105, 0, 0, 2290, 2291, 5, 116, 0, 0, 2291, 2292, 5, 104, 0, 0, 2292, 2293, 5, 111, 0, 0, 2293, 2294, 5, 117, 0, 0, 2294, 2295, 5, 116, 0, 0, 2295, 486, 1, 0, 0, 0, 2296, 2297, 5, 119, 0, 0, 2297, 2298, 5, 105, 0, 0, 2298, 2299, 5, 116, 0, 0, 2299, 2300, 5, 104, 0, 0, 2300, 2301, 5, 111, 0, 0, 2301, 2302, 5, 117, 0, 0, 2302, 2303, 5, 116, 0, 0, 2303, 2304, 5, 83, 0, 0, 2304, 2305, 5, 116, 0, 0, 2305, 2306, 5, 114, 0, 0, 2306, 2307, 5, 97, 0, 0, 2307, 2308, 5, 116, 0, 0, 2308, 2309, 5, 101, 0, 0, 2309, 2310, 5, 103, 0, 0, 2310, 2311, 5, 105, 0, 0, 2311, 2312, 5, 101, 0, 0, 2312, 2313, 5, 115, 0, 0, 2313, 488, 1, 0, 0, 0, 2314, 2315, 5, 119, 0, 0, 2315, 2316, 5, 105, 0, 0, 2316, 2317, 5, 116, 0, 0, 2317, 2318, 5, 104, 0, 0, 2318, 2319, 5, 80, 0, 0, 2319, 2320, 5, 97, 0, 0, 2320, 2321, 5, 116, 0, 0, 2321, 2322, 5, 104, 0, 0, 2322, 490, 1, 0, 0, 0, 2323, 2324, 5, 119, 0, 0, 2324, 2325, 5, 105, 0, 0, 2325, 2326, 5, 116, 0, 0, 2326, 2327, 5, 104, 0, 0, 2327, 2328, 5, 83, 0, 0, 2328, 2329, 5, 97, 0, 0, 2329, 2330, 5, 99, 0, 0, 2330, 2331, 5, 107, 0, 0, 2331, 492, 1, 0, 0, 0, 2332, 2333, 5, 119, 0, 0, 2333, 2334, 5, 105, 0, 0, 2334, 2335, 5, 116, 0, 0, 2335, 2336, 5, 104, 0, 0, 2336, 2337, 5, 83, 0, 0, 2337, 2338, 5, 105, 0, 0, 2338, 2339, 5, 100, 0, 0, 2339, 2340, 5, 101, 0, 0, 2340, 2341, 5, 69, 0, 0, 2341, 2342, 5, 102, 0, 0, 2342, 2343, 5, 102, 0, 0, 2343, 2344, 5, 101, 0, 0, 2344, 2345, 5, 99, 0, 0, 2345, 2346, 5, 116, 0, 0, 2346, 494, 1, 0, 0, 0, 2347, 2348, 5, 119, 0, 0, 2348, 2349, 5, 105, 0, 0, 2349, 2350, 5, 116, 0, 0, 2350, 2351, 5, 104, 0, 0, 2351, 2352, 5, 83, 0, 0, 2352, 2353, 5, 116, 0, 0, 2353, 2354, 5, 114, 0, 0, 2354, 2355, 5, 97, 0, 0, 2355, 2356, 5, 116, 0, 0, 2356, 2357, 5, 101, 0, 0, 2357, 2358, 5, 103, 0, 0, 2358, 2359, 5, 105, 0, 0, 2359, 2360, 5, 101, 0, 0, 2360, 2361, 5, 115, 0, 0, 2361, 496, 1, 0, 0, 0, 2362, 2363, 5, 119, 0, 0, 2363, 2364, 5, 114, 0, 0, 2364, 2365, 5, 105, 0, 0, 2365, 2366, 5, 116, 0, 0, 2366, 2367, 5, 101, 0, 0, 2367, 498, 1, 0, 0, 0, 2368, 2369, 5, 119, 0, 0, 2369, 2370, 5, 114, 0, 0, 2370, 2371, 5, 105, 0, 0, 2371, 2372, 5, 116, 0, 0, 2372, 2373, 5, 101, 0, 0, 2373, 2374, 5, 114, 0, 0, 2374, 500, 1, 0, 0, 0, 2375, 2377, 3, 555, 277, 0, 2376, 2375, 1, 0, 0, 0, 2376, 2377, 1, 0, 0, 0, 2377, 2378, 1, 0, 0, 0, 2378, 2388, 3, 503, 251, 0, 2379, 2381, 3, 555, 277, 0, 2380, 2379, 1, 0, 0, 0, 2380, 2381, 1, 0, 0, 0, 2381, 2382, 1, 0, 0, 0, 2382, 2388, 3, 505, 252, 0, 2383, 2385, 3, 555, 277, 0, 2384, 2383, 1, 0, 0, 0, 2384, 2385, 1, 0, 0, 0, 2385, 2386, 1, 0, 0, 0, 2386, 2388, 3, 507, 253, 0, 2387, 2376, 1, 0, 0, 0, 2387, 2380, 1, 0, 0, 0, 2387, 2384, 1, 0, 0, 0, 2388, 502, 1, 0, 0, 0, 2389, 2391, 3, 511, 255, 0, 2390, 2392, 3, 509, 254, 0, 2391, 2390, 1, 0, 0, 0, 2391, 2392, 1, 0, 0, 0, 2392, 504, 1, 0, 0, 0, 2393, 2395, 3, 525, 262, 0, 2394, 2396, 3, 509, 254, 0, 2395, 2394, 1, 0, 0, 0, 2395, 2396, 1, 0, 0, 0, 2396, 506, 1, 0, 0, 0, 2397, 2399, 3, 535, 267, 0, 2398, 2400, 3, 509, 254, 0, 2399, 2398, 1, 0, 0, 0, 2399, 2400, 1, 0, 0, 0, 2400, 508, 1, 0, 0, 0, 2401, 2402, 7, 0, 0, 0, 2402, 510, 1, 0, 0, 0, 2403, 2414, 5, 48, 0, 0, 2404, 2411, 3, 517, 258, 0, 2405, 2407, 3, 513, 256, 0, 2406, 2405, 1, 0, 0, 0, 2406, 2407, 1, 0, 0, 0, 2407, 2412, 1, 0, 0, 0, 2408, 2409, 3, 523, 261, 0, 2409, 2410, 3, 513, 256, 0, 2410, 2412, 1, 0, 0, 0, 2411, 2406, 1, 0, 0, 0, 2411, 2408, 1, 0, 0, 0, 2412, 2414, 1, 0, 0, 0, 2413, 2403, 1, 0, 0, 0, 2413, 2404, 1, 0, 0, 0, 2414, 512, 1, 0, 0, 0, 2415, 2420, 3, 515, 257, 0, 2416, 2418, 3, 519, 259, 0, 2417, 2416, 1, 0, 0, 0, 2417, 2418, 1, 0, 0, 0, 2418, 2419, 1, 0, 0, 0, 2419, 2421, 3, 515, 257, 0, 2420, 2417, 1, 0, 0, 0, 2420, 2421, 1, 0, 0, 0, 2421, 514, 1, 0, 0, 0, 2422, 2425, 5, 48, 0, 0, 2423, 2425, 3, 517, 258, 0, 2424, 2422, 1, 0, 0, 0, 2424, 2423, 1, 0, 0, 0, 2425, 516, 1, 0, 0, 0, 2426, 2427, 7, 1, 0, 0, 2427, 518, 1, 0, 0, 0, 2428, 2430, 3, 521, 260, 0, 2429, 2428, 1, 0, 0, 0, 2430, 2431, 1, 0, 0, 0, 2431, 2429, 1, 0, 0, 0, 2431, 2432, 1, 0, 0, 0, 2432, 520, 1, 0, 0, 0, 2433, 2436, 3, 515, 257, 0, 2434, 2436, 5, 95, 0, 0, 2435, 2433, 1, 0, 0, 0, 2435, 2434, 1, 0, 0, 0, 2436, 522, 1, 0, 0, 0, 2437, 2439, 5, 95, 0, 0, 2438, 2437, 1, 0, 0, 0, 2439, 2440, 1, 0, 0, 0, 2440, 2438, 1, 0, 0, 0, 2440, 2441, 1, 0, 0, 0, 2441, 524, 1, 0, 0, 0, 2442, 2443, 5, 48, 0, 0, 2443, 2444, 7, 2, 0, 0, 2444, 2445, 3, 527, 263, 0, 2445, 526, 1, 0, 0, 0, 2446, 2451, 3, 529, 264, 0, 2447, 2449, 3, 531, 265, 0, 2448, 2447, 1, 0, 0, 0, 2448, 2449, 1, 0, 0, 0, 2449, 2450, 1, 0, 0, 0, 2450, 2452, 3, 529, 264, 0, 2451, 2448, 1, 0, 0, 0, 2451, 2452, 1, 0, 0, 0, 2452, 528, 1, 0, 0, 0, 2453, 2454, 7, 3, 0, 0, 2454, 530, 1, 0, 0, 0, 2455, 2457, 3, 533, 266, 0, 2456, 2455, 1, 0, 0, 0, 2457, 2458, 1, 0, 0, 0, 2458, 2456, 1, 0, 0, 0, 2458, 2459, 1, 0, 0, 0, 2459, 532, 1, 0, 0, 0, 2460, 2463, 3, 529, 264, 0, 2461, 2463, 5, 95, 0, 0, 2462, 2460, 1, 0, 0, 0, 2462, 2461, 1, 0, 0, 0, 2463, 534, 1, 0, 0, 0, 2464, 2466, 5, 48, 0, 0, 2465, 2467, 3, 523, 261, 0, 2466, 2465, 1, 0, 0, 0, 2466, 2467, 1, 0, 0, 0, 2467, 2468, 1, 0, 0, 0, 2468, 2469, 3, 537, 268, 0, 2469, 536, 1, 0, 0, 0, 2470, 2475, 3, 539, 269, 0, 2471, 2473, 3, 541, 270, 0, 2472, 2471, 1, 0, 0, 0, 2472, 2473, 1, 0, 0, 0, 2473, 2474, 1, 0, 0, 0, 2474, 2476, 3, 539, 269, 0, 2475, 2472, 1, 0, 0, 0, 2475, 2476, 1, 0, 0, 0, 2476, 538, 1, 0, 0, 0, 2477, 2478, 7, 4, 0, 0, 2478, 540, 1, 0, 0, 0, 2479, 2481, 3, 543, 271, 0, 2480, 2479, 1, 0, 0, 0, 2481, 2482, 1, 0, 0, 0, 2482, 2480, 1, 0, 0, 0, 2482, 2483, 1, 0, 0, 0, 2483, 542, 1, 0, 0, 0, 2484, 2487, 3, 539, 269, 0, 2485, 2487, 5, 95, 0, 0, 2486, 2484, 1, 0, 0, 0, 2486, 2485, 1, 0, 0, 0, 2487, 544, 1, 0, 0, 0, 2488, 2490, 3, 555, 277, 0, 2489, 2488, 1, 0, 0, 0, 2489, 2490, 1, 0, 0, 0, 2490, 2491, 1, 0, 0, 0, 2491, 2492, 3, 547, 273, 0, 2492, 546, 1, 0, 0, 0, 2493, 2500, 3, 513, 256, 0, 2494, 2495, 5, 46, 0, 0, 2495, 2497, 3, 513, 256, 0, 2496, 2498, 3, 549, 274, 0, 2497, 2496, 1, 0, 0, 0, 2497, 2498, 1, 0, 0, 0, 2498, 2501, 1, 0, 0, 0, 2499, 2501, 3, 549, 274, 0, 2500, 2494, 1, 0, 0, 0, 2500, 2499, 1, 0, 0, 0, 2501, 2503, 1, 0, 0, 0, 2502, 2504, 3, 557, 278, 0, 2503, 2502, 1, 0, 0, 0, 2503, 2504, 1, 0, 0, 0, 2504, 2509, 1, 0, 0, 0, 2505, 2506, 3, 513, 256, 0, 2506, 2507, 3, 557, 278, 0, 2507, 2509, 1, 0, 0, 0, 2508, 2493, 1, 0, 0, 0, 2508, 2505, 1, 0, 0, 0, 2509, 548, 1, 0, 0, 0, 2510, 2511, 3, 551, 275, 0, 2511, 2512, 3, 553, 276, 0, 2512, 550, 1, 0, 0, 0, 2513, 2514, 7, 5, 0, 0, 2514, 552, 1, 0, 0, 0, 2515, 2517, 3, 555, 277, 0, 2516, 2515, 1, 0, 0, 0, 2516, 2517, 1, 0, 0, 0, 2517, 2518, 1, 0, 0, 0, 2518, 2519, 3, 513, 256, 0, 2519, 554, 1, 0, 0, 0, 2520, 2521, 7, 6, 0, 0, 2521, 556, 1, 0, 0, 0, 2522, 2523, 7, 7, 0, 0, 2523, 558, 1, 0, 0, 0, 2524, 2526, 3, 555, 277, 0, 2525, 2524, 1, 0, 0, 0, 2525, 2526, 1, 0, 0, 0, 2526, 2527, 1, 0, 0, 0, 2527, 2528, 3, 197, 98, 0, 2528, 560, 1, 0, 0, 0, 2529, 2530, 5, 34, 0, 0, 2530, 2531, 3, 565, 282, 0, 2531, 2532, 5, 34, 0, 0, 2532, 2538, 1, 0, 0, 0, 2533, 2534, 5, 39, 0, 0, 2534, 2535, 3, 569, 284, 0, 2535, 2536, 5, 39, 0, 0, 2536, 2538, 1, 0, 0, 0, 2537, 2529, 1, 0, 0, 0, 2537, 2533, 1, 0, 0, 0, 2538, 562, 1, 0, 0, 0, 2539, 2540, 5, 34, 0, 0, 2540, 2544, 5, 34, 0, 0, 2541, 2542, 5, 39, 0, 0, 2542, 2544, 5, 39, 0, 0, 2543, 2539, 1, 0, 0, 0, 2543, 2541, 1, 0, 0, 0, 2544, 564, 1, 0, 0, 0, 2545, 2547, 3, 567, 283, 0, 2546, 2545, 1, 0, 0, 0, 2547, 2548, 1, 0, 0, 0, 2548, 2546, 1, 0, 0, 0, 2548, 2549, 1, 0, 0, 0, 2549, 566, 1, 0, 0, 0, 2550, 2554, 8, 8, 0, 0, 2551, 2554, 3, 573, 286, 0, 2552, 2554, 3, 575, 287, 0, 2553, 2550, 1, 0, 0, 0, 2553, 2551, 1, 0, 0, 0, 2553, 2552, 1, 0, 0, 0, 2554, 568, 1, 0, 0, 0, 2555, 2557, 3, 571, 285, 0, 2556, 2555, 1, 0, 0, 0, 2557, 2558, 1, 0, 0, 0, 2558, 2556, 1, 0, 0, 0, 2558, 2559, 1, 0, 0, 0, 2559, 570, 1, 0, 0, 0, 2560, 2564, 8, 9, 0, 0, 2561, 2564, 3, 573, 286, 0, 2562, 2564, 3, 575, 287, 0, 2563, 2560, 1, 0, 0, 0, 2563, 2561, 1, 0, 0, 0, 2563, 2562, 1, 0, 0, 0, 2564, 572, 1, 0, 0, 0, 2565, 2567, 5, 92, 0, 0, 2566, 2568, 5, 13, 0, 0, 2567, 2566, 1, 0, 0, 0, 2567, 2568, 1, 0, 0, 0, 2568, 2569, 1, 0, 0, 0, 2569, 2570, 5, 10, 0, 0, 2570, 574, 1, 0, 0, 0, 2571, 2572, 5, 92, 0, 0, 2572, 2576, 7, 10, 0, 0, 2573, 2576, 3, 577, 288, 0, 2574, 2576, 3, 581, 290, 0, 2575, 2571, 1, 0, 0, 0, 2575, 2573, 1, 0, 0, 0, 2575, 2574, 1, 0, 0, 0, 2576, 576, 1, 0, 0, 0, 2577, 2578, 5, 92, 0, 0, 2578, 2589, 3, 539, 269, 0, 2579, 2580, 5, 92, 0, 0, 2580, 2581, 3, 539, 269, 0, 2581, 2582, 3, 539, 269, 0, 2582, 2589, 1, 0, 0, 0, 2583, 2584, 5, 92, 0, 0, 2584, 2585, 3, 579, 289, 0, 2585, 2586, 3, 539, 269, 0, 2586, 2587, 3, 539, 269, 0, 2587, 2589, 1, 0, 0, 0, 2588, 2577, 1, 0, 0, 0, 2588, 2579, 1, 0, 0, 0, 2588, 2583, 1, 0, 0, 0, 2589, 578, 1, 0, 0, 0, 2590, 2591, 7, 11, 0, 0, 2591, 580, 1, 0, 0, 0, 2592, 2594, 5, 92, 0, 0, 2593, 2595, 5, 117, 0, 0, 2594, 2593, 1, 0, 0, 0, 2595, 2596, 1, 0, 0, 0, 2596, 2594, 1, 0, 0, 0, 2596, 2597, 1, 0, 0, 0, 2597, 2598, 1, 0, 0, 0, 2598, 2599, 3, 529, 264, 0, 2599, 2600, 3, 529, 264, 0, 2600, 2601, 3, 529, 264, 0, 2601, 2602, 3, 529, 264, 0, 2602, 582, 1, 0, 0, 0, 2603, 2604, 5, 40, 0, 0, 2604, 584, 1, 0, 0, 0, 2605, 2606, 5, 41, 0, 0, 2606, 586, 1, 0, 0, 0, 2607, 2608, 5, 123, 0, 0, 2608, 588, 1, 0, 0, 0, 2609, 2610, 5, 125, 0, 0, 2610, 590, 1, 0, 0, 0, 2611, 2612, 5, 91, 0, 0, 2612, 592, 1, 0, 0, 0, 2613, 2614, 5, 93, 0, 0, 2614, 594, 1, 0, 0, 0, 2615, 2616, 5, 59, 0, 0, 2616, 596, 1, 0, 0, 0, 2617, 2618, 5, 44, 0, 0, 2618, 598, 1, 0, 0, 0, 2619, 2620, 5, 46, 0, 0, 2620, 600, 1, 0, 0, 0, 2621, 2622, 5, 58, 0, 0, 2622, 602, 1, 0, 0, 0, 2623, 2624, 5, 103, 0, 0, 2624, 604, 1, 0, 0, 0, 2625, 2626, 5, 95, 0, 0, 2626, 2627, 5, 95, 0, 0, 2627, 606, 1, 0, 0, 0, 2628, 2630, 7, 12, 0, 0, 2629, 2628, 1, 0, 0, 0, 2630, 2631, 1, 0, 0, 0, 2631, 2629, 1, 0, 0, 0, 2631, 2632, 1, 0, 0, 0, 2632, 2633, 1, 0, 0, 0, 2633, 2634, 6, 303, 0, 0, 2634, 608, 1, 0, 0, 0, 2635, 2636, 5, 47, 0, 0, 2636, 2637, 5, 47, 0, 0, 2637, 2641, 1, 0, 0, 0, 2638, 2640, 8, 13, 0, 0, 2639, 2638, 1, 0, 0, 0, 2640, 2643, 1, 0, 0, 0, 2641, 2639, 1, 0, 0, 0, 2641, 2642, 1, 0, 0, 0, 2642, 2644, 1, 0, 0, 0, 2643, 2641, 1, 0, 0, 0, 2644, 2645, 6, 304, 0, 0, 2645, 610, 1, 0, 0, 0, 2646, 2650, 3, 613, 306, 0, 2647, 2649, 3, 615, 307, 0, 2648, 2647, 1, 0, 0, 0, 2649, 2652, 1, 0, 0, 0, 2650, 2648, 1, 0, 0, 0, 2650, 2651, 1, 0, 0, 0, 2651, 612, 1, 0, 0, 0, 2652, 2650, 1, 0, 0, 0, 2653, 2655, 7, 14, 0, 0, 2654, 2653, 1, 0, 0, 0, 2655, 614, 1, 0, 0, 0, 2656, 2659, 3, 613, 306, 0, 2657, 2659, 7, 15, 0, 0, 2658, 2656, 1, 0, 0, 0, 2658, 2657, 1, 0, 0, 0, 2659, 616, 1, 0, 0, 0, 48, 0, 2376, 2380, 2384, 2387, 2391, 2395, 2399, 2406, 2411, 2413, 2417, 2420, 2424, 2431, 2435, 2440, 2448, 2451, 2458, 2462, 2466, 2472, 2475, 2482, 2486, 2489, 2497, 2500, 2503, 2508, 2516, 2525, 2537, 2543, 2548, 2553, 2558, 2563, 2567, 2575, 2588, 2596, 2631, 2641, 2650, 2654, 2658, 1, 6, 0, 0] \ No newline at end of file diff --git a/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinLexer.py b/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinLexer.py new file mode 100644 index 000000000..6ede8e1b1 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinLexer.py @@ -0,0 +1,24643 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +# Generated from ./Gremlin.g4 by ANTLR 4.13.1 +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, + 270, + 2660, + 6, + -1, + 2, + 0, + 7, + 0, + 2, + 1, + 7, + 1, + 2, + 2, + 7, + 2, + 2, + 3, + 7, + 3, + 2, + 4, + 7, + 4, + 2, + 5, + 7, + 5, + 2, + 6, + 7, + 6, + 2, + 7, + 7, + 7, + 2, + 8, + 7, + 8, + 2, + 9, + 7, + 9, + 2, + 10, + 7, + 10, + 2, + 11, + 7, + 11, + 2, + 12, + 7, + 12, + 2, + 13, + 7, + 13, + 2, + 14, + 7, + 14, + 2, + 15, + 7, + 15, + 2, + 16, + 7, + 16, + 2, + 17, + 7, + 17, + 2, + 18, + 7, + 18, + 2, + 19, + 7, + 19, + 2, + 20, + 7, + 20, + 2, + 21, + 7, + 21, + 2, + 22, + 7, + 22, + 2, + 23, + 7, + 23, + 2, + 24, + 7, + 24, + 2, + 25, + 7, + 25, + 2, + 26, + 7, + 26, + 2, + 27, + 7, + 27, + 2, + 28, + 7, + 28, + 2, + 29, + 7, + 29, + 2, + 30, + 7, + 30, + 2, + 31, + 7, + 31, + 2, + 32, + 7, + 32, + 2, + 33, + 7, + 33, + 2, + 34, + 7, + 34, + 2, + 35, + 7, + 35, + 2, + 36, + 7, + 36, + 2, + 37, + 7, + 37, + 2, + 38, + 7, + 38, + 2, + 39, + 7, + 39, + 2, + 40, + 7, + 40, + 2, + 41, + 7, + 41, + 2, + 42, + 7, + 42, + 2, + 43, + 7, + 43, + 2, + 44, + 7, + 44, + 2, + 45, + 7, + 45, + 2, + 46, + 7, + 46, + 2, + 47, + 7, + 47, + 2, + 48, + 7, + 48, + 2, + 49, + 7, + 49, + 2, + 50, + 7, + 50, + 2, + 51, + 7, + 51, + 2, + 52, + 7, + 52, + 2, + 53, + 7, + 53, + 2, + 54, + 7, + 54, + 2, + 55, + 7, + 55, + 2, + 56, + 7, + 56, + 2, + 57, + 7, + 57, + 2, + 58, + 7, + 58, + 2, + 59, + 7, + 59, + 2, + 60, + 7, + 60, + 2, + 61, + 7, + 61, + 2, + 62, + 7, + 62, + 2, + 63, + 7, + 63, + 2, + 64, + 7, + 64, + 2, + 65, + 7, + 65, + 2, + 66, + 7, + 66, + 2, + 67, + 7, + 67, + 2, + 68, + 7, + 68, + 2, + 69, + 7, + 69, + 2, + 70, + 7, + 70, + 2, + 71, + 7, + 71, + 2, + 72, + 7, + 72, + 2, + 73, + 7, + 73, + 2, + 74, + 7, + 74, + 2, + 75, + 7, + 75, + 2, + 76, + 7, + 76, + 2, + 77, + 7, + 77, + 2, + 78, + 7, + 78, + 2, + 79, + 7, + 79, + 2, + 80, + 7, + 80, + 2, + 81, + 7, + 81, + 2, + 82, + 7, + 82, + 2, + 83, + 7, + 83, + 2, + 84, + 7, + 84, + 2, + 85, + 7, + 85, + 2, + 86, + 7, + 86, + 2, + 87, + 7, + 87, + 2, + 88, + 7, + 88, + 2, + 89, + 7, + 89, + 2, + 90, + 7, + 90, + 2, + 91, + 7, + 91, + 2, + 92, + 7, + 92, + 2, + 93, + 7, + 93, + 2, + 94, + 7, + 94, + 2, + 95, + 7, + 95, + 2, + 96, + 7, + 96, + 2, + 97, + 7, + 97, + 2, + 98, + 7, + 98, + 2, + 99, + 7, + 99, + 2, + 100, + 7, + 100, + 2, + 101, + 7, + 101, + 2, + 102, + 7, + 102, + 2, + 103, + 7, + 103, + 2, + 104, + 7, + 104, + 2, + 105, + 7, + 105, + 2, + 106, + 7, + 106, + 2, + 107, + 7, + 107, + 2, + 108, + 7, + 108, + 2, + 109, + 7, + 109, + 2, + 110, + 7, + 110, + 2, + 111, + 7, + 111, + 2, + 112, + 7, + 112, + 2, + 113, + 7, + 113, + 2, + 114, + 7, + 114, + 2, + 115, + 7, + 115, + 2, + 116, + 7, + 116, + 2, + 117, + 7, + 117, + 2, + 118, + 7, + 118, + 2, + 119, + 7, + 119, + 2, + 120, + 7, + 120, + 2, + 121, + 7, + 121, + 2, + 122, + 7, + 122, + 2, + 123, + 7, + 123, + 2, + 124, + 7, + 124, + 2, + 125, + 7, + 125, + 2, + 126, + 7, + 126, + 2, + 127, + 7, + 127, + 2, + 128, + 7, + 128, + 2, + 129, + 7, + 129, + 2, + 130, + 7, + 130, + 2, + 131, + 7, + 131, + 2, + 132, + 7, + 132, + 2, + 133, + 7, + 133, + 2, + 134, + 7, + 134, + 2, + 135, + 7, + 135, + 2, + 136, + 7, + 136, + 2, + 137, + 7, + 137, + 2, + 138, + 7, + 138, + 2, + 139, + 7, + 139, + 2, + 140, + 7, + 140, + 2, + 141, + 7, + 141, + 2, + 142, + 7, + 142, + 2, + 143, + 7, + 143, + 2, + 144, + 7, + 144, + 2, + 145, + 7, + 145, + 2, + 146, + 7, + 146, + 2, + 147, + 7, + 147, + 2, + 148, + 7, + 148, + 2, + 149, + 7, + 149, + 2, + 150, + 7, + 150, + 2, + 151, + 7, + 151, + 2, + 152, + 7, + 152, + 2, + 153, + 7, + 153, + 2, + 154, + 7, + 154, + 2, + 155, + 7, + 155, + 2, + 156, + 7, + 156, + 2, + 157, + 7, + 157, + 2, + 158, + 7, + 158, + 2, + 159, + 7, + 159, + 2, + 160, + 7, + 160, + 2, + 161, + 7, + 161, + 2, + 162, + 7, + 162, + 2, + 163, + 7, + 163, + 2, + 164, + 7, + 164, + 2, + 165, + 7, + 165, + 2, + 166, + 7, + 166, + 2, + 167, + 7, + 167, + 2, + 168, + 7, + 168, + 2, + 169, + 7, + 169, + 2, + 170, + 7, + 170, + 2, + 171, + 7, + 171, + 2, + 172, + 7, + 172, + 2, + 173, + 7, + 173, + 2, + 174, + 7, + 174, + 2, + 175, + 7, + 175, + 2, + 176, + 7, + 176, + 2, + 177, + 7, + 177, + 2, + 178, + 7, + 178, + 2, + 179, + 7, + 179, + 2, + 180, + 7, + 180, + 2, + 181, + 7, + 181, + 2, + 182, + 7, + 182, + 2, + 183, + 7, + 183, + 2, + 184, + 7, + 184, + 2, + 185, + 7, + 185, + 2, + 186, + 7, + 186, + 2, + 187, + 7, + 187, + 2, + 188, + 7, + 188, + 2, + 189, + 7, + 189, + 2, + 190, + 7, + 190, + 2, + 191, + 7, + 191, + 2, + 192, + 7, + 192, + 2, + 193, + 7, + 193, + 2, + 194, + 7, + 194, + 2, + 195, + 7, + 195, + 2, + 196, + 7, + 196, + 2, + 197, + 7, + 197, + 2, + 198, + 7, + 198, + 2, + 199, + 7, + 199, + 2, + 200, + 7, + 200, + 2, + 201, + 7, + 201, + 2, + 202, + 7, + 202, + 2, + 203, + 7, + 203, + 2, + 204, + 7, + 204, + 2, + 205, + 7, + 205, + 2, + 206, + 7, + 206, + 2, + 207, + 7, + 207, + 2, + 208, + 7, + 208, + 2, + 209, + 7, + 209, + 2, + 210, + 7, + 210, + 2, + 211, + 7, + 211, + 2, + 212, + 7, + 212, + 2, + 213, + 7, + 213, + 2, + 214, + 7, + 214, + 2, + 215, + 7, + 215, + 2, + 216, + 7, + 216, + 2, + 217, + 7, + 217, + 2, + 218, + 7, + 218, + 2, + 219, + 7, + 219, + 2, + 220, + 7, + 220, + 2, + 221, + 7, + 221, + 2, + 222, + 7, + 222, + 2, + 223, + 7, + 223, + 2, + 224, + 7, + 224, + 2, + 225, + 7, + 225, + 2, + 226, + 7, + 226, + 2, + 227, + 7, + 227, + 2, + 228, + 7, + 228, + 2, + 229, + 7, + 229, + 2, + 230, + 7, + 230, + 2, + 231, + 7, + 231, + 2, + 232, + 7, + 232, + 2, + 233, + 7, + 233, + 2, + 234, + 7, + 234, + 2, + 235, + 7, + 235, + 2, + 236, + 7, + 236, + 2, + 237, + 7, + 237, + 2, + 238, + 7, + 238, + 2, + 239, + 7, + 239, + 2, + 240, + 7, + 240, + 2, + 241, + 7, + 241, + 2, + 242, + 7, + 242, + 2, + 243, + 7, + 243, + 2, + 244, + 7, + 244, + 2, + 245, + 7, + 245, + 2, + 246, + 7, + 246, + 2, + 247, + 7, + 247, + 2, + 248, + 7, + 248, + 2, + 249, + 7, + 249, + 2, + 250, + 7, + 250, + 2, + 251, + 7, + 251, + 2, + 252, + 7, + 252, + 2, + 253, + 7, + 253, + 2, + 254, + 7, + 254, + 2, + 255, + 7, + 255, + 2, + 256, + 7, + 256, + 2, + 257, + 7, + 257, + 2, + 258, + 7, + 258, + 2, + 259, + 7, + 259, + 2, + 260, + 7, + 260, + 2, + 261, + 7, + 261, + 2, + 262, + 7, + 262, + 2, + 263, + 7, + 263, + 2, + 264, + 7, + 264, + 2, + 265, + 7, + 265, + 2, + 266, + 7, + 266, + 2, + 267, + 7, + 267, + 2, + 268, + 7, + 268, + 2, + 269, + 7, + 269, + 2, + 270, + 7, + 270, + 2, + 271, + 7, + 271, + 2, + 272, + 7, + 272, + 2, + 273, + 7, + 273, + 2, + 274, + 7, + 274, + 2, + 275, + 7, + 275, + 2, + 276, + 7, + 276, + 2, + 277, + 7, + 277, + 2, + 278, + 7, + 278, + 2, + 279, + 7, + 279, + 2, + 280, + 7, + 280, + 2, + 281, + 7, + 281, + 2, + 282, + 7, + 282, + 2, + 283, + 7, + 283, + 2, + 284, + 7, + 284, + 2, + 285, + 7, + 285, + 2, + 286, + 7, + 286, + 2, + 287, + 7, + 287, + 2, + 288, + 7, + 288, + 2, + 289, + 7, + 289, + 2, + 290, + 7, + 290, + 2, + 291, + 7, + 291, + 2, + 292, + 7, + 292, + 2, + 293, + 7, + 293, + 2, + 294, + 7, + 294, + 2, + 295, + 7, + 295, + 2, + 296, + 7, + 296, + 2, + 297, + 7, + 297, + 2, + 298, + 7, + 298, + 2, + 299, + 7, + 299, + 2, + 300, + 7, + 300, + 2, + 301, + 7, + 301, + 2, + 302, + 7, + 302, + 2, + 303, + 7, + 303, + 2, + 304, + 7, + 304, + 2, + 305, + 7, + 305, + 2, + 306, + 7, + 306, + 2, + 307, + 7, + 307, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 3, + 1, + 3, + 1, + 3, + 1, + 3, + 1, + 3, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 8, + 1, + 8, + 1, + 8, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 23, + 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, + 25, + 1, + 25, + 1, + 25, + 1, + 25, + 1, + 25, + 1, + 25, + 1, + 25, + 1, + 25, + 1, + 26, + 1, + 26, + 1, + 26, + 1, + 26, + 1, + 26, + 1, + 26, + 1, + 26, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 39, + 1, + 39, + 1, + 39, + 1, + 39, + 1, + 39, + 1, + 39, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 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, + 55, + 1, + 55, + 1, + 55, + 1, + 56, + 1, + 56, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 61, + 1, + 61, + 1, + 61, + 1, + 61, + 1, + 61, + 1, + 61, + 1, + 61, + 1, + 61, + 1, + 61, + 1, + 61, + 1, + 61, + 1, + 62, + 1, + 62, + 1, + 62, + 1, + 63, + 1, + 63, + 1, + 63, + 1, + 63, + 1, + 63, + 1, + 63, + 1, + 63, + 1, + 63, + 1, + 64, + 1, + 64, + 1, + 64, + 1, + 64, + 1, + 64, + 1, + 65, + 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, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 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, + 75, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 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, + 84, + 1, + 84, + 1, + 85, + 1, + 85, + 1, + 85, + 1, + 85, + 1, + 85, + 1, + 85, + 1, + 85, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 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, + 97, + 1, + 97, + 1, + 97, + 1, + 97, + 1, + 97, + 1, + 97, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 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, + 101, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 102, + 1, + 102, + 1, + 102, + 1, + 102, + 1, + 103, + 1, + 103, + 1, + 103, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 108, + 1, + 108, + 1, + 108, + 1, + 108, + 1, + 108, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 110, + 1, + 110, + 1, + 110, + 1, + 110, + 1, + 110, + 1, + 110, + 1, + 111, + 1, + 111, + 1, + 111, + 1, + 111, + 1, + 111, + 1, + 112, + 1, + 112, + 1, + 112, + 1, + 112, + 1, + 112, + 1, + 112, + 1, + 112, + 1, + 113, + 1, + 113, + 1, + 113, + 1, + 113, + 1, + 113, + 1, + 113, + 1, + 114, + 1, + 114, + 1, + 114, + 1, + 114, + 1, + 114, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 115, + 1, + 116, + 1, + 116, + 1, + 116, + 1, + 116, + 1, + 116, + 1, + 116, + 1, + 117, + 1, + 117, + 1, + 117, + 1, + 118, + 1, + 118, + 1, + 118, + 1, + 118, + 1, + 119, + 1, + 119, + 1, + 119, + 1, + 119, + 1, + 119, + 1, + 119, + 1, + 120, + 1, + 120, + 1, + 120, + 1, + 120, + 1, + 121, + 1, + 121, + 1, + 121, + 1, + 121, + 1, + 121, + 1, + 121, + 1, + 122, + 1, + 122, + 1, + 122, + 1, + 122, + 1, + 122, + 1, + 123, + 1, + 123, + 1, + 123, + 1, + 123, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 125, + 1, + 125, + 1, + 125, + 1, + 125, + 1, + 125, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 127, + 1, + 127, + 1, + 127, + 1, + 127, + 1, + 127, + 1, + 127, + 1, + 128, + 1, + 128, + 1, + 128, + 1, + 128, + 1, + 128, + 1, + 128, + 1, + 128, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 130, + 1, + 130, + 1, + 130, + 1, + 130, + 1, + 131, + 1, + 131, + 1, + 131, + 1, + 131, + 1, + 131, + 1, + 131, + 1, + 131, + 1, + 132, + 1, + 132, + 1, + 132, + 1, + 132, + 1, + 132, + 1, + 132, + 1, + 133, + 1, + 133, + 1, + 133, + 1, + 133, + 1, + 133, + 1, + 133, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 135, + 1, + 135, + 1, + 135, + 1, + 135, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 137, + 1, + 137, + 1, + 137, + 1, + 137, + 1, + 137, + 1, + 138, + 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, + 139, + 1, + 140, + 1, + 140, + 1, + 140, + 1, + 140, + 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, + 141, + 1, + 141, + 1, + 141, + 1, + 141, + 1, + 141, + 1, + 141, + 1, + 141, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 143, + 1, + 143, + 1, + 143, + 1, + 143, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 145, + 1, + 145, + 1, + 145, + 1, + 145, + 1, + 146, + 1, + 146, + 1, + 146, + 1, + 146, + 1, + 146, + 1, + 146, + 1, + 146, + 1, + 146, + 1, + 146, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 148, + 1, + 148, + 1, + 148, + 1, + 148, + 1, + 148, + 1, + 148, + 1, + 148, + 1, + 148, + 1, + 148, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 151, + 1, + 151, + 1, + 151, + 1, + 151, + 1, + 151, + 1, + 151, + 1, + 151, + 1, + 152, + 1, + 152, + 1, + 152, + 1, + 152, + 1, + 152, + 1, + 152, + 1, + 152, + 1, + 152, + 1, + 152, + 1, + 153, + 1, + 153, + 1, + 153, + 1, + 153, + 1, + 153, + 1, + 153, + 1, + 154, + 1, + 154, + 1, + 154, + 1, + 154, + 1, + 154, + 1, + 154, + 1, + 155, + 1, + 155, + 1, + 155, + 1, + 156, + 1, + 156, + 1, + 156, + 1, + 156, + 1, + 156, + 1, + 156, + 1, + 156, + 1, + 157, + 1, + 157, + 1, + 157, + 1, + 157, + 1, + 158, + 1, + 158, + 1, + 158, + 1, + 158, + 1, + 159, + 1, + 159, + 1, + 159, + 1, + 159, + 1, + 159, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 161, + 1, + 161, + 1, + 161, + 1, + 161, + 1, + 161, + 1, + 162, + 1, + 162, + 1, + 163, + 1, + 163, + 1, + 163, + 1, + 163, + 1, + 163, + 1, + 163, + 1, + 163, + 1, + 163, + 1, + 163, + 1, + 164, + 1, + 164, + 1, + 164, + 1, + 164, + 1, + 164, + 1, + 164, + 1, + 164, + 1, + 164, + 1, + 164, + 1, + 165, + 1, + 165, + 1, + 165, + 1, + 165, + 1, + 165, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 167, + 1, + 167, + 1, + 167, + 1, + 167, + 1, + 167, + 1, + 167, + 1, + 167, + 1, + 167, + 1, + 167, + 1, + 167, + 1, + 167, + 1, + 167, + 1, + 167, + 1, + 168, + 1, + 168, + 1, + 168, + 1, + 168, + 1, + 168, + 1, + 169, + 1, + 169, + 1, + 169, + 1, + 169, + 1, + 170, + 1, + 170, + 1, + 170, + 1, + 170, + 1, + 170, + 1, + 170, + 1, + 170, + 1, + 170, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 173, + 1, + 173, + 1, + 173, + 1, + 173, + 1, + 173, + 1, + 173, + 1, + 173, + 1, + 173, + 1, + 173, + 1, + 173, + 1, + 173, + 1, + 173, + 1, + 174, + 1, + 174, + 1, + 174, + 1, + 174, + 1, + 174, + 1, + 174, + 1, + 174, + 1, + 174, + 1, + 174, + 1, + 174, + 1, + 174, + 1, + 174, + 1, + 174, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 177, + 1, + 177, + 1, + 177, + 1, + 177, + 1, + 177, + 1, + 177, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 183, + 1, + 183, + 1, + 183, + 1, + 183, + 1, + 183, + 1, + 183, + 1, + 183, + 1, + 184, + 1, + 184, + 1, + 184, + 1, + 184, + 1, + 184, + 1, + 184, + 1, + 184, + 1, + 184, + 1, + 185, + 1, + 185, + 1, + 185, + 1, + 185, + 1, + 185, + 1, + 185, + 1, + 185, + 1, + 185, + 1, + 185, + 1, + 186, + 1, + 186, + 1, + 186, + 1, + 186, + 1, + 186, + 1, + 186, + 1, + 187, + 1, + 187, + 1, + 187, + 1, + 187, + 1, + 187, + 1, + 188, + 1, + 188, + 1, + 188, + 1, + 188, + 1, + 188, + 1, + 188, + 1, + 188, + 1, + 189, + 1, + 189, + 1, + 189, + 1, + 189, + 1, + 189, + 1, + 189, + 1, + 190, + 1, + 190, + 1, + 190, + 1, + 190, + 1, + 190, + 1, + 190, + 1, + 190, + 1, + 191, + 1, + 191, + 1, + 191, + 1, + 191, + 1, + 191, + 1, + 191, + 1, + 191, + 1, + 192, + 1, + 192, + 1, + 192, + 1, + 192, + 1, + 193, + 1, + 193, + 1, + 193, + 1, + 193, + 1, + 193, + 1, + 193, + 1, + 193, + 1, + 193, + 1, + 193, + 1, + 193, + 1, + 193, + 1, + 193, + 1, + 193, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 195, + 1, + 195, + 1, + 195, + 1, + 195, + 1, + 195, + 1, + 195, + 1, + 195, + 1, + 195, + 1, + 196, + 1, + 196, + 1, + 196, + 1, + 196, + 1, + 196, + 1, + 196, + 1, + 196, + 1, + 196, + 1, + 196, + 1, + 196, + 1, + 196, + 1, + 197, + 1, + 197, + 1, + 197, + 1, + 197, + 1, + 197, + 1, + 197, + 1, + 197, + 1, + 197, + 1, + 197, + 1, + 197, + 1, + 197, + 1, + 198, + 1, + 198, + 1, + 198, + 1, + 198, + 1, + 198, + 1, + 198, + 1, + 198, + 1, + 199, + 1, + 199, + 1, + 199, + 1, + 199, + 1, + 199, + 1, + 200, + 1, + 200, + 1, + 200, + 1, + 200, + 1, + 200, + 1, + 200, + 1, + 201, + 1, + 201, + 1, + 201, + 1, + 201, + 1, + 201, + 1, + 201, + 1, + 201, + 1, + 201, + 1, + 201, + 1, + 201, + 1, + 201, + 1, + 201, + 1, + 201, + 1, + 202, + 1, + 202, + 1, + 202, + 1, + 202, + 1, + 202, + 1, + 202, + 1, + 203, + 1, + 203, + 1, + 203, + 1, + 203, + 1, + 203, + 1, + 203, + 1, + 203, + 1, + 203, + 1, + 203, + 1, + 204, + 1, + 204, + 1, + 204, + 1, + 204, + 1, + 204, + 1, + 204, + 1, + 204, + 1, + 204, + 1, + 204, + 1, + 204, + 1, + 205, + 1, + 205, + 1, + 205, + 1, + 205, + 1, + 206, + 1, + 206, + 1, + 206, + 1, + 206, + 1, + 206, + 1, + 206, + 1, + 206, + 1, + 206, + 1, + 207, + 1, + 207, + 1, + 208, + 1, + 208, + 1, + 208, + 1, + 208, + 1, + 208, + 1, + 209, + 1, + 209, + 1, + 209, + 1, + 209, + 1, + 209, + 1, + 209, + 1, + 209, + 1, + 210, + 1, + 210, + 1, + 210, + 1, + 210, + 1, + 210, + 1, + 210, + 1, + 211, + 1, + 211, + 1, + 211, + 1, + 211, + 1, + 211, + 1, + 211, + 1, + 211, + 1, + 211, + 1, + 211, + 1, + 211, + 1, + 212, + 1, + 212, + 1, + 212, + 1, + 212, + 1, + 212, + 1, + 212, + 1, + 213, + 1, + 213, + 1, + 213, + 1, + 214, + 1, + 214, + 1, + 214, + 1, + 214, + 1, + 214, + 1, + 214, + 1, + 214, + 1, + 214, + 1, + 214, + 1, + 214, + 1, + 215, + 1, + 215, + 1, + 215, + 1, + 215, + 1, + 215, + 1, + 215, + 1, + 215, + 1, + 216, + 1, + 216, + 1, + 216, + 1, + 216, + 1, + 216, + 1, + 216, + 1, + 216, + 1, + 217, + 1, + 217, + 1, + 217, + 1, + 217, + 1, + 217, + 1, + 217, + 1, + 217, + 1, + 217, + 1, + 218, + 1, + 218, + 1, + 218, + 1, + 218, + 1, + 218, + 1, + 218, + 1, + 219, + 1, + 219, + 1, + 219, + 1, + 219, + 1, + 219, + 1, + 219, + 1, + 219, + 1, + 219, + 1, + 219, + 1, + 220, + 1, + 220, + 1, + 220, + 1, + 220, + 1, + 220, + 1, + 220, + 1, + 220, + 1, + 220, + 1, + 221, + 1, + 221, + 1, + 221, + 1, + 221, + 1, + 222, + 1, + 222, + 1, + 222, + 1, + 222, + 1, + 223, + 1, + 223, + 1, + 223, + 1, + 223, + 1, + 223, + 1, + 224, + 1, + 224, + 1, + 224, + 1, + 224, + 1, + 224, + 1, + 225, + 1, + 225, + 1, + 225, + 1, + 225, + 1, + 225, + 1, + 226, + 1, + 226, + 1, + 226, + 1, + 226, + 1, + 226, + 1, + 226, + 1, + 226, + 1, + 226, + 1, + 227, + 1, + 227, + 1, + 227, + 1, + 228, + 1, + 228, + 1, + 228, + 1, + 228, + 1, + 228, + 1, + 228, + 1, + 228, + 1, + 229, + 1, + 229, + 1, + 229, + 1, + 229, + 1, + 229, + 1, + 229, + 1, + 230, + 1, + 230, + 1, + 230, + 1, + 230, + 1, + 230, + 1, + 230, + 1, + 231, + 1, + 231, + 1, + 231, + 1, + 231, + 1, + 231, + 1, + 232, + 1, + 232, + 1, + 233, + 1, + 233, + 1, + 233, + 1, + 233, + 1, + 233, + 1, + 233, + 1, + 233, + 1, + 233, + 1, + 233, + 1, + 234, + 1, + 234, + 1, + 234, + 1, + 234, + 1, + 234, + 1, + 234, + 1, + 234, + 1, + 235, + 1, + 235, + 1, + 235, + 1, + 235, + 1, + 235, + 1, + 235, + 1, + 236, + 1, + 236, + 1, + 236, + 1, + 236, + 1, + 236, + 1, + 236, + 1, + 236, + 1, + 237, + 1, + 237, + 1, + 237, + 1, + 237, + 1, + 237, + 1, + 237, + 1, + 238, + 1, + 238, + 1, + 238, + 1, + 238, + 1, + 238, + 1, + 239, + 1, + 239, + 1, + 239, + 1, + 239, + 1, + 239, + 1, + 239, + 1, + 239, + 1, + 239, + 1, + 239, + 1, + 240, + 1, + 240, + 1, + 240, + 1, + 240, + 1, + 240, + 1, + 240, + 1, + 240, + 1, + 241, + 1, + 241, + 1, + 241, + 1, + 241, + 1, + 241, + 1, + 241, + 1, + 241, + 1, + 241, + 1, + 241, + 1, + 241, + 1, + 241, + 1, + 241, + 1, + 242, + 1, + 242, + 1, + 242, + 1, + 242, + 1, + 242, + 1, + 242, + 1, + 242, + 1, + 242, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 244, + 1, + 244, + 1, + 244, + 1, + 244, + 1, + 244, + 1, + 244, + 1, + 244, + 1, + 244, + 1, + 244, + 1, + 245, + 1, + 245, + 1, + 245, + 1, + 245, + 1, + 245, + 1, + 245, + 1, + 245, + 1, + 245, + 1, + 245, + 1, + 246, + 1, + 246, + 1, + 246, + 1, + 246, + 1, + 246, + 1, + 246, + 1, + 246, + 1, + 246, + 1, + 246, + 1, + 246, + 1, + 246, + 1, + 246, + 1, + 246, + 1, + 246, + 1, + 246, + 1, + 247, + 1, + 247, + 1, + 247, + 1, + 247, + 1, + 247, + 1, + 247, + 1, + 247, + 1, + 247, + 1, + 247, + 1, + 247, + 1, + 247, + 1, + 247, + 1, + 247, + 1, + 247, + 1, + 247, + 1, + 248, + 1, + 248, + 1, + 248, + 1, + 248, + 1, + 248, + 1, + 248, + 1, + 249, + 1, + 249, + 1, + 249, + 1, + 249, + 1, + 249, + 1, + 249, + 1, + 249, + 1, + 250, + 3, + 250, + 2377, + 8, + 250, + 1, + 250, + 1, + 250, + 3, + 250, + 2381, + 8, + 250, + 1, + 250, + 1, + 250, + 3, + 250, + 2385, + 8, + 250, + 1, + 250, + 3, + 250, + 2388, + 8, + 250, + 1, + 251, + 1, + 251, + 3, + 251, + 2392, + 8, + 251, + 1, + 252, + 1, + 252, + 3, + 252, + 2396, + 8, + 252, + 1, + 253, + 1, + 253, + 3, + 253, + 2400, + 8, + 253, + 1, + 254, + 1, + 254, + 1, + 255, + 1, + 255, + 1, + 255, + 3, + 255, + 2407, + 8, + 255, + 1, + 255, + 1, + 255, + 1, + 255, + 3, + 255, + 2412, + 8, + 255, + 3, + 255, + 2414, + 8, + 255, + 1, + 256, + 1, + 256, + 3, + 256, + 2418, + 8, + 256, + 1, + 256, + 3, + 256, + 2421, + 8, + 256, + 1, + 257, + 1, + 257, + 3, + 257, + 2425, + 8, + 257, + 1, + 258, + 1, + 258, + 1, + 259, + 4, + 259, + 2430, + 8, + 259, + 11, + 259, + 12, + 259, + 2431, + 1, + 260, + 1, + 260, + 3, + 260, + 2436, + 8, + 260, + 1, + 261, + 4, + 261, + 2439, + 8, + 261, + 11, + 261, + 12, + 261, + 2440, + 1, + 262, + 1, + 262, + 1, + 262, + 1, + 262, + 1, + 263, + 1, + 263, + 3, + 263, + 2449, + 8, + 263, + 1, + 263, + 3, + 263, + 2452, + 8, + 263, + 1, + 264, + 1, + 264, + 1, + 265, + 4, + 265, + 2457, + 8, + 265, + 11, + 265, + 12, + 265, + 2458, + 1, + 266, + 1, + 266, + 3, + 266, + 2463, + 8, + 266, + 1, + 267, + 1, + 267, + 3, + 267, + 2467, + 8, + 267, + 1, + 267, + 1, + 267, + 1, + 268, + 1, + 268, + 3, + 268, + 2473, + 8, + 268, + 1, + 268, + 3, + 268, + 2476, + 8, + 268, + 1, + 269, + 1, + 269, + 1, + 270, + 4, + 270, + 2481, + 8, + 270, + 11, + 270, + 12, + 270, + 2482, + 1, + 271, + 1, + 271, + 3, + 271, + 2487, + 8, + 271, + 1, + 272, + 3, + 272, + 2490, + 8, + 272, + 1, + 272, + 1, + 272, + 1, + 273, + 1, + 273, + 1, + 273, + 1, + 273, + 3, + 273, + 2498, + 8, + 273, + 1, + 273, + 3, + 273, + 2501, + 8, + 273, + 1, + 273, + 3, + 273, + 2504, + 8, + 273, + 1, + 273, + 1, + 273, + 1, + 273, + 3, + 273, + 2509, + 8, + 273, + 1, + 274, + 1, + 274, + 1, + 274, + 1, + 275, + 1, + 275, + 1, + 276, + 3, + 276, + 2517, + 8, + 276, + 1, + 276, + 1, + 276, + 1, + 277, + 1, + 277, + 1, + 278, + 1, + 278, + 1, + 279, + 3, + 279, + 2526, + 8, + 279, + 1, + 279, + 1, + 279, + 1, + 280, + 1, + 280, + 1, + 280, + 1, + 280, + 1, + 280, + 1, + 280, + 1, + 280, + 1, + 280, + 3, + 280, + 2538, + 8, + 280, + 1, + 281, + 1, + 281, + 1, + 281, + 1, + 281, + 3, + 281, + 2544, + 8, + 281, + 1, + 282, + 4, + 282, + 2547, + 8, + 282, + 11, + 282, + 12, + 282, + 2548, + 1, + 283, + 1, + 283, + 1, + 283, + 3, + 283, + 2554, + 8, + 283, + 1, + 284, + 4, + 284, + 2557, + 8, + 284, + 11, + 284, + 12, + 284, + 2558, + 1, + 285, + 1, + 285, + 1, + 285, + 3, + 285, + 2564, + 8, + 285, + 1, + 286, + 1, + 286, + 3, + 286, + 2568, + 8, + 286, + 1, + 286, + 1, + 286, + 1, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 3, + 287, + 2576, + 8, + 287, + 1, + 288, + 1, + 288, + 1, + 288, + 1, + 288, + 1, + 288, + 1, + 288, + 1, + 288, + 1, + 288, + 1, + 288, + 1, + 288, + 1, + 288, + 3, + 288, + 2589, + 8, + 288, + 1, + 289, + 1, + 289, + 1, + 290, + 1, + 290, + 4, + 290, + 2595, + 8, + 290, + 11, + 290, + 12, + 290, + 2596, + 1, + 290, + 1, + 290, + 1, + 290, + 1, + 290, + 1, + 290, + 1, + 291, + 1, + 291, + 1, + 292, + 1, + 292, + 1, + 293, + 1, + 293, + 1, + 294, + 1, + 294, + 1, + 295, + 1, + 295, + 1, + 296, + 1, + 296, + 1, + 297, + 1, + 297, + 1, + 298, + 1, + 298, + 1, + 299, + 1, + 299, + 1, + 300, + 1, + 300, + 1, + 301, + 1, + 301, + 1, + 302, + 1, + 302, + 1, + 302, + 1, + 303, + 4, + 303, + 2630, + 8, + 303, + 11, + 303, + 12, + 303, + 2631, + 1, + 303, + 1, + 303, + 1, + 304, + 1, + 304, + 1, + 304, + 1, + 304, + 5, + 304, + 2640, + 8, + 304, + 10, + 304, + 12, + 304, + 2643, + 9, + 304, + 1, + 304, + 1, + 304, + 1, + 305, + 1, + 305, + 5, + 305, + 2649, + 8, + 305, + 10, + 305, + 12, + 305, + 2652, + 9, + 305, + 1, + 306, + 3, + 306, + 2655, + 8, + 306, + 1, + 307, + 1, + 307, + 3, + 307, + 2659, + 8, + 307, + 0, + 0, + 308, + 1, + 1, + 3, + 2, + 5, + 3, + 7, + 4, + 9, + 5, + 11, + 6, + 13, + 7, + 15, + 8, + 17, + 9, + 19, + 10, + 21, + 11, + 23, + 12, + 25, + 13, + 27, + 14, + 29, + 15, + 31, + 16, + 33, + 17, + 35, + 18, + 37, + 19, + 39, + 20, + 41, + 21, + 43, + 22, + 45, + 23, + 47, + 24, + 49, + 25, + 51, + 26, + 53, + 27, + 55, + 28, + 57, + 29, + 59, + 30, + 61, + 31, + 63, + 32, + 65, + 33, + 67, + 34, + 69, + 35, + 71, + 36, + 73, + 37, + 75, + 38, + 77, + 39, + 79, + 40, + 81, + 41, + 83, + 42, + 85, + 43, + 87, + 44, + 89, + 45, + 91, + 46, + 93, + 47, + 95, + 48, + 97, + 49, + 99, + 50, + 101, + 51, + 103, + 52, + 105, + 53, + 107, + 54, + 109, + 55, + 111, + 56, + 113, + 57, + 115, + 58, + 117, + 59, + 119, + 60, + 121, + 61, + 123, + 62, + 125, + 63, + 127, + 64, + 129, + 65, + 131, + 66, + 133, + 67, + 135, + 68, + 137, + 69, + 139, + 70, + 141, + 71, + 143, + 72, + 145, + 73, + 147, + 74, + 149, + 75, + 151, + 76, + 153, + 77, + 155, + 78, + 157, + 79, + 159, + 80, + 161, + 81, + 163, + 82, + 165, + 83, + 167, + 84, + 169, + 85, + 171, + 86, + 173, + 87, + 175, + 88, + 177, + 89, + 179, + 90, + 181, + 91, + 183, + 92, + 185, + 93, + 187, + 94, + 189, + 95, + 191, + 96, + 193, + 97, + 195, + 98, + 197, + 99, + 199, + 100, + 201, + 101, + 203, + 102, + 205, + 103, + 207, + 104, + 209, + 105, + 211, + 106, + 213, + 107, + 215, + 108, + 217, + 109, + 219, + 110, + 221, + 111, + 223, + 112, + 225, + 113, + 227, + 114, + 229, + 115, + 231, + 116, + 233, + 117, + 235, + 118, + 237, + 119, + 239, + 120, + 241, + 121, + 243, + 122, + 245, + 123, + 247, + 124, + 249, + 125, + 251, + 126, + 253, + 127, + 255, + 128, + 257, + 129, + 259, + 130, + 261, + 131, + 263, + 132, + 265, + 133, + 267, + 134, + 269, + 135, + 271, + 136, + 273, + 137, + 275, + 138, + 277, + 139, + 279, + 140, + 281, + 141, + 283, + 142, + 285, + 143, + 287, + 144, + 289, + 145, + 291, + 146, + 293, + 147, + 295, + 148, + 297, + 149, + 299, + 150, + 301, + 151, + 303, + 152, + 305, + 153, + 307, + 154, + 309, + 155, + 311, + 156, + 313, + 157, + 315, + 158, + 317, + 159, + 319, + 160, + 321, + 161, + 323, + 162, + 325, + 163, + 327, + 164, + 329, + 165, + 331, + 166, + 333, + 167, + 335, + 168, + 337, + 169, + 339, + 170, + 341, + 171, + 343, + 172, + 345, + 173, + 347, + 174, + 349, + 175, + 351, + 176, + 353, + 177, + 355, + 178, + 357, + 179, + 359, + 180, + 361, + 181, + 363, + 182, + 365, + 183, + 367, + 184, + 369, + 185, + 371, + 186, + 373, + 187, + 375, + 188, + 377, + 189, + 379, + 190, + 381, + 191, + 383, + 192, + 385, + 193, + 387, + 194, + 389, + 195, + 391, + 196, + 393, + 197, + 395, + 198, + 397, + 199, + 399, + 200, + 401, + 201, + 403, + 202, + 405, + 203, + 407, + 204, + 409, + 205, + 411, + 206, + 413, + 207, + 415, + 208, + 417, + 209, + 419, + 210, + 421, + 211, + 423, + 212, + 425, + 213, + 427, + 214, + 429, + 215, + 431, + 216, + 433, + 217, + 435, + 218, + 437, + 219, + 439, + 220, + 441, + 221, + 443, + 222, + 445, + 223, + 447, + 224, + 449, + 225, + 451, + 226, + 453, + 227, + 455, + 228, + 457, + 229, + 459, + 230, + 461, + 231, + 463, + 232, + 465, + 233, + 467, + 234, + 469, + 235, + 471, + 236, + 473, + 237, + 475, + 238, + 477, + 239, + 479, + 240, + 481, + 241, + 483, + 242, + 485, + 243, + 487, + 244, + 489, + 245, + 491, + 246, + 493, + 247, + 495, + 248, + 497, + 249, + 499, + 250, + 501, + 251, + 503, + 0, + 505, + 0, + 507, + 0, + 509, + 0, + 511, + 0, + 513, + 0, + 515, + 0, + 517, + 0, + 519, + 0, + 521, + 0, + 523, + 0, + 525, + 0, + 527, + 0, + 529, + 0, + 531, + 0, + 533, + 0, + 535, + 0, + 537, + 0, + 539, + 0, + 541, + 0, + 543, + 0, + 545, + 252, + 547, + 0, + 549, + 0, + 551, + 0, + 553, + 0, + 555, + 0, + 557, + 0, + 559, + 253, + 561, + 254, + 563, + 255, + 565, + 0, + 567, + 0, + 569, + 0, + 571, + 0, + 573, + 0, + 575, + 0, + 577, + 0, + 579, + 0, + 581, + 0, + 583, + 256, + 585, + 257, + 587, + 258, + 589, + 259, + 591, + 260, + 593, + 261, + 595, + 262, + 597, + 263, + 599, + 264, + 601, + 265, + 603, + 266, + 605, + 267, + 607, + 268, + 609, + 269, + 611, + 270, + 613, + 0, + 615, + 0, + 1, + 0, + 16, + 10, + 0, + 66, + 66, + 73, + 73, + 76, + 76, + 78, + 78, + 83, + 83, + 98, + 98, + 105, + 105, + 108, + 108, + 110, + 110, + 115, + 115, + 1, + 0, + 49, + 57, + 2, + 0, + 88, + 88, + 120, + 120, + 3, + 0, + 48, + 57, + 65, + 70, + 97, + 102, + 1, + 0, + 48, + 55, + 2, + 0, + 69, + 69, + 101, + 101, + 2, + 0, + 43, + 43, + 45, + 45, + 6, + 0, + 68, + 68, + 70, + 70, + 77, + 77, + 100, + 100, + 102, + 102, + 109, + 109, + 2, + 0, + 34, + 34, + 92, + 92, + 2, + 0, + 39, + 39, + 92, + 92, + 8, + 0, + 34, + 34, + 39, + 39, + 92, + 92, + 98, + 98, + 102, + 102, + 110, + 110, + 114, + 114, + 116, + 116, + 1, + 0, + 48, + 51, + 3, + 0, + 9, + 10, + 12, + 13, + 32, + 32, + 2, + 0, + 10, + 10, + 13, + 13, + 402, + 0, + 36, + 36, + 65, + 90, + 95, + 95, + 97, + 122, + 162, + 165, + 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, + 1377, + 1415, + 1423, + 1423, + 1488, + 1514, + 1520, + 1522, + 1547, + 1547, + 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, + 2208, + 2228, + 2230, + 2237, + 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, + 2547, + 2555, + 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, + 2801, + 2801, + 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, + 3065, + 3065, + 3077, + 3084, + 3086, + 3088, + 3090, + 3112, + 3114, + 3129, + 3133, + 3133, + 3160, + 3162, + 3168, + 3169, + 3200, + 3200, + 3205, + 3212, + 3214, + 3216, + 3218, + 3240, + 3242, + 3251, + 3253, + 3257, + 3261, + 3261, + 3294, + 3294, + 3296, + 3297, + 3313, + 3314, + 3333, + 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, + 3647, + 3654, + 3713, + 3714, + 3716, + 3716, + 3719, + 3720, + 3722, + 3722, + 3725, + 3725, + 3732, + 3735, + 3737, + 3743, + 3745, + 3747, + 3749, + 3749, + 3751, + 3751, + 3754, + 3755, + 3757, + 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, + 5900, + 5902, + 5905, + 5920, + 5937, + 5952, + 5969, + 5984, + 5996, + 5998, + 6000, + 6016, + 6067, + 6103, + 6103, + 6107, + 6108, + 6176, + 6263, + 6272, + 6276, + 6279, + 6312, + 6314, + 6314, + 6320, + 6389, + 6400, + 6430, + 6480, + 6509, + 6512, + 6516, + 6528, + 6571, + 6576, + 6601, + 6656, + 6678, + 6688, + 6740, + 6823, + 6823, + 6917, + 6963, + 6981, + 6987, + 7043, + 7072, + 7086, + 7087, + 7098, + 7141, + 7168, + 7203, + 7245, + 7247, + 7258, + 7293, + 7296, + 7304, + 7401, + 7404, + 7406, + 7409, + 7413, + 7414, + 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, + 8255, + 8256, + 8276, + 8276, + 8305, + 8305, + 8319, + 8319, + 8336, + 8348, + 8352, + 8383, + 8450, + 8450, + 8455, + 8455, + 8458, + 8467, + 8469, + 8469, + 8473, + 8477, + 8484, + 8484, + 8486, + 8486, + 8488, + 8488, + 8490, + 8493, + 8495, + 8505, + 8508, + 8511, + 8517, + 8521, + 8526, + 8526, + 8544, + 8584, + 11264, + 11310, + 11312, + 11358, + 11360, + 11492, + 11499, + 11502, + 11506, + 11507, + 11520, + 11557, + 11559, + 11559, + 11565, + 11565, + 11568, + 11623, + 11631, + 11631, + 11648, + 11670, + 11680, + 11686, + 11688, + 11694, + 11696, + 11702, + 11704, + 11710, + 11712, + 11718, + 11720, + 11726, + 11728, + 11734, + 11736, + 11742, + 11823, + 11823, + 12293, + 12295, + 12321, + 12329, + 12337, + 12341, + 12344, + 12348, + 12353, + 12438, + 12445, + 12447, + 12449, + 12538, + 12540, + 12543, + 12549, + 12590, + 12593, + 12686, + 12704, + 12730, + 12784, + 12799, + 13312, + 19893, + 19968, + 40938, + 40960, + 42124, + 42192, + 42237, + 42240, + 42508, + 42512, + 42527, + 42538, + 42539, + 42560, + 42606, + 42623, + 42653, + 42656, + 42735, + 42775, + 42783, + 42786, + 42888, + 42891, + 42926, + 42928, + 42935, + 42999, + 43009, + 43011, + 43013, + 43015, + 43018, + 43020, + 43042, + 43064, + 43064, + 43072, + 43123, + 43138, + 43187, + 43250, + 43255, + 43259, + 43259, + 43261, + 43261, + 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, + 43877, + 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, + 65020, + 65075, + 65076, + 65101, + 65103, + 65129, + 65129, + 65136, + 65140, + 65142, + 65276, + 65284, + 65284, + 65313, + 65338, + 65343, + 65343, + 65345, + 65370, + 65382, + 65470, + 65474, + 65479, + 65482, + 65487, + 65490, + 65495, + 65498, + 65500, + 65504, + 65505, + 65509, + 65510, + 228, + 0, + 48, + 57, + 127, + 159, + 173, + 173, + 768, + 879, + 1155, + 1159, + 1425, + 1469, + 1471, + 1471, + 1473, + 1474, + 1476, + 1477, + 1479, + 1479, + 1536, + 1541, + 1552, + 1562, + 1564, + 1564, + 1611, + 1641, + 1648, + 1648, + 1750, + 1757, + 1759, + 1764, + 1767, + 1768, + 1770, + 1773, + 1776, + 1785, + 1807, + 1807, + 1809, + 1809, + 1840, + 1866, + 1958, + 1968, + 1984, + 1993, + 2027, + 2035, + 2070, + 2073, + 2075, + 2083, + 2085, + 2087, + 2089, + 2093, + 2137, + 2139, + 2260, + 2307, + 2362, + 2364, + 2366, + 2383, + 2385, + 2391, + 2402, + 2403, + 2406, + 2415, + 2433, + 2435, + 2492, + 2492, + 2494, + 2500, + 2503, + 2504, + 2507, + 2509, + 2519, + 2519, + 2530, + 2531, + 2534, + 2543, + 2561, + 2563, + 2620, + 2620, + 2622, + 2626, + 2631, + 2632, + 2635, + 2637, + 2641, + 2641, + 2662, + 2673, + 2677, + 2677, + 2689, + 2691, + 2748, + 2748, + 2750, + 2757, + 2759, + 2761, + 2763, + 2765, + 2786, + 2787, + 2790, + 2799, + 2810, + 2815, + 2817, + 2819, + 2876, + 2876, + 2878, + 2884, + 2887, + 2888, + 2891, + 2893, + 2902, + 2903, + 2914, + 2915, + 2918, + 2927, + 2946, + 2946, + 3006, + 3010, + 3014, + 3016, + 3018, + 3021, + 3031, + 3031, + 3046, + 3055, + 3072, + 3075, + 3134, + 3140, + 3142, + 3144, + 3146, + 3149, + 3157, + 3158, + 3170, + 3171, + 3174, + 3183, + 3201, + 3203, + 3260, + 3260, + 3262, + 3268, + 3270, + 3272, + 3274, + 3277, + 3285, + 3286, + 3298, + 3299, + 3302, + 3311, + 3328, + 3331, + 3387, + 3388, + 3390, + 3396, + 3398, + 3400, + 3402, + 3405, + 3415, + 3415, + 3426, + 3427, + 3430, + 3439, + 3458, + 3459, + 3530, + 3530, + 3535, + 3540, + 3542, + 3542, + 3544, + 3551, + 3558, + 3567, + 3570, + 3571, + 3633, + 3633, + 3636, + 3642, + 3655, + 3662, + 3664, + 3673, + 3761, + 3761, + 3764, + 3769, + 3771, + 3772, + 3784, + 3789, + 3792, + 3801, + 3864, + 3865, + 3872, + 3881, + 3893, + 3893, + 3895, + 3895, + 3897, + 3897, + 3902, + 3903, + 3953, + 3972, + 3974, + 3975, + 3981, + 3991, + 3993, + 4028, + 4038, + 4038, + 4139, + 4158, + 4160, + 4169, + 4182, + 4185, + 4190, + 4192, + 4194, + 4196, + 4199, + 4205, + 4209, + 4212, + 4226, + 4237, + 4239, + 4253, + 4957, + 4959, + 5906, + 5908, + 5938, + 5940, + 5970, + 5971, + 6002, + 6003, + 6068, + 6099, + 6109, + 6109, + 6112, + 6121, + 6155, + 6158, + 6160, + 6169, + 6277, + 6278, + 6313, + 6313, + 6432, + 6443, + 6448, + 6459, + 6470, + 6479, + 6608, + 6617, + 6679, + 6683, + 6741, + 6750, + 6752, + 6780, + 6783, + 6793, + 6800, + 6809, + 6832, + 6845, + 6912, + 6916, + 6964, + 6980, + 6992, + 7001, + 7019, + 7027, + 7040, + 7042, + 7073, + 7085, + 7088, + 7097, + 7142, + 7155, + 7204, + 7223, + 7232, + 7241, + 7248, + 7257, + 7376, + 7378, + 7380, + 7400, + 7405, + 7405, + 7410, + 7412, + 7415, + 7417, + 7616, + 7673, + 7675, + 7679, + 8203, + 8207, + 8234, + 8238, + 8288, + 8292, + 8294, + 8303, + 8400, + 8412, + 8417, + 8417, + 8421, + 8432, + 11503, + 11505, + 11647, + 11647, + 11744, + 11775, + 12330, + 12335, + 12441, + 12442, + 42528, + 42537, + 42607, + 42607, + 42612, + 42621, + 42654, + 42655, + 42736, + 42737, + 43010, + 43010, + 43014, + 43014, + 43019, + 43019, + 43043, + 43047, + 43136, + 43137, + 43188, + 43205, + 43216, + 43225, + 43232, + 43249, + 43264, + 43273, + 43302, + 43309, + 43335, + 43347, + 43392, + 43395, + 43443, + 43456, + 43472, + 43481, + 43493, + 43493, + 43504, + 43513, + 43561, + 43574, + 43587, + 43587, + 43596, + 43597, + 43600, + 43609, + 43643, + 43645, + 43696, + 43696, + 43698, + 43700, + 43703, + 43704, + 43710, + 43711, + 43713, + 43713, + 43755, + 43759, + 43765, + 43766, + 44003, + 44010, + 44012, + 44013, + 44016, + 44025, + 64286, + 64286, + 65024, + 65039, + 65056, + 65071, + 65279, + 65279, + 65296, + 65305, + 65529, + 65531, + 2672, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 3, + 1, + 0, + 0, + 0, + 0, + 5, + 1, + 0, + 0, + 0, + 0, + 7, + 1, + 0, + 0, + 0, + 0, + 9, + 1, + 0, + 0, + 0, + 0, + 11, + 1, + 0, + 0, + 0, + 0, + 13, + 1, + 0, + 0, + 0, + 0, + 15, + 1, + 0, + 0, + 0, + 0, + 17, + 1, + 0, + 0, + 0, + 0, + 19, + 1, + 0, + 0, + 0, + 0, + 21, + 1, + 0, + 0, + 0, + 0, + 23, + 1, + 0, + 0, + 0, + 0, + 25, + 1, + 0, + 0, + 0, + 0, + 27, + 1, + 0, + 0, + 0, + 0, + 29, + 1, + 0, + 0, + 0, + 0, + 31, + 1, + 0, + 0, + 0, + 0, + 33, + 1, + 0, + 0, + 0, + 0, + 35, + 1, + 0, + 0, + 0, + 0, + 37, + 1, + 0, + 0, + 0, + 0, + 39, + 1, + 0, + 0, + 0, + 0, + 41, + 1, + 0, + 0, + 0, + 0, + 43, + 1, + 0, + 0, + 0, + 0, + 45, + 1, + 0, + 0, + 0, + 0, + 47, + 1, + 0, + 0, + 0, + 0, + 49, + 1, + 0, + 0, + 0, + 0, + 51, + 1, + 0, + 0, + 0, + 0, + 53, + 1, + 0, + 0, + 0, + 0, + 55, + 1, + 0, + 0, + 0, + 0, + 57, + 1, + 0, + 0, + 0, + 0, + 59, + 1, + 0, + 0, + 0, + 0, + 61, + 1, + 0, + 0, + 0, + 0, + 63, + 1, + 0, + 0, + 0, + 0, + 65, + 1, + 0, + 0, + 0, + 0, + 67, + 1, + 0, + 0, + 0, + 0, + 69, + 1, + 0, + 0, + 0, + 0, + 71, + 1, + 0, + 0, + 0, + 0, + 73, + 1, + 0, + 0, + 0, + 0, + 75, + 1, + 0, + 0, + 0, + 0, + 77, + 1, + 0, + 0, + 0, + 0, + 79, + 1, + 0, + 0, + 0, + 0, + 81, + 1, + 0, + 0, + 0, + 0, + 83, + 1, + 0, + 0, + 0, + 0, + 85, + 1, + 0, + 0, + 0, + 0, + 87, + 1, + 0, + 0, + 0, + 0, + 89, + 1, + 0, + 0, + 0, + 0, + 91, + 1, + 0, + 0, + 0, + 0, + 93, + 1, + 0, + 0, + 0, + 0, + 95, + 1, + 0, + 0, + 0, + 0, + 97, + 1, + 0, + 0, + 0, + 0, + 99, + 1, + 0, + 0, + 0, + 0, + 101, + 1, + 0, + 0, + 0, + 0, + 103, + 1, + 0, + 0, + 0, + 0, + 105, + 1, + 0, + 0, + 0, + 0, + 107, + 1, + 0, + 0, + 0, + 0, + 109, + 1, + 0, + 0, + 0, + 0, + 111, + 1, + 0, + 0, + 0, + 0, + 113, + 1, + 0, + 0, + 0, + 0, + 115, + 1, + 0, + 0, + 0, + 0, + 117, + 1, + 0, + 0, + 0, + 0, + 119, + 1, + 0, + 0, + 0, + 0, + 121, + 1, + 0, + 0, + 0, + 0, + 123, + 1, + 0, + 0, + 0, + 0, + 125, + 1, + 0, + 0, + 0, + 0, + 127, + 1, + 0, + 0, + 0, + 0, + 129, + 1, + 0, + 0, + 0, + 0, + 131, + 1, + 0, + 0, + 0, + 0, + 133, + 1, + 0, + 0, + 0, + 0, + 135, + 1, + 0, + 0, + 0, + 0, + 137, + 1, + 0, + 0, + 0, + 0, + 139, + 1, + 0, + 0, + 0, + 0, + 141, + 1, + 0, + 0, + 0, + 0, + 143, + 1, + 0, + 0, + 0, + 0, + 145, + 1, + 0, + 0, + 0, + 0, + 147, + 1, + 0, + 0, + 0, + 0, + 149, + 1, + 0, + 0, + 0, + 0, + 151, + 1, + 0, + 0, + 0, + 0, + 153, + 1, + 0, + 0, + 0, + 0, + 155, + 1, + 0, + 0, + 0, + 0, + 157, + 1, + 0, + 0, + 0, + 0, + 159, + 1, + 0, + 0, + 0, + 0, + 161, + 1, + 0, + 0, + 0, + 0, + 163, + 1, + 0, + 0, + 0, + 0, + 165, + 1, + 0, + 0, + 0, + 0, + 167, + 1, + 0, + 0, + 0, + 0, + 169, + 1, + 0, + 0, + 0, + 0, + 171, + 1, + 0, + 0, + 0, + 0, + 173, + 1, + 0, + 0, + 0, + 0, + 175, + 1, + 0, + 0, + 0, + 0, + 177, + 1, + 0, + 0, + 0, + 0, + 179, + 1, + 0, + 0, + 0, + 0, + 181, + 1, + 0, + 0, + 0, + 0, + 183, + 1, + 0, + 0, + 0, + 0, + 185, + 1, + 0, + 0, + 0, + 0, + 187, + 1, + 0, + 0, + 0, + 0, + 189, + 1, + 0, + 0, + 0, + 0, + 191, + 1, + 0, + 0, + 0, + 0, + 193, + 1, + 0, + 0, + 0, + 0, + 195, + 1, + 0, + 0, + 0, + 0, + 197, + 1, + 0, + 0, + 0, + 0, + 199, + 1, + 0, + 0, + 0, + 0, + 201, + 1, + 0, + 0, + 0, + 0, + 203, + 1, + 0, + 0, + 0, + 0, + 205, + 1, + 0, + 0, + 0, + 0, + 207, + 1, + 0, + 0, + 0, + 0, + 209, + 1, + 0, + 0, + 0, + 0, + 211, + 1, + 0, + 0, + 0, + 0, + 213, + 1, + 0, + 0, + 0, + 0, + 215, + 1, + 0, + 0, + 0, + 0, + 217, + 1, + 0, + 0, + 0, + 0, + 219, + 1, + 0, + 0, + 0, + 0, + 221, + 1, + 0, + 0, + 0, + 0, + 223, + 1, + 0, + 0, + 0, + 0, + 225, + 1, + 0, + 0, + 0, + 0, + 227, + 1, + 0, + 0, + 0, + 0, + 229, + 1, + 0, + 0, + 0, + 0, + 231, + 1, + 0, + 0, + 0, + 0, + 233, + 1, + 0, + 0, + 0, + 0, + 235, + 1, + 0, + 0, + 0, + 0, + 237, + 1, + 0, + 0, + 0, + 0, + 239, + 1, + 0, + 0, + 0, + 0, + 241, + 1, + 0, + 0, + 0, + 0, + 243, + 1, + 0, + 0, + 0, + 0, + 245, + 1, + 0, + 0, + 0, + 0, + 247, + 1, + 0, + 0, + 0, + 0, + 249, + 1, + 0, + 0, + 0, + 0, + 251, + 1, + 0, + 0, + 0, + 0, + 253, + 1, + 0, + 0, + 0, + 0, + 255, + 1, + 0, + 0, + 0, + 0, + 257, + 1, + 0, + 0, + 0, + 0, + 259, + 1, + 0, + 0, + 0, + 0, + 261, + 1, + 0, + 0, + 0, + 0, + 263, + 1, + 0, + 0, + 0, + 0, + 265, + 1, + 0, + 0, + 0, + 0, + 267, + 1, + 0, + 0, + 0, + 0, + 269, + 1, + 0, + 0, + 0, + 0, + 271, + 1, + 0, + 0, + 0, + 0, + 273, + 1, + 0, + 0, + 0, + 0, + 275, + 1, + 0, + 0, + 0, + 0, + 277, + 1, + 0, + 0, + 0, + 0, + 279, + 1, + 0, + 0, + 0, + 0, + 281, + 1, + 0, + 0, + 0, + 0, + 283, + 1, + 0, + 0, + 0, + 0, + 285, + 1, + 0, + 0, + 0, + 0, + 287, + 1, + 0, + 0, + 0, + 0, + 289, + 1, + 0, + 0, + 0, + 0, + 291, + 1, + 0, + 0, + 0, + 0, + 293, + 1, + 0, + 0, + 0, + 0, + 295, + 1, + 0, + 0, + 0, + 0, + 297, + 1, + 0, + 0, + 0, + 0, + 299, + 1, + 0, + 0, + 0, + 0, + 301, + 1, + 0, + 0, + 0, + 0, + 303, + 1, + 0, + 0, + 0, + 0, + 305, + 1, + 0, + 0, + 0, + 0, + 307, + 1, + 0, + 0, + 0, + 0, + 309, + 1, + 0, + 0, + 0, + 0, + 311, + 1, + 0, + 0, + 0, + 0, + 313, + 1, + 0, + 0, + 0, + 0, + 315, + 1, + 0, + 0, + 0, + 0, + 317, + 1, + 0, + 0, + 0, + 0, + 319, + 1, + 0, + 0, + 0, + 0, + 321, + 1, + 0, + 0, + 0, + 0, + 323, + 1, + 0, + 0, + 0, + 0, + 325, + 1, + 0, + 0, + 0, + 0, + 327, + 1, + 0, + 0, + 0, + 0, + 329, + 1, + 0, + 0, + 0, + 0, + 331, + 1, + 0, + 0, + 0, + 0, + 333, + 1, + 0, + 0, + 0, + 0, + 335, + 1, + 0, + 0, + 0, + 0, + 337, + 1, + 0, + 0, + 0, + 0, + 339, + 1, + 0, + 0, + 0, + 0, + 341, + 1, + 0, + 0, + 0, + 0, + 343, + 1, + 0, + 0, + 0, + 0, + 345, + 1, + 0, + 0, + 0, + 0, + 347, + 1, + 0, + 0, + 0, + 0, + 349, + 1, + 0, + 0, + 0, + 0, + 351, + 1, + 0, + 0, + 0, + 0, + 353, + 1, + 0, + 0, + 0, + 0, + 355, + 1, + 0, + 0, + 0, + 0, + 357, + 1, + 0, + 0, + 0, + 0, + 359, + 1, + 0, + 0, + 0, + 0, + 361, + 1, + 0, + 0, + 0, + 0, + 363, + 1, + 0, + 0, + 0, + 0, + 365, + 1, + 0, + 0, + 0, + 0, + 367, + 1, + 0, + 0, + 0, + 0, + 369, + 1, + 0, + 0, + 0, + 0, + 371, + 1, + 0, + 0, + 0, + 0, + 373, + 1, + 0, + 0, + 0, + 0, + 375, + 1, + 0, + 0, + 0, + 0, + 377, + 1, + 0, + 0, + 0, + 0, + 379, + 1, + 0, + 0, + 0, + 0, + 381, + 1, + 0, + 0, + 0, + 0, + 383, + 1, + 0, + 0, + 0, + 0, + 385, + 1, + 0, + 0, + 0, + 0, + 387, + 1, + 0, + 0, + 0, + 0, + 389, + 1, + 0, + 0, + 0, + 0, + 391, + 1, + 0, + 0, + 0, + 0, + 393, + 1, + 0, + 0, + 0, + 0, + 395, + 1, + 0, + 0, + 0, + 0, + 397, + 1, + 0, + 0, + 0, + 0, + 399, + 1, + 0, + 0, + 0, + 0, + 401, + 1, + 0, + 0, + 0, + 0, + 403, + 1, + 0, + 0, + 0, + 0, + 405, + 1, + 0, + 0, + 0, + 0, + 407, + 1, + 0, + 0, + 0, + 0, + 409, + 1, + 0, + 0, + 0, + 0, + 411, + 1, + 0, + 0, + 0, + 0, + 413, + 1, + 0, + 0, + 0, + 0, + 415, + 1, + 0, + 0, + 0, + 0, + 417, + 1, + 0, + 0, + 0, + 0, + 419, + 1, + 0, + 0, + 0, + 0, + 421, + 1, + 0, + 0, + 0, + 0, + 423, + 1, + 0, + 0, + 0, + 0, + 425, + 1, + 0, + 0, + 0, + 0, + 427, + 1, + 0, + 0, + 0, + 0, + 429, + 1, + 0, + 0, + 0, + 0, + 431, + 1, + 0, + 0, + 0, + 0, + 433, + 1, + 0, + 0, + 0, + 0, + 435, + 1, + 0, + 0, + 0, + 0, + 437, + 1, + 0, + 0, + 0, + 0, + 439, + 1, + 0, + 0, + 0, + 0, + 441, + 1, + 0, + 0, + 0, + 0, + 443, + 1, + 0, + 0, + 0, + 0, + 445, + 1, + 0, + 0, + 0, + 0, + 447, + 1, + 0, + 0, + 0, + 0, + 449, + 1, + 0, + 0, + 0, + 0, + 451, + 1, + 0, + 0, + 0, + 0, + 453, + 1, + 0, + 0, + 0, + 0, + 455, + 1, + 0, + 0, + 0, + 0, + 457, + 1, + 0, + 0, + 0, + 0, + 459, + 1, + 0, + 0, + 0, + 0, + 461, + 1, + 0, + 0, + 0, + 0, + 463, + 1, + 0, + 0, + 0, + 0, + 465, + 1, + 0, + 0, + 0, + 0, + 467, + 1, + 0, + 0, + 0, + 0, + 469, + 1, + 0, + 0, + 0, + 0, + 471, + 1, + 0, + 0, + 0, + 0, + 473, + 1, + 0, + 0, + 0, + 0, + 475, + 1, + 0, + 0, + 0, + 0, + 477, + 1, + 0, + 0, + 0, + 0, + 479, + 1, + 0, + 0, + 0, + 0, + 481, + 1, + 0, + 0, + 0, + 0, + 483, + 1, + 0, + 0, + 0, + 0, + 485, + 1, + 0, + 0, + 0, + 0, + 487, + 1, + 0, + 0, + 0, + 0, + 489, + 1, + 0, + 0, + 0, + 0, + 491, + 1, + 0, + 0, + 0, + 0, + 493, + 1, + 0, + 0, + 0, + 0, + 495, + 1, + 0, + 0, + 0, + 0, + 497, + 1, + 0, + 0, + 0, + 0, + 499, + 1, + 0, + 0, + 0, + 0, + 501, + 1, + 0, + 0, + 0, + 0, + 545, + 1, + 0, + 0, + 0, + 0, + 559, + 1, + 0, + 0, + 0, + 0, + 561, + 1, + 0, + 0, + 0, + 0, + 563, + 1, + 0, + 0, + 0, + 0, + 583, + 1, + 0, + 0, + 0, + 0, + 585, + 1, + 0, + 0, + 0, + 0, + 587, + 1, + 0, + 0, + 0, + 0, + 589, + 1, + 0, + 0, + 0, + 0, + 591, + 1, + 0, + 0, + 0, + 0, + 593, + 1, + 0, + 0, + 0, + 0, + 595, + 1, + 0, + 0, + 0, + 0, + 597, + 1, + 0, + 0, + 0, + 0, + 599, + 1, + 0, + 0, + 0, + 0, + 601, + 1, + 0, + 0, + 0, + 0, + 603, + 1, + 0, + 0, + 0, + 0, + 605, + 1, + 0, + 0, + 0, + 0, + 607, + 1, + 0, + 0, + 0, + 0, + 609, + 1, + 0, + 0, + 0, + 0, + 611, + 1, + 0, + 0, + 0, + 1, + 617, + 1, + 0, + 0, + 0, + 3, + 625, + 1, + 0, + 0, + 0, + 5, + 632, + 1, + 0, + 0, + 0, + 7, + 637, + 1, + 0, + 0, + 0, + 9, + 642, + 1, + 0, + 0, + 0, + 11, + 652, + 1, + 0, + 0, + 0, + 13, + 656, + 1, + 0, + 0, + 0, + 15, + 660, + 1, + 0, + 0, + 0, + 17, + 664, + 1, + 0, + 0, + 0, + 19, + 667, + 1, + 0, + 0, + 0, + 21, + 671, + 1, + 0, + 0, + 0, + 23, + 678, + 1, + 0, + 0, + 0, + 25, + 687, + 1, + 0, + 0, + 0, + 27, + 694, + 1, + 0, + 0, + 0, + 29, + 702, + 1, + 0, + 0, + 0, + 31, + 710, + 1, + 0, + 0, + 0, + 33, + 716, + 1, + 0, + 0, + 0, + 35, + 724, + 1, + 0, + 0, + 0, + 37, + 729, + 1, + 0, + 0, + 0, + 39, + 734, + 1, + 0, + 0, + 0, + 41, + 740, + 1, + 0, + 0, + 0, + 43, + 746, + 1, + 0, + 0, + 0, + 45, + 753, + 1, + 0, + 0, + 0, + 47, + 756, + 1, + 0, + 0, + 0, + 49, + 761, + 1, + 0, + 0, + 0, + 51, + 765, + 1, + 0, + 0, + 0, + 53, + 777, + 1, + 0, + 0, + 0, + 55, + 784, + 1, + 0, + 0, + 0, + 57, + 793, + 1, + 0, + 0, + 0, + 59, + 798, + 1, + 0, + 0, + 0, + 61, + 805, + 1, + 0, + 0, + 0, + 63, + 813, + 1, + 0, + 0, + 0, + 65, + 820, + 1, + 0, + 0, + 0, + 67, + 830, + 1, + 0, + 0, + 0, + 69, + 837, + 1, + 0, + 0, + 0, + 71, + 845, + 1, + 0, + 0, + 0, + 73, + 864, + 1, + 0, + 0, + 0, + 75, + 883, + 1, + 0, + 0, + 0, + 77, + 892, + 1, + 0, + 0, + 0, + 79, + 903, + 1, + 0, + 0, + 0, + 81, + 909, + 1, + 0, + 0, + 0, + 83, + 920, + 1, + 0, + 0, + 0, + 85, + 924, + 1, + 0, + 0, + 0, + 87, + 932, + 1, + 0, + 0, + 0, + 89, + 941, + 1, + 0, + 0, + 0, + 91, + 950, + 1, + 0, + 0, + 0, + 93, + 959, + 1, + 0, + 0, + 0, + 95, + 964, + 1, + 0, + 0, + 0, + 97, + 970, + 1, + 0, + 0, + 0, + 99, + 975, + 1, + 0, + 0, + 0, + 101, + 986, + 1, + 0, + 0, + 0, + 103, + 996, + 1, + 0, + 0, + 0, + 105, + 1005, + 1, + 0, + 0, + 0, + 107, + 1014, + 1, + 0, + 0, + 0, + 109, + 1018, + 1, + 0, + 0, + 0, + 111, + 1023, + 1, + 0, + 0, + 0, + 113, + 1026, + 1, + 0, + 0, + 0, + 115, + 1028, + 1, + 0, + 0, + 0, + 117, + 1034, + 1, + 0, + 0, + 0, + 119, + 1045, + 1, + 0, + 0, + 0, + 121, + 1053, + 1, + 0, + 0, + 0, + 123, + 1058, + 1, + 0, + 0, + 0, + 125, + 1069, + 1, + 0, + 0, + 0, + 127, + 1072, + 1, + 0, + 0, + 0, + 129, + 1080, + 1, + 0, + 0, + 0, + 131, + 1085, + 1, + 0, + 0, + 0, + 133, + 1091, + 1, + 0, + 0, + 0, + 135, + 1098, + 1, + 0, + 0, + 0, + 137, + 1104, + 1, + 0, + 0, + 0, + 139, + 1112, + 1, + 0, + 0, + 0, + 141, + 1117, + 1, + 0, + 0, + 0, + 143, + 1124, + 1, + 0, + 0, + 0, + 145, + 1129, + 1, + 0, + 0, + 0, + 147, + 1136, + 1, + 0, + 0, + 0, + 149, + 1139, + 1, + 0, + 0, + 0, + 151, + 1143, + 1, + 0, + 0, + 0, + 153, + 1151, + 1, + 0, + 0, + 0, + 155, + 1160, + 1, + 0, + 0, + 0, + 157, + 1171, + 1, + 0, + 0, + 0, + 159, + 1177, + 1, + 0, + 0, + 0, + 161, + 1182, + 1, + 0, + 0, + 0, + 163, + 1186, + 1, + 0, + 0, + 0, + 165, + 1192, + 1, + 0, + 0, + 0, + 167, + 1199, + 1, + 0, + 0, + 0, + 169, + 1208, + 1, + 0, + 0, + 0, + 171, + 1216, + 1, + 0, + 0, + 0, + 173, + 1223, + 1, + 0, + 0, + 0, + 175, + 1232, + 1, + 0, + 0, + 0, + 177, + 1237, + 1, + 0, + 0, + 0, + 179, + 1240, + 1, + 0, + 0, + 0, + 181, + 1249, + 1, + 0, + 0, + 0, + 183, + 1253, + 1, + 0, + 0, + 0, + 185, + 1256, + 1, + 0, + 0, + 0, + 187, + 1259, + 1, + 0, + 0, + 0, + 189, + 1263, + 1, + 0, + 0, + 0, + 191, + 1276, + 1, + 0, + 0, + 0, + 193, + 1281, + 1, + 0, + 0, + 0, + 195, + 1289, + 1, + 0, + 0, + 0, + 197, + 1295, + 1, + 0, + 0, + 0, + 199, + 1304, + 1, + 0, + 0, + 0, + 201, + 1311, + 1, + 0, + 0, + 0, + 203, + 1318, + 1, + 0, + 0, + 0, + 205, + 1328, + 1, + 0, + 0, + 0, + 207, + 1332, + 1, + 0, + 0, + 0, + 209, + 1335, + 1, + 0, + 0, + 0, + 211, + 1338, + 1, + 0, + 0, + 0, + 213, + 1341, + 1, + 0, + 0, + 0, + 215, + 1349, + 1, + 0, + 0, + 0, + 217, + 1353, + 1, + 0, + 0, + 0, + 219, + 1358, + 1, + 0, + 0, + 0, + 221, + 1365, + 1, + 0, + 0, + 0, + 223, + 1371, + 1, + 0, + 0, + 0, + 225, + 1376, + 1, + 0, + 0, + 0, + 227, + 1383, + 1, + 0, + 0, + 0, + 229, + 1389, + 1, + 0, + 0, + 0, + 231, + 1394, + 1, + 0, + 0, + 0, + 233, + 1400, + 1, + 0, + 0, + 0, + 235, + 1406, + 1, + 0, + 0, + 0, + 237, + 1409, + 1, + 0, + 0, + 0, + 239, + 1413, + 1, + 0, + 0, + 0, + 241, + 1419, + 1, + 0, + 0, + 0, + 243, + 1423, + 1, + 0, + 0, + 0, + 245, + 1429, + 1, + 0, + 0, + 0, + 247, + 1434, + 1, + 0, + 0, + 0, + 249, + 1438, + 1, + 0, + 0, + 0, + 251, + 1450, + 1, + 0, + 0, + 0, + 253, + 1455, + 1, + 0, + 0, + 0, + 255, + 1461, + 1, + 0, + 0, + 0, + 257, + 1467, + 1, + 0, + 0, + 0, + 259, + 1474, + 1, + 0, + 0, + 0, + 261, + 1481, + 1, + 0, + 0, + 0, + 263, + 1485, + 1, + 0, + 0, + 0, + 265, + 1492, + 1, + 0, + 0, + 0, + 267, + 1498, + 1, + 0, + 0, + 0, + 269, + 1504, + 1, + 0, + 0, + 0, + 271, + 1509, + 1, + 0, + 0, + 0, + 273, + 1513, + 1, + 0, + 0, + 0, + 275, + 1520, + 1, + 0, + 0, + 0, + 277, + 1525, + 1, + 0, + 0, + 0, + 279, + 1530, + 1, + 0, + 0, + 0, + 281, + 1539, + 1, + 0, + 0, + 0, + 283, + 1553, + 1, + 0, + 0, + 0, + 285, + 1567, + 1, + 0, + 0, + 0, + 287, + 1583, + 1, + 0, + 0, + 0, + 289, + 1587, + 1, + 0, + 0, + 0, + 291, + 1591, + 1, + 0, + 0, + 0, + 293, + 1595, + 1, + 0, + 0, + 0, + 295, + 1604, + 1, + 0, + 0, + 0, + 297, + 1609, + 1, + 0, + 0, + 0, + 299, + 1618, + 1, + 0, + 0, + 0, + 301, + 1626, + 1, + 0, + 0, + 0, + 303, + 1635, + 1, + 0, + 0, + 0, + 305, + 1642, + 1, + 0, + 0, + 0, + 307, + 1651, + 1, + 0, + 0, + 0, + 309, + 1657, + 1, + 0, + 0, + 0, + 311, + 1663, + 1, + 0, + 0, + 0, + 313, + 1666, + 1, + 0, + 0, + 0, + 315, + 1673, + 1, + 0, + 0, + 0, + 317, + 1677, + 1, + 0, + 0, + 0, + 319, + 1681, + 1, + 0, + 0, + 0, + 321, + 1686, + 1, + 0, + 0, + 0, + 323, + 1694, + 1, + 0, + 0, + 0, + 325, + 1699, + 1, + 0, + 0, + 0, + 327, + 1701, + 1, + 0, + 0, + 0, + 329, + 1710, + 1, + 0, + 0, + 0, + 331, + 1719, + 1, + 0, + 0, + 0, + 333, + 1724, + 1, + 0, + 0, + 0, + 335, + 1737, + 1, + 0, + 0, + 0, + 337, + 1750, + 1, + 0, + 0, + 0, + 339, + 1755, + 1, + 0, + 0, + 0, + 341, + 1759, + 1, + 0, + 0, + 0, + 343, + 1767, + 1, + 0, + 0, + 0, + 345, + 1775, + 1, + 0, + 0, + 0, + 347, + 1786, + 1, + 0, + 0, + 0, + 349, + 1798, + 1, + 0, + 0, + 0, + 351, + 1811, + 1, + 0, + 0, + 0, + 353, + 1820, + 1, + 0, + 0, + 0, + 355, + 1828, + 1, + 0, + 0, + 0, + 357, + 1834, + 1, + 0, + 0, + 0, + 359, + 1839, + 1, + 0, + 0, + 0, + 361, + 1846, + 1, + 0, + 0, + 0, + 363, + 1862, + 1, + 0, + 0, + 0, + 365, + 1868, + 1, + 0, + 0, + 0, + 367, + 1876, + 1, + 0, + 0, + 0, + 369, + 1883, + 1, + 0, + 0, + 0, + 371, + 1891, + 1, + 0, + 0, + 0, + 373, + 1900, + 1, + 0, + 0, + 0, + 375, + 1906, + 1, + 0, + 0, + 0, + 377, + 1911, + 1, + 0, + 0, + 0, + 379, + 1918, + 1, + 0, + 0, + 0, + 381, + 1924, + 1, + 0, + 0, + 0, + 383, + 1931, + 1, + 0, + 0, + 0, + 385, + 1938, + 1, + 0, + 0, + 0, + 387, + 1942, + 1, + 0, + 0, + 0, + 389, + 1955, + 1, + 0, + 0, + 0, + 391, + 1968, + 1, + 0, + 0, + 0, + 393, + 1976, + 1, + 0, + 0, + 0, + 395, + 1987, + 1, + 0, + 0, + 0, + 397, + 1998, + 1, + 0, + 0, + 0, + 399, + 2005, + 1, + 0, + 0, + 0, + 401, + 2010, + 1, + 0, + 0, + 0, + 403, + 2016, + 1, + 0, + 0, + 0, + 405, + 2029, + 1, + 0, + 0, + 0, + 407, + 2035, + 1, + 0, + 0, + 0, + 409, + 2044, + 1, + 0, + 0, + 0, + 411, + 2054, + 1, + 0, + 0, + 0, + 413, + 2058, + 1, + 0, + 0, + 0, + 415, + 2066, + 1, + 0, + 0, + 0, + 417, + 2068, + 1, + 0, + 0, + 0, + 419, + 2073, + 1, + 0, + 0, + 0, + 421, + 2080, + 1, + 0, + 0, + 0, + 423, + 2086, + 1, + 0, + 0, + 0, + 425, + 2096, + 1, + 0, + 0, + 0, + 427, + 2102, + 1, + 0, + 0, + 0, + 429, + 2105, + 1, + 0, + 0, + 0, + 431, + 2115, + 1, + 0, + 0, + 0, + 433, + 2122, + 1, + 0, + 0, + 0, + 435, + 2129, + 1, + 0, + 0, + 0, + 437, + 2137, + 1, + 0, + 0, + 0, + 439, + 2143, + 1, + 0, + 0, + 0, + 441, + 2152, + 1, + 0, + 0, + 0, + 443, + 2160, + 1, + 0, + 0, + 0, + 445, + 2164, + 1, + 0, + 0, + 0, + 447, + 2168, + 1, + 0, + 0, + 0, + 449, + 2173, + 1, + 0, + 0, + 0, + 451, + 2178, + 1, + 0, + 0, + 0, + 453, + 2183, + 1, + 0, + 0, + 0, + 455, + 2191, + 1, + 0, + 0, + 0, + 457, + 2194, + 1, + 0, + 0, + 0, + 459, + 2201, + 1, + 0, + 0, + 0, + 461, + 2207, + 1, + 0, + 0, + 0, + 463, + 2213, + 1, + 0, + 0, + 0, + 465, + 2218, + 1, + 0, + 0, + 0, + 467, + 2220, + 1, + 0, + 0, + 0, + 469, + 2229, + 1, + 0, + 0, + 0, + 471, + 2236, + 1, + 0, + 0, + 0, + 473, + 2242, + 1, + 0, + 0, + 0, + 475, + 2249, + 1, + 0, + 0, + 0, + 477, + 2255, + 1, + 0, + 0, + 0, + 479, + 2260, + 1, + 0, + 0, + 0, + 481, + 2269, + 1, + 0, + 0, + 0, + 483, + 2276, + 1, + 0, + 0, + 0, + 485, + 2288, + 1, + 0, + 0, + 0, + 487, + 2296, + 1, + 0, + 0, + 0, + 489, + 2314, + 1, + 0, + 0, + 0, + 491, + 2323, + 1, + 0, + 0, + 0, + 493, + 2332, + 1, + 0, + 0, + 0, + 495, + 2347, + 1, + 0, + 0, + 0, + 497, + 2362, + 1, + 0, + 0, + 0, + 499, + 2368, + 1, + 0, + 0, + 0, + 501, + 2387, + 1, + 0, + 0, + 0, + 503, + 2389, + 1, + 0, + 0, + 0, + 505, + 2393, + 1, + 0, + 0, + 0, + 507, + 2397, + 1, + 0, + 0, + 0, + 509, + 2401, + 1, + 0, + 0, + 0, + 511, + 2413, + 1, + 0, + 0, + 0, + 513, + 2415, + 1, + 0, + 0, + 0, + 515, + 2424, + 1, + 0, + 0, + 0, + 517, + 2426, + 1, + 0, + 0, + 0, + 519, + 2429, + 1, + 0, + 0, + 0, + 521, + 2435, + 1, + 0, + 0, + 0, + 523, + 2438, + 1, + 0, + 0, + 0, + 525, + 2442, + 1, + 0, + 0, + 0, + 527, + 2446, + 1, + 0, + 0, + 0, + 529, + 2453, + 1, + 0, + 0, + 0, + 531, + 2456, + 1, + 0, + 0, + 0, + 533, + 2462, + 1, + 0, + 0, + 0, + 535, + 2464, + 1, + 0, + 0, + 0, + 537, + 2470, + 1, + 0, + 0, + 0, + 539, + 2477, + 1, + 0, + 0, + 0, + 541, + 2480, + 1, + 0, + 0, + 0, + 543, + 2486, + 1, + 0, + 0, + 0, + 545, + 2489, + 1, + 0, + 0, + 0, + 547, + 2508, + 1, + 0, + 0, + 0, + 549, + 2510, + 1, + 0, + 0, + 0, + 551, + 2513, + 1, + 0, + 0, + 0, + 553, + 2516, + 1, + 0, + 0, + 0, + 555, + 2520, + 1, + 0, + 0, + 0, + 557, + 2522, + 1, + 0, + 0, + 0, + 559, + 2525, + 1, + 0, + 0, + 0, + 561, + 2537, + 1, + 0, + 0, + 0, + 563, + 2543, + 1, + 0, + 0, + 0, + 565, + 2546, + 1, + 0, + 0, + 0, + 567, + 2553, + 1, + 0, + 0, + 0, + 569, + 2556, + 1, + 0, + 0, + 0, + 571, + 2563, + 1, + 0, + 0, + 0, + 573, + 2565, + 1, + 0, + 0, + 0, + 575, + 2575, + 1, + 0, + 0, + 0, + 577, + 2588, + 1, + 0, + 0, + 0, + 579, + 2590, + 1, + 0, + 0, + 0, + 581, + 2592, + 1, + 0, + 0, + 0, + 583, + 2603, + 1, + 0, + 0, + 0, + 585, + 2605, + 1, + 0, + 0, + 0, + 587, + 2607, + 1, + 0, + 0, + 0, + 589, + 2609, + 1, + 0, + 0, + 0, + 591, + 2611, + 1, + 0, + 0, + 0, + 593, + 2613, + 1, + 0, + 0, + 0, + 595, + 2615, + 1, + 0, + 0, + 0, + 597, + 2617, + 1, + 0, + 0, + 0, + 599, + 2619, + 1, + 0, + 0, + 0, + 601, + 2621, + 1, + 0, + 0, + 0, + 603, + 2623, + 1, + 0, + 0, + 0, + 605, + 2625, + 1, + 0, + 0, + 0, + 607, + 2629, + 1, + 0, + 0, + 0, + 609, + 2635, + 1, + 0, + 0, + 0, + 611, + 2646, + 1, + 0, + 0, + 0, + 613, + 2654, + 1, + 0, + 0, + 0, + 615, + 2658, + 1, + 0, + 0, + 0, + 617, + 618, + 5, + 100, + 0, + 0, + 618, + 619, + 5, + 105, + 0, + 0, + 619, + 620, + 5, + 115, + 0, + 0, + 620, + 621, + 5, + 99, + 0, + 0, + 621, + 622, + 5, + 97, + 0, + 0, + 622, + 623, + 5, + 114, + 0, + 0, + 623, + 624, + 5, + 100, + 0, + 0, + 624, + 2, + 1, + 0, + 0, + 0, + 625, + 626, + 5, + 97, + 0, + 0, + 626, + 627, + 5, + 100, + 0, + 0, + 627, + 628, + 5, + 100, + 0, + 0, + 628, + 629, + 5, + 65, + 0, + 0, + 629, + 630, + 5, + 108, + 0, + 0, + 630, + 631, + 5, + 108, + 0, + 0, + 631, + 4, + 1, + 0, + 0, + 0, + 632, + 633, + 5, + 97, + 0, + 0, + 633, + 634, + 5, + 100, + 0, + 0, + 634, + 635, + 5, + 100, + 0, + 0, + 635, + 636, + 5, + 69, + 0, + 0, + 636, + 6, + 1, + 0, + 0, + 0, + 637, + 638, + 5, + 97, + 0, + 0, + 638, + 639, + 5, + 100, + 0, + 0, + 639, + 640, + 5, + 100, + 0, + 0, + 640, + 641, + 5, + 86, + 0, + 0, + 641, + 8, + 1, + 0, + 0, + 0, + 642, + 643, + 5, + 97, + 0, + 0, + 643, + 644, + 5, + 103, + 0, + 0, + 644, + 645, + 5, + 103, + 0, + 0, + 645, + 646, + 5, + 114, + 0, + 0, + 646, + 647, + 5, + 101, + 0, + 0, + 647, + 648, + 5, + 103, + 0, + 0, + 648, + 649, + 5, + 97, + 0, + 0, + 649, + 650, + 5, + 116, + 0, + 0, + 650, + 651, + 5, + 101, + 0, + 0, + 651, + 10, + 1, + 0, + 0, + 0, + 652, + 653, + 5, + 97, + 0, + 0, + 653, + 654, + 5, + 108, + 0, + 0, + 654, + 655, + 5, + 108, + 0, + 0, + 655, + 12, + 1, + 0, + 0, + 0, + 656, + 657, + 5, + 97, + 0, + 0, + 657, + 658, + 5, + 110, + 0, + 0, + 658, + 659, + 5, + 100, + 0, + 0, + 659, + 14, + 1, + 0, + 0, + 0, + 660, + 661, + 5, + 97, + 0, + 0, + 661, + 662, + 5, + 110, + 0, + 0, + 662, + 663, + 5, + 121, + 0, + 0, + 663, + 16, + 1, + 0, + 0, + 0, + 664, + 665, + 5, + 97, + 0, + 0, + 665, + 666, + 5, + 115, + 0, + 0, + 666, + 18, + 1, + 0, + 0, + 0, + 667, + 668, + 5, + 97, + 0, + 0, + 668, + 669, + 5, + 115, + 0, + 0, + 669, + 670, + 5, + 99, + 0, + 0, + 670, + 20, + 1, + 0, + 0, + 0, + 671, + 672, + 5, + 97, + 0, + 0, + 672, + 673, + 5, + 115, + 0, + 0, + 673, + 674, + 5, + 68, + 0, + 0, + 674, + 675, + 5, + 97, + 0, + 0, + 675, + 676, + 5, + 116, + 0, + 0, + 676, + 677, + 5, + 101, + 0, + 0, + 677, + 22, + 1, + 0, + 0, + 0, + 678, + 679, + 5, + 97, + 0, + 0, + 679, + 680, + 5, + 115, + 0, + 0, + 680, + 681, + 5, + 83, + 0, + 0, + 681, + 682, + 5, + 116, + 0, + 0, + 682, + 683, + 5, + 114, + 0, + 0, + 683, + 684, + 5, + 105, + 0, + 0, + 684, + 685, + 5, + 110, + 0, + 0, + 685, + 686, + 5, + 103, + 0, + 0, + 686, + 24, + 1, + 0, + 0, + 0, + 687, + 688, + 5, + 97, + 0, + 0, + 688, + 689, + 5, + 115, + 0, + 0, + 689, + 690, + 5, + 115, + 0, + 0, + 690, + 691, + 5, + 105, + 0, + 0, + 691, + 692, + 5, + 103, + 0, + 0, + 692, + 693, + 5, + 110, + 0, + 0, + 693, + 26, + 1, + 0, + 0, + 0, + 694, + 695, + 5, + 98, + 0, + 0, + 695, + 696, + 5, + 97, + 0, + 0, + 696, + 697, + 5, + 114, + 0, + 0, + 697, + 698, + 5, + 114, + 0, + 0, + 698, + 699, + 5, + 105, + 0, + 0, + 699, + 700, + 5, + 101, + 0, + 0, + 700, + 701, + 5, + 114, + 0, + 0, + 701, + 28, + 1, + 0, + 0, + 0, + 702, + 703, + 5, + 66, + 0, + 0, + 703, + 704, + 5, + 97, + 0, + 0, + 704, + 705, + 5, + 114, + 0, + 0, + 705, + 706, + 5, + 114, + 0, + 0, + 706, + 707, + 5, + 105, + 0, + 0, + 707, + 708, + 5, + 101, + 0, + 0, + 708, + 709, + 5, + 114, + 0, + 0, + 709, + 30, + 1, + 0, + 0, + 0, + 710, + 711, + 5, + 98, + 0, + 0, + 711, + 712, + 5, + 101, + 0, + 0, + 712, + 713, + 5, + 103, + 0, + 0, + 713, + 714, + 5, + 105, + 0, + 0, + 714, + 715, + 5, + 110, + 0, + 0, + 715, + 32, + 1, + 0, + 0, + 0, + 716, + 717, + 5, + 98, + 0, + 0, + 717, + 718, + 5, + 101, + 0, + 0, + 718, + 719, + 5, + 116, + 0, + 0, + 719, + 720, + 5, + 119, + 0, + 0, + 720, + 721, + 5, + 101, + 0, + 0, + 721, + 722, + 5, + 101, + 0, + 0, + 722, + 723, + 5, + 110, + 0, + 0, + 723, + 34, + 1, + 0, + 0, + 0, + 724, + 725, + 5, + 98, + 0, + 0, + 725, + 726, + 5, + 111, + 0, + 0, + 726, + 727, + 5, + 116, + 0, + 0, + 727, + 728, + 5, + 104, + 0, + 0, + 728, + 36, + 1, + 0, + 0, + 0, + 729, + 730, + 5, + 66, + 0, + 0, + 730, + 731, + 5, + 79, + 0, + 0, + 731, + 732, + 5, + 84, + 0, + 0, + 732, + 733, + 5, + 72, + 0, + 0, + 733, + 38, + 1, + 0, + 0, + 0, + 734, + 735, + 5, + 98, + 0, + 0, + 735, + 736, + 5, + 111, + 0, + 0, + 736, + 737, + 5, + 116, + 0, + 0, + 737, + 738, + 5, + 104, + 0, + 0, + 738, + 739, + 5, + 69, + 0, + 0, + 739, + 40, + 1, + 0, + 0, + 0, + 740, + 741, + 5, + 98, + 0, + 0, + 741, + 742, + 5, + 111, + 0, + 0, + 742, + 743, + 5, + 116, + 0, + 0, + 743, + 744, + 5, + 104, + 0, + 0, + 744, + 745, + 5, + 86, + 0, + 0, + 745, + 42, + 1, + 0, + 0, + 0, + 746, + 747, + 5, + 98, + 0, + 0, + 747, + 748, + 5, + 114, + 0, + 0, + 748, + 749, + 5, + 97, + 0, + 0, + 749, + 750, + 5, + 110, + 0, + 0, + 750, + 751, + 5, + 99, + 0, + 0, + 751, + 752, + 5, + 104, + 0, + 0, + 752, + 44, + 1, + 0, + 0, + 0, + 753, + 754, + 5, + 98, + 0, + 0, + 754, + 755, + 5, + 121, + 0, + 0, + 755, + 46, + 1, + 0, + 0, + 0, + 756, + 757, + 5, + 99, + 0, + 0, + 757, + 758, + 5, + 97, + 0, + 0, + 758, + 759, + 5, + 108, + 0, + 0, + 759, + 760, + 5, + 108, + 0, + 0, + 760, + 48, + 1, + 0, + 0, + 0, + 761, + 762, + 5, + 99, + 0, + 0, + 762, + 763, + 5, + 97, + 0, + 0, + 763, + 764, + 5, + 112, + 0, + 0, + 764, + 50, + 1, + 0, + 0, + 0, + 765, + 766, + 5, + 67, + 0, + 0, + 766, + 767, + 5, + 97, + 0, + 0, + 767, + 768, + 5, + 114, + 0, + 0, + 768, + 769, + 5, + 100, + 0, + 0, + 769, + 770, + 5, + 105, + 0, + 0, + 770, + 771, + 5, + 110, + 0, + 0, + 771, + 772, + 5, + 97, + 0, + 0, + 772, + 773, + 5, + 108, + 0, + 0, + 773, + 774, + 5, + 105, + 0, + 0, + 774, + 775, + 5, + 116, + 0, + 0, + 775, + 776, + 5, + 121, + 0, + 0, + 776, + 52, + 1, + 0, + 0, + 0, + 777, + 778, + 5, + 99, + 0, + 0, + 778, + 779, + 5, + 104, + 0, + 0, + 779, + 780, + 5, + 111, + 0, + 0, + 780, + 781, + 5, + 111, + 0, + 0, + 781, + 782, + 5, + 115, + 0, + 0, + 782, + 783, + 5, + 101, + 0, + 0, + 783, + 54, + 1, + 0, + 0, + 0, + 784, + 785, + 5, + 99, + 0, + 0, + 785, + 786, + 5, + 111, + 0, + 0, + 786, + 787, + 5, + 97, + 0, + 0, + 787, + 788, + 5, + 108, + 0, + 0, + 788, + 789, + 5, + 101, + 0, + 0, + 789, + 790, + 5, + 115, + 0, + 0, + 790, + 791, + 5, + 99, + 0, + 0, + 791, + 792, + 5, + 101, + 0, + 0, + 792, + 56, + 1, + 0, + 0, + 0, + 793, + 794, + 5, + 99, + 0, + 0, + 794, + 795, + 5, + 111, + 0, + 0, + 795, + 796, + 5, + 105, + 0, + 0, + 796, + 797, + 5, + 110, + 0, + 0, + 797, + 58, + 1, + 0, + 0, + 0, + 798, + 799, + 5, + 67, + 0, + 0, + 799, + 800, + 5, + 111, + 0, + 0, + 800, + 801, + 5, + 108, + 0, + 0, + 801, + 802, + 5, + 117, + 0, + 0, + 802, + 803, + 5, + 109, + 0, + 0, + 803, + 804, + 5, + 110, + 0, + 0, + 804, + 60, + 1, + 0, + 0, + 0, + 805, + 806, + 5, + 99, + 0, + 0, + 806, + 807, + 5, + 111, + 0, + 0, + 807, + 808, + 5, + 109, + 0, + 0, + 808, + 809, + 5, + 98, + 0, + 0, + 809, + 810, + 5, + 105, + 0, + 0, + 810, + 811, + 5, + 110, + 0, + 0, + 811, + 812, + 5, + 101, + 0, + 0, + 812, + 62, + 1, + 0, + 0, + 0, + 813, + 814, + 5, + 99, + 0, + 0, + 814, + 815, + 5, + 111, + 0, + 0, + 815, + 816, + 5, + 109, + 0, + 0, + 816, + 817, + 5, + 109, + 0, + 0, + 817, + 818, + 5, + 105, + 0, + 0, + 818, + 819, + 5, + 116, + 0, + 0, + 819, + 64, + 1, + 0, + 0, + 0, + 820, + 821, + 5, + 99, + 0, + 0, + 821, + 822, + 5, + 111, + 0, + 0, + 822, + 823, + 5, + 109, + 0, + 0, + 823, + 824, + 5, + 112, + 0, + 0, + 824, + 825, + 5, + 111, + 0, + 0, + 825, + 826, + 5, + 110, + 0, + 0, + 826, + 827, + 5, + 101, + 0, + 0, + 827, + 828, + 5, + 110, + 0, + 0, + 828, + 829, + 5, + 116, + 0, + 0, + 829, + 66, + 1, + 0, + 0, + 0, + 830, + 831, + 5, + 99, + 0, + 0, + 831, + 832, + 5, + 111, + 0, + 0, + 832, + 833, + 5, + 110, + 0, + 0, + 833, + 834, + 5, + 99, + 0, + 0, + 834, + 835, + 5, + 97, + 0, + 0, + 835, + 836, + 5, + 116, + 0, + 0, + 836, + 68, + 1, + 0, + 0, + 0, + 837, + 838, + 5, + 99, + 0, + 0, + 838, + 839, + 5, + 111, + 0, + 0, + 839, + 840, + 5, + 110, + 0, + 0, + 840, + 841, + 5, + 106, + 0, + 0, + 841, + 842, + 5, + 111, + 0, + 0, + 842, + 843, + 5, + 105, + 0, + 0, + 843, + 844, + 5, + 110, + 0, + 0, + 844, + 70, + 1, + 0, + 0, + 0, + 845, + 846, + 5, + 99, + 0, + 0, + 846, + 847, + 5, + 111, + 0, + 0, + 847, + 848, + 5, + 110, + 0, + 0, + 848, + 849, + 5, + 110, + 0, + 0, + 849, + 850, + 5, + 101, + 0, + 0, + 850, + 851, + 5, + 99, + 0, + 0, + 851, + 852, + 5, + 116, + 0, + 0, + 852, + 853, + 5, + 101, + 0, + 0, + 853, + 854, + 5, + 100, + 0, + 0, + 854, + 855, + 5, + 67, + 0, + 0, + 855, + 856, + 5, + 111, + 0, + 0, + 856, + 857, + 5, + 109, + 0, + 0, + 857, + 858, + 5, + 112, + 0, + 0, + 858, + 859, + 5, + 111, + 0, + 0, + 859, + 860, + 5, + 110, + 0, + 0, + 860, + 861, + 5, + 101, + 0, + 0, + 861, + 862, + 5, + 110, + 0, + 0, + 862, + 863, + 5, + 116, + 0, + 0, + 863, + 72, + 1, + 0, + 0, + 0, + 864, + 865, + 5, + 67, + 0, + 0, + 865, + 866, + 5, + 111, + 0, + 0, + 866, + 867, + 5, + 110, + 0, + 0, + 867, + 868, + 5, + 110, + 0, + 0, + 868, + 869, + 5, + 101, + 0, + 0, + 869, + 870, + 5, + 99, + 0, + 0, + 870, + 871, + 5, + 116, + 0, + 0, + 871, + 872, + 5, + 101, + 0, + 0, + 872, + 873, + 5, + 100, + 0, + 0, + 873, + 874, + 5, + 67, + 0, + 0, + 874, + 875, + 5, + 111, + 0, + 0, + 875, + 876, + 5, + 109, + 0, + 0, + 876, + 877, + 5, + 112, + 0, + 0, + 877, + 878, + 5, + 111, + 0, + 0, + 878, + 879, + 5, + 110, + 0, + 0, + 879, + 880, + 5, + 101, + 0, + 0, + 880, + 881, + 5, + 110, + 0, + 0, + 881, + 882, + 5, + 116, + 0, + 0, + 882, + 74, + 1, + 0, + 0, + 0, + 883, + 884, + 5, + 99, + 0, + 0, + 884, + 885, + 5, + 111, + 0, + 0, + 885, + 886, + 5, + 110, + 0, + 0, + 886, + 887, + 5, + 115, + 0, + 0, + 887, + 888, + 5, + 116, + 0, + 0, + 888, + 889, + 5, + 97, + 0, + 0, + 889, + 890, + 5, + 110, + 0, + 0, + 890, + 891, + 5, + 116, + 0, + 0, + 891, + 76, + 1, + 0, + 0, + 0, + 892, + 893, + 5, + 99, + 0, + 0, + 893, + 894, + 5, + 111, + 0, + 0, + 894, + 895, + 5, + 110, + 0, + 0, + 895, + 896, + 5, + 116, + 0, + 0, + 896, + 897, + 5, + 97, + 0, + 0, + 897, + 898, + 5, + 105, + 0, + 0, + 898, + 899, + 5, + 110, + 0, + 0, + 899, + 900, + 5, + 105, + 0, + 0, + 900, + 901, + 5, + 110, + 0, + 0, + 901, + 902, + 5, + 103, + 0, + 0, + 902, + 78, + 1, + 0, + 0, + 0, + 903, + 904, + 5, + 99, + 0, + 0, + 904, + 905, + 5, + 111, + 0, + 0, + 905, + 906, + 5, + 117, + 0, + 0, + 906, + 907, + 5, + 110, + 0, + 0, + 907, + 908, + 5, + 116, + 0, + 0, + 908, + 80, + 1, + 0, + 0, + 0, + 909, + 910, + 5, + 99, + 0, + 0, + 910, + 911, + 5, + 121, + 0, + 0, + 911, + 912, + 5, + 99, + 0, + 0, + 912, + 913, + 5, + 108, + 0, + 0, + 913, + 914, + 5, + 105, + 0, + 0, + 914, + 915, + 5, + 99, + 0, + 0, + 915, + 916, + 5, + 80, + 0, + 0, + 916, + 917, + 5, + 97, + 0, + 0, + 917, + 918, + 5, + 116, + 0, + 0, + 918, + 919, + 5, + 104, + 0, + 0, + 919, + 82, + 1, + 0, + 0, + 0, + 920, + 921, + 5, + 100, + 0, + 0, + 921, + 922, + 5, + 97, + 0, + 0, + 922, + 923, + 5, + 121, + 0, + 0, + 923, + 84, + 1, + 0, + 0, + 0, + 924, + 925, + 5, + 100, + 0, + 0, + 925, + 926, + 5, + 97, + 0, + 0, + 926, + 927, + 5, + 116, + 0, + 0, + 927, + 928, + 5, + 101, + 0, + 0, + 928, + 929, + 5, + 65, + 0, + 0, + 929, + 930, + 5, + 100, + 0, + 0, + 930, + 931, + 5, + 100, + 0, + 0, + 931, + 86, + 1, + 0, + 0, + 0, + 932, + 933, + 5, + 100, + 0, + 0, + 933, + 934, + 5, + 97, + 0, + 0, + 934, + 935, + 5, + 116, + 0, + 0, + 935, + 936, + 5, + 101, + 0, + 0, + 936, + 937, + 5, + 68, + 0, + 0, + 937, + 938, + 5, + 105, + 0, + 0, + 938, + 939, + 5, + 102, + 0, + 0, + 939, + 940, + 5, + 102, + 0, + 0, + 940, + 88, + 1, + 0, + 0, + 0, + 941, + 942, + 5, + 100, + 0, + 0, + 942, + 943, + 5, + 97, + 0, + 0, + 943, + 944, + 5, + 116, + 0, + 0, + 944, + 945, + 5, + 101, + 0, + 0, + 945, + 946, + 5, + 116, + 0, + 0, + 946, + 947, + 5, + 105, + 0, + 0, + 947, + 948, + 5, + 109, + 0, + 0, + 948, + 949, + 5, + 101, + 0, + 0, + 949, + 90, + 1, + 0, + 0, + 0, + 950, + 951, + 5, + 68, + 0, + 0, + 951, + 952, + 5, + 97, + 0, + 0, + 952, + 953, + 5, + 116, + 0, + 0, + 953, + 954, + 5, + 101, + 0, + 0, + 954, + 955, + 5, + 84, + 0, + 0, + 955, + 956, + 5, + 105, + 0, + 0, + 956, + 957, + 5, + 109, + 0, + 0, + 957, + 958, + 5, + 101, + 0, + 0, + 958, + 92, + 1, + 0, + 0, + 0, + 959, + 960, + 5, + 100, + 0, + 0, + 960, + 961, + 5, + 101, + 0, + 0, + 961, + 962, + 5, + 99, + 0, + 0, + 962, + 963, + 5, + 114, + 0, + 0, + 963, + 94, + 1, + 0, + 0, + 0, + 964, + 965, + 5, + 100, + 0, + 0, + 965, + 966, + 5, + 101, + 0, + 0, + 966, + 967, + 5, + 100, + 0, + 0, + 967, + 968, + 5, + 117, + 0, + 0, + 968, + 969, + 5, + 112, + 0, + 0, + 969, + 96, + 1, + 0, + 0, + 0, + 970, + 971, + 5, + 100, + 0, + 0, + 971, + 972, + 5, + 101, + 0, + 0, + 972, + 973, + 5, + 115, + 0, + 0, + 973, + 974, + 5, + 99, + 0, + 0, + 974, + 98, + 1, + 0, + 0, + 0, + 975, + 976, + 5, + 100, + 0, + 0, + 976, + 977, + 5, + 105, + 0, + 0, + 977, + 978, + 5, + 102, + 0, + 0, + 978, + 979, + 5, + 102, + 0, + 0, + 979, + 980, + 5, + 101, + 0, + 0, + 980, + 981, + 5, + 114, + 0, + 0, + 981, + 982, + 5, + 101, + 0, + 0, + 982, + 983, + 5, + 110, + 0, + 0, + 983, + 984, + 5, + 99, + 0, + 0, + 984, + 985, + 5, + 101, + 0, + 0, + 985, + 100, + 1, + 0, + 0, + 0, + 986, + 987, + 5, + 68, + 0, + 0, + 987, + 988, + 5, + 105, + 0, + 0, + 988, + 989, + 5, + 114, + 0, + 0, + 989, + 990, + 5, + 101, + 0, + 0, + 990, + 991, + 5, + 99, + 0, + 0, + 991, + 992, + 5, + 116, + 0, + 0, + 992, + 993, + 5, + 105, + 0, + 0, + 993, + 994, + 5, + 111, + 0, + 0, + 994, + 995, + 5, + 110, + 0, + 0, + 995, + 102, + 1, + 0, + 0, + 0, + 996, + 997, + 5, + 100, + 0, + 0, + 997, + 998, + 5, + 105, + 0, + 0, + 998, + 999, + 5, + 115, + 0, + 0, + 999, + 1000, + 5, + 106, + 0, + 0, + 1000, + 1001, + 5, + 117, + 0, + 0, + 1001, + 1002, + 5, + 110, + 0, + 0, + 1002, + 1003, + 5, + 99, + 0, + 0, + 1003, + 1004, + 5, + 116, + 0, + 0, + 1004, + 104, + 1, + 0, + 0, + 0, + 1005, + 1006, + 5, + 100, + 0, + 0, + 1006, + 1007, + 5, + 105, + 0, + 0, + 1007, + 1008, + 5, + 115, + 0, + 0, + 1008, + 1009, + 5, + 116, + 0, + 0, + 1009, + 1010, + 5, + 97, + 0, + 0, + 1010, + 1011, + 5, + 110, + 0, + 0, + 1011, + 1012, + 5, + 99, + 0, + 0, + 1012, + 1013, + 5, + 101, + 0, + 0, + 1013, + 106, + 1, + 0, + 0, + 0, + 1014, + 1015, + 5, + 100, + 0, + 0, + 1015, + 1016, + 5, + 105, + 0, + 0, + 1016, + 1017, + 5, + 118, + 0, + 0, + 1017, + 108, + 1, + 0, + 0, + 0, + 1018, + 1019, + 5, + 100, + 0, + 0, + 1019, + 1020, + 5, + 114, + 0, + 0, + 1020, + 1021, + 5, + 111, + 0, + 0, + 1021, + 1022, + 5, + 112, + 0, + 0, + 1022, + 110, + 1, + 0, + 0, + 0, + 1023, + 1024, + 5, + 68, + 0, + 0, + 1024, + 1025, + 5, + 84, + 0, + 0, + 1025, + 112, + 1, + 0, + 0, + 0, + 1026, + 1027, + 5, + 69, + 0, + 0, + 1027, + 114, + 1, + 0, + 0, + 0, + 1028, + 1029, + 5, + 101, + 0, + 0, + 1029, + 1030, + 5, + 100, + 0, + 0, + 1030, + 1031, + 5, + 103, + 0, + 0, + 1031, + 1032, + 5, + 101, + 0, + 0, + 1032, + 1033, + 5, + 115, + 0, + 0, + 1033, + 116, + 1, + 0, + 0, + 0, + 1034, + 1035, + 5, + 101, + 0, + 0, + 1035, + 1036, + 5, + 108, + 0, + 0, + 1036, + 1037, + 5, + 101, + 0, + 0, + 1037, + 1038, + 5, + 109, + 0, + 0, + 1038, + 1039, + 5, + 101, + 0, + 0, + 1039, + 1040, + 5, + 110, + 0, + 0, + 1040, + 1041, + 5, + 116, + 0, + 0, + 1041, + 1042, + 5, + 77, + 0, + 0, + 1042, + 1043, + 5, + 97, + 0, + 0, + 1043, + 1044, + 5, + 112, + 0, + 0, + 1044, + 118, + 1, + 0, + 0, + 0, + 1045, + 1046, + 5, + 101, + 0, + 0, + 1046, + 1047, + 5, + 108, + 0, + 0, + 1047, + 1048, + 5, + 101, + 0, + 0, + 1048, + 1049, + 5, + 109, + 0, + 0, + 1049, + 1050, + 5, + 101, + 0, + 0, + 1050, + 1051, + 5, + 110, + 0, + 0, + 1051, + 1052, + 5, + 116, + 0, + 0, + 1052, + 120, + 1, + 0, + 0, + 0, + 1053, + 1054, + 5, + 101, + 0, + 0, + 1054, + 1055, + 5, + 109, + 0, + 0, + 1055, + 1056, + 5, + 105, + 0, + 0, + 1056, + 1057, + 5, + 116, + 0, + 0, + 1057, + 122, + 1, + 0, + 0, + 0, + 1058, + 1059, + 5, + 101, + 0, + 0, + 1059, + 1060, + 5, + 110, + 0, + 0, + 1060, + 1061, + 5, + 100, + 0, + 0, + 1061, + 1062, + 5, + 105, + 0, + 0, + 1062, + 1063, + 5, + 110, + 0, + 0, + 1063, + 1064, + 5, + 103, + 0, + 0, + 1064, + 1065, + 5, + 87, + 0, + 0, + 1065, + 1066, + 5, + 105, + 0, + 0, + 1066, + 1067, + 5, + 116, + 0, + 0, + 1067, + 1068, + 5, + 104, + 0, + 0, + 1068, + 124, + 1, + 0, + 0, + 0, + 1069, + 1070, + 5, + 101, + 0, + 0, + 1070, + 1071, + 5, + 113, + 0, + 0, + 1071, + 126, + 1, + 0, + 0, + 0, + 1072, + 1073, + 5, + 101, + 0, + 0, + 1073, + 1074, + 5, + 120, + 0, + 0, + 1074, + 1075, + 5, + 112, + 0, + 0, + 1075, + 1076, + 5, + 108, + 0, + 0, + 1076, + 1077, + 5, + 97, + 0, + 0, + 1077, + 1078, + 5, + 105, + 0, + 0, + 1078, + 1079, + 5, + 110, + 0, + 0, + 1079, + 128, + 1, + 0, + 0, + 0, + 1080, + 1081, + 5, + 102, + 0, + 0, + 1081, + 1082, + 5, + 97, + 0, + 0, + 1082, + 1083, + 5, + 105, + 0, + 0, + 1083, + 1084, + 5, + 108, + 0, + 0, + 1084, + 130, + 1, + 0, + 0, + 0, + 1085, + 1086, + 5, + 102, + 0, + 0, + 1086, + 1087, + 5, + 97, + 0, + 0, + 1087, + 1088, + 5, + 108, + 0, + 0, + 1088, + 1089, + 5, + 115, + 0, + 0, + 1089, + 1090, + 5, + 101, + 0, + 0, + 1090, + 132, + 1, + 0, + 0, + 0, + 1091, + 1092, + 5, + 102, + 0, + 0, + 1092, + 1093, + 5, + 105, + 0, + 0, + 1093, + 1094, + 5, + 108, + 0, + 0, + 1094, + 1095, + 5, + 116, + 0, + 0, + 1095, + 1096, + 5, + 101, + 0, + 0, + 1096, + 1097, + 5, + 114, + 0, + 0, + 1097, + 134, + 1, + 0, + 0, + 0, + 1098, + 1099, + 5, + 102, + 0, + 0, + 1099, + 1100, + 5, + 105, + 0, + 0, + 1100, + 1101, + 5, + 114, + 0, + 0, + 1101, + 1102, + 5, + 115, + 0, + 0, + 1102, + 1103, + 5, + 116, + 0, + 0, + 1103, + 136, + 1, + 0, + 0, + 0, + 1104, + 1105, + 5, + 102, + 0, + 0, + 1105, + 1106, + 5, + 108, + 0, + 0, + 1106, + 1107, + 5, + 97, + 0, + 0, + 1107, + 1108, + 5, + 116, + 0, + 0, + 1108, + 1109, + 5, + 77, + 0, + 0, + 1109, + 1110, + 5, + 97, + 0, + 0, + 1110, + 1111, + 5, + 112, + 0, + 0, + 1111, + 138, + 1, + 0, + 0, + 0, + 1112, + 1113, + 5, + 102, + 0, + 0, + 1113, + 1114, + 5, + 111, + 0, + 0, + 1114, + 1115, + 5, + 108, + 0, + 0, + 1115, + 1116, + 5, + 100, + 0, + 0, + 1116, + 140, + 1, + 0, + 0, + 0, + 1117, + 1118, + 5, + 102, + 0, + 0, + 1118, + 1119, + 5, + 111, + 0, + 0, + 1119, + 1120, + 5, + 114, + 0, + 0, + 1120, + 1121, + 5, + 109, + 0, + 0, + 1121, + 1122, + 5, + 97, + 0, + 0, + 1122, + 1123, + 5, + 116, + 0, + 0, + 1123, + 142, + 1, + 0, + 0, + 0, + 1124, + 1125, + 5, + 102, + 0, + 0, + 1125, + 1126, + 5, + 114, + 0, + 0, + 1126, + 1127, + 5, + 111, + 0, + 0, + 1127, + 1128, + 5, + 109, + 0, + 0, + 1128, + 144, + 1, + 0, + 0, + 0, + 1129, + 1130, + 5, + 103, + 0, + 0, + 1130, + 1131, + 5, + 108, + 0, + 0, + 1131, + 1132, + 5, + 111, + 0, + 0, + 1132, + 1133, + 5, + 98, + 0, + 0, + 1133, + 1134, + 5, + 97, + 0, + 0, + 1134, + 1135, + 5, + 108, + 0, + 0, + 1135, + 146, + 1, + 0, + 0, + 0, + 1136, + 1137, + 5, + 103, + 0, + 0, + 1137, + 1138, + 5, + 116, + 0, + 0, + 1138, + 148, + 1, + 0, + 0, + 0, + 1139, + 1140, + 5, + 103, + 0, + 0, + 1140, + 1141, + 5, + 116, + 0, + 0, + 1141, + 1142, + 5, + 101, + 0, + 0, + 1142, + 150, + 1, + 0, + 0, + 0, + 1143, + 1144, + 5, + 103, + 0, + 0, + 1144, + 1145, + 5, + 114, + 0, + 0, + 1145, + 1146, + 5, + 97, + 0, + 0, + 1146, + 1147, + 5, + 112, + 0, + 0, + 1147, + 1148, + 5, + 104, + 0, + 0, + 1148, + 1149, + 5, + 109, + 0, + 0, + 1149, + 1150, + 5, + 108, + 0, + 0, + 1150, + 152, + 1, + 0, + 0, + 0, + 1151, + 1152, + 5, + 103, + 0, + 0, + 1152, + 1153, + 5, + 114, + 0, + 0, + 1153, + 1154, + 5, + 97, + 0, + 0, + 1154, + 1155, + 5, + 112, + 0, + 0, + 1155, + 1156, + 5, + 104, + 0, + 0, + 1156, + 1157, + 5, + 115, + 0, + 0, + 1157, + 1158, + 5, + 111, + 0, + 0, + 1158, + 1159, + 5, + 110, + 0, + 0, + 1159, + 154, + 1, + 0, + 0, + 0, + 1160, + 1161, + 5, + 103, + 0, + 0, + 1161, + 1162, + 5, + 114, + 0, + 0, + 1162, + 1163, + 5, + 111, + 0, + 0, + 1163, + 1164, + 5, + 117, + 0, + 0, + 1164, + 1165, + 5, + 112, + 0, + 0, + 1165, + 1166, + 5, + 67, + 0, + 0, + 1166, + 1167, + 5, + 111, + 0, + 0, + 1167, + 1168, + 5, + 117, + 0, + 0, + 1168, + 1169, + 5, + 110, + 0, + 0, + 1169, + 1170, + 5, + 116, + 0, + 0, + 1170, + 156, + 1, + 0, + 0, + 0, + 1171, + 1172, + 5, + 103, + 0, + 0, + 1172, + 1173, + 5, + 114, + 0, + 0, + 1173, + 1174, + 5, + 111, + 0, + 0, + 1174, + 1175, + 5, + 117, + 0, + 0, + 1175, + 1176, + 5, + 112, + 0, + 0, + 1176, + 158, + 1, + 0, + 0, + 0, + 1177, + 1178, + 5, + 103, + 0, + 0, + 1178, + 1179, + 5, + 114, + 0, + 0, + 1179, + 1180, + 5, + 121, + 0, + 0, + 1180, + 1181, + 5, + 111, + 0, + 0, + 1181, + 160, + 1, + 0, + 0, + 0, + 1182, + 1183, + 5, + 104, + 0, + 0, + 1183, + 1184, + 5, + 97, + 0, + 0, + 1184, + 1185, + 5, + 115, + 0, + 0, + 1185, + 162, + 1, + 0, + 0, + 0, + 1186, + 1187, + 5, + 104, + 0, + 0, + 1187, + 1188, + 5, + 97, + 0, + 0, + 1188, + 1189, + 5, + 115, + 0, + 0, + 1189, + 1190, + 5, + 73, + 0, + 0, + 1190, + 1191, + 5, + 100, + 0, + 0, + 1191, + 164, + 1, + 0, + 0, + 0, + 1192, + 1193, + 5, + 104, + 0, + 0, + 1193, + 1194, + 5, + 97, + 0, + 0, + 1194, + 1195, + 5, + 115, + 0, + 0, + 1195, + 1196, + 5, + 75, + 0, + 0, + 1196, + 1197, + 5, + 101, + 0, + 0, + 1197, + 1198, + 5, + 121, + 0, + 0, + 1198, + 166, + 1, + 0, + 0, + 0, + 1199, + 1200, + 5, + 104, + 0, + 0, + 1200, + 1201, + 5, + 97, + 0, + 0, + 1201, + 1202, + 5, + 115, + 0, + 0, + 1202, + 1203, + 5, + 76, + 0, + 0, + 1203, + 1204, + 5, + 97, + 0, + 0, + 1204, + 1205, + 5, + 98, + 0, + 0, + 1205, + 1206, + 5, + 101, + 0, + 0, + 1206, + 1207, + 5, + 108, + 0, + 0, + 1207, + 168, + 1, + 0, + 0, + 0, + 1208, + 1209, + 5, + 104, + 0, + 0, + 1209, + 1210, + 5, + 97, + 0, + 0, + 1210, + 1211, + 5, + 115, + 0, + 0, + 1211, + 1212, + 5, + 78, + 0, + 0, + 1212, + 1213, + 5, + 101, + 0, + 0, + 1213, + 1214, + 5, + 120, + 0, + 0, + 1214, + 1215, + 5, + 116, + 0, + 0, + 1215, + 170, + 1, + 0, + 0, + 0, + 1216, + 1217, + 5, + 104, + 0, + 0, + 1217, + 1218, + 5, + 97, + 0, + 0, + 1218, + 1219, + 5, + 115, + 0, + 0, + 1219, + 1220, + 5, + 78, + 0, + 0, + 1220, + 1221, + 5, + 111, + 0, + 0, + 1221, + 1222, + 5, + 116, + 0, + 0, + 1222, + 172, + 1, + 0, + 0, + 0, + 1223, + 1224, + 5, + 104, + 0, + 0, + 1224, + 1225, + 5, + 97, + 0, + 0, + 1225, + 1226, + 5, + 115, + 0, + 0, + 1226, + 1227, + 5, + 86, + 0, + 0, + 1227, + 1228, + 5, + 97, + 0, + 0, + 1228, + 1229, + 5, + 108, + 0, + 0, + 1229, + 1230, + 5, + 117, + 0, + 0, + 1230, + 1231, + 5, + 101, + 0, + 0, + 1231, + 174, + 1, + 0, + 0, + 0, + 1232, + 1233, + 5, + 104, + 0, + 0, + 1233, + 1234, + 5, + 111, + 0, + 0, + 1234, + 1235, + 5, + 117, + 0, + 0, + 1235, + 1236, + 5, + 114, + 0, + 0, + 1236, + 176, + 1, + 0, + 0, + 0, + 1237, + 1238, + 5, + 105, + 0, + 0, + 1238, + 1239, + 5, + 100, + 0, + 0, + 1239, + 178, + 1, + 0, + 0, + 0, + 1240, + 1241, + 5, + 105, + 0, + 0, + 1241, + 1242, + 5, + 100, + 0, + 0, + 1242, + 1243, + 5, + 101, + 0, + 0, + 1243, + 1244, + 5, + 110, + 0, + 0, + 1244, + 1245, + 5, + 116, + 0, + 0, + 1245, + 1246, + 5, + 105, + 0, + 0, + 1246, + 1247, + 5, + 116, + 0, + 0, + 1247, + 1248, + 5, + 121, + 0, + 0, + 1248, + 180, + 1, + 0, + 0, + 0, + 1249, + 1250, + 5, + 105, + 0, + 0, + 1250, + 1251, + 5, + 100, + 0, + 0, + 1251, + 1252, + 5, + 115, + 0, + 0, + 1252, + 182, + 1, + 0, + 0, + 0, + 1253, + 1254, + 5, + 105, + 0, + 0, + 1254, + 1255, + 5, + 110, + 0, + 0, + 1255, + 184, + 1, + 0, + 0, + 0, + 1256, + 1257, + 5, + 73, + 0, + 0, + 1257, + 1258, + 5, + 78, + 0, + 0, + 1258, + 186, + 1, + 0, + 0, + 0, + 1259, + 1260, + 5, + 105, + 0, + 0, + 1260, + 1261, + 5, + 110, + 0, + 0, + 1261, + 1262, + 5, + 69, + 0, + 0, + 1262, + 188, + 1, + 0, + 0, + 0, + 1263, + 1264, + 5, + 105, + 0, + 0, + 1264, + 1265, + 5, + 110, + 0, + 0, + 1265, + 1266, + 5, + 99, + 0, + 0, + 1266, + 1267, + 5, + 108, + 0, + 0, + 1267, + 1268, + 5, + 117, + 0, + 0, + 1268, + 1269, + 5, + 100, + 0, + 0, + 1269, + 1270, + 5, + 101, + 0, + 0, + 1270, + 1271, + 5, + 69, + 0, + 0, + 1271, + 1272, + 5, + 100, + 0, + 0, + 1272, + 1273, + 5, + 103, + 0, + 0, + 1273, + 1274, + 5, + 101, + 0, + 0, + 1274, + 1275, + 5, + 115, + 0, + 0, + 1275, + 190, + 1, + 0, + 0, + 0, + 1276, + 1277, + 5, + 105, + 0, + 0, + 1277, + 1278, + 5, + 110, + 0, + 0, + 1278, + 1279, + 5, + 99, + 0, + 0, + 1279, + 1280, + 5, + 114, + 0, + 0, + 1280, + 192, + 1, + 0, + 0, + 0, + 1281, + 1282, + 5, + 105, + 0, + 0, + 1282, + 1283, + 5, + 110, + 0, + 0, + 1283, + 1284, + 5, + 100, + 0, + 0, + 1284, + 1285, + 5, + 101, + 0, + 0, + 1285, + 1286, + 5, + 120, + 0, + 0, + 1286, + 1287, + 5, + 101, + 0, + 0, + 1287, + 1288, + 5, + 114, + 0, + 0, + 1288, + 194, + 1, + 0, + 0, + 0, + 1289, + 1290, + 5, + 105, + 0, + 0, + 1290, + 1291, + 5, + 110, + 0, + 0, + 1291, + 1292, + 5, + 100, + 0, + 0, + 1292, + 1293, + 5, + 101, + 0, + 0, + 1293, + 1294, + 5, + 120, + 0, + 0, + 1294, + 196, + 1, + 0, + 0, + 0, + 1295, + 1296, + 5, + 73, + 0, + 0, + 1296, + 1297, + 5, + 110, + 0, + 0, + 1297, + 1298, + 5, + 102, + 0, + 0, + 1298, + 1299, + 5, + 105, + 0, + 0, + 1299, + 1300, + 5, + 110, + 0, + 0, + 1300, + 1301, + 5, + 105, + 0, + 0, + 1301, + 1302, + 5, + 116, + 0, + 0, + 1302, + 1303, + 5, + 121, + 0, + 0, + 1303, + 198, + 1, + 0, + 0, + 0, + 1304, + 1305, + 5, + 105, + 0, + 0, + 1305, + 1306, + 5, + 110, + 0, + 0, + 1306, + 1307, + 5, + 106, + 0, + 0, + 1307, + 1308, + 5, + 101, + 0, + 0, + 1308, + 1309, + 5, + 99, + 0, + 0, + 1309, + 1310, + 5, + 116, + 0, + 0, + 1310, + 200, + 1, + 0, + 0, + 0, + 1311, + 1312, + 5, + 105, + 0, + 0, + 1312, + 1313, + 5, + 110, + 0, + 0, + 1313, + 1314, + 5, + 115, + 0, + 0, + 1314, + 1315, + 5, + 105, + 0, + 0, + 1315, + 1316, + 5, + 100, + 0, + 0, + 1316, + 1317, + 5, + 101, + 0, + 0, + 1317, + 202, + 1, + 0, + 0, + 0, + 1318, + 1319, + 5, + 105, + 0, + 0, + 1319, + 1320, + 5, + 110, + 0, + 0, + 1320, + 1321, + 5, + 116, + 0, + 0, + 1321, + 1322, + 5, + 101, + 0, + 0, + 1322, + 1323, + 5, + 114, + 0, + 0, + 1323, + 1324, + 5, + 115, + 0, + 0, + 1324, + 1325, + 5, + 101, + 0, + 0, + 1325, + 1326, + 5, + 99, + 0, + 0, + 1326, + 1327, + 5, + 116, + 0, + 0, + 1327, + 204, + 1, + 0, + 0, + 0, + 1328, + 1329, + 5, + 105, + 0, + 0, + 1329, + 1330, + 5, + 110, + 0, + 0, + 1330, + 1331, + 5, + 86, + 0, + 0, + 1331, + 206, + 1, + 0, + 0, + 0, + 1332, + 1333, + 5, + 73, + 0, + 0, + 1333, + 1334, + 5, + 79, + 0, + 0, + 1334, + 208, + 1, + 0, + 0, + 0, + 1335, + 1336, + 5, + 105, + 0, + 0, + 1336, + 1337, + 5, + 111, + 0, + 0, + 1337, + 210, + 1, + 0, + 0, + 0, + 1338, + 1339, + 5, + 105, + 0, + 0, + 1339, + 1340, + 5, + 115, + 0, + 0, + 1340, + 212, + 1, + 0, + 0, + 0, + 1341, + 1342, + 5, + 105, + 0, + 0, + 1342, + 1343, + 5, + 116, + 0, + 0, + 1343, + 1344, + 5, + 101, + 0, + 0, + 1344, + 1345, + 5, + 114, + 0, + 0, + 1345, + 1346, + 5, + 97, + 0, + 0, + 1346, + 1347, + 5, + 116, + 0, + 0, + 1347, + 1348, + 5, + 101, + 0, + 0, + 1348, + 214, + 1, + 0, + 0, + 0, + 1349, + 1350, + 5, + 107, + 0, + 0, + 1350, + 1351, + 5, + 101, + 0, + 0, + 1351, + 1352, + 5, + 121, + 0, + 0, + 1352, + 216, + 1, + 0, + 0, + 0, + 1353, + 1354, + 5, + 107, + 0, + 0, + 1354, + 1355, + 5, + 101, + 0, + 0, + 1355, + 1356, + 5, + 121, + 0, + 0, + 1356, + 1357, + 5, + 115, + 0, + 0, + 1357, + 218, + 1, + 0, + 0, + 0, + 1358, + 1359, + 5, + 108, + 0, + 0, + 1359, + 1360, + 5, + 97, + 0, + 0, + 1360, + 1361, + 5, + 98, + 0, + 0, + 1361, + 1362, + 5, + 101, + 0, + 0, + 1362, + 1363, + 5, + 108, + 0, + 0, + 1363, + 1364, + 5, + 115, + 0, + 0, + 1364, + 220, + 1, + 0, + 0, + 0, + 1365, + 1366, + 5, + 108, + 0, + 0, + 1366, + 1367, + 5, + 97, + 0, + 0, + 1367, + 1368, + 5, + 98, + 0, + 0, + 1368, + 1369, + 5, + 101, + 0, + 0, + 1369, + 1370, + 5, + 108, + 0, + 0, + 1370, + 222, + 1, + 0, + 0, + 0, + 1371, + 1372, + 5, + 108, + 0, + 0, + 1372, + 1373, + 5, + 97, + 0, + 0, + 1373, + 1374, + 5, + 115, + 0, + 0, + 1374, + 1375, + 5, + 116, + 0, + 0, + 1375, + 224, + 1, + 0, + 0, + 0, + 1376, + 1377, + 5, + 108, + 0, + 0, + 1377, + 1378, + 5, + 101, + 0, + 0, + 1378, + 1379, + 5, + 110, + 0, + 0, + 1379, + 1380, + 5, + 103, + 0, + 0, + 1380, + 1381, + 5, + 116, + 0, + 0, + 1381, + 1382, + 5, + 104, + 0, + 0, + 1382, + 226, + 1, + 0, + 0, + 0, + 1383, + 1384, + 5, + 108, + 0, + 0, + 1384, + 1385, + 5, + 105, + 0, + 0, + 1385, + 1386, + 5, + 109, + 0, + 0, + 1386, + 1387, + 5, + 105, + 0, + 0, + 1387, + 1388, + 5, + 116, + 0, + 0, + 1388, + 228, + 1, + 0, + 0, + 0, + 1389, + 1390, + 5, + 108, + 0, + 0, + 1390, + 1391, + 5, + 105, + 0, + 0, + 1391, + 1392, + 5, + 115, + 0, + 0, + 1392, + 1393, + 5, + 116, + 0, + 0, + 1393, + 230, + 1, + 0, + 0, + 0, + 1394, + 1395, + 5, + 108, + 0, + 0, + 1395, + 1396, + 5, + 111, + 0, + 0, + 1396, + 1397, + 5, + 99, + 0, + 0, + 1397, + 1398, + 5, + 97, + 0, + 0, + 1398, + 1399, + 5, + 108, + 0, + 0, + 1399, + 232, + 1, + 0, + 0, + 0, + 1400, + 1401, + 5, + 108, + 0, + 0, + 1401, + 1402, + 5, + 111, + 0, + 0, + 1402, + 1403, + 5, + 111, + 0, + 0, + 1403, + 1404, + 5, + 112, + 0, + 0, + 1404, + 1405, + 5, + 115, + 0, + 0, + 1405, + 234, + 1, + 0, + 0, + 0, + 1406, + 1407, + 5, + 108, + 0, + 0, + 1407, + 1408, + 5, + 116, + 0, + 0, + 1408, + 236, + 1, + 0, + 0, + 0, + 1409, + 1410, + 5, + 108, + 0, + 0, + 1410, + 1411, + 5, + 116, + 0, + 0, + 1411, + 1412, + 5, + 101, + 0, + 0, + 1412, + 238, + 1, + 0, + 0, + 0, + 1413, + 1414, + 5, + 108, + 0, + 0, + 1414, + 1415, + 5, + 84, + 0, + 0, + 1415, + 1416, + 5, + 114, + 0, + 0, + 1416, + 1417, + 5, + 105, + 0, + 0, + 1417, + 1418, + 5, + 109, + 0, + 0, + 1418, + 240, + 1, + 0, + 0, + 0, + 1419, + 1420, + 5, + 109, + 0, + 0, + 1420, + 1421, + 5, + 97, + 0, + 0, + 1421, + 1422, + 5, + 112, + 0, + 0, + 1422, + 242, + 1, + 0, + 0, + 0, + 1423, + 1424, + 5, + 109, + 0, + 0, + 1424, + 1425, + 5, + 97, + 0, + 0, + 1425, + 1426, + 5, + 116, + 0, + 0, + 1426, + 1427, + 5, + 99, + 0, + 0, + 1427, + 1428, + 5, + 104, + 0, + 0, + 1428, + 244, + 1, + 0, + 0, + 0, + 1429, + 1430, + 5, + 109, + 0, + 0, + 1430, + 1431, + 5, + 97, + 0, + 0, + 1431, + 1432, + 5, + 116, + 0, + 0, + 1432, + 1433, + 5, + 104, + 0, + 0, + 1433, + 246, + 1, + 0, + 0, + 0, + 1434, + 1435, + 5, + 109, + 0, + 0, + 1435, + 1436, + 5, + 97, + 0, + 0, + 1436, + 1437, + 5, + 120, + 0, + 0, + 1437, + 248, + 1, + 0, + 0, + 0, + 1438, + 1439, + 5, + 109, + 0, + 0, + 1439, + 1440, + 5, + 97, + 0, + 0, + 1440, + 1441, + 5, + 120, + 0, + 0, + 1441, + 1442, + 5, + 68, + 0, + 0, + 1442, + 1443, + 5, + 105, + 0, + 0, + 1443, + 1444, + 5, + 115, + 0, + 0, + 1444, + 1445, + 5, + 116, + 0, + 0, + 1445, + 1446, + 5, + 97, + 0, + 0, + 1446, + 1447, + 5, + 110, + 0, + 0, + 1447, + 1448, + 5, + 99, + 0, + 0, + 1448, + 1449, + 5, + 101, + 0, + 0, + 1449, + 250, + 1, + 0, + 0, + 0, + 1450, + 1451, + 5, + 109, + 0, + 0, + 1451, + 1452, + 5, + 101, + 0, + 0, + 1452, + 1453, + 5, + 97, + 0, + 0, + 1453, + 1454, + 5, + 110, + 0, + 0, + 1454, + 252, + 1, + 0, + 0, + 0, + 1455, + 1456, + 5, + 77, + 0, + 0, + 1456, + 1457, + 5, + 101, + 0, + 0, + 1457, + 1458, + 5, + 114, + 0, + 0, + 1458, + 1459, + 5, + 103, + 0, + 0, + 1459, + 1460, + 5, + 101, + 0, + 0, + 1460, + 254, + 1, + 0, + 0, + 0, + 1461, + 1462, + 5, + 109, + 0, + 0, + 1462, + 1463, + 5, + 101, + 0, + 0, + 1463, + 1464, + 5, + 114, + 0, + 0, + 1464, + 1465, + 5, + 103, + 0, + 0, + 1465, + 1466, + 5, + 101, + 0, + 0, + 1466, + 256, + 1, + 0, + 0, + 0, + 1467, + 1468, + 5, + 109, + 0, + 0, + 1468, + 1469, + 5, + 101, + 0, + 0, + 1469, + 1470, + 5, + 114, + 0, + 0, + 1470, + 1471, + 5, + 103, + 0, + 0, + 1471, + 1472, + 5, + 101, + 0, + 0, + 1472, + 1473, + 5, + 69, + 0, + 0, + 1473, + 258, + 1, + 0, + 0, + 0, + 1474, + 1475, + 5, + 109, + 0, + 0, + 1475, + 1476, + 5, + 101, + 0, + 0, + 1476, + 1477, + 5, + 114, + 0, + 0, + 1477, + 1478, + 5, + 103, + 0, + 0, + 1478, + 1479, + 5, + 101, + 0, + 0, + 1479, + 1480, + 5, + 86, + 0, + 0, + 1480, + 260, + 1, + 0, + 0, + 0, + 1481, + 1482, + 5, + 109, + 0, + 0, + 1482, + 1483, + 5, + 105, + 0, + 0, + 1483, + 1484, + 5, + 110, + 0, + 0, + 1484, + 262, + 1, + 0, + 0, + 0, + 1485, + 1486, + 5, + 109, + 0, + 0, + 1486, + 1487, + 5, + 105, + 0, + 0, + 1487, + 1488, + 5, + 110, + 0, + 0, + 1488, + 1489, + 5, + 117, + 0, + 0, + 1489, + 1490, + 5, + 116, + 0, + 0, + 1490, + 1491, + 5, + 101, + 0, + 0, + 1491, + 264, + 1, + 0, + 0, + 0, + 1492, + 1493, + 5, + 109, + 0, + 0, + 1493, + 1494, + 5, + 105, + 0, + 0, + 1494, + 1495, + 5, + 110, + 0, + 0, + 1495, + 1496, + 5, + 117, + 0, + 0, + 1496, + 1497, + 5, + 115, + 0, + 0, + 1497, + 266, + 1, + 0, + 0, + 0, + 1498, + 1499, + 5, + 109, + 0, + 0, + 1499, + 1500, + 5, + 105, + 0, + 0, + 1500, + 1501, + 5, + 120, + 0, + 0, + 1501, + 1502, + 5, + 101, + 0, + 0, + 1502, + 1503, + 5, + 100, + 0, + 0, + 1503, + 268, + 1, + 0, + 0, + 0, + 1504, + 1505, + 5, + 109, + 0, + 0, + 1505, + 1506, + 5, + 117, + 0, + 0, + 1506, + 1507, + 5, + 108, + 0, + 0, + 1507, + 1508, + 5, + 116, + 0, + 0, + 1508, + 270, + 1, + 0, + 0, + 0, + 1509, + 1510, + 5, + 78, + 0, + 0, + 1510, + 1511, + 5, + 97, + 0, + 0, + 1511, + 1512, + 5, + 78, + 0, + 0, + 1512, + 272, + 1, + 0, + 0, + 0, + 1513, + 1514, + 5, + 110, + 0, + 0, + 1514, + 1515, + 5, + 101, + 0, + 0, + 1515, + 1516, + 5, + 103, + 0, + 0, + 1516, + 1517, + 5, + 97, + 0, + 0, + 1517, + 1518, + 5, + 116, + 0, + 0, + 1518, + 1519, + 5, + 101, + 0, + 0, + 1519, + 274, + 1, + 0, + 0, + 0, + 1520, + 1521, + 5, + 110, + 0, + 0, + 1521, + 1522, + 5, + 101, + 0, + 0, + 1522, + 1523, + 5, + 120, + 0, + 0, + 1523, + 1524, + 5, + 116, + 0, + 0, + 1524, + 276, + 1, + 0, + 0, + 0, + 1525, + 1526, + 5, + 110, + 0, + 0, + 1526, + 1527, + 5, + 111, + 0, + 0, + 1527, + 1528, + 5, + 110, + 0, + 0, + 1528, + 1529, + 5, + 101, + 0, + 0, + 1529, + 278, + 1, + 0, + 0, + 0, + 1530, + 1531, + 5, + 110, + 0, + 0, + 1531, + 1532, + 5, + 111, + 0, + 0, + 1532, + 1533, + 5, + 116, + 0, + 0, + 1533, + 1534, + 5, + 82, + 0, + 0, + 1534, + 1535, + 5, + 101, + 0, + 0, + 1535, + 1536, + 5, + 103, + 0, + 0, + 1536, + 1537, + 5, + 101, + 0, + 0, + 1537, + 1538, + 5, + 120, + 0, + 0, + 1538, + 280, + 1, + 0, + 0, + 0, + 1539, + 1540, + 5, + 110, + 0, + 0, + 1540, + 1541, + 5, + 111, + 0, + 0, + 1541, + 1542, + 5, + 116, + 0, + 0, + 1542, + 1543, + 5, + 67, + 0, + 0, + 1543, + 1544, + 5, + 111, + 0, + 0, + 1544, + 1545, + 5, + 110, + 0, + 0, + 1545, + 1546, + 5, + 116, + 0, + 0, + 1546, + 1547, + 5, + 97, + 0, + 0, + 1547, + 1548, + 5, + 105, + 0, + 0, + 1548, + 1549, + 5, + 110, + 0, + 0, + 1549, + 1550, + 5, + 105, + 0, + 0, + 1550, + 1551, + 5, + 110, + 0, + 0, + 1551, + 1552, + 5, + 103, + 0, + 0, + 1552, + 282, + 1, + 0, + 0, + 0, + 1553, + 1554, + 5, + 110, + 0, + 0, + 1554, + 1555, + 5, + 111, + 0, + 0, + 1555, + 1556, + 5, + 116, + 0, + 0, + 1556, + 1557, + 5, + 69, + 0, + 0, + 1557, + 1558, + 5, + 110, + 0, + 0, + 1558, + 1559, + 5, + 100, + 0, + 0, + 1559, + 1560, + 5, + 105, + 0, + 0, + 1560, + 1561, + 5, + 110, + 0, + 0, + 1561, + 1562, + 5, + 103, + 0, + 0, + 1562, + 1563, + 5, + 87, + 0, + 0, + 1563, + 1564, + 5, + 105, + 0, + 0, + 1564, + 1565, + 5, + 116, + 0, + 0, + 1565, + 1566, + 5, + 104, + 0, + 0, + 1566, + 284, + 1, + 0, + 0, + 0, + 1567, + 1568, + 5, + 110, + 0, + 0, + 1568, + 1569, + 5, + 111, + 0, + 0, + 1569, + 1570, + 5, + 116, + 0, + 0, + 1570, + 1571, + 5, + 83, + 0, + 0, + 1571, + 1572, + 5, + 116, + 0, + 0, + 1572, + 1573, + 5, + 97, + 0, + 0, + 1573, + 1574, + 5, + 114, + 0, + 0, + 1574, + 1575, + 5, + 116, + 0, + 0, + 1575, + 1576, + 5, + 105, + 0, + 0, + 1576, + 1577, + 5, + 110, + 0, + 0, + 1577, + 1578, + 5, + 103, + 0, + 0, + 1578, + 1579, + 5, + 87, + 0, + 0, + 1579, + 1580, + 5, + 105, + 0, + 0, + 1580, + 1581, + 5, + 116, + 0, + 0, + 1581, + 1582, + 5, + 104, + 0, + 0, + 1582, + 286, + 1, + 0, + 0, + 0, + 1583, + 1584, + 5, + 110, + 0, + 0, + 1584, + 1585, + 5, + 111, + 0, + 0, + 1585, + 1586, + 5, + 116, + 0, + 0, + 1586, + 288, + 1, + 0, + 0, + 0, + 1587, + 1588, + 5, + 110, + 0, + 0, + 1588, + 1589, + 5, + 101, + 0, + 0, + 1589, + 1590, + 5, + 113, + 0, + 0, + 1590, + 290, + 1, + 0, + 0, + 0, + 1591, + 1592, + 5, + 110, + 0, + 0, + 1592, + 1593, + 5, + 101, + 0, + 0, + 1593, + 1594, + 5, + 119, + 0, + 0, + 1594, + 292, + 1, + 0, + 0, + 0, + 1595, + 1596, + 5, + 110, + 0, + 0, + 1596, + 1597, + 5, + 111, + 0, + 0, + 1597, + 1598, + 5, + 114, + 0, + 0, + 1598, + 1599, + 5, + 109, + 0, + 0, + 1599, + 1600, + 5, + 83, + 0, + 0, + 1600, + 1601, + 5, + 97, + 0, + 0, + 1601, + 1602, + 5, + 99, + 0, + 0, + 1602, + 1603, + 5, + 107, + 0, + 0, + 1603, + 294, + 1, + 0, + 0, + 0, + 1604, + 1605, + 5, + 110, + 0, + 0, + 1605, + 1606, + 5, + 117, + 0, + 0, + 1606, + 1607, + 5, + 108, + 0, + 0, + 1607, + 1608, + 5, + 108, + 0, + 0, + 1608, + 296, + 1, + 0, + 0, + 0, + 1609, + 1610, + 5, + 111, + 0, + 0, + 1610, + 1611, + 5, + 110, + 0, + 0, + 1611, + 1612, + 5, + 67, + 0, + 0, + 1612, + 1613, + 5, + 114, + 0, + 0, + 1613, + 1614, + 5, + 101, + 0, + 0, + 1614, + 1615, + 5, + 97, + 0, + 0, + 1615, + 1616, + 5, + 116, + 0, + 0, + 1616, + 1617, + 5, + 101, + 0, + 0, + 1617, + 298, + 1, + 0, + 0, + 0, + 1618, + 1619, + 5, + 111, + 0, + 0, + 1619, + 1620, + 5, + 110, + 0, + 0, + 1620, + 1621, + 5, + 77, + 0, + 0, + 1621, + 1622, + 5, + 97, + 0, + 0, + 1622, + 1623, + 5, + 116, + 0, + 0, + 1623, + 1624, + 5, + 99, + 0, + 0, + 1624, + 1625, + 5, + 104, + 0, + 0, + 1625, + 300, + 1, + 0, + 0, + 0, + 1626, + 1627, + 5, + 79, + 0, + 0, + 1627, + 1628, + 5, + 112, + 0, + 0, + 1628, + 1629, + 5, + 101, + 0, + 0, + 1629, + 1630, + 5, + 114, + 0, + 0, + 1630, + 1631, + 5, + 97, + 0, + 0, + 1631, + 1632, + 5, + 116, + 0, + 0, + 1632, + 1633, + 5, + 111, + 0, + 0, + 1633, + 1634, + 5, + 114, + 0, + 0, + 1634, + 302, + 1, + 0, + 0, + 0, + 1635, + 1636, + 5, + 111, + 0, + 0, + 1636, + 1637, + 5, + 112, + 0, + 0, + 1637, + 1638, + 5, + 116, + 0, + 0, + 1638, + 1639, + 5, + 105, + 0, + 0, + 1639, + 1640, + 5, + 111, + 0, + 0, + 1640, + 1641, + 5, + 110, + 0, + 0, + 1641, + 304, + 1, + 0, + 0, + 0, + 1642, + 1643, + 5, + 111, + 0, + 0, + 1643, + 1644, + 5, + 112, + 0, + 0, + 1644, + 1645, + 5, + 116, + 0, + 0, + 1645, + 1646, + 5, + 105, + 0, + 0, + 1646, + 1647, + 5, + 111, + 0, + 0, + 1647, + 1648, + 5, + 110, + 0, + 0, + 1648, + 1649, + 5, + 97, + 0, + 0, + 1649, + 1650, + 5, + 108, + 0, + 0, + 1650, + 306, + 1, + 0, + 0, + 0, + 1651, + 1652, + 5, + 79, + 0, + 0, + 1652, + 1653, + 5, + 114, + 0, + 0, + 1653, + 1654, + 5, + 100, + 0, + 0, + 1654, + 1655, + 5, + 101, + 0, + 0, + 1655, + 1656, + 5, + 114, + 0, + 0, + 1656, + 308, + 1, + 0, + 0, + 0, + 1657, + 1658, + 5, + 111, + 0, + 0, + 1658, + 1659, + 5, + 114, + 0, + 0, + 1659, + 1660, + 5, + 100, + 0, + 0, + 1660, + 1661, + 5, + 101, + 0, + 0, + 1661, + 1662, + 5, + 114, + 0, + 0, + 1662, + 310, + 1, + 0, + 0, + 0, + 1663, + 1664, + 5, + 111, + 0, + 0, + 1664, + 1665, + 5, + 114, + 0, + 0, + 1665, + 312, + 1, + 0, + 0, + 0, + 1666, + 1667, + 5, + 111, + 0, + 0, + 1667, + 1668, + 5, + 116, + 0, + 0, + 1668, + 1669, + 5, + 104, + 0, + 0, + 1669, + 1670, + 5, + 101, + 0, + 0, + 1670, + 1671, + 5, + 114, + 0, + 0, + 1671, + 1672, + 5, + 86, + 0, + 0, + 1672, + 314, + 1, + 0, + 0, + 0, + 1673, + 1674, + 5, + 79, + 0, + 0, + 1674, + 1675, + 5, + 85, + 0, + 0, + 1675, + 1676, + 5, + 84, + 0, + 0, + 1676, + 316, + 1, + 0, + 0, + 0, + 1677, + 1678, + 5, + 111, + 0, + 0, + 1678, + 1679, + 5, + 117, + 0, + 0, + 1679, + 1680, + 5, + 116, + 0, + 0, + 1680, + 318, + 1, + 0, + 0, + 0, + 1681, + 1682, + 5, + 111, + 0, + 0, + 1682, + 1683, + 5, + 117, + 0, + 0, + 1683, + 1684, + 5, + 116, + 0, + 0, + 1684, + 1685, + 5, + 69, + 0, + 0, + 1685, + 320, + 1, + 0, + 0, + 0, + 1686, + 1687, + 5, + 111, + 0, + 0, + 1687, + 1688, + 5, + 117, + 0, + 0, + 1688, + 1689, + 5, + 116, + 0, + 0, + 1689, + 1690, + 5, + 115, + 0, + 0, + 1690, + 1691, + 5, + 105, + 0, + 0, + 1691, + 1692, + 5, + 100, + 0, + 0, + 1692, + 1693, + 5, + 101, + 0, + 0, + 1693, + 322, + 1, + 0, + 0, + 0, + 1694, + 1695, + 5, + 111, + 0, + 0, + 1695, + 1696, + 5, + 117, + 0, + 0, + 1696, + 1697, + 5, + 116, + 0, + 0, + 1697, + 1698, + 5, + 86, + 0, + 0, + 1698, + 324, + 1, + 0, + 0, + 0, + 1699, + 1700, + 5, + 80, + 0, + 0, + 1700, + 326, + 1, + 0, + 0, + 0, + 1701, + 1702, + 5, + 80, + 0, + 0, + 1702, + 1703, + 5, + 97, + 0, + 0, + 1703, + 1704, + 5, + 103, + 0, + 0, + 1704, + 1705, + 5, + 101, + 0, + 0, + 1705, + 1706, + 5, + 82, + 0, + 0, + 1706, + 1707, + 5, + 97, + 0, + 0, + 1707, + 1708, + 5, + 110, + 0, + 0, + 1708, + 1709, + 5, + 107, + 0, + 0, + 1709, + 328, + 1, + 0, + 0, + 0, + 1710, + 1711, + 5, + 112, + 0, + 0, + 1711, + 1712, + 5, + 97, + 0, + 0, + 1712, + 1713, + 5, + 103, + 0, + 0, + 1713, + 1714, + 5, + 101, + 0, + 0, + 1714, + 1715, + 5, + 82, + 0, + 0, + 1715, + 1716, + 5, + 97, + 0, + 0, + 1716, + 1717, + 5, + 110, + 0, + 0, + 1717, + 1718, + 5, + 107, + 0, + 0, + 1718, + 330, + 1, + 0, + 0, + 0, + 1719, + 1720, + 5, + 112, + 0, + 0, + 1720, + 1721, + 5, + 97, + 0, + 0, + 1721, + 1722, + 5, + 116, + 0, + 0, + 1722, + 1723, + 5, + 104, + 0, + 0, + 1723, + 332, + 1, + 0, + 0, + 0, + 1724, + 1725, + 5, + 80, + 0, + 0, + 1725, + 1726, + 5, + 101, + 0, + 0, + 1726, + 1727, + 5, + 101, + 0, + 0, + 1727, + 1728, + 5, + 114, + 0, + 0, + 1728, + 1729, + 5, + 80, + 0, + 0, + 1729, + 1730, + 5, + 114, + 0, + 0, + 1730, + 1731, + 5, + 101, + 0, + 0, + 1731, + 1732, + 5, + 115, + 0, + 0, + 1732, + 1733, + 5, + 115, + 0, + 0, + 1733, + 1734, + 5, + 117, + 0, + 0, + 1734, + 1735, + 5, + 114, + 0, + 0, + 1735, + 1736, + 5, + 101, + 0, + 0, + 1736, + 334, + 1, + 0, + 0, + 0, + 1737, + 1738, + 5, + 112, + 0, + 0, + 1738, + 1739, + 5, + 101, + 0, + 0, + 1739, + 1740, + 5, + 101, + 0, + 0, + 1740, + 1741, + 5, + 114, + 0, + 0, + 1741, + 1742, + 5, + 80, + 0, + 0, + 1742, + 1743, + 5, + 114, + 0, + 0, + 1743, + 1744, + 5, + 101, + 0, + 0, + 1744, + 1745, + 5, + 115, + 0, + 0, + 1745, + 1746, + 5, + 115, + 0, + 0, + 1746, + 1747, + 5, + 117, + 0, + 0, + 1747, + 1748, + 5, + 114, + 0, + 0, + 1748, + 1749, + 5, + 101, + 0, + 0, + 1749, + 336, + 1, + 0, + 0, + 0, + 1750, + 1751, + 5, + 80, + 0, + 0, + 1751, + 1752, + 5, + 105, + 0, + 0, + 1752, + 1753, + 5, + 99, + 0, + 0, + 1753, + 1754, + 5, + 107, + 0, + 0, + 1754, + 338, + 1, + 0, + 0, + 0, + 1755, + 1756, + 5, + 80, + 0, + 0, + 1756, + 1757, + 5, + 111, + 0, + 0, + 1757, + 1758, + 5, + 112, + 0, + 0, + 1758, + 340, + 1, + 0, + 0, + 0, + 1759, + 1760, + 5, + 112, + 0, + 0, + 1760, + 1761, + 5, + 114, + 0, + 0, + 1761, + 1762, + 5, + 111, + 0, + 0, + 1762, + 1763, + 5, + 102, + 0, + 0, + 1763, + 1764, + 5, + 105, + 0, + 0, + 1764, + 1765, + 5, + 108, + 0, + 0, + 1765, + 1766, + 5, + 101, + 0, + 0, + 1766, + 342, + 1, + 0, + 0, + 0, + 1767, + 1768, + 5, + 112, + 0, + 0, + 1768, + 1769, + 5, + 114, + 0, + 0, + 1769, + 1770, + 5, + 111, + 0, + 0, + 1770, + 1771, + 5, + 106, + 0, + 0, + 1771, + 1772, + 5, + 101, + 0, + 0, + 1772, + 1773, + 5, + 99, + 0, + 0, + 1773, + 1774, + 5, + 116, + 0, + 0, + 1774, + 344, + 1, + 0, + 0, + 0, + 1775, + 1776, + 5, + 112, + 0, + 0, + 1776, + 1777, + 5, + 114, + 0, + 0, + 1777, + 1778, + 5, + 111, + 0, + 0, + 1778, + 1779, + 5, + 112, + 0, + 0, + 1779, + 1780, + 5, + 101, + 0, + 0, + 1780, + 1781, + 5, + 114, + 0, + 0, + 1781, + 1782, + 5, + 116, + 0, + 0, + 1782, + 1783, + 5, + 105, + 0, + 0, + 1783, + 1784, + 5, + 101, + 0, + 0, + 1784, + 1785, + 5, + 115, + 0, + 0, + 1785, + 346, + 1, + 0, + 0, + 0, + 1786, + 1787, + 5, + 112, + 0, + 0, + 1787, + 1788, + 5, + 114, + 0, + 0, + 1788, + 1789, + 5, + 111, + 0, + 0, + 1789, + 1790, + 5, + 112, + 0, + 0, + 1790, + 1791, + 5, + 101, + 0, + 0, + 1791, + 1792, + 5, + 114, + 0, + 0, + 1792, + 1793, + 5, + 116, + 0, + 0, + 1793, + 1794, + 5, + 121, + 0, + 0, + 1794, + 1795, + 5, + 77, + 0, + 0, + 1795, + 1796, + 5, + 97, + 0, + 0, + 1796, + 1797, + 5, + 112, + 0, + 0, + 1797, + 348, + 1, + 0, + 0, + 0, + 1798, + 1799, + 5, + 112, + 0, + 0, + 1799, + 1800, + 5, + 114, + 0, + 0, + 1800, + 1801, + 5, + 111, + 0, + 0, + 1801, + 1802, + 5, + 112, + 0, + 0, + 1802, + 1803, + 5, + 101, + 0, + 0, + 1803, + 1804, + 5, + 114, + 0, + 0, + 1804, + 1805, + 5, + 116, + 0, + 0, + 1805, + 1806, + 5, + 121, + 0, + 0, + 1806, + 1807, + 5, + 78, + 0, + 0, + 1807, + 1808, + 5, + 97, + 0, + 0, + 1808, + 1809, + 5, + 109, + 0, + 0, + 1809, + 1810, + 5, + 101, + 0, + 0, + 1810, + 350, + 1, + 0, + 0, + 0, + 1811, + 1812, + 5, + 112, + 0, + 0, + 1812, + 1813, + 5, + 114, + 0, + 0, + 1813, + 1814, + 5, + 111, + 0, + 0, + 1814, + 1815, + 5, + 112, + 0, + 0, + 1815, + 1816, + 5, + 101, + 0, + 0, + 1816, + 1817, + 5, + 114, + 0, + 0, + 1817, + 1818, + 5, + 116, + 0, + 0, + 1818, + 1819, + 5, + 121, + 0, + 0, + 1819, + 352, + 1, + 0, + 0, + 0, + 1820, + 1821, + 5, + 112, + 0, + 0, + 1821, + 1822, + 5, + 114, + 0, + 0, + 1822, + 1823, + 5, + 111, + 0, + 0, + 1823, + 1824, + 5, + 100, + 0, + 0, + 1824, + 1825, + 5, + 117, + 0, + 0, + 1825, + 1826, + 5, + 99, + 0, + 0, + 1826, + 1827, + 5, + 116, + 0, + 0, + 1827, + 354, + 1, + 0, + 0, + 0, + 1828, + 1829, + 5, + 114, + 0, + 0, + 1829, + 1830, + 5, + 97, + 0, + 0, + 1830, + 1831, + 5, + 110, + 0, + 0, + 1831, + 1832, + 5, + 103, + 0, + 0, + 1832, + 1833, + 5, + 101, + 0, + 0, + 1833, + 356, + 1, + 0, + 0, + 0, + 1834, + 1835, + 5, + 114, + 0, + 0, + 1835, + 1836, + 5, + 101, + 0, + 0, + 1836, + 1837, + 5, + 97, + 0, + 0, + 1837, + 1838, + 5, + 100, + 0, + 0, + 1838, + 358, + 1, + 0, + 0, + 0, + 1839, + 1840, + 5, + 114, + 0, + 0, + 1840, + 1841, + 5, + 101, + 0, + 0, + 1841, + 1842, + 5, + 97, + 0, + 0, + 1842, + 1843, + 5, + 100, + 0, + 0, + 1843, + 1844, + 5, + 101, + 0, + 0, + 1844, + 1845, + 5, + 114, + 0, + 0, + 1845, + 360, + 1, + 0, + 0, + 0, + 1846, + 1847, + 5, + 82, + 0, + 0, + 1847, + 1848, + 5, + 101, + 0, + 0, + 1848, + 1849, + 5, + 102, + 0, + 0, + 1849, + 1850, + 5, + 101, + 0, + 0, + 1850, + 1851, + 5, + 114, + 0, + 0, + 1851, + 1852, + 5, + 101, + 0, + 0, + 1852, + 1853, + 5, + 110, + 0, + 0, + 1853, + 1854, + 5, + 99, + 0, + 0, + 1854, + 1855, + 5, + 101, + 0, + 0, + 1855, + 1856, + 5, + 86, + 0, + 0, + 1856, + 1857, + 5, + 101, + 0, + 0, + 1857, + 1858, + 5, + 114, + 0, + 0, + 1858, + 1859, + 5, + 116, + 0, + 0, + 1859, + 1860, + 5, + 101, + 0, + 0, + 1860, + 1861, + 5, + 120, + 0, + 0, + 1861, + 362, + 1, + 0, + 0, + 0, + 1862, + 1863, + 5, + 114, + 0, + 0, + 1863, + 1864, + 5, + 101, + 0, + 0, + 1864, + 1865, + 5, + 103, + 0, + 0, + 1865, + 1866, + 5, + 101, + 0, + 0, + 1866, + 1867, + 5, + 120, + 0, + 0, + 1867, + 364, + 1, + 0, + 0, + 0, + 1868, + 1869, + 5, + 114, + 0, + 0, + 1869, + 1870, + 5, + 101, + 0, + 0, + 1870, + 1871, + 5, + 112, + 0, + 0, + 1871, + 1872, + 5, + 108, + 0, + 0, + 1872, + 1873, + 5, + 97, + 0, + 0, + 1873, + 1874, + 5, + 99, + 0, + 0, + 1874, + 1875, + 5, + 101, + 0, + 0, + 1875, + 366, + 1, + 0, + 0, + 0, + 1876, + 1877, + 5, + 114, + 0, + 0, + 1877, + 1878, + 5, + 101, + 0, + 0, + 1878, + 1879, + 5, + 112, + 0, + 0, + 1879, + 1880, + 5, + 101, + 0, + 0, + 1880, + 1881, + 5, + 97, + 0, + 0, + 1881, + 1882, + 5, + 116, + 0, + 0, + 1882, + 368, + 1, + 0, + 0, + 0, + 1883, + 1884, + 5, + 114, + 0, + 0, + 1884, + 1885, + 5, + 101, + 0, + 0, + 1885, + 1886, + 5, + 118, + 0, + 0, + 1886, + 1887, + 5, + 101, + 0, + 0, + 1887, + 1888, + 5, + 114, + 0, + 0, + 1888, + 1889, + 5, + 115, + 0, + 0, + 1889, + 1890, + 5, + 101, + 0, + 0, + 1890, + 370, + 1, + 0, + 0, + 0, + 1891, + 1892, + 5, + 114, + 0, + 0, + 1892, + 1893, + 5, + 111, + 0, + 0, + 1893, + 1894, + 5, + 108, + 0, + 0, + 1894, + 1895, + 5, + 108, + 0, + 0, + 1895, + 1896, + 5, + 98, + 0, + 0, + 1896, + 1897, + 5, + 97, + 0, + 0, + 1897, + 1898, + 5, + 99, + 0, + 0, + 1898, + 1899, + 5, + 107, + 0, + 0, + 1899, + 372, + 1, + 0, + 0, + 0, + 1900, + 1901, + 5, + 114, + 0, + 0, + 1901, + 1902, + 5, + 84, + 0, + 0, + 1902, + 1903, + 5, + 114, + 0, + 0, + 1903, + 1904, + 5, + 105, + 0, + 0, + 1904, + 1905, + 5, + 109, + 0, + 0, + 1905, + 374, + 1, + 0, + 0, + 0, + 1906, + 1907, + 5, + 115, + 0, + 0, + 1907, + 1908, + 5, + 97, + 0, + 0, + 1908, + 1909, + 5, + 99, + 0, + 0, + 1909, + 1910, + 5, + 107, + 0, + 0, + 1910, + 376, + 1, + 0, + 0, + 0, + 1911, + 1912, + 5, + 115, + 0, + 0, + 1912, + 1913, + 5, + 97, + 0, + 0, + 1913, + 1914, + 5, + 109, + 0, + 0, + 1914, + 1915, + 5, + 112, + 0, + 0, + 1915, + 1916, + 5, + 108, + 0, + 0, + 1916, + 1917, + 5, + 101, + 0, + 0, + 1917, + 378, + 1, + 0, + 0, + 0, + 1918, + 1919, + 5, + 83, + 0, + 0, + 1919, + 1920, + 5, + 99, + 0, + 0, + 1920, + 1921, + 5, + 111, + 0, + 0, + 1921, + 1922, + 5, + 112, + 0, + 0, + 1922, + 1923, + 5, + 101, + 0, + 0, + 1923, + 380, + 1, + 0, + 0, + 0, + 1924, + 1925, + 5, + 115, + 0, + 0, + 1925, + 1926, + 5, + 101, + 0, + 0, + 1926, + 1927, + 5, + 99, + 0, + 0, + 1927, + 1928, + 5, + 111, + 0, + 0, + 1928, + 1929, + 5, + 110, + 0, + 0, + 1929, + 1930, + 5, + 100, + 0, + 0, + 1930, + 382, + 1, + 0, + 0, + 0, + 1931, + 1932, + 5, + 115, + 0, + 0, + 1932, + 1933, + 5, + 101, + 0, + 0, + 1933, + 1934, + 5, + 108, + 0, + 0, + 1934, + 1935, + 5, + 101, + 0, + 0, + 1935, + 1936, + 5, + 99, + 0, + 0, + 1936, + 1937, + 5, + 116, + 0, + 0, + 1937, + 384, + 1, + 0, + 0, + 0, + 1938, + 1939, + 5, + 115, + 0, + 0, + 1939, + 1940, + 5, + 101, + 0, + 0, + 1940, + 1941, + 5, + 116, + 0, + 0, + 1941, + 386, + 1, + 0, + 0, + 0, + 1942, + 1943, + 5, + 83, + 0, + 0, + 1943, + 1944, + 5, + 104, + 0, + 0, + 1944, + 1945, + 5, + 111, + 0, + 0, + 1945, + 1946, + 5, + 114, + 0, + 0, + 1946, + 1947, + 5, + 116, + 0, + 0, + 1947, + 1948, + 5, + 101, + 0, + 0, + 1948, + 1949, + 5, + 115, + 0, + 0, + 1949, + 1950, + 5, + 116, + 0, + 0, + 1950, + 1951, + 5, + 80, + 0, + 0, + 1951, + 1952, + 5, + 97, + 0, + 0, + 1952, + 1953, + 5, + 116, + 0, + 0, + 1953, + 1954, + 5, + 104, + 0, + 0, + 1954, + 388, + 1, + 0, + 0, + 0, + 1955, + 1956, + 5, + 115, + 0, + 0, + 1956, + 1957, + 5, + 104, + 0, + 0, + 1957, + 1958, + 5, + 111, + 0, + 0, + 1958, + 1959, + 5, + 114, + 0, + 0, + 1959, + 1960, + 5, + 116, + 0, + 0, + 1960, + 1961, + 5, + 101, + 0, + 0, + 1961, + 1962, + 5, + 115, + 0, + 0, + 1962, + 1963, + 5, + 116, + 0, + 0, + 1963, + 1964, + 5, + 80, + 0, + 0, + 1964, + 1965, + 5, + 97, + 0, + 0, + 1965, + 1966, + 5, + 116, + 0, + 0, + 1966, + 1967, + 5, + 104, + 0, + 0, + 1967, + 390, + 1, + 0, + 0, + 0, + 1968, + 1969, + 5, + 115, + 0, + 0, + 1969, + 1970, + 5, + 104, + 0, + 0, + 1970, + 1971, + 5, + 117, + 0, + 0, + 1971, + 1972, + 5, + 102, + 0, + 0, + 1972, + 1973, + 5, + 102, + 0, + 0, + 1973, + 1974, + 5, + 108, + 0, + 0, + 1974, + 1975, + 5, + 101, + 0, + 0, + 1975, + 392, + 1, + 0, + 0, + 0, + 1976, + 1977, + 5, + 115, + 0, + 0, + 1977, + 1978, + 5, + 105, + 0, + 0, + 1978, + 1979, + 5, + 100, + 0, + 0, + 1979, + 1980, + 5, + 101, + 0, + 0, + 1980, + 1981, + 5, + 69, + 0, + 0, + 1981, + 1982, + 5, + 102, + 0, + 0, + 1982, + 1983, + 5, + 102, + 0, + 0, + 1983, + 1984, + 5, + 101, + 0, + 0, + 1984, + 1985, + 5, + 99, + 0, + 0, + 1985, + 1986, + 5, + 116, + 0, + 0, + 1986, + 394, + 1, + 0, + 0, + 0, + 1987, + 1988, + 5, + 115, + 0, + 0, + 1988, + 1989, + 5, + 105, + 0, + 0, + 1989, + 1990, + 5, + 109, + 0, + 0, + 1990, + 1991, + 5, + 112, + 0, + 0, + 1991, + 1992, + 5, + 108, + 0, + 0, + 1992, + 1993, + 5, + 101, + 0, + 0, + 1993, + 1994, + 5, + 80, + 0, + 0, + 1994, + 1995, + 5, + 97, + 0, + 0, + 1995, + 1996, + 5, + 116, + 0, + 0, + 1996, + 1997, + 5, + 104, + 0, + 0, + 1997, + 396, + 1, + 0, + 0, + 0, + 1998, + 1999, + 5, + 115, + 0, + 0, + 1999, + 2000, + 5, + 105, + 0, + 0, + 2000, + 2001, + 5, + 110, + 0, + 0, + 2001, + 2002, + 5, + 103, + 0, + 0, + 2002, + 2003, + 5, + 108, + 0, + 0, + 2003, + 2004, + 5, + 101, + 0, + 0, + 2004, + 398, + 1, + 0, + 0, + 0, + 2005, + 2006, + 5, + 115, + 0, + 0, + 2006, + 2007, + 5, + 107, + 0, + 0, + 2007, + 2008, + 5, + 105, + 0, + 0, + 2008, + 2009, + 5, + 112, + 0, + 0, + 2009, + 400, + 1, + 0, + 0, + 0, + 2010, + 2011, + 5, + 115, + 0, + 0, + 2011, + 2012, + 5, + 112, + 0, + 0, + 2012, + 2013, + 5, + 108, + 0, + 0, + 2013, + 2014, + 5, + 105, + 0, + 0, + 2014, + 2015, + 5, + 116, + 0, + 0, + 2015, + 402, + 1, + 0, + 0, + 0, + 2016, + 2017, + 5, + 115, + 0, + 0, + 2017, + 2018, + 5, + 116, + 0, + 0, + 2018, + 2019, + 5, + 97, + 0, + 0, + 2019, + 2020, + 5, + 114, + 0, + 0, + 2020, + 2021, + 5, + 116, + 0, + 0, + 2021, + 2022, + 5, + 105, + 0, + 0, + 2022, + 2023, + 5, + 110, + 0, + 0, + 2023, + 2024, + 5, + 103, + 0, + 0, + 2024, + 2025, + 5, + 87, + 0, + 0, + 2025, + 2026, + 5, + 105, + 0, + 0, + 2026, + 2027, + 5, + 116, + 0, + 0, + 2027, + 2028, + 5, + 104, + 0, + 0, + 2028, + 404, + 1, + 0, + 0, + 0, + 2029, + 2030, + 5, + 115, + 0, + 0, + 2030, + 2031, + 5, + 116, + 0, + 0, + 2031, + 2032, + 5, + 111, + 0, + 0, + 2032, + 2033, + 5, + 114, + 0, + 0, + 2033, + 2034, + 5, + 101, + 0, + 0, + 2034, + 406, + 1, + 0, + 0, + 0, + 2035, + 2036, + 5, + 115, + 0, + 0, + 2036, + 2037, + 5, + 117, + 0, + 0, + 2037, + 2038, + 5, + 98, + 0, + 0, + 2038, + 2039, + 5, + 103, + 0, + 0, + 2039, + 2040, + 5, + 114, + 0, + 0, + 2040, + 2041, + 5, + 97, + 0, + 0, + 2041, + 2042, + 5, + 112, + 0, + 0, + 2042, + 2043, + 5, + 104, + 0, + 0, + 2043, + 408, + 1, + 0, + 0, + 0, + 2044, + 2045, + 5, + 115, + 0, + 0, + 2045, + 2046, + 5, + 117, + 0, + 0, + 2046, + 2047, + 5, + 98, + 0, + 0, + 2047, + 2048, + 5, + 115, + 0, + 0, + 2048, + 2049, + 5, + 116, + 0, + 0, + 2049, + 2050, + 5, + 114, + 0, + 0, + 2050, + 2051, + 5, + 105, + 0, + 0, + 2051, + 2052, + 5, + 110, + 0, + 0, + 2052, + 2053, + 5, + 103, + 0, + 0, + 2053, + 410, + 1, + 0, + 0, + 0, + 2054, + 2055, + 5, + 115, + 0, + 0, + 2055, + 2056, + 5, + 117, + 0, + 0, + 2056, + 2057, + 5, + 109, + 0, + 0, + 2057, + 412, + 1, + 0, + 0, + 0, + 2058, + 2059, + 5, + 115, + 0, + 0, + 2059, + 2060, + 5, + 117, + 0, + 0, + 2060, + 2061, + 5, + 109, + 0, + 0, + 2061, + 2062, + 5, + 76, + 0, + 0, + 2062, + 2063, + 5, + 111, + 0, + 0, + 2063, + 2064, + 5, + 110, + 0, + 0, + 2064, + 2065, + 5, + 103, + 0, + 0, + 2065, + 414, + 1, + 0, + 0, + 0, + 2066, + 2067, + 5, + 84, + 0, + 0, + 2067, + 416, + 1, + 0, + 0, + 0, + 2068, + 2069, + 5, + 116, + 0, + 0, + 2069, + 2070, + 5, + 97, + 0, + 0, + 2070, + 2071, + 5, + 105, + 0, + 0, + 2071, + 2072, + 5, + 108, + 0, + 0, + 2072, + 418, + 1, + 0, + 0, + 0, + 2073, + 2074, + 5, + 116, + 0, + 0, + 2074, + 2075, + 5, + 97, + 0, + 0, + 2075, + 2076, + 5, + 114, + 0, + 0, + 2076, + 2077, + 5, + 103, + 0, + 0, + 2077, + 2078, + 5, + 101, + 0, + 0, + 2078, + 2079, + 5, + 116, + 0, + 0, + 2079, + 420, + 1, + 0, + 0, + 0, + 2080, + 2081, + 5, + 84, + 0, + 0, + 2081, + 2082, + 5, + 101, + 0, + 0, + 2082, + 2083, + 5, + 120, + 0, + 0, + 2083, + 2084, + 5, + 116, + 0, + 0, + 2084, + 2085, + 5, + 80, + 0, + 0, + 2085, + 422, + 1, + 0, + 0, + 0, + 2086, + 2087, + 5, + 116, + 0, + 0, + 2087, + 2088, + 5, + 105, + 0, + 0, + 2088, + 2089, + 5, + 109, + 0, + 0, + 2089, + 2090, + 5, + 101, + 0, + 0, + 2090, + 2091, + 5, + 76, + 0, + 0, + 2091, + 2092, + 5, + 105, + 0, + 0, + 2092, + 2093, + 5, + 109, + 0, + 0, + 2093, + 2094, + 5, + 105, + 0, + 0, + 2094, + 2095, + 5, + 116, + 0, + 0, + 2095, + 424, + 1, + 0, + 0, + 0, + 2096, + 2097, + 5, + 116, + 0, + 0, + 2097, + 2098, + 5, + 105, + 0, + 0, + 2098, + 2099, + 5, + 109, + 0, + 0, + 2099, + 2100, + 5, + 101, + 0, + 0, + 2100, + 2101, + 5, + 115, + 0, + 0, + 2101, + 426, + 1, + 0, + 0, + 0, + 2102, + 2103, + 5, + 116, + 0, + 0, + 2103, + 2104, + 5, + 111, + 0, + 0, + 2104, + 428, + 1, + 0, + 0, + 0, + 2105, + 2106, + 5, + 116, + 0, + 0, + 2106, + 2107, + 5, + 111, + 0, + 0, + 2107, + 2108, + 5, + 66, + 0, + 0, + 2108, + 2109, + 5, + 117, + 0, + 0, + 2109, + 2110, + 5, + 108, + 0, + 0, + 2110, + 2111, + 5, + 107, + 0, + 0, + 2111, + 2112, + 5, + 83, + 0, + 0, + 2112, + 2113, + 5, + 101, + 0, + 0, + 2113, + 2114, + 5, + 116, + 0, + 0, + 2114, + 430, + 1, + 0, + 0, + 0, + 2115, + 2116, + 5, + 116, + 0, + 0, + 2116, + 2117, + 5, + 111, + 0, + 0, + 2117, + 2118, + 5, + 107, + 0, + 0, + 2118, + 2119, + 5, + 101, + 0, + 0, + 2119, + 2120, + 5, + 110, + 0, + 0, + 2120, + 2121, + 5, + 115, + 0, + 0, + 2121, + 432, + 1, + 0, + 0, + 0, + 2122, + 2123, + 5, + 116, + 0, + 0, + 2123, + 2124, + 5, + 111, + 0, + 0, + 2124, + 2125, + 5, + 76, + 0, + 0, + 2125, + 2126, + 5, + 105, + 0, + 0, + 2126, + 2127, + 5, + 115, + 0, + 0, + 2127, + 2128, + 5, + 116, + 0, + 0, + 2128, + 434, + 1, + 0, + 0, + 0, + 2129, + 2130, + 5, + 116, + 0, + 0, + 2130, + 2131, + 5, + 111, + 0, + 0, + 2131, + 2132, + 5, + 76, + 0, + 0, + 2132, + 2133, + 5, + 111, + 0, + 0, + 2133, + 2134, + 5, + 119, + 0, + 0, + 2134, + 2135, + 5, + 101, + 0, + 0, + 2135, + 2136, + 5, + 114, + 0, + 0, + 2136, + 436, + 1, + 0, + 0, + 0, + 2137, + 2138, + 5, + 116, + 0, + 0, + 2138, + 2139, + 5, + 111, + 0, + 0, + 2139, + 2140, + 5, + 83, + 0, + 0, + 2140, + 2141, + 5, + 101, + 0, + 0, + 2141, + 2142, + 5, + 116, + 0, + 0, + 2142, + 438, + 1, + 0, + 0, + 0, + 2143, + 2144, + 5, + 116, + 0, + 0, + 2144, + 2145, + 5, + 111, + 0, + 0, + 2145, + 2146, + 5, + 83, + 0, + 0, + 2146, + 2147, + 5, + 116, + 0, + 0, + 2147, + 2148, + 5, + 114, + 0, + 0, + 2148, + 2149, + 5, + 105, + 0, + 0, + 2149, + 2150, + 5, + 110, + 0, + 0, + 2150, + 2151, + 5, + 103, + 0, + 0, + 2151, + 440, + 1, + 0, + 0, + 0, + 2152, + 2153, + 5, + 116, + 0, + 0, + 2153, + 2154, + 5, + 111, + 0, + 0, + 2154, + 2155, + 5, + 85, + 0, + 0, + 2155, + 2156, + 5, + 112, + 0, + 0, + 2156, + 2157, + 5, + 112, + 0, + 0, + 2157, + 2158, + 5, + 101, + 0, + 0, + 2158, + 2159, + 5, + 114, + 0, + 0, + 2159, + 442, + 1, + 0, + 0, + 0, + 2160, + 2161, + 5, + 116, + 0, + 0, + 2161, + 2162, + 5, + 111, + 0, + 0, + 2162, + 2163, + 5, + 69, + 0, + 0, + 2163, + 444, + 1, + 0, + 0, + 0, + 2164, + 2165, + 5, + 116, + 0, + 0, + 2165, + 2166, + 5, + 111, + 0, + 0, + 2166, + 2167, + 5, + 86, + 0, + 0, + 2167, + 446, + 1, + 0, + 0, + 0, + 2168, + 2169, + 5, + 116, + 0, + 0, + 2169, + 2170, + 5, + 114, + 0, + 0, + 2170, + 2171, + 5, + 101, + 0, + 0, + 2171, + 2172, + 5, + 101, + 0, + 0, + 2172, + 448, + 1, + 0, + 0, + 0, + 2173, + 2174, + 5, + 116, + 0, + 0, + 2174, + 2175, + 5, + 114, + 0, + 0, + 2175, + 2176, + 5, + 105, + 0, + 0, + 2176, + 2177, + 5, + 109, + 0, + 0, + 2177, + 450, + 1, + 0, + 0, + 0, + 2178, + 2179, + 5, + 116, + 0, + 0, + 2179, + 2180, + 5, + 114, + 0, + 0, + 2180, + 2181, + 5, + 117, + 0, + 0, + 2181, + 2182, + 5, + 101, + 0, + 0, + 2182, + 452, + 1, + 0, + 0, + 0, + 2183, + 2184, + 5, + 116, + 0, + 0, + 2184, + 2185, + 5, + 114, + 0, + 0, + 2185, + 2186, + 5, + 121, + 0, + 0, + 2186, + 2187, + 5, + 78, + 0, + 0, + 2187, + 2188, + 5, + 101, + 0, + 0, + 2188, + 2189, + 5, + 120, + 0, + 0, + 2189, + 2190, + 5, + 116, + 0, + 0, + 2190, + 454, + 1, + 0, + 0, + 0, + 2191, + 2192, + 5, + 116, + 0, + 0, + 2192, + 2193, + 5, + 120, + 0, + 0, + 2193, + 456, + 1, + 0, + 0, + 0, + 2194, + 2195, + 5, + 117, + 0, + 0, + 2195, + 2196, + 5, + 110, + 0, + 0, + 2196, + 2197, + 5, + 102, + 0, + 0, + 2197, + 2198, + 5, + 111, + 0, + 0, + 2198, + 2199, + 5, + 108, + 0, + 0, + 2199, + 2200, + 5, + 100, + 0, + 0, + 2200, + 458, + 1, + 0, + 0, + 0, + 2201, + 2202, + 5, + 117, + 0, + 0, + 2202, + 2203, + 5, + 110, + 0, + 0, + 2203, + 2204, + 5, + 105, + 0, + 0, + 2204, + 2205, + 5, + 111, + 0, + 0, + 2205, + 2206, + 5, + 110, + 0, + 0, + 2206, + 460, + 1, + 0, + 0, + 0, + 2207, + 2208, + 5, + 117, + 0, + 0, + 2208, + 2209, + 5, + 110, + 0, + 0, + 2209, + 2210, + 5, + 116, + 0, + 0, + 2210, + 2211, + 5, + 105, + 0, + 0, + 2211, + 2212, + 5, + 108, + 0, + 0, + 2212, + 462, + 1, + 0, + 0, + 0, + 2213, + 2214, + 5, + 85, + 0, + 0, + 2214, + 2215, + 5, + 85, + 0, + 0, + 2215, + 2216, + 5, + 73, + 0, + 0, + 2216, + 2217, + 5, + 68, + 0, + 0, + 2217, + 464, + 1, + 0, + 0, + 0, + 2218, + 2219, + 5, + 86, + 0, + 0, + 2219, + 466, + 1, + 0, + 0, + 0, + 2220, + 2221, + 5, + 118, + 0, + 0, + 2221, + 2222, + 5, + 97, + 0, + 0, + 2222, + 2223, + 5, + 108, + 0, + 0, + 2223, + 2224, + 5, + 117, + 0, + 0, + 2224, + 2225, + 5, + 101, + 0, + 0, + 2225, + 2226, + 5, + 77, + 0, + 0, + 2226, + 2227, + 5, + 97, + 0, + 0, + 2227, + 2228, + 5, + 112, + 0, + 0, + 2228, + 468, + 1, + 0, + 0, + 0, + 2229, + 2230, + 5, + 118, + 0, + 0, + 2230, + 2231, + 5, + 97, + 0, + 0, + 2231, + 2232, + 5, + 108, + 0, + 0, + 2232, + 2233, + 5, + 117, + 0, + 0, + 2233, + 2234, + 5, + 101, + 0, + 0, + 2234, + 2235, + 5, + 115, + 0, + 0, + 2235, + 470, + 1, + 0, + 0, + 0, + 2236, + 2237, + 5, + 118, + 0, + 0, + 2237, + 2238, + 5, + 97, + 0, + 0, + 2238, + 2239, + 5, + 108, + 0, + 0, + 2239, + 2240, + 5, + 117, + 0, + 0, + 2240, + 2241, + 5, + 101, + 0, + 0, + 2241, + 472, + 1, + 0, + 0, + 0, + 2242, + 2243, + 5, + 86, + 0, + 0, + 2243, + 2244, + 5, + 101, + 0, + 0, + 2244, + 2245, + 5, + 114, + 0, + 0, + 2245, + 2246, + 5, + 116, + 0, + 0, + 2246, + 2247, + 5, + 101, + 0, + 0, + 2247, + 2248, + 5, + 120, + 0, + 0, + 2248, + 474, + 1, + 0, + 0, + 0, + 2249, + 2250, + 5, + 119, + 0, + 0, + 2250, + 2251, + 5, + 104, + 0, + 0, + 2251, + 2252, + 5, + 101, + 0, + 0, + 2252, + 2253, + 5, + 114, + 0, + 0, + 2253, + 2254, + 5, + 101, + 0, + 0, + 2254, + 476, + 1, + 0, + 0, + 0, + 2255, + 2256, + 5, + 119, + 0, + 0, + 2256, + 2257, + 5, + 105, + 0, + 0, + 2257, + 2258, + 5, + 116, + 0, + 0, + 2258, + 2259, + 5, + 104, + 0, + 0, + 2259, + 478, + 1, + 0, + 0, + 0, + 2260, + 2261, + 5, + 119, + 0, + 0, + 2261, + 2262, + 5, + 105, + 0, + 0, + 2262, + 2263, + 5, + 116, + 0, + 0, + 2263, + 2264, + 5, + 104, + 0, + 0, + 2264, + 2265, + 5, + 66, + 0, + 0, + 2265, + 2266, + 5, + 117, + 0, + 0, + 2266, + 2267, + 5, + 108, + 0, + 0, + 2267, + 2268, + 5, + 107, + 0, + 0, + 2268, + 480, + 1, + 0, + 0, + 0, + 2269, + 2270, + 5, + 119, + 0, + 0, + 2270, + 2271, + 5, + 105, + 0, + 0, + 2271, + 2272, + 5, + 116, + 0, + 0, + 2272, + 2273, + 5, + 104, + 0, + 0, + 2273, + 2274, + 5, + 105, + 0, + 0, + 2274, + 2275, + 5, + 110, + 0, + 0, + 2275, + 482, + 1, + 0, + 0, + 0, + 2276, + 2277, + 5, + 87, + 0, + 0, + 2277, + 2278, + 5, + 105, + 0, + 0, + 2278, + 2279, + 5, + 116, + 0, + 0, + 2279, + 2280, + 5, + 104, + 0, + 0, + 2280, + 2281, + 5, + 79, + 0, + 0, + 2281, + 2282, + 5, + 112, + 0, + 0, + 2282, + 2283, + 5, + 116, + 0, + 0, + 2283, + 2284, + 5, + 105, + 0, + 0, + 2284, + 2285, + 5, + 111, + 0, + 0, + 2285, + 2286, + 5, + 110, + 0, + 0, + 2286, + 2287, + 5, + 115, + 0, + 0, + 2287, + 484, + 1, + 0, + 0, + 0, + 2288, + 2289, + 5, + 119, + 0, + 0, + 2289, + 2290, + 5, + 105, + 0, + 0, + 2290, + 2291, + 5, + 116, + 0, + 0, + 2291, + 2292, + 5, + 104, + 0, + 0, + 2292, + 2293, + 5, + 111, + 0, + 0, + 2293, + 2294, + 5, + 117, + 0, + 0, + 2294, + 2295, + 5, + 116, + 0, + 0, + 2295, + 486, + 1, + 0, + 0, + 0, + 2296, + 2297, + 5, + 119, + 0, + 0, + 2297, + 2298, + 5, + 105, + 0, + 0, + 2298, + 2299, + 5, + 116, + 0, + 0, + 2299, + 2300, + 5, + 104, + 0, + 0, + 2300, + 2301, + 5, + 111, + 0, + 0, + 2301, + 2302, + 5, + 117, + 0, + 0, + 2302, + 2303, + 5, + 116, + 0, + 0, + 2303, + 2304, + 5, + 83, + 0, + 0, + 2304, + 2305, + 5, + 116, + 0, + 0, + 2305, + 2306, + 5, + 114, + 0, + 0, + 2306, + 2307, + 5, + 97, + 0, + 0, + 2307, + 2308, + 5, + 116, + 0, + 0, + 2308, + 2309, + 5, + 101, + 0, + 0, + 2309, + 2310, + 5, + 103, + 0, + 0, + 2310, + 2311, + 5, + 105, + 0, + 0, + 2311, + 2312, + 5, + 101, + 0, + 0, + 2312, + 2313, + 5, + 115, + 0, + 0, + 2313, + 488, + 1, + 0, + 0, + 0, + 2314, + 2315, + 5, + 119, + 0, + 0, + 2315, + 2316, + 5, + 105, + 0, + 0, + 2316, + 2317, + 5, + 116, + 0, + 0, + 2317, + 2318, + 5, + 104, + 0, + 0, + 2318, + 2319, + 5, + 80, + 0, + 0, + 2319, + 2320, + 5, + 97, + 0, + 0, + 2320, + 2321, + 5, + 116, + 0, + 0, + 2321, + 2322, + 5, + 104, + 0, + 0, + 2322, + 490, + 1, + 0, + 0, + 0, + 2323, + 2324, + 5, + 119, + 0, + 0, + 2324, + 2325, + 5, + 105, + 0, + 0, + 2325, + 2326, + 5, + 116, + 0, + 0, + 2326, + 2327, + 5, + 104, + 0, + 0, + 2327, + 2328, + 5, + 83, + 0, + 0, + 2328, + 2329, + 5, + 97, + 0, + 0, + 2329, + 2330, + 5, + 99, + 0, + 0, + 2330, + 2331, + 5, + 107, + 0, + 0, + 2331, + 492, + 1, + 0, + 0, + 0, + 2332, + 2333, + 5, + 119, + 0, + 0, + 2333, + 2334, + 5, + 105, + 0, + 0, + 2334, + 2335, + 5, + 116, + 0, + 0, + 2335, + 2336, + 5, + 104, + 0, + 0, + 2336, + 2337, + 5, + 83, + 0, + 0, + 2337, + 2338, + 5, + 105, + 0, + 0, + 2338, + 2339, + 5, + 100, + 0, + 0, + 2339, + 2340, + 5, + 101, + 0, + 0, + 2340, + 2341, + 5, + 69, + 0, + 0, + 2341, + 2342, + 5, + 102, + 0, + 0, + 2342, + 2343, + 5, + 102, + 0, + 0, + 2343, + 2344, + 5, + 101, + 0, + 0, + 2344, + 2345, + 5, + 99, + 0, + 0, + 2345, + 2346, + 5, + 116, + 0, + 0, + 2346, + 494, + 1, + 0, + 0, + 0, + 2347, + 2348, + 5, + 119, + 0, + 0, + 2348, + 2349, + 5, + 105, + 0, + 0, + 2349, + 2350, + 5, + 116, + 0, + 0, + 2350, + 2351, + 5, + 104, + 0, + 0, + 2351, + 2352, + 5, + 83, + 0, + 0, + 2352, + 2353, + 5, + 116, + 0, + 0, + 2353, + 2354, + 5, + 114, + 0, + 0, + 2354, + 2355, + 5, + 97, + 0, + 0, + 2355, + 2356, + 5, + 116, + 0, + 0, + 2356, + 2357, + 5, + 101, + 0, + 0, + 2357, + 2358, + 5, + 103, + 0, + 0, + 2358, + 2359, + 5, + 105, + 0, + 0, + 2359, + 2360, + 5, + 101, + 0, + 0, + 2360, + 2361, + 5, + 115, + 0, + 0, + 2361, + 496, + 1, + 0, + 0, + 0, + 2362, + 2363, + 5, + 119, + 0, + 0, + 2363, + 2364, + 5, + 114, + 0, + 0, + 2364, + 2365, + 5, + 105, + 0, + 0, + 2365, + 2366, + 5, + 116, + 0, + 0, + 2366, + 2367, + 5, + 101, + 0, + 0, + 2367, + 498, + 1, + 0, + 0, + 0, + 2368, + 2369, + 5, + 119, + 0, + 0, + 2369, + 2370, + 5, + 114, + 0, + 0, + 2370, + 2371, + 5, + 105, + 0, + 0, + 2371, + 2372, + 5, + 116, + 0, + 0, + 2372, + 2373, + 5, + 101, + 0, + 0, + 2373, + 2374, + 5, + 114, + 0, + 0, + 2374, + 500, + 1, + 0, + 0, + 0, + 2375, + 2377, + 3, + 555, + 277, + 0, + 2376, + 2375, + 1, + 0, + 0, + 0, + 2376, + 2377, + 1, + 0, + 0, + 0, + 2377, + 2378, + 1, + 0, + 0, + 0, + 2378, + 2388, + 3, + 503, + 251, + 0, + 2379, + 2381, + 3, + 555, + 277, + 0, + 2380, + 2379, + 1, + 0, + 0, + 0, + 2380, + 2381, + 1, + 0, + 0, + 0, + 2381, + 2382, + 1, + 0, + 0, + 0, + 2382, + 2388, + 3, + 505, + 252, + 0, + 2383, + 2385, + 3, + 555, + 277, + 0, + 2384, + 2383, + 1, + 0, + 0, + 0, + 2384, + 2385, + 1, + 0, + 0, + 0, + 2385, + 2386, + 1, + 0, + 0, + 0, + 2386, + 2388, + 3, + 507, + 253, + 0, + 2387, + 2376, + 1, + 0, + 0, + 0, + 2387, + 2380, + 1, + 0, + 0, + 0, + 2387, + 2384, + 1, + 0, + 0, + 0, + 2388, + 502, + 1, + 0, + 0, + 0, + 2389, + 2391, + 3, + 511, + 255, + 0, + 2390, + 2392, + 3, + 509, + 254, + 0, + 2391, + 2390, + 1, + 0, + 0, + 0, + 2391, + 2392, + 1, + 0, + 0, + 0, + 2392, + 504, + 1, + 0, + 0, + 0, + 2393, + 2395, + 3, + 525, + 262, + 0, + 2394, + 2396, + 3, + 509, + 254, + 0, + 2395, + 2394, + 1, + 0, + 0, + 0, + 2395, + 2396, + 1, + 0, + 0, + 0, + 2396, + 506, + 1, + 0, + 0, + 0, + 2397, + 2399, + 3, + 535, + 267, + 0, + 2398, + 2400, + 3, + 509, + 254, + 0, + 2399, + 2398, + 1, + 0, + 0, + 0, + 2399, + 2400, + 1, + 0, + 0, + 0, + 2400, + 508, + 1, + 0, + 0, + 0, + 2401, + 2402, + 7, + 0, + 0, + 0, + 2402, + 510, + 1, + 0, + 0, + 0, + 2403, + 2414, + 5, + 48, + 0, + 0, + 2404, + 2411, + 3, + 517, + 258, + 0, + 2405, + 2407, + 3, + 513, + 256, + 0, + 2406, + 2405, + 1, + 0, + 0, + 0, + 2406, + 2407, + 1, + 0, + 0, + 0, + 2407, + 2412, + 1, + 0, + 0, + 0, + 2408, + 2409, + 3, + 523, + 261, + 0, + 2409, + 2410, + 3, + 513, + 256, + 0, + 2410, + 2412, + 1, + 0, + 0, + 0, + 2411, + 2406, + 1, + 0, + 0, + 0, + 2411, + 2408, + 1, + 0, + 0, + 0, + 2412, + 2414, + 1, + 0, + 0, + 0, + 2413, + 2403, + 1, + 0, + 0, + 0, + 2413, + 2404, + 1, + 0, + 0, + 0, + 2414, + 512, + 1, + 0, + 0, + 0, + 2415, + 2420, + 3, + 515, + 257, + 0, + 2416, + 2418, + 3, + 519, + 259, + 0, + 2417, + 2416, + 1, + 0, + 0, + 0, + 2417, + 2418, + 1, + 0, + 0, + 0, + 2418, + 2419, + 1, + 0, + 0, + 0, + 2419, + 2421, + 3, + 515, + 257, + 0, + 2420, + 2417, + 1, + 0, + 0, + 0, + 2420, + 2421, + 1, + 0, + 0, + 0, + 2421, + 514, + 1, + 0, + 0, + 0, + 2422, + 2425, + 5, + 48, + 0, + 0, + 2423, + 2425, + 3, + 517, + 258, + 0, + 2424, + 2422, + 1, + 0, + 0, + 0, + 2424, + 2423, + 1, + 0, + 0, + 0, + 2425, + 516, + 1, + 0, + 0, + 0, + 2426, + 2427, + 7, + 1, + 0, + 0, + 2427, + 518, + 1, + 0, + 0, + 0, + 2428, + 2430, + 3, + 521, + 260, + 0, + 2429, + 2428, + 1, + 0, + 0, + 0, + 2430, + 2431, + 1, + 0, + 0, + 0, + 2431, + 2429, + 1, + 0, + 0, + 0, + 2431, + 2432, + 1, + 0, + 0, + 0, + 2432, + 520, + 1, + 0, + 0, + 0, + 2433, + 2436, + 3, + 515, + 257, + 0, + 2434, + 2436, + 5, + 95, + 0, + 0, + 2435, + 2433, + 1, + 0, + 0, + 0, + 2435, + 2434, + 1, + 0, + 0, + 0, + 2436, + 522, + 1, + 0, + 0, + 0, + 2437, + 2439, + 5, + 95, + 0, + 0, + 2438, + 2437, + 1, + 0, + 0, + 0, + 2439, + 2440, + 1, + 0, + 0, + 0, + 2440, + 2438, + 1, + 0, + 0, + 0, + 2440, + 2441, + 1, + 0, + 0, + 0, + 2441, + 524, + 1, + 0, + 0, + 0, + 2442, + 2443, + 5, + 48, + 0, + 0, + 2443, + 2444, + 7, + 2, + 0, + 0, + 2444, + 2445, + 3, + 527, + 263, + 0, + 2445, + 526, + 1, + 0, + 0, + 0, + 2446, + 2451, + 3, + 529, + 264, + 0, + 2447, + 2449, + 3, + 531, + 265, + 0, + 2448, + 2447, + 1, + 0, + 0, + 0, + 2448, + 2449, + 1, + 0, + 0, + 0, + 2449, + 2450, + 1, + 0, + 0, + 0, + 2450, + 2452, + 3, + 529, + 264, + 0, + 2451, + 2448, + 1, + 0, + 0, + 0, + 2451, + 2452, + 1, + 0, + 0, + 0, + 2452, + 528, + 1, + 0, + 0, + 0, + 2453, + 2454, + 7, + 3, + 0, + 0, + 2454, + 530, + 1, + 0, + 0, + 0, + 2455, + 2457, + 3, + 533, + 266, + 0, + 2456, + 2455, + 1, + 0, + 0, + 0, + 2457, + 2458, + 1, + 0, + 0, + 0, + 2458, + 2456, + 1, + 0, + 0, + 0, + 2458, + 2459, + 1, + 0, + 0, + 0, + 2459, + 532, + 1, + 0, + 0, + 0, + 2460, + 2463, + 3, + 529, + 264, + 0, + 2461, + 2463, + 5, + 95, + 0, + 0, + 2462, + 2460, + 1, + 0, + 0, + 0, + 2462, + 2461, + 1, + 0, + 0, + 0, + 2463, + 534, + 1, + 0, + 0, + 0, + 2464, + 2466, + 5, + 48, + 0, + 0, + 2465, + 2467, + 3, + 523, + 261, + 0, + 2466, + 2465, + 1, + 0, + 0, + 0, + 2466, + 2467, + 1, + 0, + 0, + 0, + 2467, + 2468, + 1, + 0, + 0, + 0, + 2468, + 2469, + 3, + 537, + 268, + 0, + 2469, + 536, + 1, + 0, + 0, + 0, + 2470, + 2475, + 3, + 539, + 269, + 0, + 2471, + 2473, + 3, + 541, + 270, + 0, + 2472, + 2471, + 1, + 0, + 0, + 0, + 2472, + 2473, + 1, + 0, + 0, + 0, + 2473, + 2474, + 1, + 0, + 0, + 0, + 2474, + 2476, + 3, + 539, + 269, + 0, + 2475, + 2472, + 1, + 0, + 0, + 0, + 2475, + 2476, + 1, + 0, + 0, + 0, + 2476, + 538, + 1, + 0, + 0, + 0, + 2477, + 2478, + 7, + 4, + 0, + 0, + 2478, + 540, + 1, + 0, + 0, + 0, + 2479, + 2481, + 3, + 543, + 271, + 0, + 2480, + 2479, + 1, + 0, + 0, + 0, + 2481, + 2482, + 1, + 0, + 0, + 0, + 2482, + 2480, + 1, + 0, + 0, + 0, + 2482, + 2483, + 1, + 0, + 0, + 0, + 2483, + 542, + 1, + 0, + 0, + 0, + 2484, + 2487, + 3, + 539, + 269, + 0, + 2485, + 2487, + 5, + 95, + 0, + 0, + 2486, + 2484, + 1, + 0, + 0, + 0, + 2486, + 2485, + 1, + 0, + 0, + 0, + 2487, + 544, + 1, + 0, + 0, + 0, + 2488, + 2490, + 3, + 555, + 277, + 0, + 2489, + 2488, + 1, + 0, + 0, + 0, + 2489, + 2490, + 1, + 0, + 0, + 0, + 2490, + 2491, + 1, + 0, + 0, + 0, + 2491, + 2492, + 3, + 547, + 273, + 0, + 2492, + 546, + 1, + 0, + 0, + 0, + 2493, + 2500, + 3, + 513, + 256, + 0, + 2494, + 2495, + 5, + 46, + 0, + 0, + 2495, + 2497, + 3, + 513, + 256, + 0, + 2496, + 2498, + 3, + 549, + 274, + 0, + 2497, + 2496, + 1, + 0, + 0, + 0, + 2497, + 2498, + 1, + 0, + 0, + 0, + 2498, + 2501, + 1, + 0, + 0, + 0, + 2499, + 2501, + 3, + 549, + 274, + 0, + 2500, + 2494, + 1, + 0, + 0, + 0, + 2500, + 2499, + 1, + 0, + 0, + 0, + 2501, + 2503, + 1, + 0, + 0, + 0, + 2502, + 2504, + 3, + 557, + 278, + 0, + 2503, + 2502, + 1, + 0, + 0, + 0, + 2503, + 2504, + 1, + 0, + 0, + 0, + 2504, + 2509, + 1, + 0, + 0, + 0, + 2505, + 2506, + 3, + 513, + 256, + 0, + 2506, + 2507, + 3, + 557, + 278, + 0, + 2507, + 2509, + 1, + 0, + 0, + 0, + 2508, + 2493, + 1, + 0, + 0, + 0, + 2508, + 2505, + 1, + 0, + 0, + 0, + 2509, + 548, + 1, + 0, + 0, + 0, + 2510, + 2511, + 3, + 551, + 275, + 0, + 2511, + 2512, + 3, + 553, + 276, + 0, + 2512, + 550, + 1, + 0, + 0, + 0, + 2513, + 2514, + 7, + 5, + 0, + 0, + 2514, + 552, + 1, + 0, + 0, + 0, + 2515, + 2517, + 3, + 555, + 277, + 0, + 2516, + 2515, + 1, + 0, + 0, + 0, + 2516, + 2517, + 1, + 0, + 0, + 0, + 2517, + 2518, + 1, + 0, + 0, + 0, + 2518, + 2519, + 3, + 513, + 256, + 0, + 2519, + 554, + 1, + 0, + 0, + 0, + 2520, + 2521, + 7, + 6, + 0, + 0, + 2521, + 556, + 1, + 0, + 0, + 0, + 2522, + 2523, + 7, + 7, + 0, + 0, + 2523, + 558, + 1, + 0, + 0, + 0, + 2524, + 2526, + 3, + 555, + 277, + 0, + 2525, + 2524, + 1, + 0, + 0, + 0, + 2525, + 2526, + 1, + 0, + 0, + 0, + 2526, + 2527, + 1, + 0, + 0, + 0, + 2527, + 2528, + 3, + 197, + 98, + 0, + 2528, + 560, + 1, + 0, + 0, + 0, + 2529, + 2530, + 5, + 34, + 0, + 0, + 2530, + 2531, + 3, + 565, + 282, + 0, + 2531, + 2532, + 5, + 34, + 0, + 0, + 2532, + 2538, + 1, + 0, + 0, + 0, + 2533, + 2534, + 5, + 39, + 0, + 0, + 2534, + 2535, + 3, + 569, + 284, + 0, + 2535, + 2536, + 5, + 39, + 0, + 0, + 2536, + 2538, + 1, + 0, + 0, + 0, + 2537, + 2529, + 1, + 0, + 0, + 0, + 2537, + 2533, + 1, + 0, + 0, + 0, + 2538, + 562, + 1, + 0, + 0, + 0, + 2539, + 2540, + 5, + 34, + 0, + 0, + 2540, + 2544, + 5, + 34, + 0, + 0, + 2541, + 2542, + 5, + 39, + 0, + 0, + 2542, + 2544, + 5, + 39, + 0, + 0, + 2543, + 2539, + 1, + 0, + 0, + 0, + 2543, + 2541, + 1, + 0, + 0, + 0, + 2544, + 564, + 1, + 0, + 0, + 0, + 2545, + 2547, + 3, + 567, + 283, + 0, + 2546, + 2545, + 1, + 0, + 0, + 0, + 2547, + 2548, + 1, + 0, + 0, + 0, + 2548, + 2546, + 1, + 0, + 0, + 0, + 2548, + 2549, + 1, + 0, + 0, + 0, + 2549, + 566, + 1, + 0, + 0, + 0, + 2550, + 2554, + 8, + 8, + 0, + 0, + 2551, + 2554, + 3, + 573, + 286, + 0, + 2552, + 2554, + 3, + 575, + 287, + 0, + 2553, + 2550, + 1, + 0, + 0, + 0, + 2553, + 2551, + 1, + 0, + 0, + 0, + 2553, + 2552, + 1, + 0, + 0, + 0, + 2554, + 568, + 1, + 0, + 0, + 0, + 2555, + 2557, + 3, + 571, + 285, + 0, + 2556, + 2555, + 1, + 0, + 0, + 0, + 2557, + 2558, + 1, + 0, + 0, + 0, + 2558, + 2556, + 1, + 0, + 0, + 0, + 2558, + 2559, + 1, + 0, + 0, + 0, + 2559, + 570, + 1, + 0, + 0, + 0, + 2560, + 2564, + 8, + 9, + 0, + 0, + 2561, + 2564, + 3, + 573, + 286, + 0, + 2562, + 2564, + 3, + 575, + 287, + 0, + 2563, + 2560, + 1, + 0, + 0, + 0, + 2563, + 2561, + 1, + 0, + 0, + 0, + 2563, + 2562, + 1, + 0, + 0, + 0, + 2564, + 572, + 1, + 0, + 0, + 0, + 2565, + 2567, + 5, + 92, + 0, + 0, + 2566, + 2568, + 5, + 13, + 0, + 0, + 2567, + 2566, + 1, + 0, + 0, + 0, + 2567, + 2568, + 1, + 0, + 0, + 0, + 2568, + 2569, + 1, + 0, + 0, + 0, + 2569, + 2570, + 5, + 10, + 0, + 0, + 2570, + 574, + 1, + 0, + 0, + 0, + 2571, + 2572, + 5, + 92, + 0, + 0, + 2572, + 2576, + 7, + 10, + 0, + 0, + 2573, + 2576, + 3, + 577, + 288, + 0, + 2574, + 2576, + 3, + 581, + 290, + 0, + 2575, + 2571, + 1, + 0, + 0, + 0, + 2575, + 2573, + 1, + 0, + 0, + 0, + 2575, + 2574, + 1, + 0, + 0, + 0, + 2576, + 576, + 1, + 0, + 0, + 0, + 2577, + 2578, + 5, + 92, + 0, + 0, + 2578, + 2589, + 3, + 539, + 269, + 0, + 2579, + 2580, + 5, + 92, + 0, + 0, + 2580, + 2581, + 3, + 539, + 269, + 0, + 2581, + 2582, + 3, + 539, + 269, + 0, + 2582, + 2589, + 1, + 0, + 0, + 0, + 2583, + 2584, + 5, + 92, + 0, + 0, + 2584, + 2585, + 3, + 579, + 289, + 0, + 2585, + 2586, + 3, + 539, + 269, + 0, + 2586, + 2587, + 3, + 539, + 269, + 0, + 2587, + 2589, + 1, + 0, + 0, + 0, + 2588, + 2577, + 1, + 0, + 0, + 0, + 2588, + 2579, + 1, + 0, + 0, + 0, + 2588, + 2583, + 1, + 0, + 0, + 0, + 2589, + 578, + 1, + 0, + 0, + 0, + 2590, + 2591, + 7, + 11, + 0, + 0, + 2591, + 580, + 1, + 0, + 0, + 0, + 2592, + 2594, + 5, + 92, + 0, + 0, + 2593, + 2595, + 5, + 117, + 0, + 0, + 2594, + 2593, + 1, + 0, + 0, + 0, + 2595, + 2596, + 1, + 0, + 0, + 0, + 2596, + 2594, + 1, + 0, + 0, + 0, + 2596, + 2597, + 1, + 0, + 0, + 0, + 2597, + 2598, + 1, + 0, + 0, + 0, + 2598, + 2599, + 3, + 529, + 264, + 0, + 2599, + 2600, + 3, + 529, + 264, + 0, + 2600, + 2601, + 3, + 529, + 264, + 0, + 2601, + 2602, + 3, + 529, + 264, + 0, + 2602, + 582, + 1, + 0, + 0, + 0, + 2603, + 2604, + 5, + 40, + 0, + 0, + 2604, + 584, + 1, + 0, + 0, + 0, + 2605, + 2606, + 5, + 41, + 0, + 0, + 2606, + 586, + 1, + 0, + 0, + 0, + 2607, + 2608, + 5, + 123, + 0, + 0, + 2608, + 588, + 1, + 0, + 0, + 0, + 2609, + 2610, + 5, + 125, + 0, + 0, + 2610, + 590, + 1, + 0, + 0, + 0, + 2611, + 2612, + 5, + 91, + 0, + 0, + 2612, + 592, + 1, + 0, + 0, + 0, + 2613, + 2614, + 5, + 93, + 0, + 0, + 2614, + 594, + 1, + 0, + 0, + 0, + 2615, + 2616, + 5, + 59, + 0, + 0, + 2616, + 596, + 1, + 0, + 0, + 0, + 2617, + 2618, + 5, + 44, + 0, + 0, + 2618, + 598, + 1, + 0, + 0, + 0, + 2619, + 2620, + 5, + 46, + 0, + 0, + 2620, + 600, + 1, + 0, + 0, + 0, + 2621, + 2622, + 5, + 58, + 0, + 0, + 2622, + 602, + 1, + 0, + 0, + 0, + 2623, + 2624, + 5, + 103, + 0, + 0, + 2624, + 604, + 1, + 0, + 0, + 0, + 2625, + 2626, + 5, + 95, + 0, + 0, + 2626, + 2627, + 5, + 95, + 0, + 0, + 2627, + 606, + 1, + 0, + 0, + 0, + 2628, + 2630, + 7, + 12, + 0, + 0, + 2629, + 2628, + 1, + 0, + 0, + 0, + 2630, + 2631, + 1, + 0, + 0, + 0, + 2631, + 2629, + 1, + 0, + 0, + 0, + 2631, + 2632, + 1, + 0, + 0, + 0, + 2632, + 2633, + 1, + 0, + 0, + 0, + 2633, + 2634, + 6, + 303, + 0, + 0, + 2634, + 608, + 1, + 0, + 0, + 0, + 2635, + 2636, + 5, + 47, + 0, + 0, + 2636, + 2637, + 5, + 47, + 0, + 0, + 2637, + 2641, + 1, + 0, + 0, + 0, + 2638, + 2640, + 8, + 13, + 0, + 0, + 2639, + 2638, + 1, + 0, + 0, + 0, + 2640, + 2643, + 1, + 0, + 0, + 0, + 2641, + 2639, + 1, + 0, + 0, + 0, + 2641, + 2642, + 1, + 0, + 0, + 0, + 2642, + 2644, + 1, + 0, + 0, + 0, + 2643, + 2641, + 1, + 0, + 0, + 0, + 2644, + 2645, + 6, + 304, + 0, + 0, + 2645, + 610, + 1, + 0, + 0, + 0, + 2646, + 2650, + 3, + 613, + 306, + 0, + 2647, + 2649, + 3, + 615, + 307, + 0, + 2648, + 2647, + 1, + 0, + 0, + 0, + 2649, + 2652, + 1, + 0, + 0, + 0, + 2650, + 2648, + 1, + 0, + 0, + 0, + 2650, + 2651, + 1, + 0, + 0, + 0, + 2651, + 612, + 1, + 0, + 0, + 0, + 2652, + 2650, + 1, + 0, + 0, + 0, + 2653, + 2655, + 7, + 14, + 0, + 0, + 2654, + 2653, + 1, + 0, + 0, + 0, + 2655, + 614, + 1, + 0, + 0, + 0, + 2656, + 2659, + 3, + 613, + 306, + 0, + 2657, + 2659, + 7, + 15, + 0, + 0, + 2658, + 2656, + 1, + 0, + 0, + 0, + 2658, + 2657, + 1, + 0, + 0, + 0, + 2659, + 616, + 1, + 0, + 0, + 0, + 48, + 0, + 2376, + 2380, + 2384, + 2387, + 2391, + 2395, + 2399, + 2406, + 2411, + 2413, + 2417, + 2420, + 2424, + 2431, + 2435, + 2440, + 2448, + 2451, + 2458, + 2462, + 2466, + 2472, + 2475, + 2482, + 2486, + 2489, + 2497, + 2500, + 2503, + 2508, + 2516, + 2525, + 2537, + 2543, + 2548, + 2553, + 2558, + 2563, + 2567, + 2575, + 2588, + 2596, + 2631, + 2641, + 2650, + 2654, + 2658, + 1, + 6, + 0, + 0, + ] + + +class GremlinLexer(Lexer): + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] + + T__0 = 1 + K_ADDALL = 2 + K_ADDE = 3 + K_ADDV = 4 + K_AGGREGATE = 5 + K_ALL = 6 + K_AND = 7 + K_ANY = 8 + K_AS = 9 + K_ASC = 10 + K_ASDATE = 11 + K_ASSTRING = 12 + K_ASSIGN = 13 + K_BARRIER = 14 + K_BARRIERU = 15 + K_BEGIN = 16 + K_BETWEEN = 17 + K_BOTH = 18 + K_BOTHU = 19 + K_BOTHE = 20 + K_BOTHV = 21 + K_BRANCH = 22 + K_BY = 23 + K_CALL = 24 + K_CAP = 25 + K_CARDINALITY = 26 + K_CHOOSE = 27 + K_COALESCE = 28 + K_COIN = 29 + K_COLUMN = 30 + K_COMBINE = 31 + K_COMMIT = 32 + K_COMPONENT = 33 + K_CONCAT = 34 + K_CONJOIN = 35 + K_CONNECTEDCOMPONENT = 36 + K_CONNECTEDCOMPONENTU = 37 + K_CONSTANT = 38 + K_CONTAINING = 39 + K_COUNT = 40 + K_CYCLICPATH = 41 + K_DAY = 42 + K_DATEADD = 43 + K_DATEDIFF = 44 + K_DATETIME = 45 + K_DATETIMEU = 46 + K_DECR = 47 + K_DEDUP = 48 + K_DESC = 49 + K_DIFFERENCE = 50 + K_DIRECTION = 51 + K_DISJUNCT = 52 + K_DISTANCE = 53 + K_DIV = 54 + K_DROP = 55 + K_DT = 56 + K_E = 57 + K_EDGES = 58 + K_ELEMENTMAP = 59 + K_ELEMENT = 60 + K_EMIT = 61 + K_ENDINGWITH = 62 + K_EQ = 63 + K_EXPLAIN = 64 + K_FAIL = 65 + K_FALSE = 66 + K_FILTER = 67 + K_FIRST = 68 + K_FLATMAP = 69 + K_FOLD = 70 + K_FORMAT = 71 + K_FROM = 72 + K_GLOBAL = 73 + K_GT = 74 + K_GTE = 75 + K_GRAPHML = 76 + K_GRAPHSON = 77 + K_GROUPCOUNT = 78 + K_GROUP = 79 + K_GRYO = 80 + K_HAS = 81 + K_HASID = 82 + K_HASKEY = 83 + K_HASLABEL = 84 + K_HASNEXT = 85 + K_HASNOT = 86 + K_HASVALUE = 87 + K_HOUR = 88 + K_ID = 89 + K_IDENTITY = 90 + K_IDS = 91 + K_IN = 92 + K_INU = 93 + K_INE = 94 + K_INCLUDEEDGES = 95 + K_INCR = 96 + K_INDEXER = 97 + K_INDEX = 98 + K_INFINITY = 99 + K_INJECT = 100 + K_INSIDE = 101 + K_INTERSECT = 102 + K_INV = 103 + K_IOU = 104 + K_IO = 105 + K_IS = 106 + K_ITERATE = 107 + K_KEY = 108 + K_KEYS = 109 + K_LABELS = 110 + K_LABEL = 111 + K_LAST = 112 + K_LENGTH = 113 + K_LIMIT = 114 + K_LIST = 115 + K_LOCAL = 116 + K_LOOPS = 117 + K_LT = 118 + K_LTE = 119 + K_LTRIM = 120 + K_MAP = 121 + K_MATCH = 122 + K_MATH = 123 + K_MAX = 124 + K_MAXDISTANCE = 125 + K_MEAN = 126 + K_MERGEU = 127 + K_MERGE = 128 + K_MERGEE = 129 + K_MERGEV = 130 + K_MIN = 131 + K_MINUTE = 132 + K_MINUS = 133 + K_MIXED = 134 + K_MULT = 135 + K_NAN = 136 + K_NEGATE = 137 + K_NEXT = 138 + K_NONE = 139 + K_NOTREGEX = 140 + K_NOTCONTAINING = 141 + K_NOTENDINGWITH = 142 + K_NOTSTARTINGWITH = 143 + K_NOT = 144 + K_NEQ = 145 + K_NEW = 146 + K_NORMSACK = 147 + K_NULL = 148 + K_ONCREATE = 149 + K_ONMATCH = 150 + K_OPERATOR = 151 + K_OPTION = 152 + K_OPTIONAL = 153 + K_ORDERU = 154 + K_ORDER = 155 + K_OR = 156 + K_OTHERV = 157 + K_OUTU = 158 + K_OUT = 159 + K_OUTE = 160 + K_OUTSIDE = 161 + K_OUTV = 162 + K_P = 163 + K_PAGERANKU = 164 + K_PAGERANK = 165 + K_PATH = 166 + K_PEERPRESSUREU = 167 + K_PEERPRESSURE = 168 + K_PICK = 169 + K_POP = 170 + K_PROFILE = 171 + K_PROJECT = 172 + K_PROPERTIES = 173 + K_PROPERTYMAP = 174 + K_PROPERTYNAME = 175 + K_PROPERTY = 176 + K_PRODUCT = 177 + K_RANGE = 178 + K_READ = 179 + K_READER = 180 + K_REFERENCEVERTEX = 181 + K_REGEX = 182 + K_REPLACE = 183 + K_REPEAT = 184 + K_REVERSE = 185 + K_ROLLBACK = 186 + K_RTRIM = 187 + K_SACK = 188 + K_SAMPLE = 189 + K_SCOPE = 190 + K_SECOND = 191 + K_SELECT = 192 + K_SET = 193 + K_SHORTESTPATHU = 194 + K_SHORTESTPATH = 195 + K_SHUFFLE = 196 + K_SIDEEFFECT = 197 + K_SIMPLEPATH = 198 + K_SINGLE = 199 + K_SKIP = 200 + K_SPLIT = 201 + K_STARTINGWITH = 202 + K_STORE = 203 + K_SUBGRAPH = 204 + K_SUBSTRING = 205 + K_SUM = 206 + K_SUMLONG = 207 + K_T = 208 + K_TAIL = 209 + K_TARGET = 210 + K_TEXTP = 211 + K_TIMELIMIT = 212 + K_TIMES = 213 + K_TO = 214 + K_TOBULKSET = 215 + K_TOKENS = 216 + K_TOLIST = 217 + K_TOLOWER = 218 + K_TOSET = 219 + K_TOSTRING = 220 + K_TOUPPER = 221 + K_TOE = 222 + K_TOV = 223 + K_TREE = 224 + K_TRIM = 225 + K_TRUE = 226 + K_TRYNEXT = 227 + K_TX = 228 + K_UNFOLD = 229 + K_UNION = 230 + K_UNTIL = 231 + K_UUID = 232 + K_V = 233 + K_VALUEMAP = 234 + K_VALUES = 235 + K_VALUE = 236 + K_VERTEX = 237 + K_WHERE = 238 + K_WITH = 239 + K_WITHBULK = 240 + K_WITHIN = 241 + K_WITHOPTOPTIONS = 242 + K_WITHOUT = 243 + K_WITHOUTSTRATEGIES = 244 + K_WITHPATH = 245 + K_WITHSACK = 246 + K_WITHSIDEEFFECT = 247 + K_WITHSTRATEGIES = 248 + K_WRITE = 249 + K_WRITER = 250 + IntegerLiteral = 251 + FloatingPointLiteral = 252 + SignedInfLiteral = 253 + NonEmptyStringLiteral = 254 + EmptyStringLiteral = 255 + LPAREN = 256 + RPAREN = 257 + LBRACE = 258 + RBRACE = 259 + LBRACK = 260 + RBRACK = 261 + SEMI = 262 + COMMA = 263 + DOT = 264 + COLON = 265 + TRAVERSAL_ROOT = 266 + ANON_TRAVERSAL_ROOT = 267 + WS = 268 + LINE_COMMENT = 269 + Identifier = 270 + + channelNames = ["DEFAULT_TOKEN_CHANNEL", "HIDDEN"] + + modeNames = ["DEFAULT_MODE"] + + literalNames = [ + "", + "'discard'", + "'addAll'", + "'addE'", + "'addV'", + "'aggregate'", + "'all'", + "'and'", + "'any'", + "'as'", + "'asc'", + "'asDate'", + "'asString'", + "'assign'", + "'barrier'", + "'Barrier'", + "'begin'", + "'between'", + "'both'", + "'BOTH'", + "'bothE'", + "'bothV'", + "'branch'", + "'by'", + "'call'", + "'cap'", + "'Cardinality'", + "'choose'", + "'coalesce'", + "'coin'", + "'Column'", + "'combine'", + "'commit'", + "'component'", + "'concat'", + "'conjoin'", + "'connectedComponent'", + "'ConnectedComponent'", + "'constant'", + "'containing'", + "'count'", + "'cyclicPath'", + "'day'", + "'dateAdd'", + "'dateDiff'", + "'datetime'", + "'DateTime'", + "'decr'", + "'dedup'", + "'desc'", + "'difference'", + "'Direction'", + "'disjunct'", + "'distance'", + "'div'", + "'drop'", + "'DT'", + "'E'", + "'edges'", + "'elementMap'", + "'element'", + "'emit'", + "'endingWith'", + "'eq'", + "'explain'", + "'fail'", + "'false'", + "'filter'", + "'first'", + "'flatMap'", + "'fold'", + "'format'", + "'from'", + "'global'", + "'gt'", + "'gte'", + "'graphml'", + "'graphson'", + "'groupCount'", + "'group'", + "'gryo'", + "'has'", + "'hasId'", + "'hasKey'", + "'hasLabel'", + "'hasNext'", + "'hasNot'", + "'hasValue'", + "'hour'", + "'id'", + "'identity'", + "'ids'", + "'in'", + "'IN'", + "'inE'", + "'includeEdges'", + "'incr'", + "'indexer'", + "'index'", + "'Infinity'", + "'inject'", + "'inside'", + "'intersect'", + "'inV'", + "'IO'", + "'io'", + "'is'", + "'iterate'", + "'key'", + "'keys'", + "'labels'", + "'label'", + "'last'", + "'length'", + "'limit'", + "'list'", + "'local'", + "'loops'", + "'lt'", + "'lte'", + "'lTrim'", + "'map'", + "'match'", + "'math'", + "'max'", + "'maxDistance'", + "'mean'", + "'Merge'", + "'merge'", + "'mergeE'", + "'mergeV'", + "'min'", + "'minute'", + "'minus'", + "'mixed'", + "'mult'", + "'NaN'", + "'negate'", + "'next'", + "'none'", + "'notRegex'", + "'notContaining'", + "'notEndingWith'", + "'notStartingWith'", + "'not'", + "'neq'", + "'new'", + "'normSack'", + "'null'", + "'onCreate'", + "'onMatch'", + "'Operator'", + "'option'", + "'optional'", + "'Order'", + "'order'", + "'or'", + "'otherV'", + "'OUT'", + "'out'", + "'outE'", + "'outside'", + "'outV'", + "'P'", + "'PageRank'", + "'pageRank'", + "'path'", + "'PeerPressure'", + "'peerPressure'", + "'Pick'", + "'Pop'", + "'profile'", + "'project'", + "'properties'", + "'propertyMap'", + "'propertyName'", + "'property'", + "'product'", + "'range'", + "'read'", + "'reader'", + "'ReferenceVertex'", + "'regex'", + "'replace'", + "'repeat'", + "'reverse'", + "'rollback'", + "'rTrim'", + "'sack'", + "'sample'", + "'Scope'", + "'second'", + "'select'", + "'set'", + "'ShortestPath'", + "'shortestPath'", + "'shuffle'", + "'sideEffect'", + "'simplePath'", + "'single'", + "'skip'", + "'split'", + "'startingWith'", + "'store'", + "'subgraph'", + "'substring'", + "'sum'", + "'sumLong'", + "'T'", + "'tail'", + "'target'", + "'TextP'", + "'timeLimit'", + "'times'", + "'to'", + "'toBulkSet'", + "'tokens'", + "'toList'", + "'toLower'", + "'toSet'", + "'toString'", + "'toUpper'", + "'toE'", + "'toV'", + "'tree'", + "'trim'", + "'true'", + "'tryNext'", + "'tx'", + "'unfold'", + "'union'", + "'until'", + "'UUID'", + "'V'", + "'valueMap'", + "'values'", + "'value'", + "'Vertex'", + "'where'", + "'with'", + "'withBulk'", + "'within'", + "'WithOptions'", + "'without'", + "'withoutStrategies'", + "'withPath'", + "'withSack'", + "'withSideEffect'", + "'withStrategies'", + "'write'", + "'writer'", + "'('", + "')'", + "'{'", + "'}'", + "'['", + "']'", + "';'", + "','", + "'.'", + "':'", + "'g'", + "'__'", + ] + + symbolicNames = [ + "", + "K_ADDALL", + "K_ADDE", + "K_ADDV", + "K_AGGREGATE", + "K_ALL", + "K_AND", + "K_ANY", + "K_AS", + "K_ASC", + "K_ASDATE", + "K_ASSTRING", + "K_ASSIGN", + "K_BARRIER", + "K_BARRIERU", + "K_BEGIN", + "K_BETWEEN", + "K_BOTH", + "K_BOTHU", + "K_BOTHE", + "K_BOTHV", + "K_BRANCH", + "K_BY", + "K_CALL", + "K_CAP", + "K_CARDINALITY", + "K_CHOOSE", + "K_COALESCE", + "K_COIN", + "K_COLUMN", + "K_COMBINE", + "K_COMMIT", + "K_COMPONENT", + "K_CONCAT", + "K_CONJOIN", + "K_CONNECTEDCOMPONENT", + "K_CONNECTEDCOMPONENTU", + "K_CONSTANT", + "K_CONTAINING", + "K_COUNT", + "K_CYCLICPATH", + "K_DAY", + "K_DATEADD", + "K_DATEDIFF", + "K_DATETIME", + "K_DATETIMEU", + "K_DECR", + "K_DEDUP", + "K_DESC", + "K_DIFFERENCE", + "K_DIRECTION", + "K_DISJUNCT", + "K_DISTANCE", + "K_DIV", + "K_DROP", + "K_DT", + "K_E", + "K_EDGES", + "K_ELEMENTMAP", + "K_ELEMENT", + "K_EMIT", + "K_ENDINGWITH", + "K_EQ", + "K_EXPLAIN", + "K_FAIL", + "K_FALSE", + "K_FILTER", + "K_FIRST", + "K_FLATMAP", + "K_FOLD", + "K_FORMAT", + "K_FROM", + "K_GLOBAL", + "K_GT", + "K_GTE", + "K_GRAPHML", + "K_GRAPHSON", + "K_GROUPCOUNT", + "K_GROUP", + "K_GRYO", + "K_HAS", + "K_HASID", + "K_HASKEY", + "K_HASLABEL", + "K_HASNEXT", + "K_HASNOT", + "K_HASVALUE", + "K_HOUR", + "K_ID", + "K_IDENTITY", + "K_IDS", + "K_IN", + "K_INU", + "K_INE", + "K_INCLUDEEDGES", + "K_INCR", + "K_INDEXER", + "K_INDEX", + "K_INFINITY", + "K_INJECT", + "K_INSIDE", + "K_INTERSECT", + "K_INV", + "K_IOU", + "K_IO", + "K_IS", + "K_ITERATE", + "K_KEY", + "K_KEYS", + "K_LABELS", + "K_LABEL", + "K_LAST", + "K_LENGTH", + "K_LIMIT", + "K_LIST", + "K_LOCAL", + "K_LOOPS", + "K_LT", + "K_LTE", + "K_LTRIM", + "K_MAP", + "K_MATCH", + "K_MATH", + "K_MAX", + "K_MAXDISTANCE", + "K_MEAN", + "K_MERGEU", + "K_MERGE", + "K_MERGEE", + "K_MERGEV", + "K_MIN", + "K_MINUTE", + "K_MINUS", + "K_MIXED", + "K_MULT", + "K_NAN", + "K_NEGATE", + "K_NEXT", + "K_NONE", + "K_NOTREGEX", + "K_NOTCONTAINING", + "K_NOTENDINGWITH", + "K_NOTSTARTINGWITH", + "K_NOT", + "K_NEQ", + "K_NEW", + "K_NORMSACK", + "K_NULL", + "K_ONCREATE", + "K_ONMATCH", + "K_OPERATOR", + "K_OPTION", + "K_OPTIONAL", + "K_ORDERU", + "K_ORDER", + "K_OR", + "K_OTHERV", + "K_OUTU", + "K_OUT", + "K_OUTE", + "K_OUTSIDE", + "K_OUTV", + "K_P", + "K_PAGERANKU", + "K_PAGERANK", + "K_PATH", + "K_PEERPRESSUREU", + "K_PEERPRESSURE", + "K_PICK", + "K_POP", + "K_PROFILE", + "K_PROJECT", + "K_PROPERTIES", + "K_PROPERTYMAP", + "K_PROPERTYNAME", + "K_PROPERTY", + "K_PRODUCT", + "K_RANGE", + "K_READ", + "K_READER", + "K_REFERENCEVERTEX", + "K_REGEX", + "K_REPLACE", + "K_REPEAT", + "K_REVERSE", + "K_ROLLBACK", + "K_RTRIM", + "K_SACK", + "K_SAMPLE", + "K_SCOPE", + "K_SECOND", + "K_SELECT", + "K_SET", + "K_SHORTESTPATHU", + "K_SHORTESTPATH", + "K_SHUFFLE", + "K_SIDEEFFECT", + "K_SIMPLEPATH", + "K_SINGLE", + "K_SKIP", + "K_SPLIT", + "K_STARTINGWITH", + "K_STORE", + "K_SUBGRAPH", + "K_SUBSTRING", + "K_SUM", + "K_SUMLONG", + "K_T", + "K_TAIL", + "K_TARGET", + "K_TEXTP", + "K_TIMELIMIT", + "K_TIMES", + "K_TO", + "K_TOBULKSET", + "K_TOKENS", + "K_TOLIST", + "K_TOLOWER", + "K_TOSET", + "K_TOSTRING", + "K_TOUPPER", + "K_TOE", + "K_TOV", + "K_TREE", + "K_TRIM", + "K_TRUE", + "K_TRYNEXT", + "K_TX", + "K_UNFOLD", + "K_UNION", + "K_UNTIL", + "K_UUID", + "K_V", + "K_VALUEMAP", + "K_VALUES", + "K_VALUE", + "K_VERTEX", + "K_WHERE", + "K_WITH", + "K_WITHBULK", + "K_WITHIN", + "K_WITHOPTOPTIONS", + "K_WITHOUT", + "K_WITHOUTSTRATEGIES", + "K_WITHPATH", + "K_WITHSACK", + "K_WITHSIDEEFFECT", + "K_WITHSTRATEGIES", + "K_WRITE", + "K_WRITER", + "IntegerLiteral", + "FloatingPointLiteral", + "SignedInfLiteral", + "NonEmptyStringLiteral", + "EmptyStringLiteral", + "LPAREN", + "RPAREN", + "LBRACE", + "RBRACE", + "LBRACK", + "RBRACK", + "SEMI", + "COMMA", + "DOT", + "COLON", + "TRAVERSAL_ROOT", + "ANON_TRAVERSAL_ROOT", + "WS", + "LINE_COMMENT", + "Identifier", + ] + + ruleNames = [ + "T__0", + "K_ADDALL", + "K_ADDE", + "K_ADDV", + "K_AGGREGATE", + "K_ALL", + "K_AND", + "K_ANY", + "K_AS", + "K_ASC", + "K_ASDATE", + "K_ASSTRING", + "K_ASSIGN", + "K_BARRIER", + "K_BARRIERU", + "K_BEGIN", + "K_BETWEEN", + "K_BOTH", + "K_BOTHU", + "K_BOTHE", + "K_BOTHV", + "K_BRANCH", + "K_BY", + "K_CALL", + "K_CAP", + "K_CARDINALITY", + "K_CHOOSE", + "K_COALESCE", + "K_COIN", + "K_COLUMN", + "K_COMBINE", + "K_COMMIT", + "K_COMPONENT", + "K_CONCAT", + "K_CONJOIN", + "K_CONNECTEDCOMPONENT", + "K_CONNECTEDCOMPONENTU", + "K_CONSTANT", + "K_CONTAINING", + "K_COUNT", + "K_CYCLICPATH", + "K_DAY", + "K_DATEADD", + "K_DATEDIFF", + "K_DATETIME", + "K_DATETIMEU", + "K_DECR", + "K_DEDUP", + "K_DESC", + "K_DIFFERENCE", + "K_DIRECTION", + "K_DISJUNCT", + "K_DISTANCE", + "K_DIV", + "K_DROP", + "K_DT", + "K_E", + "K_EDGES", + "K_ELEMENTMAP", + "K_ELEMENT", + "K_EMIT", + "K_ENDINGWITH", + "K_EQ", + "K_EXPLAIN", + "K_FAIL", + "K_FALSE", + "K_FILTER", + "K_FIRST", + "K_FLATMAP", + "K_FOLD", + "K_FORMAT", + "K_FROM", + "K_GLOBAL", + "K_GT", + "K_GTE", + "K_GRAPHML", + "K_GRAPHSON", + "K_GROUPCOUNT", + "K_GROUP", + "K_GRYO", + "K_HAS", + "K_HASID", + "K_HASKEY", + "K_HASLABEL", + "K_HASNEXT", + "K_HASNOT", + "K_HASVALUE", + "K_HOUR", + "K_ID", + "K_IDENTITY", + "K_IDS", + "K_IN", + "K_INU", + "K_INE", + "K_INCLUDEEDGES", + "K_INCR", + "K_INDEXER", + "K_INDEX", + "K_INFINITY", + "K_INJECT", + "K_INSIDE", + "K_INTERSECT", + "K_INV", + "K_IOU", + "K_IO", + "K_IS", + "K_ITERATE", + "K_KEY", + "K_KEYS", + "K_LABELS", + "K_LABEL", + "K_LAST", + "K_LENGTH", + "K_LIMIT", + "K_LIST", + "K_LOCAL", + "K_LOOPS", + "K_LT", + "K_LTE", + "K_LTRIM", + "K_MAP", + "K_MATCH", + "K_MATH", + "K_MAX", + "K_MAXDISTANCE", + "K_MEAN", + "K_MERGEU", + "K_MERGE", + "K_MERGEE", + "K_MERGEV", + "K_MIN", + "K_MINUTE", + "K_MINUS", + "K_MIXED", + "K_MULT", + "K_NAN", + "K_NEGATE", + "K_NEXT", + "K_NONE", + "K_NOTREGEX", + "K_NOTCONTAINING", + "K_NOTENDINGWITH", + "K_NOTSTARTINGWITH", + "K_NOT", + "K_NEQ", + "K_NEW", + "K_NORMSACK", + "K_NULL", + "K_ONCREATE", + "K_ONMATCH", + "K_OPERATOR", + "K_OPTION", + "K_OPTIONAL", + "K_ORDERU", + "K_ORDER", + "K_OR", + "K_OTHERV", + "K_OUTU", + "K_OUT", + "K_OUTE", + "K_OUTSIDE", + "K_OUTV", + "K_P", + "K_PAGERANKU", + "K_PAGERANK", + "K_PATH", + "K_PEERPRESSUREU", + "K_PEERPRESSURE", + "K_PICK", + "K_POP", + "K_PROFILE", + "K_PROJECT", + "K_PROPERTIES", + "K_PROPERTYMAP", + "K_PROPERTYNAME", + "K_PROPERTY", + "K_PRODUCT", + "K_RANGE", + "K_READ", + "K_READER", + "K_REFERENCEVERTEX", + "K_REGEX", + "K_REPLACE", + "K_REPEAT", + "K_REVERSE", + "K_ROLLBACK", + "K_RTRIM", + "K_SACK", + "K_SAMPLE", + "K_SCOPE", + "K_SECOND", + "K_SELECT", + "K_SET", + "K_SHORTESTPATHU", + "K_SHORTESTPATH", + "K_SHUFFLE", + "K_SIDEEFFECT", + "K_SIMPLEPATH", + "K_SINGLE", + "K_SKIP", + "K_SPLIT", + "K_STARTINGWITH", + "K_STORE", + "K_SUBGRAPH", + "K_SUBSTRING", + "K_SUM", + "K_SUMLONG", + "K_T", + "K_TAIL", + "K_TARGET", + "K_TEXTP", + "K_TIMELIMIT", + "K_TIMES", + "K_TO", + "K_TOBULKSET", + "K_TOKENS", + "K_TOLIST", + "K_TOLOWER", + "K_TOSET", + "K_TOSTRING", + "K_TOUPPER", + "K_TOE", + "K_TOV", + "K_TREE", + "K_TRIM", + "K_TRUE", + "K_TRYNEXT", + "K_TX", + "K_UNFOLD", + "K_UNION", + "K_UNTIL", + "K_UUID", + "K_V", + "K_VALUEMAP", + "K_VALUES", + "K_VALUE", + "K_VERTEX", + "K_WHERE", + "K_WITH", + "K_WITHBULK", + "K_WITHIN", + "K_WITHOPTOPTIONS", + "K_WITHOUT", + "K_WITHOUTSTRATEGIES", + "K_WITHPATH", + "K_WITHSACK", + "K_WITHSIDEEFFECT", + "K_WITHSTRATEGIES", + "K_WRITE", + "K_WRITER", + "IntegerLiteral", + "DecimalIntegerLiteral", + "HexIntegerLiteral", + "OctalIntegerLiteral", + "IntegerTypeSuffix", + "DecimalNumeral", + "Digits", + "Digit", + "NonZeroDigit", + "DigitsAndUnderscores", + "DigitOrUnderscore", + "Underscores", + "HexNumeral", + "HexDigits", + "HexDigit", + "HexDigitsAndUnderscores", + "HexDigitOrUnderscore", + "OctalNumeral", + "OctalDigits", + "OctalDigit", + "OctalDigitsAndUnderscores", + "OctalDigitOrUnderscore", + "FloatingPointLiteral", + "DecimalFloatingPointLiteral", + "ExponentPart", + "ExponentIndicator", + "SignedInteger", + "Sign", + "FloatTypeSuffix", + "SignedInfLiteral", + "NonEmptyStringLiteral", + "EmptyStringLiteral", + "DoubleQuotedStringCharacters", + "DoubleQuotedStringCharacter", + "SingleQuotedStringCharacters", + "SingleQuotedStringCharacter", + "JoinLineEscape", + "EscapeSequence", + "OctalEscape", + "ZeroToThree", + "UnicodeEscape", + "LPAREN", + "RPAREN", + "LBRACE", + "RBRACE", + "LBRACK", + "RBRACK", + "SEMI", + "COMMA", + "DOT", + "COLON", + "TRAVERSAL_ROOT", + "ANON_TRAVERSAL_ROOT", + "WS", + "LINE_COMMENT", + "Identifier", + "IdentifierStart", + "IdentifierPart", + ] + + grammarFileName = "Gremlin.g4" + + def __init__(self, input=None, output: TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.13.1") + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._actions = None + self._predicates = None diff --git a/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinLexer.tokens b/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinLexer.tokens new file mode 100644 index 000000000..0b40f3f1c --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinLexer.tokens @@ -0,0 +1,532 @@ +T__0=1 +K_ADDALL=2 +K_ADDE=3 +K_ADDV=4 +K_AGGREGATE=5 +K_ALL=6 +K_AND=7 +K_ANY=8 +K_AS=9 +K_ASC=10 +K_ASDATE=11 +K_ASSTRING=12 +K_ASSIGN=13 +K_BARRIER=14 +K_BARRIERU=15 +K_BEGIN=16 +K_BETWEEN=17 +K_BOTH=18 +K_BOTHU=19 +K_BOTHE=20 +K_BOTHV=21 +K_BRANCH=22 +K_BY=23 +K_CALL=24 +K_CAP=25 +K_CARDINALITY=26 +K_CHOOSE=27 +K_COALESCE=28 +K_COIN=29 +K_COLUMN=30 +K_COMBINE=31 +K_COMMIT=32 +K_COMPONENT=33 +K_CONCAT=34 +K_CONJOIN=35 +K_CONNECTEDCOMPONENT=36 +K_CONNECTEDCOMPONENTU=37 +K_CONSTANT=38 +K_CONTAINING=39 +K_COUNT=40 +K_CYCLICPATH=41 +K_DAY=42 +K_DATEADD=43 +K_DATEDIFF=44 +K_DATETIME=45 +K_DATETIMEU=46 +K_DECR=47 +K_DEDUP=48 +K_DESC=49 +K_DIFFERENCE=50 +K_DIRECTION=51 +K_DISJUNCT=52 +K_DISTANCE=53 +K_DIV=54 +K_DROP=55 +K_DT=56 +K_E=57 +K_EDGES=58 +K_ELEMENTMAP=59 +K_ELEMENT=60 +K_EMIT=61 +K_ENDINGWITH=62 +K_EQ=63 +K_EXPLAIN=64 +K_FAIL=65 +K_FALSE=66 +K_FILTER=67 +K_FIRST=68 +K_FLATMAP=69 +K_FOLD=70 +K_FORMAT=71 +K_FROM=72 +K_GLOBAL=73 +K_GT=74 +K_GTE=75 +K_GRAPHML=76 +K_GRAPHSON=77 +K_GROUPCOUNT=78 +K_GROUP=79 +K_GRYO=80 +K_HAS=81 +K_HASID=82 +K_HASKEY=83 +K_HASLABEL=84 +K_HASNEXT=85 +K_HASNOT=86 +K_HASVALUE=87 +K_HOUR=88 +K_ID=89 +K_IDENTITY=90 +K_IDS=91 +K_IN=92 +K_INU=93 +K_INE=94 +K_INCLUDEEDGES=95 +K_INCR=96 +K_INDEXER=97 +K_INDEX=98 +K_INFINITY=99 +K_INJECT=100 +K_INSIDE=101 +K_INTERSECT=102 +K_INV=103 +K_IOU=104 +K_IO=105 +K_IS=106 +K_ITERATE=107 +K_KEY=108 +K_KEYS=109 +K_LABELS=110 +K_LABEL=111 +K_LAST=112 +K_LENGTH=113 +K_LIMIT=114 +K_LIST=115 +K_LOCAL=116 +K_LOOPS=117 +K_LT=118 +K_LTE=119 +K_LTRIM=120 +K_MAP=121 +K_MATCH=122 +K_MATH=123 +K_MAX=124 +K_MAXDISTANCE=125 +K_MEAN=126 +K_MERGEU=127 +K_MERGE=128 +K_MERGEE=129 +K_MERGEV=130 +K_MIN=131 +K_MINUTE=132 +K_MINUS=133 +K_MIXED=134 +K_MULT=135 +K_NAN=136 +K_NEGATE=137 +K_NEXT=138 +K_NONE=139 +K_NOTREGEX=140 +K_NOTCONTAINING=141 +K_NOTENDINGWITH=142 +K_NOTSTARTINGWITH=143 +K_NOT=144 +K_NEQ=145 +K_NEW=146 +K_NORMSACK=147 +K_NULL=148 +K_ONCREATE=149 +K_ONMATCH=150 +K_OPERATOR=151 +K_OPTION=152 +K_OPTIONAL=153 +K_ORDERU=154 +K_ORDER=155 +K_OR=156 +K_OTHERV=157 +K_OUTU=158 +K_OUT=159 +K_OUTE=160 +K_OUTSIDE=161 +K_OUTV=162 +K_P=163 +K_PAGERANKU=164 +K_PAGERANK=165 +K_PATH=166 +K_PEERPRESSUREU=167 +K_PEERPRESSURE=168 +K_PICK=169 +K_POP=170 +K_PROFILE=171 +K_PROJECT=172 +K_PROPERTIES=173 +K_PROPERTYMAP=174 +K_PROPERTYNAME=175 +K_PROPERTY=176 +K_PRODUCT=177 +K_RANGE=178 +K_READ=179 +K_READER=180 +K_REFERENCEVERTEX=181 +K_REGEX=182 +K_REPLACE=183 +K_REPEAT=184 +K_REVERSE=185 +K_ROLLBACK=186 +K_RTRIM=187 +K_SACK=188 +K_SAMPLE=189 +K_SCOPE=190 +K_SECOND=191 +K_SELECT=192 +K_SET=193 +K_SHORTESTPATHU=194 +K_SHORTESTPATH=195 +K_SHUFFLE=196 +K_SIDEEFFECT=197 +K_SIMPLEPATH=198 +K_SINGLE=199 +K_SKIP=200 +K_SPLIT=201 +K_STARTINGWITH=202 +K_STORE=203 +K_SUBGRAPH=204 +K_SUBSTRING=205 +K_SUM=206 +K_SUMLONG=207 +K_T=208 +K_TAIL=209 +K_TARGET=210 +K_TEXTP=211 +K_TIMELIMIT=212 +K_TIMES=213 +K_TO=214 +K_TOBULKSET=215 +K_TOKENS=216 +K_TOLIST=217 +K_TOLOWER=218 +K_TOSET=219 +K_TOSTRING=220 +K_TOUPPER=221 +K_TOE=222 +K_TOV=223 +K_TREE=224 +K_TRIM=225 +K_TRUE=226 +K_TRYNEXT=227 +K_TX=228 +K_UNFOLD=229 +K_UNION=230 +K_UNTIL=231 +K_UUID=232 +K_V=233 +K_VALUEMAP=234 +K_VALUES=235 +K_VALUE=236 +K_VERTEX=237 +K_WHERE=238 +K_WITH=239 +K_WITHBULK=240 +K_WITHIN=241 +K_WITHOPTOPTIONS=242 +K_WITHOUT=243 +K_WITHOUTSTRATEGIES=244 +K_WITHPATH=245 +K_WITHSACK=246 +K_WITHSIDEEFFECT=247 +K_WITHSTRATEGIES=248 +K_WRITE=249 +K_WRITER=250 +IntegerLiteral=251 +FloatingPointLiteral=252 +SignedInfLiteral=253 +NonEmptyStringLiteral=254 +EmptyStringLiteral=255 +LPAREN=256 +RPAREN=257 +LBRACE=258 +RBRACE=259 +LBRACK=260 +RBRACK=261 +SEMI=262 +COMMA=263 +DOT=264 +COLON=265 +TRAVERSAL_ROOT=266 +ANON_TRAVERSAL_ROOT=267 +WS=268 +LINE_COMMENT=269 +Identifier=270 +'discard'=1 +'addAll'=2 +'addE'=3 +'addV'=4 +'aggregate'=5 +'all'=6 +'and'=7 +'any'=8 +'as'=9 +'asc'=10 +'asDate'=11 +'asString'=12 +'assign'=13 +'barrier'=14 +'Barrier'=15 +'begin'=16 +'between'=17 +'both'=18 +'BOTH'=19 +'bothE'=20 +'bothV'=21 +'branch'=22 +'by'=23 +'call'=24 +'cap'=25 +'Cardinality'=26 +'choose'=27 +'coalesce'=28 +'coin'=29 +'Column'=30 +'combine'=31 +'commit'=32 +'component'=33 +'concat'=34 +'conjoin'=35 +'connectedComponent'=36 +'ConnectedComponent'=37 +'constant'=38 +'containing'=39 +'count'=40 +'cyclicPath'=41 +'day'=42 +'dateAdd'=43 +'dateDiff'=44 +'datetime'=45 +'DateTime'=46 +'decr'=47 +'dedup'=48 +'desc'=49 +'difference'=50 +'Direction'=51 +'disjunct'=52 +'distance'=53 +'div'=54 +'drop'=55 +'DT'=56 +'E'=57 +'edges'=58 +'elementMap'=59 +'element'=60 +'emit'=61 +'endingWith'=62 +'eq'=63 +'explain'=64 +'fail'=65 +'false'=66 +'filter'=67 +'first'=68 +'flatMap'=69 +'fold'=70 +'format'=71 +'from'=72 +'global'=73 +'gt'=74 +'gte'=75 +'graphml'=76 +'graphson'=77 +'groupCount'=78 +'group'=79 +'gryo'=80 +'has'=81 +'hasId'=82 +'hasKey'=83 +'hasLabel'=84 +'hasNext'=85 +'hasNot'=86 +'hasValue'=87 +'hour'=88 +'id'=89 +'identity'=90 +'ids'=91 +'in'=92 +'IN'=93 +'inE'=94 +'includeEdges'=95 +'incr'=96 +'indexer'=97 +'index'=98 +'Infinity'=99 +'inject'=100 +'inside'=101 +'intersect'=102 +'inV'=103 +'IO'=104 +'io'=105 +'is'=106 +'iterate'=107 +'key'=108 +'keys'=109 +'labels'=110 +'label'=111 +'last'=112 +'length'=113 +'limit'=114 +'list'=115 +'local'=116 +'loops'=117 +'lt'=118 +'lte'=119 +'lTrim'=120 +'map'=121 +'match'=122 +'math'=123 +'max'=124 +'maxDistance'=125 +'mean'=126 +'Merge'=127 +'merge'=128 +'mergeE'=129 +'mergeV'=130 +'min'=131 +'minute'=132 +'minus'=133 +'mixed'=134 +'mult'=135 +'NaN'=136 +'negate'=137 +'next'=138 +'none'=139 +'notRegex'=140 +'notContaining'=141 +'notEndingWith'=142 +'notStartingWith'=143 +'not'=144 +'neq'=145 +'new'=146 +'normSack'=147 +'null'=148 +'onCreate'=149 +'onMatch'=150 +'Operator'=151 +'option'=152 +'optional'=153 +'Order'=154 +'order'=155 +'or'=156 +'otherV'=157 +'OUT'=158 +'out'=159 +'outE'=160 +'outside'=161 +'outV'=162 +'P'=163 +'PageRank'=164 +'pageRank'=165 +'path'=166 +'PeerPressure'=167 +'peerPressure'=168 +'Pick'=169 +'Pop'=170 +'profile'=171 +'project'=172 +'properties'=173 +'propertyMap'=174 +'propertyName'=175 +'property'=176 +'product'=177 +'range'=178 +'read'=179 +'reader'=180 +'ReferenceVertex'=181 +'regex'=182 +'replace'=183 +'repeat'=184 +'reverse'=185 +'rollback'=186 +'rTrim'=187 +'sack'=188 +'sample'=189 +'Scope'=190 +'second'=191 +'select'=192 +'set'=193 +'ShortestPath'=194 +'shortestPath'=195 +'shuffle'=196 +'sideEffect'=197 +'simplePath'=198 +'single'=199 +'skip'=200 +'split'=201 +'startingWith'=202 +'store'=203 +'subgraph'=204 +'substring'=205 +'sum'=206 +'sumLong'=207 +'T'=208 +'tail'=209 +'target'=210 +'TextP'=211 +'timeLimit'=212 +'times'=213 +'to'=214 +'toBulkSet'=215 +'tokens'=216 +'toList'=217 +'toLower'=218 +'toSet'=219 +'toString'=220 +'toUpper'=221 +'toE'=222 +'toV'=223 +'tree'=224 +'trim'=225 +'true'=226 +'tryNext'=227 +'tx'=228 +'unfold'=229 +'union'=230 +'until'=231 +'UUID'=232 +'V'=233 +'valueMap'=234 +'values'=235 +'value'=236 +'Vertex'=237 +'where'=238 +'with'=239 +'withBulk'=240 +'within'=241 +'WithOptions'=242 +'without'=243 +'withoutStrategies'=244 +'withPath'=245 +'withSack'=246 +'withSideEffect'=247 +'withStrategies'=248 +'write'=249 +'writer'=250 +'('=256 +')'=257 +'{'=258 +'}'=259 +'['=260 +']'=261 +';'=262 +','=263 +'.'=264 +':'=265 +'g'=266 +'__'=267 diff --git a/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinListener.py b/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinListener.py new file mode 100644 index 000000000..69902cd42 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinListener.py @@ -0,0 +1,3523 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +# Generated from ./Gremlin.g4 by ANTLR 4.13.1 +from antlr4 import * + +if "." in __name__: + from .GremlinParser import GremlinParser +else: + from GremlinParser import GremlinParser + + +# This class defines a complete listener for a parse tree produced by GremlinParser. +class GremlinListener(ParseTreeListener): + # Enter a parse tree produced by GremlinParser#queryList. + def enterQueryList(self, ctx: GremlinParser.QueryListContext): + pass + + # Exit a parse tree produced by GremlinParser#queryList. + def exitQueryList(self, ctx: GremlinParser.QueryListContext): + pass + + # Enter a parse tree produced by GremlinParser#query. + def enterQuery(self, ctx: GremlinParser.QueryContext): + pass + + # Exit a parse tree produced by GremlinParser#query. + def exitQuery(self, ctx: GremlinParser.QueryContext): + pass + + # Enter a parse tree produced by GremlinParser#emptyQuery. + def enterEmptyQuery(self, ctx: GremlinParser.EmptyQueryContext): + pass + + # Exit a parse tree produced by GremlinParser#emptyQuery. + def exitEmptyQuery(self, ctx: GremlinParser.EmptyQueryContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalSource. + def enterTraversalSource(self, ctx: GremlinParser.TraversalSourceContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalSource. + def exitTraversalSource(self, ctx: GremlinParser.TraversalSourceContext): + pass + + # Enter a parse tree produced by GremlinParser#transactionPart. + def enterTransactionPart(self, ctx: GremlinParser.TransactionPartContext): + pass + + # Exit a parse tree produced by GremlinParser#transactionPart. + def exitTransactionPart(self, ctx: GremlinParser.TransactionPartContext): + pass + + # Enter a parse tree produced by GremlinParser#rootTraversal. + def enterRootTraversal(self, ctx: GremlinParser.RootTraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#rootTraversal. + def exitRootTraversal(self, ctx: GremlinParser.RootTraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSelfMethod. + def enterTraversalSourceSelfMethod(self, ctx: GremlinParser.TraversalSourceSelfMethodContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSelfMethod. + def exitTraversalSourceSelfMethod(self, ctx: GremlinParser.TraversalSourceSelfMethodContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSelfMethod_withBulk. + def enterTraversalSourceSelfMethod_withBulk(self, ctx: GremlinParser.TraversalSourceSelfMethod_withBulkContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSelfMethod_withBulk. + def exitTraversalSourceSelfMethod_withBulk(self, ctx: GremlinParser.TraversalSourceSelfMethod_withBulkContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSelfMethod_withPath. + def enterTraversalSourceSelfMethod_withPath(self, ctx: GremlinParser.TraversalSourceSelfMethod_withPathContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSelfMethod_withPath. + def exitTraversalSourceSelfMethod_withPath(self, ctx: GremlinParser.TraversalSourceSelfMethod_withPathContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSelfMethod_withSack. + def enterTraversalSourceSelfMethod_withSack(self, ctx: GremlinParser.TraversalSourceSelfMethod_withSackContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSelfMethod_withSack. + def exitTraversalSourceSelfMethod_withSack(self, ctx: GremlinParser.TraversalSourceSelfMethod_withSackContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSelfMethod_withSideEffect. + def enterTraversalSourceSelfMethod_withSideEffect( + self, ctx: GremlinParser.TraversalSourceSelfMethod_withSideEffectContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSelfMethod_withSideEffect. + def exitTraversalSourceSelfMethod_withSideEffect( + self, ctx: GremlinParser.TraversalSourceSelfMethod_withSideEffectContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSelfMethod_withStrategies. + def enterTraversalSourceSelfMethod_withStrategies( + self, ctx: GremlinParser.TraversalSourceSelfMethod_withStrategiesContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSelfMethod_withStrategies. + def exitTraversalSourceSelfMethod_withStrategies( + self, ctx: GremlinParser.TraversalSourceSelfMethod_withStrategiesContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSelfMethod_withoutStrategies. + def enterTraversalSourceSelfMethod_withoutStrategies( + self, ctx: GremlinParser.TraversalSourceSelfMethod_withoutStrategiesContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSelfMethod_withoutStrategies. + def exitTraversalSourceSelfMethod_withoutStrategies( + self, ctx: GremlinParser.TraversalSourceSelfMethod_withoutStrategiesContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSelfMethod_with. + def enterTraversalSourceSelfMethod_with(self, ctx: GremlinParser.TraversalSourceSelfMethod_withContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSelfMethod_with. + def exitTraversalSourceSelfMethod_with(self, ctx: GremlinParser.TraversalSourceSelfMethod_withContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod. + def enterTraversalSourceSpawnMethod(self, ctx: GremlinParser.TraversalSourceSpawnMethodContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod. + def exitTraversalSourceSpawnMethod(self, ctx: GremlinParser.TraversalSourceSpawnMethodContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_addE. + def enterTraversalSourceSpawnMethod_addE(self, ctx: GremlinParser.TraversalSourceSpawnMethod_addEContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_addE. + def exitTraversalSourceSpawnMethod_addE(self, ctx: GremlinParser.TraversalSourceSpawnMethod_addEContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_addV. + def enterTraversalSourceSpawnMethod_addV(self, ctx: GremlinParser.TraversalSourceSpawnMethod_addVContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_addV. + def exitTraversalSourceSpawnMethod_addV(self, ctx: GremlinParser.TraversalSourceSpawnMethod_addVContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_E. + def enterTraversalSourceSpawnMethod_E(self, ctx: GremlinParser.TraversalSourceSpawnMethod_EContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_E. + def exitTraversalSourceSpawnMethod_E(self, ctx: GremlinParser.TraversalSourceSpawnMethod_EContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_V. + def enterTraversalSourceSpawnMethod_V(self, ctx: GremlinParser.TraversalSourceSpawnMethod_VContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_V. + def exitTraversalSourceSpawnMethod_V(self, ctx: GremlinParser.TraversalSourceSpawnMethod_VContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_inject. + def enterTraversalSourceSpawnMethod_inject(self, ctx: GremlinParser.TraversalSourceSpawnMethod_injectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_inject. + def exitTraversalSourceSpawnMethod_inject(self, ctx: GremlinParser.TraversalSourceSpawnMethod_injectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_io. + def enterTraversalSourceSpawnMethod_io(self, ctx: GremlinParser.TraversalSourceSpawnMethod_ioContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_io. + def exitTraversalSourceSpawnMethod_io(self, ctx: GremlinParser.TraversalSourceSpawnMethod_ioContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_mergeV_Map. + def enterTraversalSourceSpawnMethod_mergeV_Map( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_mergeV_MapContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_mergeV_Map. + def exitTraversalSourceSpawnMethod_mergeV_Map( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_mergeV_MapContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_mergeV_Traversal. + def enterTraversalSourceSpawnMethod_mergeV_Traversal( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_mergeV_TraversalContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_mergeV_Traversal. + def exitTraversalSourceSpawnMethod_mergeV_Traversal( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_mergeV_TraversalContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_mergeE_Map. + def enterTraversalSourceSpawnMethod_mergeE_Map( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_mergeE_MapContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_mergeE_Map. + def exitTraversalSourceSpawnMethod_mergeE_Map( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_mergeE_MapContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_mergeE_Traversal. + def enterTraversalSourceSpawnMethod_mergeE_Traversal( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_mergeE_TraversalContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_mergeE_Traversal. + def exitTraversalSourceSpawnMethod_mergeE_Traversal( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_mergeE_TraversalContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_call_empty. + def enterTraversalSourceSpawnMethod_call_empty( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_emptyContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_call_empty. + def exitTraversalSourceSpawnMethod_call_empty( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_emptyContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_call_string. + def enterTraversalSourceSpawnMethod_call_string( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_stringContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_call_string. + def exitTraversalSourceSpawnMethod_call_string( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_stringContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_call_string_map. + def enterTraversalSourceSpawnMethod_call_string_map( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_string_mapContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_call_string_map. + def exitTraversalSourceSpawnMethod_call_string_map( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_string_mapContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_call_string_traversal. + def enterTraversalSourceSpawnMethod_call_string_traversal( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_string_traversalContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_call_string_traversal. + def exitTraversalSourceSpawnMethod_call_string_traversal( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_string_traversalContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_call_string_map_traversal. + def enterTraversalSourceSpawnMethod_call_string_map_traversal( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_string_map_traversalContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_call_string_map_traversal. + def exitTraversalSourceSpawnMethod_call_string_map_traversal( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_string_map_traversalContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalSourceSpawnMethod_union. + def enterTraversalSourceSpawnMethod_union(self, ctx: GremlinParser.TraversalSourceSpawnMethod_unionContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_union. + def exitTraversalSourceSpawnMethod_union(self, ctx: GremlinParser.TraversalSourceSpawnMethod_unionContext): + pass + + # Enter a parse tree produced by GremlinParser#chainedTraversal. + def enterChainedTraversal(self, ctx: GremlinParser.ChainedTraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#chainedTraversal. + def exitChainedTraversal(self, ctx: GremlinParser.ChainedTraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#nestedTraversal. + def enterNestedTraversal(self, ctx: GremlinParser.NestedTraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#nestedTraversal. + def exitNestedTraversal(self, ctx: GremlinParser.NestedTraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#terminatedTraversal. + def enterTerminatedTraversal(self, ctx: GremlinParser.TerminatedTraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#terminatedTraversal. + def exitTerminatedTraversal(self, ctx: GremlinParser.TerminatedTraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod. + def enterTraversalMethod(self, ctx: GremlinParser.TraversalMethodContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod. + def exitTraversalMethod(self, ctx: GremlinParser.TraversalMethodContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_V. + def enterTraversalMethod_V(self, ctx: GremlinParser.TraversalMethod_VContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_V. + def exitTraversalMethod_V(self, ctx: GremlinParser.TraversalMethod_VContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_E. + def enterTraversalMethod_E(self, ctx: GremlinParser.TraversalMethod_EContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_E. + def exitTraversalMethod_E(self, ctx: GremlinParser.TraversalMethod_EContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_addE_String. + def enterTraversalMethod_addE_String(self, ctx: GremlinParser.TraversalMethod_addE_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_addE_String. + def exitTraversalMethod_addE_String(self, ctx: GremlinParser.TraversalMethod_addE_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_addE_Traversal. + def enterTraversalMethod_addE_Traversal(self, ctx: GremlinParser.TraversalMethod_addE_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_addE_Traversal. + def exitTraversalMethod_addE_Traversal(self, ctx: GremlinParser.TraversalMethod_addE_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_addV_Empty. + def enterTraversalMethod_addV_Empty(self, ctx: GremlinParser.TraversalMethod_addV_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_addV_Empty. + def exitTraversalMethod_addV_Empty(self, ctx: GremlinParser.TraversalMethod_addV_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_addV_String. + def enterTraversalMethod_addV_String(self, ctx: GremlinParser.TraversalMethod_addV_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_addV_String. + def exitTraversalMethod_addV_String(self, ctx: GremlinParser.TraversalMethod_addV_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_addV_Traversal. + def enterTraversalMethod_addV_Traversal(self, ctx: GremlinParser.TraversalMethod_addV_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_addV_Traversal. + def exitTraversalMethod_addV_Traversal(self, ctx: GremlinParser.TraversalMethod_addV_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_aggregate_Scope_String. + def enterTraversalMethod_aggregate_Scope_String( + self, ctx: GremlinParser.TraversalMethod_aggregate_Scope_StringContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_aggregate_Scope_String. + def exitTraversalMethod_aggregate_Scope_String( + self, ctx: GremlinParser.TraversalMethod_aggregate_Scope_StringContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_aggregate_String. + def enterTraversalMethod_aggregate_String(self, ctx: GremlinParser.TraversalMethod_aggregate_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_aggregate_String. + def exitTraversalMethod_aggregate_String(self, ctx: GremlinParser.TraversalMethod_aggregate_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_all_P. + def enterTraversalMethod_all_P(self, ctx: GremlinParser.TraversalMethod_all_PContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_all_P. + def exitTraversalMethod_all_P(self, ctx: GremlinParser.TraversalMethod_all_PContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_and. + def enterTraversalMethod_and(self, ctx: GremlinParser.TraversalMethod_andContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_and. + def exitTraversalMethod_and(self, ctx: GremlinParser.TraversalMethod_andContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_any_P. + def enterTraversalMethod_any_P(self, ctx: GremlinParser.TraversalMethod_any_PContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_any_P. + def exitTraversalMethod_any_P(self, ctx: GremlinParser.TraversalMethod_any_PContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_as. + def enterTraversalMethod_as(self, ctx: GremlinParser.TraversalMethod_asContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_as. + def exitTraversalMethod_as(self, ctx: GremlinParser.TraversalMethod_asContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_asDate. + def enterTraversalMethod_asDate(self, ctx: GremlinParser.TraversalMethod_asDateContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_asDate. + def exitTraversalMethod_asDate(self, ctx: GremlinParser.TraversalMethod_asDateContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_asString_Empty. + def enterTraversalMethod_asString_Empty(self, ctx: GremlinParser.TraversalMethod_asString_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_asString_Empty. + def exitTraversalMethod_asString_Empty(self, ctx: GremlinParser.TraversalMethod_asString_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_asString_Scope. + def enterTraversalMethod_asString_Scope(self, ctx: GremlinParser.TraversalMethod_asString_ScopeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_asString_Scope. + def exitTraversalMethod_asString_Scope(self, ctx: GremlinParser.TraversalMethod_asString_ScopeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_barrier_Consumer. + def enterTraversalMethod_barrier_Consumer(self, ctx: GremlinParser.TraversalMethod_barrier_ConsumerContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_barrier_Consumer. + def exitTraversalMethod_barrier_Consumer(self, ctx: GremlinParser.TraversalMethod_barrier_ConsumerContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_barrier_Empty. + def enterTraversalMethod_barrier_Empty(self, ctx: GremlinParser.TraversalMethod_barrier_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_barrier_Empty. + def exitTraversalMethod_barrier_Empty(self, ctx: GremlinParser.TraversalMethod_barrier_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_barrier_int. + def enterTraversalMethod_barrier_int(self, ctx: GremlinParser.TraversalMethod_barrier_intContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_barrier_int. + def exitTraversalMethod_barrier_int(self, ctx: GremlinParser.TraversalMethod_barrier_intContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_both. + def enterTraversalMethod_both(self, ctx: GremlinParser.TraversalMethod_bothContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_both. + def exitTraversalMethod_both(self, ctx: GremlinParser.TraversalMethod_bothContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_bothE. + def enterTraversalMethod_bothE(self, ctx: GremlinParser.TraversalMethod_bothEContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_bothE. + def exitTraversalMethod_bothE(self, ctx: GremlinParser.TraversalMethod_bothEContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_bothV. + def enterTraversalMethod_bothV(self, ctx: GremlinParser.TraversalMethod_bothVContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_bothV. + def exitTraversalMethod_bothV(self, ctx: GremlinParser.TraversalMethod_bothVContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_branch. + def enterTraversalMethod_branch(self, ctx: GremlinParser.TraversalMethod_branchContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_branch. + def exitTraversalMethod_branch(self, ctx: GremlinParser.TraversalMethod_branchContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_by_Comparator. + def enterTraversalMethod_by_Comparator(self, ctx: GremlinParser.TraversalMethod_by_ComparatorContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_by_Comparator. + def exitTraversalMethod_by_Comparator(self, ctx: GremlinParser.TraversalMethod_by_ComparatorContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_by_Empty. + def enterTraversalMethod_by_Empty(self, ctx: GremlinParser.TraversalMethod_by_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_by_Empty. + def exitTraversalMethod_by_Empty(self, ctx: GremlinParser.TraversalMethod_by_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_by_Function. + def enterTraversalMethod_by_Function(self, ctx: GremlinParser.TraversalMethod_by_FunctionContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_by_Function. + def exitTraversalMethod_by_Function(self, ctx: GremlinParser.TraversalMethod_by_FunctionContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_by_Function_Comparator. + def enterTraversalMethod_by_Function_Comparator( + self, ctx: GremlinParser.TraversalMethod_by_Function_ComparatorContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_by_Function_Comparator. + def exitTraversalMethod_by_Function_Comparator( + self, ctx: GremlinParser.TraversalMethod_by_Function_ComparatorContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_by_Order. + def enterTraversalMethod_by_Order(self, ctx: GremlinParser.TraversalMethod_by_OrderContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_by_Order. + def exitTraversalMethod_by_Order(self, ctx: GremlinParser.TraversalMethod_by_OrderContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_by_String. + def enterTraversalMethod_by_String(self, ctx: GremlinParser.TraversalMethod_by_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_by_String. + def exitTraversalMethod_by_String(self, ctx: GremlinParser.TraversalMethod_by_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_by_String_Comparator. + def enterTraversalMethod_by_String_Comparator(self, ctx: GremlinParser.TraversalMethod_by_String_ComparatorContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_by_String_Comparator. + def exitTraversalMethod_by_String_Comparator(self, ctx: GremlinParser.TraversalMethod_by_String_ComparatorContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_by_T. + def enterTraversalMethod_by_T(self, ctx: GremlinParser.TraversalMethod_by_TContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_by_T. + def exitTraversalMethod_by_T(self, ctx: GremlinParser.TraversalMethod_by_TContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_by_Traversal. + def enterTraversalMethod_by_Traversal(self, ctx: GremlinParser.TraversalMethod_by_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_by_Traversal. + def exitTraversalMethod_by_Traversal(self, ctx: GremlinParser.TraversalMethod_by_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_by_Traversal_Comparator. + def enterTraversalMethod_by_Traversal_Comparator( + self, ctx: GremlinParser.TraversalMethod_by_Traversal_ComparatorContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_by_Traversal_Comparator. + def exitTraversalMethod_by_Traversal_Comparator( + self, ctx: GremlinParser.TraversalMethod_by_Traversal_ComparatorContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_call_string. + def enterTraversalMethod_call_string(self, ctx: GremlinParser.TraversalMethod_call_stringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_call_string. + def exitTraversalMethod_call_string(self, ctx: GremlinParser.TraversalMethod_call_stringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_call_string_map. + def enterTraversalMethod_call_string_map(self, ctx: GremlinParser.TraversalMethod_call_string_mapContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_call_string_map. + def exitTraversalMethod_call_string_map(self, ctx: GremlinParser.TraversalMethod_call_string_mapContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_call_string_traversal. + def enterTraversalMethod_call_string_traversal( + self, ctx: GremlinParser.TraversalMethod_call_string_traversalContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_call_string_traversal. + def exitTraversalMethod_call_string_traversal( + self, ctx: GremlinParser.TraversalMethod_call_string_traversalContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_call_string_map_traversal. + def enterTraversalMethod_call_string_map_traversal( + self, ctx: GremlinParser.TraversalMethod_call_string_map_traversalContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_call_string_map_traversal. + def exitTraversalMethod_call_string_map_traversal( + self, ctx: GremlinParser.TraversalMethod_call_string_map_traversalContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_cap. + def enterTraversalMethod_cap(self, ctx: GremlinParser.TraversalMethod_capContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_cap. + def exitTraversalMethod_cap(self, ctx: GremlinParser.TraversalMethod_capContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_choose_Function. + def enterTraversalMethod_choose_Function(self, ctx: GremlinParser.TraversalMethod_choose_FunctionContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_choose_Function. + def exitTraversalMethod_choose_Function(self, ctx: GremlinParser.TraversalMethod_choose_FunctionContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_choose_Predicate_Traversal. + def enterTraversalMethod_choose_Predicate_Traversal( + self, ctx: GremlinParser.TraversalMethod_choose_Predicate_TraversalContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_choose_Predicate_Traversal. + def exitTraversalMethod_choose_Predicate_Traversal( + self, ctx: GremlinParser.TraversalMethod_choose_Predicate_TraversalContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_choose_Predicate_Traversal_Traversal. + def enterTraversalMethod_choose_Predicate_Traversal_Traversal( + self, ctx: GremlinParser.TraversalMethod_choose_Predicate_Traversal_TraversalContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_choose_Predicate_Traversal_Traversal. + def exitTraversalMethod_choose_Predicate_Traversal_Traversal( + self, ctx: GremlinParser.TraversalMethod_choose_Predicate_Traversal_TraversalContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_choose_Traversal. + def enterTraversalMethod_choose_Traversal(self, ctx: GremlinParser.TraversalMethod_choose_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_choose_Traversal. + def exitTraversalMethod_choose_Traversal(self, ctx: GremlinParser.TraversalMethod_choose_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_choose_Traversal_Traversal. + def enterTraversalMethod_choose_Traversal_Traversal( + self, ctx: GremlinParser.TraversalMethod_choose_Traversal_TraversalContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_choose_Traversal_Traversal. + def exitTraversalMethod_choose_Traversal_Traversal( + self, ctx: GremlinParser.TraversalMethod_choose_Traversal_TraversalContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_choose_Traversal_Traversal_Traversal. + def enterTraversalMethod_choose_Traversal_Traversal_Traversal( + self, ctx: GremlinParser.TraversalMethod_choose_Traversal_Traversal_TraversalContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_choose_Traversal_Traversal_Traversal. + def exitTraversalMethod_choose_Traversal_Traversal_Traversal( + self, ctx: GremlinParser.TraversalMethod_choose_Traversal_Traversal_TraversalContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_coalesce. + def enterTraversalMethod_coalesce(self, ctx: GremlinParser.TraversalMethod_coalesceContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_coalesce. + def exitTraversalMethod_coalesce(self, ctx: GremlinParser.TraversalMethod_coalesceContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_coin. + def enterTraversalMethod_coin(self, ctx: GremlinParser.TraversalMethod_coinContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_coin. + def exitTraversalMethod_coin(self, ctx: GremlinParser.TraversalMethod_coinContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_combine_Object. + def enterTraversalMethod_combine_Object(self, ctx: GremlinParser.TraversalMethod_combine_ObjectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_combine_Object. + def exitTraversalMethod_combine_Object(self, ctx: GremlinParser.TraversalMethod_combine_ObjectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_concat_Traversal_Traversal. + def enterTraversalMethod_concat_Traversal_Traversal( + self, ctx: GremlinParser.TraversalMethod_concat_Traversal_TraversalContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_concat_Traversal_Traversal. + def exitTraversalMethod_concat_Traversal_Traversal( + self, ctx: GremlinParser.TraversalMethod_concat_Traversal_TraversalContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_concat_String. + def enterTraversalMethod_concat_String(self, ctx: GremlinParser.TraversalMethod_concat_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_concat_String. + def exitTraversalMethod_concat_String(self, ctx: GremlinParser.TraversalMethod_concat_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_conjoin_String. + def enterTraversalMethod_conjoin_String(self, ctx: GremlinParser.TraversalMethod_conjoin_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_conjoin_String. + def exitTraversalMethod_conjoin_String(self, ctx: GremlinParser.TraversalMethod_conjoin_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_connectedComponent. + def enterTraversalMethod_connectedComponent(self, ctx: GremlinParser.TraversalMethod_connectedComponentContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_connectedComponent. + def exitTraversalMethod_connectedComponent(self, ctx: GremlinParser.TraversalMethod_connectedComponentContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_constant. + def enterTraversalMethod_constant(self, ctx: GremlinParser.TraversalMethod_constantContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_constant. + def exitTraversalMethod_constant(self, ctx: GremlinParser.TraversalMethod_constantContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_count_Empty. + def enterTraversalMethod_count_Empty(self, ctx: GremlinParser.TraversalMethod_count_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_count_Empty. + def exitTraversalMethod_count_Empty(self, ctx: GremlinParser.TraversalMethod_count_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_count_Scope. + def enterTraversalMethod_count_Scope(self, ctx: GremlinParser.TraversalMethod_count_ScopeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_count_Scope. + def exitTraversalMethod_count_Scope(self, ctx: GremlinParser.TraversalMethod_count_ScopeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_cyclicPath. + def enterTraversalMethod_cyclicPath(self, ctx: GremlinParser.TraversalMethod_cyclicPathContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_cyclicPath. + def exitTraversalMethod_cyclicPath(self, ctx: GremlinParser.TraversalMethod_cyclicPathContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_dateAdd. + def enterTraversalMethod_dateAdd(self, ctx: GremlinParser.TraversalMethod_dateAddContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_dateAdd. + def exitTraversalMethod_dateAdd(self, ctx: GremlinParser.TraversalMethod_dateAddContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_dateDiff_Traversal. + def enterTraversalMethod_dateDiff_Traversal(self, ctx: GremlinParser.TraversalMethod_dateDiff_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_dateDiff_Traversal. + def exitTraversalMethod_dateDiff_Traversal(self, ctx: GremlinParser.TraversalMethod_dateDiff_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_dateDiff_Date. + def enterTraversalMethod_dateDiff_Date(self, ctx: GremlinParser.TraversalMethod_dateDiff_DateContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_dateDiff_Date. + def exitTraversalMethod_dateDiff_Date(self, ctx: GremlinParser.TraversalMethod_dateDiff_DateContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_dedup_Scope_String. + def enterTraversalMethod_dedup_Scope_String(self, ctx: GremlinParser.TraversalMethod_dedup_Scope_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_dedup_Scope_String. + def exitTraversalMethod_dedup_Scope_String(self, ctx: GremlinParser.TraversalMethod_dedup_Scope_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_dedup_String. + def enterTraversalMethod_dedup_String(self, ctx: GremlinParser.TraversalMethod_dedup_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_dedup_String. + def exitTraversalMethod_dedup_String(self, ctx: GremlinParser.TraversalMethod_dedup_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_difference_Object. + def enterTraversalMethod_difference_Object(self, ctx: GremlinParser.TraversalMethod_difference_ObjectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_difference_Object. + def exitTraversalMethod_difference_Object(self, ctx: GremlinParser.TraversalMethod_difference_ObjectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_discard. + def enterTraversalMethod_discard(self, ctx: GremlinParser.TraversalMethod_discardContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_discard. + def exitTraversalMethod_discard(self, ctx: GremlinParser.TraversalMethod_discardContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_disjunct_Object. + def enterTraversalMethod_disjunct_Object(self, ctx: GremlinParser.TraversalMethod_disjunct_ObjectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_disjunct_Object. + def exitTraversalMethod_disjunct_Object(self, ctx: GremlinParser.TraversalMethod_disjunct_ObjectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_drop. + def enterTraversalMethod_drop(self, ctx: GremlinParser.TraversalMethod_dropContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_drop. + def exitTraversalMethod_drop(self, ctx: GremlinParser.TraversalMethod_dropContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_element. + def enterTraversalMethod_element(self, ctx: GremlinParser.TraversalMethod_elementContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_element. + def exitTraversalMethod_element(self, ctx: GremlinParser.TraversalMethod_elementContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_elementMap. + def enterTraversalMethod_elementMap(self, ctx: GremlinParser.TraversalMethod_elementMapContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_elementMap. + def exitTraversalMethod_elementMap(self, ctx: GremlinParser.TraversalMethod_elementMapContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_emit_Empty. + def enterTraversalMethod_emit_Empty(self, ctx: GremlinParser.TraversalMethod_emit_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_emit_Empty. + def exitTraversalMethod_emit_Empty(self, ctx: GremlinParser.TraversalMethod_emit_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_emit_Predicate. + def enterTraversalMethod_emit_Predicate(self, ctx: GremlinParser.TraversalMethod_emit_PredicateContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_emit_Predicate. + def exitTraversalMethod_emit_Predicate(self, ctx: GremlinParser.TraversalMethod_emit_PredicateContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_emit_Traversal. + def enterTraversalMethod_emit_Traversal(self, ctx: GremlinParser.TraversalMethod_emit_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_emit_Traversal. + def exitTraversalMethod_emit_Traversal(self, ctx: GremlinParser.TraversalMethod_emit_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_fail_Empty. + def enterTraversalMethod_fail_Empty(self, ctx: GremlinParser.TraversalMethod_fail_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_fail_Empty. + def exitTraversalMethod_fail_Empty(self, ctx: GremlinParser.TraversalMethod_fail_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_fail_String. + def enterTraversalMethod_fail_String(self, ctx: GremlinParser.TraversalMethod_fail_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_fail_String. + def exitTraversalMethod_fail_String(self, ctx: GremlinParser.TraversalMethod_fail_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_filter_Predicate. + def enterTraversalMethod_filter_Predicate(self, ctx: GremlinParser.TraversalMethod_filter_PredicateContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_filter_Predicate. + def exitTraversalMethod_filter_Predicate(self, ctx: GremlinParser.TraversalMethod_filter_PredicateContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_filter_Traversal. + def enterTraversalMethod_filter_Traversal(self, ctx: GremlinParser.TraversalMethod_filter_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_filter_Traversal. + def exitTraversalMethod_filter_Traversal(self, ctx: GremlinParser.TraversalMethod_filter_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_flatMap. + def enterTraversalMethod_flatMap(self, ctx: GremlinParser.TraversalMethod_flatMapContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_flatMap. + def exitTraversalMethod_flatMap(self, ctx: GremlinParser.TraversalMethod_flatMapContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_fold_Empty. + def enterTraversalMethod_fold_Empty(self, ctx: GremlinParser.TraversalMethod_fold_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_fold_Empty. + def exitTraversalMethod_fold_Empty(self, ctx: GremlinParser.TraversalMethod_fold_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_fold_Object_BiFunction. + def enterTraversalMethod_fold_Object_BiFunction( + self, ctx: GremlinParser.TraversalMethod_fold_Object_BiFunctionContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_fold_Object_BiFunction. + def exitTraversalMethod_fold_Object_BiFunction( + self, ctx: GremlinParser.TraversalMethod_fold_Object_BiFunctionContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_format_String. + def enterTraversalMethod_format_String(self, ctx: GremlinParser.TraversalMethod_format_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_format_String. + def exitTraversalMethod_format_String(self, ctx: GremlinParser.TraversalMethod_format_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_from_String. + def enterTraversalMethod_from_String(self, ctx: GremlinParser.TraversalMethod_from_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_from_String. + def exitTraversalMethod_from_String(self, ctx: GremlinParser.TraversalMethod_from_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_from_Vertex. + def enterTraversalMethod_from_Vertex(self, ctx: GremlinParser.TraversalMethod_from_VertexContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_from_Vertex. + def exitTraversalMethod_from_Vertex(self, ctx: GremlinParser.TraversalMethod_from_VertexContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_from_Traversal. + def enterTraversalMethod_from_Traversal(self, ctx: GremlinParser.TraversalMethod_from_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_from_Traversal. + def exitTraversalMethod_from_Traversal(self, ctx: GremlinParser.TraversalMethod_from_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_group_Empty. + def enterTraversalMethod_group_Empty(self, ctx: GremlinParser.TraversalMethod_group_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_group_Empty. + def exitTraversalMethod_group_Empty(self, ctx: GremlinParser.TraversalMethod_group_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_group_String. + def enterTraversalMethod_group_String(self, ctx: GremlinParser.TraversalMethod_group_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_group_String. + def exitTraversalMethod_group_String(self, ctx: GremlinParser.TraversalMethod_group_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_groupCount_Empty. + def enterTraversalMethod_groupCount_Empty(self, ctx: GremlinParser.TraversalMethod_groupCount_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_groupCount_Empty. + def exitTraversalMethod_groupCount_Empty(self, ctx: GremlinParser.TraversalMethod_groupCount_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_groupCount_String. + def enterTraversalMethod_groupCount_String(self, ctx: GremlinParser.TraversalMethod_groupCount_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_groupCount_String. + def exitTraversalMethod_groupCount_String(self, ctx: GremlinParser.TraversalMethod_groupCount_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_has_String. + def enterTraversalMethod_has_String(self, ctx: GremlinParser.TraversalMethod_has_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_has_String. + def exitTraversalMethod_has_String(self, ctx: GremlinParser.TraversalMethod_has_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_has_String_Object. + def enterTraversalMethod_has_String_Object(self, ctx: GremlinParser.TraversalMethod_has_String_ObjectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_has_String_Object. + def exitTraversalMethod_has_String_Object(self, ctx: GremlinParser.TraversalMethod_has_String_ObjectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_has_String_P. + def enterTraversalMethod_has_String_P(self, ctx: GremlinParser.TraversalMethod_has_String_PContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_has_String_P. + def exitTraversalMethod_has_String_P(self, ctx: GremlinParser.TraversalMethod_has_String_PContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_has_String_String_Object. + def enterTraversalMethod_has_String_String_Object( + self, ctx: GremlinParser.TraversalMethod_has_String_String_ObjectContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_has_String_String_Object. + def exitTraversalMethod_has_String_String_Object( + self, ctx: GremlinParser.TraversalMethod_has_String_String_ObjectContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_has_String_String_P. + def enterTraversalMethod_has_String_String_P(self, ctx: GremlinParser.TraversalMethod_has_String_String_PContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_has_String_String_P. + def exitTraversalMethod_has_String_String_P(self, ctx: GremlinParser.TraversalMethod_has_String_String_PContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_has_String_Traversal. + def enterTraversalMethod_has_String_Traversal(self, ctx: GremlinParser.TraversalMethod_has_String_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_has_String_Traversal. + def exitTraversalMethod_has_String_Traversal(self, ctx: GremlinParser.TraversalMethod_has_String_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_has_T_Object. + def enterTraversalMethod_has_T_Object(self, ctx: GremlinParser.TraversalMethod_has_T_ObjectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_has_T_Object. + def exitTraversalMethod_has_T_Object(self, ctx: GremlinParser.TraversalMethod_has_T_ObjectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_has_T_P. + def enterTraversalMethod_has_T_P(self, ctx: GremlinParser.TraversalMethod_has_T_PContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_has_T_P. + def exitTraversalMethod_has_T_P(self, ctx: GremlinParser.TraversalMethod_has_T_PContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_has_T_Traversal. + def enterTraversalMethod_has_T_Traversal(self, ctx: GremlinParser.TraversalMethod_has_T_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_has_T_Traversal. + def exitTraversalMethod_has_T_Traversal(self, ctx: GremlinParser.TraversalMethod_has_T_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_hasId_Object_Object. + def enterTraversalMethod_hasId_Object_Object(self, ctx: GremlinParser.TraversalMethod_hasId_Object_ObjectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_hasId_Object_Object. + def exitTraversalMethod_hasId_Object_Object(self, ctx: GremlinParser.TraversalMethod_hasId_Object_ObjectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_hasId_P. + def enterTraversalMethod_hasId_P(self, ctx: GremlinParser.TraversalMethod_hasId_PContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_hasId_P. + def exitTraversalMethod_hasId_P(self, ctx: GremlinParser.TraversalMethod_hasId_PContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_hasKey_P. + def enterTraversalMethod_hasKey_P(self, ctx: GremlinParser.TraversalMethod_hasKey_PContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_hasKey_P. + def exitTraversalMethod_hasKey_P(self, ctx: GremlinParser.TraversalMethod_hasKey_PContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_hasKey_String_String. + def enterTraversalMethod_hasKey_String_String(self, ctx: GremlinParser.TraversalMethod_hasKey_String_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_hasKey_String_String. + def exitTraversalMethod_hasKey_String_String(self, ctx: GremlinParser.TraversalMethod_hasKey_String_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_hasLabel_P. + def enterTraversalMethod_hasLabel_P(self, ctx: GremlinParser.TraversalMethod_hasLabel_PContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_hasLabel_P. + def exitTraversalMethod_hasLabel_P(self, ctx: GremlinParser.TraversalMethod_hasLabel_PContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_hasLabel_String_String. + def enterTraversalMethod_hasLabel_String_String( + self, ctx: GremlinParser.TraversalMethod_hasLabel_String_StringContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_hasLabel_String_String. + def exitTraversalMethod_hasLabel_String_String( + self, ctx: GremlinParser.TraversalMethod_hasLabel_String_StringContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_hasNot. + def enterTraversalMethod_hasNot(self, ctx: GremlinParser.TraversalMethod_hasNotContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_hasNot. + def exitTraversalMethod_hasNot(self, ctx: GremlinParser.TraversalMethod_hasNotContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_hasValue_Object_Object. + def enterTraversalMethod_hasValue_Object_Object( + self, ctx: GremlinParser.TraversalMethod_hasValue_Object_ObjectContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_hasValue_Object_Object. + def exitTraversalMethod_hasValue_Object_Object( + self, ctx: GremlinParser.TraversalMethod_hasValue_Object_ObjectContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_hasValue_P. + def enterTraversalMethod_hasValue_P(self, ctx: GremlinParser.TraversalMethod_hasValue_PContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_hasValue_P. + def exitTraversalMethod_hasValue_P(self, ctx: GremlinParser.TraversalMethod_hasValue_PContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_id. + def enterTraversalMethod_id(self, ctx: GremlinParser.TraversalMethod_idContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_id. + def exitTraversalMethod_id(self, ctx: GremlinParser.TraversalMethod_idContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_identity. + def enterTraversalMethod_identity(self, ctx: GremlinParser.TraversalMethod_identityContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_identity. + def exitTraversalMethod_identity(self, ctx: GremlinParser.TraversalMethod_identityContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_in. + def enterTraversalMethod_in(self, ctx: GremlinParser.TraversalMethod_inContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_in. + def exitTraversalMethod_in(self, ctx: GremlinParser.TraversalMethod_inContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_inE. + def enterTraversalMethod_inE(self, ctx: GremlinParser.TraversalMethod_inEContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_inE. + def exitTraversalMethod_inE(self, ctx: GremlinParser.TraversalMethod_inEContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_intersect_Object. + def enterTraversalMethod_intersect_Object(self, ctx: GremlinParser.TraversalMethod_intersect_ObjectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_intersect_Object. + def exitTraversalMethod_intersect_Object(self, ctx: GremlinParser.TraversalMethod_intersect_ObjectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_inV. + def enterTraversalMethod_inV(self, ctx: GremlinParser.TraversalMethod_inVContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_inV. + def exitTraversalMethod_inV(self, ctx: GremlinParser.TraversalMethod_inVContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_index. + def enterTraversalMethod_index(self, ctx: GremlinParser.TraversalMethod_indexContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_index. + def exitTraversalMethod_index(self, ctx: GremlinParser.TraversalMethod_indexContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_inject. + def enterTraversalMethod_inject(self, ctx: GremlinParser.TraversalMethod_injectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_inject. + def exitTraversalMethod_inject(self, ctx: GremlinParser.TraversalMethod_injectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_is_Object. + def enterTraversalMethod_is_Object(self, ctx: GremlinParser.TraversalMethod_is_ObjectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_is_Object. + def exitTraversalMethod_is_Object(self, ctx: GremlinParser.TraversalMethod_is_ObjectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_is_P. + def enterTraversalMethod_is_P(self, ctx: GremlinParser.TraversalMethod_is_PContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_is_P. + def exitTraversalMethod_is_P(self, ctx: GremlinParser.TraversalMethod_is_PContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_key. + def enterTraversalMethod_key(self, ctx: GremlinParser.TraversalMethod_keyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_key. + def exitTraversalMethod_key(self, ctx: GremlinParser.TraversalMethod_keyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_label. + def enterTraversalMethod_label(self, ctx: GremlinParser.TraversalMethod_labelContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_label. + def exitTraversalMethod_label(self, ctx: GremlinParser.TraversalMethod_labelContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_length_Empty. + def enterTraversalMethod_length_Empty(self, ctx: GremlinParser.TraversalMethod_length_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_length_Empty. + def exitTraversalMethod_length_Empty(self, ctx: GremlinParser.TraversalMethod_length_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_length_Scope. + def enterTraversalMethod_length_Scope(self, ctx: GremlinParser.TraversalMethod_length_ScopeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_length_Scope. + def exitTraversalMethod_length_Scope(self, ctx: GremlinParser.TraversalMethod_length_ScopeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_limit_Scope_long. + def enterTraversalMethod_limit_Scope_long(self, ctx: GremlinParser.TraversalMethod_limit_Scope_longContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_limit_Scope_long. + def exitTraversalMethod_limit_Scope_long(self, ctx: GremlinParser.TraversalMethod_limit_Scope_longContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_limit_long. + def enterTraversalMethod_limit_long(self, ctx: GremlinParser.TraversalMethod_limit_longContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_limit_long. + def exitTraversalMethod_limit_long(self, ctx: GremlinParser.TraversalMethod_limit_longContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_local. + def enterTraversalMethod_local(self, ctx: GremlinParser.TraversalMethod_localContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_local. + def exitTraversalMethod_local(self, ctx: GremlinParser.TraversalMethod_localContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_loops_Empty. + def enterTraversalMethod_loops_Empty(self, ctx: GremlinParser.TraversalMethod_loops_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_loops_Empty. + def exitTraversalMethod_loops_Empty(self, ctx: GremlinParser.TraversalMethod_loops_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_loops_String. + def enterTraversalMethod_loops_String(self, ctx: GremlinParser.TraversalMethod_loops_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_loops_String. + def exitTraversalMethod_loops_String(self, ctx: GremlinParser.TraversalMethod_loops_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_lTrim_Empty. + def enterTraversalMethod_lTrim_Empty(self, ctx: GremlinParser.TraversalMethod_lTrim_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_lTrim_Empty. + def exitTraversalMethod_lTrim_Empty(self, ctx: GremlinParser.TraversalMethod_lTrim_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_lTrim_Scope. + def enterTraversalMethod_lTrim_Scope(self, ctx: GremlinParser.TraversalMethod_lTrim_ScopeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_lTrim_Scope. + def exitTraversalMethod_lTrim_Scope(self, ctx: GremlinParser.TraversalMethod_lTrim_ScopeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_map. + def enterTraversalMethod_map(self, ctx: GremlinParser.TraversalMethod_mapContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_map. + def exitTraversalMethod_map(self, ctx: GremlinParser.TraversalMethod_mapContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_match. + def enterTraversalMethod_match(self, ctx: GremlinParser.TraversalMethod_matchContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_match. + def exitTraversalMethod_match(self, ctx: GremlinParser.TraversalMethod_matchContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_math. + def enterTraversalMethod_math(self, ctx: GremlinParser.TraversalMethod_mathContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_math. + def exitTraversalMethod_math(self, ctx: GremlinParser.TraversalMethod_mathContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_max_Empty. + def enterTraversalMethod_max_Empty(self, ctx: GremlinParser.TraversalMethod_max_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_max_Empty. + def exitTraversalMethod_max_Empty(self, ctx: GremlinParser.TraversalMethod_max_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_max_Scope. + def enterTraversalMethod_max_Scope(self, ctx: GremlinParser.TraversalMethod_max_ScopeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_max_Scope. + def exitTraversalMethod_max_Scope(self, ctx: GremlinParser.TraversalMethod_max_ScopeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_mean_Empty. + def enterTraversalMethod_mean_Empty(self, ctx: GremlinParser.TraversalMethod_mean_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_mean_Empty. + def exitTraversalMethod_mean_Empty(self, ctx: GremlinParser.TraversalMethod_mean_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_mean_Scope. + def enterTraversalMethod_mean_Scope(self, ctx: GremlinParser.TraversalMethod_mean_ScopeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_mean_Scope. + def exitTraversalMethod_mean_Scope(self, ctx: GremlinParser.TraversalMethod_mean_ScopeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_merge_Object. + def enterTraversalMethod_merge_Object(self, ctx: GremlinParser.TraversalMethod_merge_ObjectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_merge_Object. + def exitTraversalMethod_merge_Object(self, ctx: GremlinParser.TraversalMethod_merge_ObjectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_mergeV_empty. + def enterTraversalMethod_mergeV_empty(self, ctx: GremlinParser.TraversalMethod_mergeV_emptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_mergeV_empty. + def exitTraversalMethod_mergeV_empty(self, ctx: GremlinParser.TraversalMethod_mergeV_emptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_mergeV_Map. + def enterTraversalMethod_mergeV_Map(self, ctx: GremlinParser.TraversalMethod_mergeV_MapContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_mergeV_Map. + def exitTraversalMethod_mergeV_Map(self, ctx: GremlinParser.TraversalMethod_mergeV_MapContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_mergeV_Traversal. + def enterTraversalMethod_mergeV_Traversal(self, ctx: GremlinParser.TraversalMethod_mergeV_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_mergeV_Traversal. + def exitTraversalMethod_mergeV_Traversal(self, ctx: GremlinParser.TraversalMethod_mergeV_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_mergeE_empty. + def enterTraversalMethod_mergeE_empty(self, ctx: GremlinParser.TraversalMethod_mergeE_emptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_mergeE_empty. + def exitTraversalMethod_mergeE_empty(self, ctx: GremlinParser.TraversalMethod_mergeE_emptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_mergeE_Map. + def enterTraversalMethod_mergeE_Map(self, ctx: GremlinParser.TraversalMethod_mergeE_MapContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_mergeE_Map. + def exitTraversalMethod_mergeE_Map(self, ctx: GremlinParser.TraversalMethod_mergeE_MapContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_mergeE_Traversal. + def enterTraversalMethod_mergeE_Traversal(self, ctx: GremlinParser.TraversalMethod_mergeE_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_mergeE_Traversal. + def exitTraversalMethod_mergeE_Traversal(self, ctx: GremlinParser.TraversalMethod_mergeE_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_min_Empty. + def enterTraversalMethod_min_Empty(self, ctx: GremlinParser.TraversalMethod_min_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_min_Empty. + def exitTraversalMethod_min_Empty(self, ctx: GremlinParser.TraversalMethod_min_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_min_Scope. + def enterTraversalMethod_min_Scope(self, ctx: GremlinParser.TraversalMethod_min_ScopeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_min_Scope. + def exitTraversalMethod_min_Scope(self, ctx: GremlinParser.TraversalMethod_min_ScopeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_none_P. + def enterTraversalMethod_none_P(self, ctx: GremlinParser.TraversalMethod_none_PContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_none_P. + def exitTraversalMethod_none_P(self, ctx: GremlinParser.TraversalMethod_none_PContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_not. + def enterTraversalMethod_not(self, ctx: GremlinParser.TraversalMethod_notContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_not. + def exitTraversalMethod_not(self, ctx: GremlinParser.TraversalMethod_notContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_option_Predicate_Traversal. + def enterTraversalMethod_option_Predicate_Traversal( + self, ctx: GremlinParser.TraversalMethod_option_Predicate_TraversalContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_option_Predicate_Traversal. + def exitTraversalMethod_option_Predicate_Traversal( + self, ctx: GremlinParser.TraversalMethod_option_Predicate_TraversalContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_option_Merge_Map. + def enterTraversalMethod_option_Merge_Map(self, ctx: GremlinParser.TraversalMethod_option_Merge_MapContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_option_Merge_Map. + def exitTraversalMethod_option_Merge_Map(self, ctx: GremlinParser.TraversalMethod_option_Merge_MapContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_option_Merge_Map_Cardinality. + def enterTraversalMethod_option_Merge_Map_Cardinality( + self, ctx: GremlinParser.TraversalMethod_option_Merge_Map_CardinalityContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_option_Merge_Map_Cardinality. + def exitTraversalMethod_option_Merge_Map_Cardinality( + self, ctx: GremlinParser.TraversalMethod_option_Merge_Map_CardinalityContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_option_Merge_Traversal. + def enterTraversalMethod_option_Merge_Traversal( + self, ctx: GremlinParser.TraversalMethod_option_Merge_TraversalContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_option_Merge_Traversal. + def exitTraversalMethod_option_Merge_Traversal( + self, ctx: GremlinParser.TraversalMethod_option_Merge_TraversalContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_option_Object_Traversal. + def enterTraversalMethod_option_Object_Traversal( + self, ctx: GremlinParser.TraversalMethod_option_Object_TraversalContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_option_Object_Traversal. + def exitTraversalMethod_option_Object_Traversal( + self, ctx: GremlinParser.TraversalMethod_option_Object_TraversalContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_option_Traversal. + def enterTraversalMethod_option_Traversal(self, ctx: GremlinParser.TraversalMethod_option_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_option_Traversal. + def exitTraversalMethod_option_Traversal(self, ctx: GremlinParser.TraversalMethod_option_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_optional. + def enterTraversalMethod_optional(self, ctx: GremlinParser.TraversalMethod_optionalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_optional. + def exitTraversalMethod_optional(self, ctx: GremlinParser.TraversalMethod_optionalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_or. + def enterTraversalMethod_or(self, ctx: GremlinParser.TraversalMethod_orContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_or. + def exitTraversalMethod_or(self, ctx: GremlinParser.TraversalMethod_orContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_order_Empty. + def enterTraversalMethod_order_Empty(self, ctx: GremlinParser.TraversalMethod_order_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_order_Empty. + def exitTraversalMethod_order_Empty(self, ctx: GremlinParser.TraversalMethod_order_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_order_Scope. + def enterTraversalMethod_order_Scope(self, ctx: GremlinParser.TraversalMethod_order_ScopeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_order_Scope. + def exitTraversalMethod_order_Scope(self, ctx: GremlinParser.TraversalMethod_order_ScopeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_otherV. + def enterTraversalMethod_otherV(self, ctx: GremlinParser.TraversalMethod_otherVContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_otherV. + def exitTraversalMethod_otherV(self, ctx: GremlinParser.TraversalMethod_otherVContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_out. + def enterTraversalMethod_out(self, ctx: GremlinParser.TraversalMethod_outContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_out. + def exitTraversalMethod_out(self, ctx: GremlinParser.TraversalMethod_outContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_outE. + def enterTraversalMethod_outE(self, ctx: GremlinParser.TraversalMethod_outEContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_outE. + def exitTraversalMethod_outE(self, ctx: GremlinParser.TraversalMethod_outEContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_outV. + def enterTraversalMethod_outV(self, ctx: GremlinParser.TraversalMethod_outVContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_outV. + def exitTraversalMethod_outV(self, ctx: GremlinParser.TraversalMethod_outVContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_pageRank_Empty. + def enterTraversalMethod_pageRank_Empty(self, ctx: GremlinParser.TraversalMethod_pageRank_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_pageRank_Empty. + def exitTraversalMethod_pageRank_Empty(self, ctx: GremlinParser.TraversalMethod_pageRank_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_pageRank_double. + def enterTraversalMethod_pageRank_double(self, ctx: GremlinParser.TraversalMethod_pageRank_doubleContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_pageRank_double. + def exitTraversalMethod_pageRank_double(self, ctx: GremlinParser.TraversalMethod_pageRank_doubleContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_path. + def enterTraversalMethod_path(self, ctx: GremlinParser.TraversalMethod_pathContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_path. + def exitTraversalMethod_path(self, ctx: GremlinParser.TraversalMethod_pathContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_peerPressure. + def enterTraversalMethod_peerPressure(self, ctx: GremlinParser.TraversalMethod_peerPressureContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_peerPressure. + def exitTraversalMethod_peerPressure(self, ctx: GremlinParser.TraversalMethod_peerPressureContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_product_Object. + def enterTraversalMethod_product_Object(self, ctx: GremlinParser.TraversalMethod_product_ObjectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_product_Object. + def exitTraversalMethod_product_Object(self, ctx: GremlinParser.TraversalMethod_product_ObjectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_profile_Empty. + def enterTraversalMethod_profile_Empty(self, ctx: GremlinParser.TraversalMethod_profile_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_profile_Empty. + def exitTraversalMethod_profile_Empty(self, ctx: GremlinParser.TraversalMethod_profile_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_profile_String. + def enterTraversalMethod_profile_String(self, ctx: GremlinParser.TraversalMethod_profile_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_profile_String. + def exitTraversalMethod_profile_String(self, ctx: GremlinParser.TraversalMethod_profile_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_project. + def enterTraversalMethod_project(self, ctx: GremlinParser.TraversalMethod_projectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_project. + def exitTraversalMethod_project(self, ctx: GremlinParser.TraversalMethod_projectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_properties. + def enterTraversalMethod_properties(self, ctx: GremlinParser.TraversalMethod_propertiesContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_properties. + def exitTraversalMethod_properties(self, ctx: GremlinParser.TraversalMethod_propertiesContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_property_Cardinality_Object_Object_Object. + def enterTraversalMethod_property_Cardinality_Object_Object_Object( + self, ctx: GremlinParser.TraversalMethod_property_Cardinality_Object_Object_ObjectContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_property_Cardinality_Object_Object_Object. + def exitTraversalMethod_property_Cardinality_Object_Object_Object( + self, ctx: GremlinParser.TraversalMethod_property_Cardinality_Object_Object_ObjectContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_property_Cardinality_Object. + def enterTraversalMethod_property_Cardinality_Object( + self, ctx: GremlinParser.TraversalMethod_property_Cardinality_ObjectContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_property_Cardinality_Object. + def exitTraversalMethod_property_Cardinality_Object( + self, ctx: GremlinParser.TraversalMethod_property_Cardinality_ObjectContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_property_Object_Object_Object. + def enterTraversalMethod_property_Object_Object_Object( + self, ctx: GremlinParser.TraversalMethod_property_Object_Object_ObjectContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_property_Object_Object_Object. + def exitTraversalMethod_property_Object_Object_Object( + self, ctx: GremlinParser.TraversalMethod_property_Object_Object_ObjectContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_property_Object. + def enterTraversalMethod_property_Object(self, ctx: GremlinParser.TraversalMethod_property_ObjectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_property_Object. + def exitTraversalMethod_property_Object(self, ctx: GremlinParser.TraversalMethod_property_ObjectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_propertyMap. + def enterTraversalMethod_propertyMap(self, ctx: GremlinParser.TraversalMethod_propertyMapContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_propertyMap. + def exitTraversalMethod_propertyMap(self, ctx: GremlinParser.TraversalMethod_propertyMapContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_range_Scope_long_long. + def enterTraversalMethod_range_Scope_long_long( + self, ctx: GremlinParser.TraversalMethod_range_Scope_long_longContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_range_Scope_long_long. + def exitTraversalMethod_range_Scope_long_long( + self, ctx: GremlinParser.TraversalMethod_range_Scope_long_longContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_range_long_long. + def enterTraversalMethod_range_long_long(self, ctx: GremlinParser.TraversalMethod_range_long_longContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_range_long_long. + def exitTraversalMethod_range_long_long(self, ctx: GremlinParser.TraversalMethod_range_long_longContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_read. + def enterTraversalMethod_read(self, ctx: GremlinParser.TraversalMethod_readContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_read. + def exitTraversalMethod_read(self, ctx: GremlinParser.TraversalMethod_readContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_repeat_String_Traversal. + def enterTraversalMethod_repeat_String_Traversal( + self, ctx: GremlinParser.TraversalMethod_repeat_String_TraversalContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_repeat_String_Traversal. + def exitTraversalMethod_repeat_String_Traversal( + self, ctx: GremlinParser.TraversalMethod_repeat_String_TraversalContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_repeat_Traversal. + def enterTraversalMethod_repeat_Traversal(self, ctx: GremlinParser.TraversalMethod_repeat_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_repeat_Traversal. + def exitTraversalMethod_repeat_Traversal(self, ctx: GremlinParser.TraversalMethod_repeat_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_replace_String_String. + def enterTraversalMethod_replace_String_String( + self, ctx: GremlinParser.TraversalMethod_replace_String_StringContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_replace_String_String. + def exitTraversalMethod_replace_String_String( + self, ctx: GremlinParser.TraversalMethod_replace_String_StringContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_replace_Scope_String_String. + def enterTraversalMethod_replace_Scope_String_String( + self, ctx: GremlinParser.TraversalMethod_replace_Scope_String_StringContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_replace_Scope_String_String. + def exitTraversalMethod_replace_Scope_String_String( + self, ctx: GremlinParser.TraversalMethod_replace_Scope_String_StringContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_reverse_Empty. + def enterTraversalMethod_reverse_Empty(self, ctx: GremlinParser.TraversalMethod_reverse_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_reverse_Empty. + def exitTraversalMethod_reverse_Empty(self, ctx: GremlinParser.TraversalMethod_reverse_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_rTrim_Empty. + def enterTraversalMethod_rTrim_Empty(self, ctx: GremlinParser.TraversalMethod_rTrim_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_rTrim_Empty. + def exitTraversalMethod_rTrim_Empty(self, ctx: GremlinParser.TraversalMethod_rTrim_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_rTrim_Scope. + def enterTraversalMethod_rTrim_Scope(self, ctx: GremlinParser.TraversalMethod_rTrim_ScopeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_rTrim_Scope. + def exitTraversalMethod_rTrim_Scope(self, ctx: GremlinParser.TraversalMethod_rTrim_ScopeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_sack_BiFunction. + def enterTraversalMethod_sack_BiFunction(self, ctx: GremlinParser.TraversalMethod_sack_BiFunctionContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_sack_BiFunction. + def exitTraversalMethod_sack_BiFunction(self, ctx: GremlinParser.TraversalMethod_sack_BiFunctionContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_sack_Empty. + def enterTraversalMethod_sack_Empty(self, ctx: GremlinParser.TraversalMethod_sack_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_sack_Empty. + def exitTraversalMethod_sack_Empty(self, ctx: GremlinParser.TraversalMethod_sack_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_sample_Scope_int. + def enterTraversalMethod_sample_Scope_int(self, ctx: GremlinParser.TraversalMethod_sample_Scope_intContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_sample_Scope_int. + def exitTraversalMethod_sample_Scope_int(self, ctx: GremlinParser.TraversalMethod_sample_Scope_intContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_sample_int. + def enterTraversalMethod_sample_int(self, ctx: GremlinParser.TraversalMethod_sample_intContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_sample_int. + def exitTraversalMethod_sample_int(self, ctx: GremlinParser.TraversalMethod_sample_intContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_select_Column. + def enterTraversalMethod_select_Column(self, ctx: GremlinParser.TraversalMethod_select_ColumnContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_select_Column. + def exitTraversalMethod_select_Column(self, ctx: GremlinParser.TraversalMethod_select_ColumnContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_select_Pop_String. + def enterTraversalMethod_select_Pop_String(self, ctx: GremlinParser.TraversalMethod_select_Pop_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_select_Pop_String. + def exitTraversalMethod_select_Pop_String(self, ctx: GremlinParser.TraversalMethod_select_Pop_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_select_Pop_String_String_String. + def enterTraversalMethod_select_Pop_String_String_String( + self, ctx: GremlinParser.TraversalMethod_select_Pop_String_String_StringContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_select_Pop_String_String_String. + def exitTraversalMethod_select_Pop_String_String_String( + self, ctx: GremlinParser.TraversalMethod_select_Pop_String_String_StringContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_select_Pop_Traversal. + def enterTraversalMethod_select_Pop_Traversal(self, ctx: GremlinParser.TraversalMethod_select_Pop_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_select_Pop_Traversal. + def exitTraversalMethod_select_Pop_Traversal(self, ctx: GremlinParser.TraversalMethod_select_Pop_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_select_String. + def enterTraversalMethod_select_String(self, ctx: GremlinParser.TraversalMethod_select_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_select_String. + def exitTraversalMethod_select_String(self, ctx: GremlinParser.TraversalMethod_select_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_select_String_String_String. + def enterTraversalMethod_select_String_String_String( + self, ctx: GremlinParser.TraversalMethod_select_String_String_StringContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_select_String_String_String. + def exitTraversalMethod_select_String_String_String( + self, ctx: GremlinParser.TraversalMethod_select_String_String_StringContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_select_Traversal. + def enterTraversalMethod_select_Traversal(self, ctx: GremlinParser.TraversalMethod_select_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_select_Traversal. + def exitTraversalMethod_select_Traversal(self, ctx: GremlinParser.TraversalMethod_select_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_shortestPath. + def enterTraversalMethod_shortestPath(self, ctx: GremlinParser.TraversalMethod_shortestPathContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_shortestPath. + def exitTraversalMethod_shortestPath(self, ctx: GremlinParser.TraversalMethod_shortestPathContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_sideEffect. + def enterTraversalMethod_sideEffect(self, ctx: GremlinParser.TraversalMethod_sideEffectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_sideEffect. + def exitTraversalMethod_sideEffect(self, ctx: GremlinParser.TraversalMethod_sideEffectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_simplePath. + def enterTraversalMethod_simplePath(self, ctx: GremlinParser.TraversalMethod_simplePathContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_simplePath. + def exitTraversalMethod_simplePath(self, ctx: GremlinParser.TraversalMethod_simplePathContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_skip_Scope_long. + def enterTraversalMethod_skip_Scope_long(self, ctx: GremlinParser.TraversalMethod_skip_Scope_longContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_skip_Scope_long. + def exitTraversalMethod_skip_Scope_long(self, ctx: GremlinParser.TraversalMethod_skip_Scope_longContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_skip_long. + def enterTraversalMethod_skip_long(self, ctx: GremlinParser.TraversalMethod_skip_longContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_skip_long. + def exitTraversalMethod_skip_long(self, ctx: GremlinParser.TraversalMethod_skip_longContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_split_String. + def enterTraversalMethod_split_String(self, ctx: GremlinParser.TraversalMethod_split_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_split_String. + def exitTraversalMethod_split_String(self, ctx: GremlinParser.TraversalMethod_split_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_split_Scope_String. + def enterTraversalMethod_split_Scope_String(self, ctx: GremlinParser.TraversalMethod_split_Scope_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_split_Scope_String. + def exitTraversalMethod_split_Scope_String(self, ctx: GremlinParser.TraversalMethod_split_Scope_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_store. + def enterTraversalMethod_store(self, ctx: GremlinParser.TraversalMethod_storeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_store. + def exitTraversalMethod_store(self, ctx: GremlinParser.TraversalMethod_storeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_subgraph. + def enterTraversalMethod_subgraph(self, ctx: GremlinParser.TraversalMethod_subgraphContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_subgraph. + def exitTraversalMethod_subgraph(self, ctx: GremlinParser.TraversalMethod_subgraphContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_substring_int. + def enterTraversalMethod_substring_int(self, ctx: GremlinParser.TraversalMethod_substring_intContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_substring_int. + def exitTraversalMethod_substring_int(self, ctx: GremlinParser.TraversalMethod_substring_intContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_substring_Scope_int. + def enterTraversalMethod_substring_Scope_int(self, ctx: GremlinParser.TraversalMethod_substring_Scope_intContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_substring_Scope_int. + def exitTraversalMethod_substring_Scope_int(self, ctx: GremlinParser.TraversalMethod_substring_Scope_intContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_substring_int_int. + def enterTraversalMethod_substring_int_int(self, ctx: GremlinParser.TraversalMethod_substring_int_intContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_substring_int_int. + def exitTraversalMethod_substring_int_int(self, ctx: GremlinParser.TraversalMethod_substring_int_intContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_substring_Scope_int_int. + def enterTraversalMethod_substring_Scope_int_int( + self, ctx: GremlinParser.TraversalMethod_substring_Scope_int_intContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_substring_Scope_int_int. + def exitTraversalMethod_substring_Scope_int_int( + self, ctx: GremlinParser.TraversalMethod_substring_Scope_int_intContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_sum_Empty. + def enterTraversalMethod_sum_Empty(self, ctx: GremlinParser.TraversalMethod_sum_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_sum_Empty. + def exitTraversalMethod_sum_Empty(self, ctx: GremlinParser.TraversalMethod_sum_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_sum_Scope. + def enterTraversalMethod_sum_Scope(self, ctx: GremlinParser.TraversalMethod_sum_ScopeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_sum_Scope. + def exitTraversalMethod_sum_Scope(self, ctx: GremlinParser.TraversalMethod_sum_ScopeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_tail_Empty. + def enterTraversalMethod_tail_Empty(self, ctx: GremlinParser.TraversalMethod_tail_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_tail_Empty. + def exitTraversalMethod_tail_Empty(self, ctx: GremlinParser.TraversalMethod_tail_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_tail_Scope. + def enterTraversalMethod_tail_Scope(self, ctx: GremlinParser.TraversalMethod_tail_ScopeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_tail_Scope. + def exitTraversalMethod_tail_Scope(self, ctx: GremlinParser.TraversalMethod_tail_ScopeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_tail_Scope_long. + def enterTraversalMethod_tail_Scope_long(self, ctx: GremlinParser.TraversalMethod_tail_Scope_longContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_tail_Scope_long. + def exitTraversalMethod_tail_Scope_long(self, ctx: GremlinParser.TraversalMethod_tail_Scope_longContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_tail_long. + def enterTraversalMethod_tail_long(self, ctx: GremlinParser.TraversalMethod_tail_longContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_tail_long. + def exitTraversalMethod_tail_long(self, ctx: GremlinParser.TraversalMethod_tail_longContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_timeLimit. + def enterTraversalMethod_timeLimit(self, ctx: GremlinParser.TraversalMethod_timeLimitContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_timeLimit. + def exitTraversalMethod_timeLimit(self, ctx: GremlinParser.TraversalMethod_timeLimitContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_times. + def enterTraversalMethod_times(self, ctx: GremlinParser.TraversalMethod_timesContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_times. + def exitTraversalMethod_times(self, ctx: GremlinParser.TraversalMethod_timesContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_to_Direction_String. + def enterTraversalMethod_to_Direction_String(self, ctx: GremlinParser.TraversalMethod_to_Direction_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_to_Direction_String. + def exitTraversalMethod_to_Direction_String(self, ctx: GremlinParser.TraversalMethod_to_Direction_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_to_String. + def enterTraversalMethod_to_String(self, ctx: GremlinParser.TraversalMethod_to_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_to_String. + def exitTraversalMethod_to_String(self, ctx: GremlinParser.TraversalMethod_to_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_to_Vertex. + def enterTraversalMethod_to_Vertex(self, ctx: GremlinParser.TraversalMethod_to_VertexContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_to_Vertex. + def exitTraversalMethod_to_Vertex(self, ctx: GremlinParser.TraversalMethod_to_VertexContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_to_Traversal. + def enterTraversalMethod_to_Traversal(self, ctx: GremlinParser.TraversalMethod_to_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_to_Traversal. + def exitTraversalMethod_to_Traversal(self, ctx: GremlinParser.TraversalMethod_to_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_toE. + def enterTraversalMethod_toE(self, ctx: GremlinParser.TraversalMethod_toEContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_toE. + def exitTraversalMethod_toE(self, ctx: GremlinParser.TraversalMethod_toEContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_toLower_Empty. + def enterTraversalMethod_toLower_Empty(self, ctx: GremlinParser.TraversalMethod_toLower_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_toLower_Empty. + def exitTraversalMethod_toLower_Empty(self, ctx: GremlinParser.TraversalMethod_toLower_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_toLower_Scope. + def enterTraversalMethod_toLower_Scope(self, ctx: GremlinParser.TraversalMethod_toLower_ScopeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_toLower_Scope. + def exitTraversalMethod_toLower_Scope(self, ctx: GremlinParser.TraversalMethod_toLower_ScopeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_toUpper_Empty. + def enterTraversalMethod_toUpper_Empty(self, ctx: GremlinParser.TraversalMethod_toUpper_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_toUpper_Empty. + def exitTraversalMethod_toUpper_Empty(self, ctx: GremlinParser.TraversalMethod_toUpper_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_toUpper_Scope. + def enterTraversalMethod_toUpper_Scope(self, ctx: GremlinParser.TraversalMethod_toUpper_ScopeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_toUpper_Scope. + def exitTraversalMethod_toUpper_Scope(self, ctx: GremlinParser.TraversalMethod_toUpper_ScopeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_toV. + def enterTraversalMethod_toV(self, ctx: GremlinParser.TraversalMethod_toVContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_toV. + def exitTraversalMethod_toV(self, ctx: GremlinParser.TraversalMethod_toVContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_tree_Empty. + def enterTraversalMethod_tree_Empty(self, ctx: GremlinParser.TraversalMethod_tree_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_tree_Empty. + def exitTraversalMethod_tree_Empty(self, ctx: GremlinParser.TraversalMethod_tree_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_tree_String. + def enterTraversalMethod_tree_String(self, ctx: GremlinParser.TraversalMethod_tree_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_tree_String. + def exitTraversalMethod_tree_String(self, ctx: GremlinParser.TraversalMethod_tree_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_trim_Empty. + def enterTraversalMethod_trim_Empty(self, ctx: GremlinParser.TraversalMethod_trim_EmptyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_trim_Empty. + def exitTraversalMethod_trim_Empty(self, ctx: GremlinParser.TraversalMethod_trim_EmptyContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_trim_Scope. + def enterTraversalMethod_trim_Scope(self, ctx: GremlinParser.TraversalMethod_trim_ScopeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_trim_Scope. + def exitTraversalMethod_trim_Scope(self, ctx: GremlinParser.TraversalMethod_trim_ScopeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_unfold. + def enterTraversalMethod_unfold(self, ctx: GremlinParser.TraversalMethod_unfoldContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_unfold. + def exitTraversalMethod_unfold(self, ctx: GremlinParser.TraversalMethod_unfoldContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_union. + def enterTraversalMethod_union(self, ctx: GremlinParser.TraversalMethod_unionContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_union. + def exitTraversalMethod_union(self, ctx: GremlinParser.TraversalMethod_unionContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_until_Predicate. + def enterTraversalMethod_until_Predicate(self, ctx: GremlinParser.TraversalMethod_until_PredicateContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_until_Predicate. + def exitTraversalMethod_until_Predicate(self, ctx: GremlinParser.TraversalMethod_until_PredicateContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_until_Traversal. + def enterTraversalMethod_until_Traversal(self, ctx: GremlinParser.TraversalMethod_until_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_until_Traversal. + def exitTraversalMethod_until_Traversal(self, ctx: GremlinParser.TraversalMethod_until_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_value. + def enterTraversalMethod_value(self, ctx: GremlinParser.TraversalMethod_valueContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_value. + def exitTraversalMethod_value(self, ctx: GremlinParser.TraversalMethod_valueContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_valueMap_String. + def enterTraversalMethod_valueMap_String(self, ctx: GremlinParser.TraversalMethod_valueMap_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_valueMap_String. + def exitTraversalMethod_valueMap_String(self, ctx: GremlinParser.TraversalMethod_valueMap_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_valueMap_boolean_String. + def enterTraversalMethod_valueMap_boolean_String( + self, ctx: GremlinParser.TraversalMethod_valueMap_boolean_StringContext + ): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_valueMap_boolean_String. + def exitTraversalMethod_valueMap_boolean_String( + self, ctx: GremlinParser.TraversalMethod_valueMap_boolean_StringContext + ): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_values. + def enterTraversalMethod_values(self, ctx: GremlinParser.TraversalMethod_valuesContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_values. + def exitTraversalMethod_values(self, ctx: GremlinParser.TraversalMethod_valuesContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_where_P. + def enterTraversalMethod_where_P(self, ctx: GremlinParser.TraversalMethod_where_PContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_where_P. + def exitTraversalMethod_where_P(self, ctx: GremlinParser.TraversalMethod_where_PContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_where_String_P. + def enterTraversalMethod_where_String_P(self, ctx: GremlinParser.TraversalMethod_where_String_PContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_where_String_P. + def exitTraversalMethod_where_String_P(self, ctx: GremlinParser.TraversalMethod_where_String_PContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_where_Traversal. + def enterTraversalMethod_where_Traversal(self, ctx: GremlinParser.TraversalMethod_where_TraversalContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_where_Traversal. + def exitTraversalMethod_where_Traversal(self, ctx: GremlinParser.TraversalMethod_where_TraversalContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_with_String. + def enterTraversalMethod_with_String(self, ctx: GremlinParser.TraversalMethod_with_StringContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_with_String. + def exitTraversalMethod_with_String(self, ctx: GremlinParser.TraversalMethod_with_StringContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_with_String_Object. + def enterTraversalMethod_with_String_Object(self, ctx: GremlinParser.TraversalMethod_with_String_ObjectContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_with_String_Object. + def exitTraversalMethod_with_String_Object(self, ctx: GremlinParser.TraversalMethod_with_String_ObjectContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMethod_write. + def enterTraversalMethod_write(self, ctx: GremlinParser.TraversalMethod_writeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMethod_write. + def exitTraversalMethod_write(self, ctx: GremlinParser.TraversalMethod_writeContext): + pass + + # Enter a parse tree produced by GremlinParser#structureVertexLiteral. + def enterStructureVertexLiteral(self, ctx: GremlinParser.StructureVertexLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#structureVertexLiteral. + def exitStructureVertexLiteral(self, ctx: GremlinParser.StructureVertexLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalStrategy. + def enterTraversalStrategy(self, ctx: GremlinParser.TraversalStrategyContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalStrategy. + def exitTraversalStrategy(self, ctx: GremlinParser.TraversalStrategyContext): + pass + + # Enter a parse tree produced by GremlinParser#configuration. + def enterConfiguration(self, ctx: GremlinParser.ConfigurationContext): + pass + + # Exit a parse tree produced by GremlinParser#configuration. + def exitConfiguration(self, ctx: GremlinParser.ConfigurationContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalScope. + def enterTraversalScope(self, ctx: GremlinParser.TraversalScopeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalScope. + def exitTraversalScope(self, ctx: GremlinParser.TraversalScopeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalBarrier. + def enterTraversalBarrier(self, ctx: GremlinParser.TraversalBarrierContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalBarrier. + def exitTraversalBarrier(self, ctx: GremlinParser.TraversalBarrierContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalT. + def enterTraversalT(self, ctx: GremlinParser.TraversalTContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalT. + def exitTraversalT(self, ctx: GremlinParser.TraversalTContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalTShort. + def enterTraversalTShort(self, ctx: GremlinParser.TraversalTShortContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalTShort. + def exitTraversalTShort(self, ctx: GremlinParser.TraversalTShortContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalTLong. + def enterTraversalTLong(self, ctx: GremlinParser.TraversalTLongContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalTLong. + def exitTraversalTLong(self, ctx: GremlinParser.TraversalTLongContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalMerge. + def enterTraversalMerge(self, ctx: GremlinParser.TraversalMergeContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalMerge. + def exitTraversalMerge(self, ctx: GremlinParser.TraversalMergeContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalOrder. + def enterTraversalOrder(self, ctx: GremlinParser.TraversalOrderContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalOrder. + def exitTraversalOrder(self, ctx: GremlinParser.TraversalOrderContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalDirection. + def enterTraversalDirection(self, ctx: GremlinParser.TraversalDirectionContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalDirection. + def exitTraversalDirection(self, ctx: GremlinParser.TraversalDirectionContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalDirectionShort. + def enterTraversalDirectionShort(self, ctx: GremlinParser.TraversalDirectionShortContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalDirectionShort. + def exitTraversalDirectionShort(self, ctx: GremlinParser.TraversalDirectionShortContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalDirectionLong. + def enterTraversalDirectionLong(self, ctx: GremlinParser.TraversalDirectionLongContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalDirectionLong. + def exitTraversalDirectionLong(self, ctx: GremlinParser.TraversalDirectionLongContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalCardinality. + def enterTraversalCardinality(self, ctx: GremlinParser.TraversalCardinalityContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalCardinality. + def exitTraversalCardinality(self, ctx: GremlinParser.TraversalCardinalityContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalColumn. + def enterTraversalColumn(self, ctx: GremlinParser.TraversalColumnContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalColumn. + def exitTraversalColumn(self, ctx: GremlinParser.TraversalColumnContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPop. + def enterTraversalPop(self, ctx: GremlinParser.TraversalPopContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPop. + def exitTraversalPop(self, ctx: GremlinParser.TraversalPopContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalOperator. + def enterTraversalOperator(self, ctx: GremlinParser.TraversalOperatorContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalOperator. + def exitTraversalOperator(self, ctx: GremlinParser.TraversalOperatorContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPick. + def enterTraversalPick(self, ctx: GremlinParser.TraversalPickContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPick. + def exitTraversalPick(self, ctx: GremlinParser.TraversalPickContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalDT. + def enterTraversalDT(self, ctx: GremlinParser.TraversalDTContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalDT. + def exitTraversalDT(self, ctx: GremlinParser.TraversalDTContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate. + def enterTraversalPredicate(self, ctx: GremlinParser.TraversalPredicateContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate. + def exitTraversalPredicate(self, ctx: GremlinParser.TraversalPredicateContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalTerminalMethod. + def enterTraversalTerminalMethod(self, ctx: GremlinParser.TraversalTerminalMethodContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalTerminalMethod. + def exitTraversalTerminalMethod(self, ctx: GremlinParser.TraversalTerminalMethodContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalSackMethod. + def enterTraversalSackMethod(self, ctx: GremlinParser.TraversalSackMethodContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalSackMethod. + def exitTraversalSackMethod(self, ctx: GremlinParser.TraversalSackMethodContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalComparator. + def enterTraversalComparator(self, ctx: GremlinParser.TraversalComparatorContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalComparator. + def exitTraversalComparator(self, ctx: GremlinParser.TraversalComparatorContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalFunction. + def enterTraversalFunction(self, ctx: GremlinParser.TraversalFunctionContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalFunction. + def exitTraversalFunction(self, ctx: GremlinParser.TraversalFunctionContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalBiFunction. + def enterTraversalBiFunction(self, ctx: GremlinParser.TraversalBiFunctionContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalBiFunction. + def exitTraversalBiFunction(self, ctx: GremlinParser.TraversalBiFunctionContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_eq. + def enterTraversalPredicate_eq(self, ctx: GremlinParser.TraversalPredicate_eqContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_eq. + def exitTraversalPredicate_eq(self, ctx: GremlinParser.TraversalPredicate_eqContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_neq. + def enterTraversalPredicate_neq(self, ctx: GremlinParser.TraversalPredicate_neqContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_neq. + def exitTraversalPredicate_neq(self, ctx: GremlinParser.TraversalPredicate_neqContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_lt. + def enterTraversalPredicate_lt(self, ctx: GremlinParser.TraversalPredicate_ltContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_lt. + def exitTraversalPredicate_lt(self, ctx: GremlinParser.TraversalPredicate_ltContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_lte. + def enterTraversalPredicate_lte(self, ctx: GremlinParser.TraversalPredicate_lteContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_lte. + def exitTraversalPredicate_lte(self, ctx: GremlinParser.TraversalPredicate_lteContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_gt. + def enterTraversalPredicate_gt(self, ctx: GremlinParser.TraversalPredicate_gtContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_gt. + def exitTraversalPredicate_gt(self, ctx: GremlinParser.TraversalPredicate_gtContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_gte. + def enterTraversalPredicate_gte(self, ctx: GremlinParser.TraversalPredicate_gteContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_gte. + def exitTraversalPredicate_gte(self, ctx: GremlinParser.TraversalPredicate_gteContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_inside. + def enterTraversalPredicate_inside(self, ctx: GremlinParser.TraversalPredicate_insideContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_inside. + def exitTraversalPredicate_inside(self, ctx: GremlinParser.TraversalPredicate_insideContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_outside. + def enterTraversalPredicate_outside(self, ctx: GremlinParser.TraversalPredicate_outsideContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_outside. + def exitTraversalPredicate_outside(self, ctx: GremlinParser.TraversalPredicate_outsideContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_between. + def enterTraversalPredicate_between(self, ctx: GremlinParser.TraversalPredicate_betweenContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_between. + def exitTraversalPredicate_between(self, ctx: GremlinParser.TraversalPredicate_betweenContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_within. + def enterTraversalPredicate_within(self, ctx: GremlinParser.TraversalPredicate_withinContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_within. + def exitTraversalPredicate_within(self, ctx: GremlinParser.TraversalPredicate_withinContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_without. + def enterTraversalPredicate_without(self, ctx: GremlinParser.TraversalPredicate_withoutContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_without. + def exitTraversalPredicate_without(self, ctx: GremlinParser.TraversalPredicate_withoutContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_not. + def enterTraversalPredicate_not(self, ctx: GremlinParser.TraversalPredicate_notContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_not. + def exitTraversalPredicate_not(self, ctx: GremlinParser.TraversalPredicate_notContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_containing. + def enterTraversalPredicate_containing(self, ctx: GremlinParser.TraversalPredicate_containingContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_containing. + def exitTraversalPredicate_containing(self, ctx: GremlinParser.TraversalPredicate_containingContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_notContaining. + def enterTraversalPredicate_notContaining(self, ctx: GremlinParser.TraversalPredicate_notContainingContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_notContaining. + def exitTraversalPredicate_notContaining(self, ctx: GremlinParser.TraversalPredicate_notContainingContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_startingWith. + def enterTraversalPredicate_startingWith(self, ctx: GremlinParser.TraversalPredicate_startingWithContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_startingWith. + def exitTraversalPredicate_startingWith(self, ctx: GremlinParser.TraversalPredicate_startingWithContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_notStartingWith. + def enterTraversalPredicate_notStartingWith(self, ctx: GremlinParser.TraversalPredicate_notStartingWithContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_notStartingWith. + def exitTraversalPredicate_notStartingWith(self, ctx: GremlinParser.TraversalPredicate_notStartingWithContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_endingWith. + def enterTraversalPredicate_endingWith(self, ctx: GremlinParser.TraversalPredicate_endingWithContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_endingWith. + def exitTraversalPredicate_endingWith(self, ctx: GremlinParser.TraversalPredicate_endingWithContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_notEndingWith. + def enterTraversalPredicate_notEndingWith(self, ctx: GremlinParser.TraversalPredicate_notEndingWithContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_notEndingWith. + def exitTraversalPredicate_notEndingWith(self, ctx: GremlinParser.TraversalPredicate_notEndingWithContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_regex. + def enterTraversalPredicate_regex(self, ctx: GremlinParser.TraversalPredicate_regexContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_regex. + def exitTraversalPredicate_regex(self, ctx: GremlinParser.TraversalPredicate_regexContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalPredicate_notRegex. + def enterTraversalPredicate_notRegex(self, ctx: GremlinParser.TraversalPredicate_notRegexContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalPredicate_notRegex. + def exitTraversalPredicate_notRegex(self, ctx: GremlinParser.TraversalPredicate_notRegexContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalTerminalMethod_explain. + def enterTraversalTerminalMethod_explain(self, ctx: GremlinParser.TraversalTerminalMethod_explainContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalTerminalMethod_explain. + def exitTraversalTerminalMethod_explain(self, ctx: GremlinParser.TraversalTerminalMethod_explainContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalTerminalMethod_hasNext. + def enterTraversalTerminalMethod_hasNext(self, ctx: GremlinParser.TraversalTerminalMethod_hasNextContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalTerminalMethod_hasNext. + def exitTraversalTerminalMethod_hasNext(self, ctx: GremlinParser.TraversalTerminalMethod_hasNextContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalTerminalMethod_iterate. + def enterTraversalTerminalMethod_iterate(self, ctx: GremlinParser.TraversalTerminalMethod_iterateContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalTerminalMethod_iterate. + def exitTraversalTerminalMethod_iterate(self, ctx: GremlinParser.TraversalTerminalMethod_iterateContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalTerminalMethod_tryNext. + def enterTraversalTerminalMethod_tryNext(self, ctx: GremlinParser.TraversalTerminalMethod_tryNextContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalTerminalMethod_tryNext. + def exitTraversalTerminalMethod_tryNext(self, ctx: GremlinParser.TraversalTerminalMethod_tryNextContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalTerminalMethod_next. + def enterTraversalTerminalMethod_next(self, ctx: GremlinParser.TraversalTerminalMethod_nextContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalTerminalMethod_next. + def exitTraversalTerminalMethod_next(self, ctx: GremlinParser.TraversalTerminalMethod_nextContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalTerminalMethod_toList. + def enterTraversalTerminalMethod_toList(self, ctx: GremlinParser.TraversalTerminalMethod_toListContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalTerminalMethod_toList. + def exitTraversalTerminalMethod_toList(self, ctx: GremlinParser.TraversalTerminalMethod_toListContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalTerminalMethod_toSet. + def enterTraversalTerminalMethod_toSet(self, ctx: GremlinParser.TraversalTerminalMethod_toSetContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalTerminalMethod_toSet. + def exitTraversalTerminalMethod_toSet(self, ctx: GremlinParser.TraversalTerminalMethod_toSetContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalTerminalMethod_toBulkSet. + def enterTraversalTerminalMethod_toBulkSet(self, ctx: GremlinParser.TraversalTerminalMethod_toBulkSetContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalTerminalMethod_toBulkSet. + def exitTraversalTerminalMethod_toBulkSet(self, ctx: GremlinParser.TraversalTerminalMethod_toBulkSetContext): + pass + + # Enter a parse tree produced by GremlinParser#withOptionKeys. + def enterWithOptionKeys(self, ctx: GremlinParser.WithOptionKeysContext): + pass + + # Exit a parse tree produced by GremlinParser#withOptionKeys. + def exitWithOptionKeys(self, ctx: GremlinParser.WithOptionKeysContext): + pass + + # Enter a parse tree produced by GremlinParser#connectedComponentConstants. + def enterConnectedComponentConstants(self, ctx: GremlinParser.ConnectedComponentConstantsContext): + pass + + # Exit a parse tree produced by GremlinParser#connectedComponentConstants. + def exitConnectedComponentConstants(self, ctx: GremlinParser.ConnectedComponentConstantsContext): + pass + + # Enter a parse tree produced by GremlinParser#pageRankConstants. + def enterPageRankConstants(self, ctx: GremlinParser.PageRankConstantsContext): + pass + + # Exit a parse tree produced by GremlinParser#pageRankConstants. + def exitPageRankConstants(self, ctx: GremlinParser.PageRankConstantsContext): + pass + + # Enter a parse tree produced by GremlinParser#peerPressureConstants. + def enterPeerPressureConstants(self, ctx: GremlinParser.PeerPressureConstantsContext): + pass + + # Exit a parse tree produced by GremlinParser#peerPressureConstants. + def exitPeerPressureConstants(self, ctx: GremlinParser.PeerPressureConstantsContext): + pass + + # Enter a parse tree produced by GremlinParser#shortestPathConstants. + def enterShortestPathConstants(self, ctx: GremlinParser.ShortestPathConstantsContext): + pass + + # Exit a parse tree produced by GremlinParser#shortestPathConstants. + def exitShortestPathConstants(self, ctx: GremlinParser.ShortestPathConstantsContext): + pass + + # Enter a parse tree produced by GremlinParser#withOptionsValues. + def enterWithOptionsValues(self, ctx: GremlinParser.WithOptionsValuesContext): + pass + + # Exit a parse tree produced by GremlinParser#withOptionsValues. + def exitWithOptionsValues(self, ctx: GremlinParser.WithOptionsValuesContext): + pass + + # Enter a parse tree produced by GremlinParser#ioOptionsKeys. + def enterIoOptionsKeys(self, ctx: GremlinParser.IoOptionsKeysContext): + pass + + # Exit a parse tree produced by GremlinParser#ioOptionsKeys. + def exitIoOptionsKeys(self, ctx: GremlinParser.IoOptionsKeysContext): + pass + + # Enter a parse tree produced by GremlinParser#ioOptionsValues. + def enterIoOptionsValues(self, ctx: GremlinParser.IoOptionsValuesContext): + pass + + # Exit a parse tree produced by GremlinParser#ioOptionsValues. + def exitIoOptionsValues(self, ctx: GremlinParser.IoOptionsValuesContext): + pass + + # Enter a parse tree produced by GremlinParser#connectedComponentConstants_component. + def enterConnectedComponentConstants_component( + self, ctx: GremlinParser.ConnectedComponentConstants_componentContext + ): + pass + + # Exit a parse tree produced by GremlinParser#connectedComponentConstants_component. + def exitConnectedComponentConstants_component( + self, ctx: GremlinParser.ConnectedComponentConstants_componentContext + ): + pass + + # Enter a parse tree produced by GremlinParser#connectedComponentConstants_edges. + def enterConnectedComponentConstants_edges(self, ctx: GremlinParser.ConnectedComponentConstants_edgesContext): + pass + + # Exit a parse tree produced by GremlinParser#connectedComponentConstants_edges. + def exitConnectedComponentConstants_edges(self, ctx: GremlinParser.ConnectedComponentConstants_edgesContext): + pass + + # Enter a parse tree produced by GremlinParser#connectedComponentConstants_propertyName. + def enterConnectedComponentConstants_propertyName( + self, ctx: GremlinParser.ConnectedComponentConstants_propertyNameContext + ): + pass + + # Exit a parse tree produced by GremlinParser#connectedComponentConstants_propertyName. + def exitConnectedComponentConstants_propertyName( + self, ctx: GremlinParser.ConnectedComponentConstants_propertyNameContext + ): + pass + + # Enter a parse tree produced by GremlinParser#pageRankConstants_edges. + def enterPageRankConstants_edges(self, ctx: GremlinParser.PageRankConstants_edgesContext): + pass + + # Exit a parse tree produced by GremlinParser#pageRankConstants_edges. + def exitPageRankConstants_edges(self, ctx: GremlinParser.PageRankConstants_edgesContext): + pass + + # Enter a parse tree produced by GremlinParser#pageRankConstants_times. + def enterPageRankConstants_times(self, ctx: GremlinParser.PageRankConstants_timesContext): + pass + + # Exit a parse tree produced by GremlinParser#pageRankConstants_times. + def exitPageRankConstants_times(self, ctx: GremlinParser.PageRankConstants_timesContext): + pass + + # Enter a parse tree produced by GremlinParser#pageRankConstants_propertyName. + def enterPageRankConstants_propertyName(self, ctx: GremlinParser.PageRankConstants_propertyNameContext): + pass + + # Exit a parse tree produced by GremlinParser#pageRankConstants_propertyName. + def exitPageRankConstants_propertyName(self, ctx: GremlinParser.PageRankConstants_propertyNameContext): + pass + + # Enter a parse tree produced by GremlinParser#peerPressureConstants_edges. + def enterPeerPressureConstants_edges(self, ctx: GremlinParser.PeerPressureConstants_edgesContext): + pass + + # Exit a parse tree produced by GremlinParser#peerPressureConstants_edges. + def exitPeerPressureConstants_edges(self, ctx: GremlinParser.PeerPressureConstants_edgesContext): + pass + + # Enter a parse tree produced by GremlinParser#peerPressureConstants_times. + def enterPeerPressureConstants_times(self, ctx: GremlinParser.PeerPressureConstants_timesContext): + pass + + # Exit a parse tree produced by GremlinParser#peerPressureConstants_times. + def exitPeerPressureConstants_times(self, ctx: GremlinParser.PeerPressureConstants_timesContext): + pass + + # Enter a parse tree produced by GremlinParser#peerPressureConstants_propertyName. + def enterPeerPressureConstants_propertyName(self, ctx: GremlinParser.PeerPressureConstants_propertyNameContext): + pass + + # Exit a parse tree produced by GremlinParser#peerPressureConstants_propertyName. + def exitPeerPressureConstants_propertyName(self, ctx: GremlinParser.PeerPressureConstants_propertyNameContext): + pass + + # Enter a parse tree produced by GremlinParser#shortestPathConstants_target. + def enterShortestPathConstants_target(self, ctx: GremlinParser.ShortestPathConstants_targetContext): + pass + + # Exit a parse tree produced by GremlinParser#shortestPathConstants_target. + def exitShortestPathConstants_target(self, ctx: GremlinParser.ShortestPathConstants_targetContext): + pass + + # Enter a parse tree produced by GremlinParser#shortestPathConstants_edges. + def enterShortestPathConstants_edges(self, ctx: GremlinParser.ShortestPathConstants_edgesContext): + pass + + # Exit a parse tree produced by GremlinParser#shortestPathConstants_edges. + def exitShortestPathConstants_edges(self, ctx: GremlinParser.ShortestPathConstants_edgesContext): + pass + + # Enter a parse tree produced by GremlinParser#shortestPathConstants_distance. + def enterShortestPathConstants_distance(self, ctx: GremlinParser.ShortestPathConstants_distanceContext): + pass + + # Exit a parse tree produced by GremlinParser#shortestPathConstants_distance. + def exitShortestPathConstants_distance(self, ctx: GremlinParser.ShortestPathConstants_distanceContext): + pass + + # Enter a parse tree produced by GremlinParser#shortestPathConstants_maxDistance. + def enterShortestPathConstants_maxDistance(self, ctx: GremlinParser.ShortestPathConstants_maxDistanceContext): + pass + + # Exit a parse tree produced by GremlinParser#shortestPathConstants_maxDistance. + def exitShortestPathConstants_maxDistance(self, ctx: GremlinParser.ShortestPathConstants_maxDistanceContext): + pass + + # Enter a parse tree produced by GremlinParser#shortestPathConstants_includeEdges. + def enterShortestPathConstants_includeEdges(self, ctx: GremlinParser.ShortestPathConstants_includeEdgesContext): + pass + + # Exit a parse tree produced by GremlinParser#shortestPathConstants_includeEdges. + def exitShortestPathConstants_includeEdges(self, ctx: GremlinParser.ShortestPathConstants_includeEdgesContext): + pass + + # Enter a parse tree produced by GremlinParser#withOptionsConstants_tokens. + def enterWithOptionsConstants_tokens(self, ctx: GremlinParser.WithOptionsConstants_tokensContext): + pass + + # Exit a parse tree produced by GremlinParser#withOptionsConstants_tokens. + def exitWithOptionsConstants_tokens(self, ctx: GremlinParser.WithOptionsConstants_tokensContext): + pass + + # Enter a parse tree produced by GremlinParser#withOptionsConstants_none. + def enterWithOptionsConstants_none(self, ctx: GremlinParser.WithOptionsConstants_noneContext): + pass + + # Exit a parse tree produced by GremlinParser#withOptionsConstants_none. + def exitWithOptionsConstants_none(self, ctx: GremlinParser.WithOptionsConstants_noneContext): + pass + + # Enter a parse tree produced by GremlinParser#withOptionsConstants_ids. + def enterWithOptionsConstants_ids(self, ctx: GremlinParser.WithOptionsConstants_idsContext): + pass + + # Exit a parse tree produced by GremlinParser#withOptionsConstants_ids. + def exitWithOptionsConstants_ids(self, ctx: GremlinParser.WithOptionsConstants_idsContext): + pass + + # Enter a parse tree produced by GremlinParser#withOptionsConstants_labels. + def enterWithOptionsConstants_labels(self, ctx: GremlinParser.WithOptionsConstants_labelsContext): + pass + + # Exit a parse tree produced by GremlinParser#withOptionsConstants_labels. + def exitWithOptionsConstants_labels(self, ctx: GremlinParser.WithOptionsConstants_labelsContext): + pass + + # Enter a parse tree produced by GremlinParser#withOptionsConstants_keys. + def enterWithOptionsConstants_keys(self, ctx: GremlinParser.WithOptionsConstants_keysContext): + pass + + # Exit a parse tree produced by GremlinParser#withOptionsConstants_keys. + def exitWithOptionsConstants_keys(self, ctx: GremlinParser.WithOptionsConstants_keysContext): + pass + + # Enter a parse tree produced by GremlinParser#withOptionsConstants_values. + def enterWithOptionsConstants_values(self, ctx: GremlinParser.WithOptionsConstants_valuesContext): + pass + + # Exit a parse tree produced by GremlinParser#withOptionsConstants_values. + def exitWithOptionsConstants_values(self, ctx: GremlinParser.WithOptionsConstants_valuesContext): + pass + + # Enter a parse tree produced by GremlinParser#withOptionsConstants_all. + def enterWithOptionsConstants_all(self, ctx: GremlinParser.WithOptionsConstants_allContext): + pass + + # Exit a parse tree produced by GremlinParser#withOptionsConstants_all. + def exitWithOptionsConstants_all(self, ctx: GremlinParser.WithOptionsConstants_allContext): + pass + + # Enter a parse tree produced by GremlinParser#withOptionsConstants_indexer. + def enterWithOptionsConstants_indexer(self, ctx: GremlinParser.WithOptionsConstants_indexerContext): + pass + + # Exit a parse tree produced by GremlinParser#withOptionsConstants_indexer. + def exitWithOptionsConstants_indexer(self, ctx: GremlinParser.WithOptionsConstants_indexerContext): + pass + + # Enter a parse tree produced by GremlinParser#withOptionsConstants_list. + def enterWithOptionsConstants_list(self, ctx: GremlinParser.WithOptionsConstants_listContext): + pass + + # Exit a parse tree produced by GremlinParser#withOptionsConstants_list. + def exitWithOptionsConstants_list(self, ctx: GremlinParser.WithOptionsConstants_listContext): + pass + + # Enter a parse tree produced by GremlinParser#withOptionsConstants_map. + def enterWithOptionsConstants_map(self, ctx: GremlinParser.WithOptionsConstants_mapContext): + pass + + # Exit a parse tree produced by GremlinParser#withOptionsConstants_map. + def exitWithOptionsConstants_map(self, ctx: GremlinParser.WithOptionsConstants_mapContext): + pass + + # Enter a parse tree produced by GremlinParser#ioOptionsConstants_reader. + def enterIoOptionsConstants_reader(self, ctx: GremlinParser.IoOptionsConstants_readerContext): + pass + + # Exit a parse tree produced by GremlinParser#ioOptionsConstants_reader. + def exitIoOptionsConstants_reader(self, ctx: GremlinParser.IoOptionsConstants_readerContext): + pass + + # Enter a parse tree produced by GremlinParser#ioOptionsConstants_writer. + def enterIoOptionsConstants_writer(self, ctx: GremlinParser.IoOptionsConstants_writerContext): + pass + + # Exit a parse tree produced by GremlinParser#ioOptionsConstants_writer. + def exitIoOptionsConstants_writer(self, ctx: GremlinParser.IoOptionsConstants_writerContext): + pass + + # Enter a parse tree produced by GremlinParser#ioOptionsConstants_gryo. + def enterIoOptionsConstants_gryo(self, ctx: GremlinParser.IoOptionsConstants_gryoContext): + pass + + # Exit a parse tree produced by GremlinParser#ioOptionsConstants_gryo. + def exitIoOptionsConstants_gryo(self, ctx: GremlinParser.IoOptionsConstants_gryoContext): + pass + + # Enter a parse tree produced by GremlinParser#ioOptionsConstants_graphson. + def enterIoOptionsConstants_graphson(self, ctx: GremlinParser.IoOptionsConstants_graphsonContext): + pass + + # Exit a parse tree produced by GremlinParser#ioOptionsConstants_graphson. + def exitIoOptionsConstants_graphson(self, ctx: GremlinParser.IoOptionsConstants_graphsonContext): + pass + + # Enter a parse tree produced by GremlinParser#ioOptionsConstants_graphml. + def enterIoOptionsConstants_graphml(self, ctx: GremlinParser.IoOptionsConstants_graphmlContext): + pass + + # Exit a parse tree produced by GremlinParser#ioOptionsConstants_graphml. + def exitIoOptionsConstants_graphml(self, ctx: GremlinParser.IoOptionsConstants_graphmlContext): + pass + + # Enter a parse tree produced by GremlinParser#connectedComponentStringConstant. + def enterConnectedComponentStringConstant(self, ctx: GremlinParser.ConnectedComponentStringConstantContext): + pass + + # Exit a parse tree produced by GremlinParser#connectedComponentStringConstant. + def exitConnectedComponentStringConstant(self, ctx: GremlinParser.ConnectedComponentStringConstantContext): + pass + + # Enter a parse tree produced by GremlinParser#pageRankStringConstant. + def enterPageRankStringConstant(self, ctx: GremlinParser.PageRankStringConstantContext): + pass + + # Exit a parse tree produced by GremlinParser#pageRankStringConstant. + def exitPageRankStringConstant(self, ctx: GremlinParser.PageRankStringConstantContext): + pass + + # Enter a parse tree produced by GremlinParser#peerPressureStringConstant. + def enterPeerPressureStringConstant(self, ctx: GremlinParser.PeerPressureStringConstantContext): + pass + + # Exit a parse tree produced by GremlinParser#peerPressureStringConstant. + def exitPeerPressureStringConstant(self, ctx: GremlinParser.PeerPressureStringConstantContext): + pass + + # Enter a parse tree produced by GremlinParser#shortestPathStringConstant. + def enterShortestPathStringConstant(self, ctx: GremlinParser.ShortestPathStringConstantContext): + pass + + # Exit a parse tree produced by GremlinParser#shortestPathStringConstant. + def exitShortestPathStringConstant(self, ctx: GremlinParser.ShortestPathStringConstantContext): + pass + + # Enter a parse tree produced by GremlinParser#withOptionsStringConstant. + def enterWithOptionsStringConstant(self, ctx: GremlinParser.WithOptionsStringConstantContext): + pass + + # Exit a parse tree produced by GremlinParser#withOptionsStringConstant. + def exitWithOptionsStringConstant(self, ctx: GremlinParser.WithOptionsStringConstantContext): + pass + + # Enter a parse tree produced by GremlinParser#ioOptionsStringConstant. + def enterIoOptionsStringConstant(self, ctx: GremlinParser.IoOptionsStringConstantContext): + pass + + # Exit a parse tree produced by GremlinParser#ioOptionsStringConstant. + def exitIoOptionsStringConstant(self, ctx: GremlinParser.IoOptionsStringConstantContext): + pass + + # Enter a parse tree produced by GremlinParser#booleanArgument. + def enterBooleanArgument(self, ctx: GremlinParser.BooleanArgumentContext): + pass + + # Exit a parse tree produced by GremlinParser#booleanArgument. + def exitBooleanArgument(self, ctx: GremlinParser.BooleanArgumentContext): + pass + + # Enter a parse tree produced by GremlinParser#integerArgument. + def enterIntegerArgument(self, ctx: GremlinParser.IntegerArgumentContext): + pass + + # Exit a parse tree produced by GremlinParser#integerArgument. + def exitIntegerArgument(self, ctx: GremlinParser.IntegerArgumentContext): + pass + + # Enter a parse tree produced by GremlinParser#floatArgument. + def enterFloatArgument(self, ctx: GremlinParser.FloatArgumentContext): + pass + + # Exit a parse tree produced by GremlinParser#floatArgument. + def exitFloatArgument(self, ctx: GremlinParser.FloatArgumentContext): + pass + + # Enter a parse tree produced by GremlinParser#stringArgument. + def enterStringArgument(self, ctx: GremlinParser.StringArgumentContext): + pass + + # Exit a parse tree produced by GremlinParser#stringArgument. + def exitStringArgument(self, ctx: GremlinParser.StringArgumentContext): + pass + + # Enter a parse tree produced by GremlinParser#stringNullableArgument. + def enterStringNullableArgument(self, ctx: GremlinParser.StringNullableArgumentContext): + pass + + # Exit a parse tree produced by GremlinParser#stringNullableArgument. + def exitStringNullableArgument(self, ctx: GremlinParser.StringNullableArgumentContext): + pass + + # Enter a parse tree produced by GremlinParser#stringNullableArgumentVarargs. + def enterStringNullableArgumentVarargs(self, ctx: GremlinParser.StringNullableArgumentVarargsContext): + pass + + # Exit a parse tree produced by GremlinParser#stringNullableArgumentVarargs. + def exitStringNullableArgumentVarargs(self, ctx: GremlinParser.StringNullableArgumentVarargsContext): + pass + + # Enter a parse tree produced by GremlinParser#dateArgument. + def enterDateArgument(self, ctx: GremlinParser.DateArgumentContext): + pass + + # Exit a parse tree produced by GremlinParser#dateArgument. + def exitDateArgument(self, ctx: GremlinParser.DateArgumentContext): + pass + + # Enter a parse tree produced by GremlinParser#genericArgument. + def enterGenericArgument(self, ctx: GremlinParser.GenericArgumentContext): + pass + + # Exit a parse tree produced by GremlinParser#genericArgument. + def exitGenericArgument(self, ctx: GremlinParser.GenericArgumentContext): + pass + + # Enter a parse tree produced by GremlinParser#genericArgumentVarargs. + def enterGenericArgumentVarargs(self, ctx: GremlinParser.GenericArgumentVarargsContext): + pass + + # Exit a parse tree produced by GremlinParser#genericArgumentVarargs. + def exitGenericArgumentVarargs(self, ctx: GremlinParser.GenericArgumentVarargsContext): + pass + + # Enter a parse tree produced by GremlinParser#genericMapArgument. + def enterGenericMapArgument(self, ctx: GremlinParser.GenericMapArgumentContext): + pass + + # Exit a parse tree produced by GremlinParser#genericMapArgument. + def exitGenericMapArgument(self, ctx: GremlinParser.GenericMapArgumentContext): + pass + + # Enter a parse tree produced by GremlinParser#genericMapNullableArgument. + def enterGenericMapNullableArgument(self, ctx: GremlinParser.GenericMapNullableArgumentContext): + pass + + # Exit a parse tree produced by GremlinParser#genericMapNullableArgument. + def exitGenericMapNullableArgument(self, ctx: GremlinParser.GenericMapNullableArgumentContext): + pass + + # Enter a parse tree produced by GremlinParser#nullableGenericLiteralMap. + def enterNullableGenericLiteralMap(self, ctx: GremlinParser.NullableGenericLiteralMapContext): + pass + + # Exit a parse tree produced by GremlinParser#nullableGenericLiteralMap. + def exitNullableGenericLiteralMap(self, ctx: GremlinParser.NullableGenericLiteralMapContext): + pass + + # Enter a parse tree produced by GremlinParser#structureVertexArgument. + def enterStructureVertexArgument(self, ctx: GremlinParser.StructureVertexArgumentContext): + pass + + # Exit a parse tree produced by GremlinParser#structureVertexArgument. + def exitStructureVertexArgument(self, ctx: GremlinParser.StructureVertexArgumentContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalStrategyVarargs. + def enterTraversalStrategyVarargs(self, ctx: GremlinParser.TraversalStrategyVarargsContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalStrategyVarargs. + def exitTraversalStrategyVarargs(self, ctx: GremlinParser.TraversalStrategyVarargsContext): + pass + + # Enter a parse tree produced by GremlinParser#traversalStrategyExpr. + def enterTraversalStrategyExpr(self, ctx: GremlinParser.TraversalStrategyExprContext): + pass + + # Exit a parse tree produced by GremlinParser#traversalStrategyExpr. + def exitTraversalStrategyExpr(self, ctx: GremlinParser.TraversalStrategyExprContext): + pass + + # Enter a parse tree produced by GremlinParser#classTypeList. + def enterClassTypeList(self, ctx: GremlinParser.ClassTypeListContext): + pass + + # Exit a parse tree produced by GremlinParser#classTypeList. + def exitClassTypeList(self, ctx: GremlinParser.ClassTypeListContext): + pass + + # Enter a parse tree produced by GremlinParser#classTypeExpr. + def enterClassTypeExpr(self, ctx: GremlinParser.ClassTypeExprContext): + pass + + # Exit a parse tree produced by GremlinParser#classTypeExpr. + def exitClassTypeExpr(self, ctx: GremlinParser.ClassTypeExprContext): + pass + + # Enter a parse tree produced by GremlinParser#nestedTraversalList. + def enterNestedTraversalList(self, ctx: GremlinParser.NestedTraversalListContext): + pass + + # Exit a parse tree produced by GremlinParser#nestedTraversalList. + def exitNestedTraversalList(self, ctx: GremlinParser.NestedTraversalListContext): + pass + + # Enter a parse tree produced by GremlinParser#nestedTraversalExpr. + def enterNestedTraversalExpr(self, ctx: GremlinParser.NestedTraversalExprContext): + pass + + # Exit a parse tree produced by GremlinParser#nestedTraversalExpr. + def exitNestedTraversalExpr(self, ctx: GremlinParser.NestedTraversalExprContext): + pass + + # Enter a parse tree produced by GremlinParser#genericCollectionLiteral. + def enterGenericCollectionLiteral(self, ctx: GremlinParser.GenericCollectionLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#genericCollectionLiteral. + def exitGenericCollectionLiteral(self, ctx: GremlinParser.GenericCollectionLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#genericLiteralVarargs. + def enterGenericLiteralVarargs(self, ctx: GremlinParser.GenericLiteralVarargsContext): + pass + + # Exit a parse tree produced by GremlinParser#genericLiteralVarargs. + def exitGenericLiteralVarargs(self, ctx: GremlinParser.GenericLiteralVarargsContext): + pass + + # Enter a parse tree produced by GremlinParser#genericLiteralExpr. + def enterGenericLiteralExpr(self, ctx: GremlinParser.GenericLiteralExprContext): + pass + + # Exit a parse tree produced by GremlinParser#genericLiteralExpr. + def exitGenericLiteralExpr(self, ctx: GremlinParser.GenericLiteralExprContext): + pass + + # Enter a parse tree produced by GremlinParser#genericMapNullableLiteral. + def enterGenericMapNullableLiteral(self, ctx: GremlinParser.GenericMapNullableLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#genericMapNullableLiteral. + def exitGenericMapNullableLiteral(self, ctx: GremlinParser.GenericMapNullableLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#genericRangeLiteral. + def enterGenericRangeLiteral(self, ctx: GremlinParser.GenericRangeLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#genericRangeLiteral. + def exitGenericRangeLiteral(self, ctx: GremlinParser.GenericRangeLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#genericSetLiteral. + def enterGenericSetLiteral(self, ctx: GremlinParser.GenericSetLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#genericSetLiteral. + def exitGenericSetLiteral(self, ctx: GremlinParser.GenericSetLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#stringNullableLiteralVarargs. + def enterStringNullableLiteralVarargs(self, ctx: GremlinParser.StringNullableLiteralVarargsContext): + pass + + # Exit a parse tree produced by GremlinParser#stringNullableLiteralVarargs. + def exitStringNullableLiteralVarargs(self, ctx: GremlinParser.StringNullableLiteralVarargsContext): + pass + + # Enter a parse tree produced by GremlinParser#genericLiteral. + def enterGenericLiteral(self, ctx: GremlinParser.GenericLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#genericLiteral. + def exitGenericLiteral(self, ctx: GremlinParser.GenericLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#genericMapLiteral. + def enterGenericMapLiteral(self, ctx: GremlinParser.GenericMapLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#genericMapLiteral. + def exitGenericMapLiteral(self, ctx: GremlinParser.GenericMapLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#mapKey. + def enterMapKey(self, ctx: GremlinParser.MapKeyContext): + pass + + # Exit a parse tree produced by GremlinParser#mapKey. + def exitMapKey(self, ctx: GremlinParser.MapKeyContext): + pass + + # Enter a parse tree produced by GremlinParser#mapEntry. + def enterMapEntry(self, ctx: GremlinParser.MapEntryContext): + pass + + # Exit a parse tree produced by GremlinParser#mapEntry. + def exitMapEntry(self, ctx: GremlinParser.MapEntryContext): + pass + + # Enter a parse tree produced by GremlinParser#stringLiteral. + def enterStringLiteral(self, ctx: GremlinParser.StringLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#stringLiteral. + def exitStringLiteral(self, ctx: GremlinParser.StringLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#stringNullableLiteral. + def enterStringNullableLiteral(self, ctx: GremlinParser.StringNullableLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#stringNullableLiteral. + def exitStringNullableLiteral(self, ctx: GremlinParser.StringNullableLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#integerLiteral. + def enterIntegerLiteral(self, ctx: GremlinParser.IntegerLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#integerLiteral. + def exitIntegerLiteral(self, ctx: GremlinParser.IntegerLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#floatLiteral. + def enterFloatLiteral(self, ctx: GremlinParser.FloatLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#floatLiteral. + def exitFloatLiteral(self, ctx: GremlinParser.FloatLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#numericLiteral. + def enterNumericLiteral(self, ctx: GremlinParser.NumericLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#numericLiteral. + def exitNumericLiteral(self, ctx: GremlinParser.NumericLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#booleanLiteral. + def enterBooleanLiteral(self, ctx: GremlinParser.BooleanLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#booleanLiteral. + def exitBooleanLiteral(self, ctx: GremlinParser.BooleanLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#dateLiteral. + def enterDateLiteral(self, ctx: GremlinParser.DateLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#dateLiteral. + def exitDateLiteral(self, ctx: GremlinParser.DateLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#nullLiteral. + def enterNullLiteral(self, ctx: GremlinParser.NullLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#nullLiteral. + def exitNullLiteral(self, ctx: GremlinParser.NullLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#nanLiteral. + def enterNanLiteral(self, ctx: GremlinParser.NanLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#nanLiteral. + def exitNanLiteral(self, ctx: GremlinParser.NanLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#infLiteral. + def enterInfLiteral(self, ctx: GremlinParser.InfLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#infLiteral. + def exitInfLiteral(self, ctx: GremlinParser.InfLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#uuidLiteral. + def enterUuidLiteral(self, ctx: GremlinParser.UuidLiteralContext): + pass + + # Exit a parse tree produced by GremlinParser#uuidLiteral. + def exitUuidLiteral(self, ctx: GremlinParser.UuidLiteralContext): + pass + + # Enter a parse tree produced by GremlinParser#nakedKey. + def enterNakedKey(self, ctx: GremlinParser.NakedKeyContext): + pass + + # Exit a parse tree produced by GremlinParser#nakedKey. + def exitNakedKey(self, ctx: GremlinParser.NakedKeyContext): + pass + + # Enter a parse tree produced by GremlinParser#classType. + def enterClassType(self, ctx: GremlinParser.ClassTypeContext): + pass + + # Exit a parse tree produced by GremlinParser#classType. + def exitClassType(self, ctx: GremlinParser.ClassTypeContext): + pass + + # Enter a parse tree produced by GremlinParser#variable. + def enterVariable(self, ctx: GremlinParser.VariableContext): + pass + + # Exit a parse tree produced by GremlinParser#variable. + def exitVariable(self, ctx: GremlinParser.VariableContext): + pass + + # Enter a parse tree produced by GremlinParser#keyword. + def enterKeyword(self, ctx: GremlinParser.KeywordContext): + pass + + # Exit a parse tree produced by GremlinParser#keyword. + def exitKeyword(self, ctx: GremlinParser.KeywordContext): + pass + + +del GremlinParser diff --git a/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinParser.py b/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinParser.py new file mode 100644 index 000000000..fc96637b6 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinParser.py @@ -0,0 +1,61946 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +# Generated from ./Gremlin.g4 by ANTLR 4.13.1 +# 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, + 270, + 3582, + 2, + 0, + 7, + 0, + 2, + 1, + 7, + 1, + 2, + 2, + 7, + 2, + 2, + 3, + 7, + 3, + 2, + 4, + 7, + 4, + 2, + 5, + 7, + 5, + 2, + 6, + 7, + 6, + 2, + 7, + 7, + 7, + 2, + 8, + 7, + 8, + 2, + 9, + 7, + 9, + 2, + 10, + 7, + 10, + 2, + 11, + 7, + 11, + 2, + 12, + 7, + 12, + 2, + 13, + 7, + 13, + 2, + 14, + 7, + 14, + 2, + 15, + 7, + 15, + 2, + 16, + 7, + 16, + 2, + 17, + 7, + 17, + 2, + 18, + 7, + 18, + 2, + 19, + 7, + 19, + 2, + 20, + 7, + 20, + 2, + 21, + 7, + 21, + 2, + 22, + 7, + 22, + 2, + 23, + 7, + 23, + 2, + 24, + 7, + 24, + 2, + 25, + 7, + 25, + 2, + 26, + 7, + 26, + 2, + 27, + 7, + 27, + 2, + 28, + 7, + 28, + 2, + 29, + 7, + 29, + 2, + 30, + 7, + 30, + 2, + 31, + 7, + 31, + 2, + 32, + 7, + 32, + 2, + 33, + 7, + 33, + 2, + 34, + 7, + 34, + 2, + 35, + 7, + 35, + 2, + 36, + 7, + 36, + 2, + 37, + 7, + 37, + 2, + 38, + 7, + 38, + 2, + 39, + 7, + 39, + 2, + 40, + 7, + 40, + 2, + 41, + 7, + 41, + 2, + 42, + 7, + 42, + 2, + 43, + 7, + 43, + 2, + 44, + 7, + 44, + 2, + 45, + 7, + 45, + 2, + 46, + 7, + 46, + 2, + 47, + 7, + 47, + 2, + 48, + 7, + 48, + 2, + 49, + 7, + 49, + 2, + 50, + 7, + 50, + 2, + 51, + 7, + 51, + 2, + 52, + 7, + 52, + 2, + 53, + 7, + 53, + 2, + 54, + 7, + 54, + 2, + 55, + 7, + 55, + 2, + 56, + 7, + 56, + 2, + 57, + 7, + 57, + 2, + 58, + 7, + 58, + 2, + 59, + 7, + 59, + 2, + 60, + 7, + 60, + 2, + 61, + 7, + 61, + 2, + 62, + 7, + 62, + 2, + 63, + 7, + 63, + 2, + 64, + 7, + 64, + 2, + 65, + 7, + 65, + 2, + 66, + 7, + 66, + 2, + 67, + 7, + 67, + 2, + 68, + 7, + 68, + 2, + 69, + 7, + 69, + 2, + 70, + 7, + 70, + 2, + 71, + 7, + 71, + 2, + 72, + 7, + 72, + 2, + 73, + 7, + 73, + 2, + 74, + 7, + 74, + 2, + 75, + 7, + 75, + 2, + 76, + 7, + 76, + 2, + 77, + 7, + 77, + 2, + 78, + 7, + 78, + 2, + 79, + 7, + 79, + 2, + 80, + 7, + 80, + 2, + 81, + 7, + 81, + 2, + 82, + 7, + 82, + 2, + 83, + 7, + 83, + 2, + 84, + 7, + 84, + 2, + 85, + 7, + 85, + 2, + 86, + 7, + 86, + 2, + 87, + 7, + 87, + 2, + 88, + 7, + 88, + 2, + 89, + 7, + 89, + 2, + 90, + 7, + 90, + 2, + 91, + 7, + 91, + 2, + 92, + 7, + 92, + 2, + 93, + 7, + 93, + 2, + 94, + 7, + 94, + 2, + 95, + 7, + 95, + 2, + 96, + 7, + 96, + 2, + 97, + 7, + 97, + 2, + 98, + 7, + 98, + 2, + 99, + 7, + 99, + 2, + 100, + 7, + 100, + 2, + 101, + 7, + 101, + 2, + 102, + 7, + 102, + 2, + 103, + 7, + 103, + 2, + 104, + 7, + 104, + 2, + 105, + 7, + 105, + 2, + 106, + 7, + 106, + 2, + 107, + 7, + 107, + 2, + 108, + 7, + 108, + 2, + 109, + 7, + 109, + 2, + 110, + 7, + 110, + 2, + 111, + 7, + 111, + 2, + 112, + 7, + 112, + 2, + 113, + 7, + 113, + 2, + 114, + 7, + 114, + 2, + 115, + 7, + 115, + 2, + 116, + 7, + 116, + 2, + 117, + 7, + 117, + 2, + 118, + 7, + 118, + 2, + 119, + 7, + 119, + 2, + 120, + 7, + 120, + 2, + 121, + 7, + 121, + 2, + 122, + 7, + 122, + 2, + 123, + 7, + 123, + 2, + 124, + 7, + 124, + 2, + 125, + 7, + 125, + 2, + 126, + 7, + 126, + 2, + 127, + 7, + 127, + 2, + 128, + 7, + 128, + 2, + 129, + 7, + 129, + 2, + 130, + 7, + 130, + 2, + 131, + 7, + 131, + 2, + 132, + 7, + 132, + 2, + 133, + 7, + 133, + 2, + 134, + 7, + 134, + 2, + 135, + 7, + 135, + 2, + 136, + 7, + 136, + 2, + 137, + 7, + 137, + 2, + 138, + 7, + 138, + 2, + 139, + 7, + 139, + 2, + 140, + 7, + 140, + 2, + 141, + 7, + 141, + 2, + 142, + 7, + 142, + 2, + 143, + 7, + 143, + 2, + 144, + 7, + 144, + 2, + 145, + 7, + 145, + 2, + 146, + 7, + 146, + 2, + 147, + 7, + 147, + 2, + 148, + 7, + 148, + 2, + 149, + 7, + 149, + 2, + 150, + 7, + 150, + 2, + 151, + 7, + 151, + 2, + 152, + 7, + 152, + 2, + 153, + 7, + 153, + 2, + 154, + 7, + 154, + 2, + 155, + 7, + 155, + 2, + 156, + 7, + 156, + 2, + 157, + 7, + 157, + 2, + 158, + 7, + 158, + 2, + 159, + 7, + 159, + 2, + 160, + 7, + 160, + 2, + 161, + 7, + 161, + 2, + 162, + 7, + 162, + 2, + 163, + 7, + 163, + 2, + 164, + 7, + 164, + 2, + 165, + 7, + 165, + 2, + 166, + 7, + 166, + 2, + 167, + 7, + 167, + 2, + 168, + 7, + 168, + 2, + 169, + 7, + 169, + 2, + 170, + 7, + 170, + 2, + 171, + 7, + 171, + 2, + 172, + 7, + 172, + 2, + 173, + 7, + 173, + 2, + 174, + 7, + 174, + 2, + 175, + 7, + 175, + 2, + 176, + 7, + 176, + 2, + 177, + 7, + 177, + 2, + 178, + 7, + 178, + 2, + 179, + 7, + 179, + 2, + 180, + 7, + 180, + 2, + 181, + 7, + 181, + 2, + 182, + 7, + 182, + 2, + 183, + 7, + 183, + 2, + 184, + 7, + 184, + 2, + 185, + 7, + 185, + 2, + 186, + 7, + 186, + 2, + 187, + 7, + 187, + 2, + 188, + 7, + 188, + 2, + 189, + 7, + 189, + 2, + 190, + 7, + 190, + 2, + 191, + 7, + 191, + 2, + 192, + 7, + 192, + 2, + 193, + 7, + 193, + 2, + 194, + 7, + 194, + 2, + 195, + 7, + 195, + 2, + 196, + 7, + 196, + 2, + 197, + 7, + 197, + 2, + 198, + 7, + 198, + 2, + 199, + 7, + 199, + 2, + 200, + 7, + 200, + 2, + 201, + 7, + 201, + 2, + 202, + 7, + 202, + 2, + 203, + 7, + 203, + 2, + 204, + 7, + 204, + 2, + 205, + 7, + 205, + 2, + 206, + 7, + 206, + 2, + 207, + 7, + 207, + 2, + 208, + 7, + 208, + 2, + 209, + 7, + 209, + 2, + 210, + 7, + 210, + 2, + 211, + 7, + 211, + 2, + 212, + 7, + 212, + 2, + 213, + 7, + 213, + 2, + 214, + 7, + 214, + 2, + 215, + 7, + 215, + 2, + 216, + 7, + 216, + 2, + 217, + 7, + 217, + 2, + 218, + 7, + 218, + 2, + 219, + 7, + 219, + 2, + 220, + 7, + 220, + 2, + 221, + 7, + 221, + 2, + 222, + 7, + 222, + 2, + 223, + 7, + 223, + 2, + 224, + 7, + 224, + 2, + 225, + 7, + 225, + 2, + 226, + 7, + 226, + 2, + 227, + 7, + 227, + 2, + 228, + 7, + 228, + 2, + 229, + 7, + 229, + 2, + 230, + 7, + 230, + 2, + 231, + 7, + 231, + 2, + 232, + 7, + 232, + 2, + 233, + 7, + 233, + 2, + 234, + 7, + 234, + 2, + 235, + 7, + 235, + 2, + 236, + 7, + 236, + 2, + 237, + 7, + 237, + 2, + 238, + 7, + 238, + 2, + 239, + 7, + 239, + 2, + 240, + 7, + 240, + 2, + 241, + 7, + 241, + 2, + 242, + 7, + 242, + 2, + 243, + 7, + 243, + 2, + 244, + 7, + 244, + 2, + 245, + 7, + 245, + 2, + 246, + 7, + 246, + 2, + 247, + 7, + 247, + 2, + 248, + 7, + 248, + 2, + 249, + 7, + 249, + 2, + 250, + 7, + 250, + 2, + 251, + 7, + 251, + 2, + 252, + 7, + 252, + 2, + 253, + 7, + 253, + 2, + 254, + 7, + 254, + 2, + 255, + 7, + 255, + 2, + 256, + 7, + 256, + 2, + 257, + 7, + 257, + 2, + 258, + 7, + 258, + 2, + 259, + 7, + 259, + 2, + 260, + 7, + 260, + 2, + 261, + 7, + 261, + 2, + 262, + 7, + 262, + 2, + 263, + 7, + 263, + 2, + 264, + 7, + 264, + 2, + 265, + 7, + 265, + 2, + 266, + 7, + 266, + 2, + 267, + 7, + 267, + 2, + 268, + 7, + 268, + 2, + 269, + 7, + 269, + 2, + 270, + 7, + 270, + 2, + 271, + 7, + 271, + 2, + 272, + 7, + 272, + 2, + 273, + 7, + 273, + 2, + 274, + 7, + 274, + 2, + 275, + 7, + 275, + 2, + 276, + 7, + 276, + 2, + 277, + 7, + 277, + 2, + 278, + 7, + 278, + 2, + 279, + 7, + 279, + 2, + 280, + 7, + 280, + 2, + 281, + 7, + 281, + 2, + 282, + 7, + 282, + 2, + 283, + 7, + 283, + 2, + 284, + 7, + 284, + 2, + 285, + 7, + 285, + 2, + 286, + 7, + 286, + 2, + 287, + 7, + 287, + 2, + 288, + 7, + 288, + 2, + 289, + 7, + 289, + 2, + 290, + 7, + 290, + 2, + 291, + 7, + 291, + 2, + 292, + 7, + 292, + 2, + 293, + 7, + 293, + 2, + 294, + 7, + 294, + 2, + 295, + 7, + 295, + 2, + 296, + 7, + 296, + 2, + 297, + 7, + 297, + 2, + 298, + 7, + 298, + 2, + 299, + 7, + 299, + 2, + 300, + 7, + 300, + 2, + 301, + 7, + 301, + 2, + 302, + 7, + 302, + 2, + 303, + 7, + 303, + 1, + 0, + 1, + 0, + 3, + 0, + 611, + 8, + 0, + 1, + 0, + 5, + 0, + 614, + 8, + 0, + 10, + 0, + 12, + 0, + 617, + 9, + 0, + 1, + 0, + 3, + 0, + 620, + 8, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 3, + 1, + 636, + 8, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 5, + 1, + 643, + 8, + 1, + 10, + 1, + 12, + 1, + 646, + 9, + 1, + 1, + 2, + 1, + 2, + 1, + 3, + 1, + 3, + 1, + 3, + 1, + 3, + 1, + 3, + 3, + 3, + 655, + 8, + 3, + 1, + 3, + 1, + 3, + 1, + 3, + 5, + 3, + 660, + 8, + 3, + 10, + 3, + 12, + 3, + 663, + 9, + 3, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 3, + 4, + 686, + 8, + 4, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 3, + 5, + 698, + 8, + 5, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 3, + 6, + 707, + 8, + 6, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 8, + 1, + 8, + 1, + 8, + 1, + 8, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 3, + 9, + 730, + 8, + 9, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 3, + 10, + 748, + 8, + 10, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 3, + 11, + 755, + 8, + 11, + 1, + 11, + 1, + 11, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 3, + 12, + 764, + 8, + 12, + 1, + 12, + 1, + 12, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 3, + 13, + 780, + 8, + 13, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 3, + 14, + 792, + 8, + 14, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 3, + 15, + 804, + 8, + 15, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 3, + 16, + 819, + 8, + 16, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 3, + 21, + 851, + 8, + 21, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 3, + 22, + 863, + 8, + 22, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 3, + 23, + 896, + 8, + 23, + 1, + 24, + 1, + 24, + 1, + 24, + 1, + 24, + 1, + 24, + 1, + 25, + 1, + 25, + 1, + 25, + 1, + 25, + 1, + 25, + 1, + 25, + 5, + 25, + 909, + 8, + 25, + 10, + 25, + 12, + 25, + 912, + 9, + 25, + 1, + 26, + 1, + 26, + 1, + 26, + 1, + 26, + 3, + 26, + 918, + 8, + 26, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 3, + 28, + 1058, + 8, + 28, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 30, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 3, + 31, + 1080, + 8, + 31, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 3, + 32, + 1095, + 8, + 32, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 1109, + 8, + 33, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 3, + 37, + 1131, + 8, + 37, + 1, + 37, + 1, + 37, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 39, + 1, + 39, + 1, + 39, + 1, + 39, + 1, + 39, + 1, + 39, + 1, + 39, + 1, + 39, + 3, + 39, + 1147, + 8, + 39, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 3, + 40, + 1162, + 8, + 40, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 3, + 45, + 1237, + 8, + 45, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 3, + 46, + 1267, + 8, + 46, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 3, + 47, + 1274, + 8, + 47, + 1, + 47, + 1, + 47, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 3, + 48, + 1320, + 8, + 48, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 3, + 52, + 1342, + 8, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 3, + 52, + 1351, + 8, + 52, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 3, + 56, + 1375, + 8, + 56, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 59, + 3, + 59, + 1398, + 8, + 59, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 3, + 60, + 1405, + 8, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 3, + 60, + 1414, + 8, + 60, + 1, + 61, + 1, + 61, + 1, + 61, + 1, + 61, + 1, + 61, + 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, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 3, + 67, + 1456, + 8, + 67, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 3, + 68, + 1466, + 8, + 68, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 3, + 69, + 1478, + 8, + 69, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 3, + 71, + 1495, + 8, + 71, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 3, + 73, + 1517, + 8, + 73, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 3, + 74, + 1527, + 8, + 74, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 3, + 75, + 1537, + 8, + 75, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 3, + 76, + 1604, + 8, + 76, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 3, + 77, + 1611, + 8, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 3, + 77, + 1620, + 8, + 77, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 3, + 78, + 1632, + 8, + 78, + 1, + 78, + 1, + 78, + 3, + 78, + 1636, + 8, + 78, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 3, + 79, + 1648, + 8, + 79, + 1, + 79, + 1, + 79, + 3, + 79, + 1652, + 8, + 79, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 3, + 81, + 1664, + 8, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 3, + 81, + 1673, + 8, + 81, + 1, + 82, + 1, + 82, + 1, + 82, + 1, + 82, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 85, + 1, + 85, + 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, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 3, + 90, + 1721, + 8, + 90, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 3, + 93, + 1739, + 8, + 93, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 3, + 94, + 1753, + 8, + 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, + 3, + 96, + 1768, + 8, + 96, + 1, + 97, + 1, + 97, + 1, + 97, + 1, + 97, + 1, + 97, + 1, + 97, + 1, + 97, + 1, + 97, + 3, + 97, + 1778, + 8, + 97, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 101, + 3, + 101, + 1803, + 8, + 101, + 1, + 102, + 1, + 102, + 1, + 102, + 1, + 102, + 1, + 102, + 1, + 102, + 1, + 102, + 1, + 102, + 3, + 102, + 1813, + 8, + 102, + 1, + 103, + 1, + 103, + 1, + 103, + 1, + 103, + 1, + 103, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 3, + 104, + 1833, + 8, + 104, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 3, + 105, + 1848, + 8, + 105, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 106, + 3, + 106, + 1858, + 8, + 106, + 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, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 3, + 109, + 1912, + 8, + 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, + 112, + 1, + 112, + 1, + 112, + 1, + 112, + 3, + 112, + 1932, + 8, + 112, + 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, + 116, + 1, + 116, + 1, + 116, + 1, + 116, + 1, + 117, + 1, + 117, + 1, + 117, + 1, + 117, + 1, + 117, + 1, + 117, + 1, + 117, + 1, + 117, + 3, + 117, + 1960, + 8, + 117, + 1, + 118, + 1, + 118, + 1, + 118, + 1, + 118, + 1, + 119, + 1, + 119, + 1, + 119, + 1, + 119, + 1, + 120, + 1, + 120, + 1, + 120, + 1, + 120, + 1, + 120, + 1, + 121, + 1, + 121, + 1, + 121, + 1, + 121, + 1, + 121, + 1, + 121, + 1, + 121, + 1, + 121, + 3, + 121, + 1983, + 8, + 121, + 1, + 122, + 1, + 122, + 1, + 122, + 1, + 122, + 1, + 122, + 3, + 122, + 1990, + 8, + 122, + 1, + 122, + 1, + 122, + 1, + 123, + 1, + 123, + 1, + 123, + 1, + 123, + 1, + 123, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 3, + 124, + 2008, + 8, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 3, + 124, + 2026, + 8, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 1, + 124, + 3, + 124, + 2035, + 8, + 124, + 1, + 125, + 1, + 125, + 1, + 125, + 1, + 125, + 1, + 125, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 1, + 126, + 3, + 126, + 2058, + 8, + 126, + 1, + 127, + 1, + 127, + 1, + 127, + 1, + 127, + 1, + 128, + 1, + 128, + 1, + 128, + 1, + 128, + 1, + 128, + 1, + 128, + 1, + 128, + 1, + 128, + 1, + 128, + 1, + 128, + 1, + 128, + 1, + 128, + 3, + 128, + 2076, + 8, + 128, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 1, + 129, + 3, + 129, + 2094, + 8, + 129, + 1, + 130, + 1, + 130, + 1, + 130, + 1, + 130, + 1, + 131, + 1, + 131, + 1, + 131, + 1, + 131, + 1, + 131, + 1, + 131, + 1, + 131, + 1, + 131, + 3, + 131, + 2108, + 8, + 131, + 1, + 132, + 1, + 132, + 1, + 132, + 1, + 132, + 1, + 132, + 1, + 132, + 1, + 132, + 1, + 132, + 3, + 132, + 2118, + 8, + 132, + 1, + 133, + 1, + 133, + 1, + 133, + 1, + 133, + 1, + 133, + 1, + 133, + 1, + 133, + 1, + 133, + 1, + 133, + 1, + 133, + 1, + 133, + 1, + 133, + 3, + 133, + 2132, + 8, + 133, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 3, + 134, + 2155, + 8, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 3, + 134, + 2178, + 8, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 1, + 134, + 3, + 134, + 2187, + 8, + 134, + 1, + 135, + 1, + 135, + 1, + 135, + 1, + 135, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 136, + 1, + 137, + 1, + 137, + 1, + 137, + 1, + 137, + 1, + 138, + 1, + 138, + 1, + 138, + 1, + 138, + 1, + 138, + 1, + 138, + 1, + 138, + 1, + 138, + 1, + 138, + 1, + 138, + 1, + 138, + 1, + 138, + 3, + 138, + 2214, + 8, + 138, + 1, + 139, + 1, + 139, + 1, + 139, + 1, + 139, + 1, + 139, + 1, + 139, + 1, + 139, + 1, + 139, + 1, + 139, + 1, + 139, + 1, + 139, + 1, + 139, + 3, + 139, + 2228, + 8, + 139, + 1, + 140, + 1, + 140, + 1, + 140, + 1, + 140, + 1, + 140, + 1, + 141, + 1, + 141, + 1, + 141, + 1, + 141, + 1, + 141, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 1, + 142, + 3, + 142, + 2268, + 8, + 142, + 1, + 143, + 1, + 143, + 1, + 143, + 1, + 143, + 1, + 143, + 1, + 143, + 1, + 143, + 1, + 143, + 3, + 143, + 2278, + 8, + 143, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 1, + 144, + 3, + 144, + 2300, + 8, + 144, + 1, + 145, + 1, + 145, + 1, + 145, + 1, + 145, + 1, + 145, + 1, + 146, + 1, + 146, + 1, + 146, + 1, + 146, + 1, + 146, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 3, + 147, + 2317, + 8, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 1, + 147, + 3, + 147, + 2336, + 8, + 147, + 1, + 148, + 1, + 148, + 1, + 148, + 1, + 148, + 1, + 148, + 3, + 148, + 2343, + 8, + 148, + 1, + 148, + 1, + 148, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 1, + 149, + 3, + 149, + 2355, + 8, + 149, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 1, + 150, + 3, + 150, + 2365, + 8, + 150, + 1, + 151, + 1, + 151, + 1, + 151, + 1, + 151, + 1, + 151, + 1, + 152, + 1, + 152, + 1, + 152, + 1, + 152, + 1, + 152, + 1, + 152, + 1, + 152, + 1, + 152, + 3, + 152, + 2380, + 8, + 152, + 1, + 153, + 1, + 153, + 1, + 153, + 1, + 153, + 1, + 153, + 1, + 153, + 1, + 153, + 1, + 153, + 3, + 153, + 2390, + 8, + 153, + 1, + 154, + 1, + 154, + 1, + 154, + 1, + 154, + 1, + 155, + 1, + 155, + 1, + 155, + 1, + 155, + 1, + 155, + 1, + 156, + 1, + 156, + 1, + 156, + 1, + 156, + 1, + 156, + 1, + 156, + 1, + 156, + 1, + 156, + 1, + 156, + 1, + 156, + 3, + 156, + 2411, + 8, + 156, + 1, + 157, + 1, + 157, + 1, + 157, + 1, + 157, + 1, + 158, + 1, + 158, + 1, + 158, + 1, + 158, + 1, + 158, + 1, + 158, + 1, + 158, + 1, + 158, + 1, + 158, + 1, + 158, + 3, + 158, + 2427, + 8, + 158, + 1, + 158, + 1, + 158, + 3, + 158, + 2431, + 8, + 158, + 1, + 159, + 1, + 159, + 1, + 159, + 1, + 159, + 1, + 159, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 1, + 160, + 3, + 160, + 2455, + 8, + 160, + 1, + 161, + 1, + 161, + 1, + 161, + 1, + 161, + 3, + 161, + 2461, + 8, + 161, + 1, + 161, + 1, + 161, + 1, + 161, + 1, + 161, + 1, + 161, + 1, + 161, + 3, + 161, + 2469, + 8, + 161, + 1, + 161, + 1, + 161, + 1, + 161, + 1, + 161, + 3, + 161, + 2475, + 8, + 161, + 1, + 161, + 1, + 161, + 3, + 161, + 2479, + 8, + 161, + 1, + 162, + 1, + 162, + 1, + 162, + 1, + 162, + 1, + 163, + 3, + 163, + 2486, + 8, + 163, + 1, + 163, + 1, + 163, + 1, + 163, + 1, + 163, + 1, + 163, + 1, + 163, + 1, + 163, + 1, + 164, + 3, + 164, + 2496, + 8, + 164, + 1, + 164, + 1, + 164, + 1, + 164, + 1, + 164, + 1, + 164, + 5, + 164, + 2503, + 8, + 164, + 10, + 164, + 12, + 164, + 2506, + 9, + 164, + 3, + 164, + 2508, + 8, + 164, + 1, + 164, + 3, + 164, + 2511, + 8, + 164, + 1, + 165, + 1, + 165, + 3, + 165, + 2515, + 8, + 165, + 1, + 165, + 1, + 165, + 1, + 165, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 166, + 1, + 166, + 3, + 166, + 2528, + 8, + 166, + 1, + 167, + 1, + 167, + 1, + 167, + 1, + 167, + 3, + 167, + 2534, + 8, + 167, + 1, + 168, + 1, + 168, + 3, + 168, + 2538, + 8, + 168, + 1, + 169, + 1, + 169, + 1, + 170, + 1, + 170, + 1, + 170, + 1, + 170, + 1, + 170, + 1, + 170, + 1, + 170, + 1, + 170, + 1, + 170, + 1, + 170, + 1, + 170, + 1, + 170, + 3, + 170, + 2554, + 8, + 170, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 1, + 171, + 3, + 171, + 2572, + 8, + 171, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 1, + 172, + 3, + 172, + 2586, + 8, + 172, + 1, + 173, + 1, + 173, + 3, + 173, + 2590, + 8, + 173, + 1, + 174, + 1, + 174, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 1, + 175, + 3, + 175, + 2609, + 8, + 175, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 3, + 176, + 2615, + 8, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 3, + 176, + 2625, + 8, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 3, + 176, + 2635, + 8, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 1, + 176, + 3, + 176, + 2653, + 8, + 176, + 1, + 177, + 1, + 177, + 1, + 177, + 1, + 177, + 1, + 177, + 1, + 177, + 1, + 177, + 1, + 177, + 3, + 177, + 2663, + 8, + 177, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 178, + 1, + 178, + 3, + 178, + 2681, + 8, + 178, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 1, + 179, + 3, + 179, + 2727, + 8, + 179, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 1, + 180, + 3, + 180, + 2737, + 8, + 180, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 1, + 181, + 3, + 181, + 2755, + 8, + 181, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 3, + 182, + 2778, + 8, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 1, + 182, + 5, + 182, + 2799, + 8, + 182, + 10, + 182, + 12, + 182, + 2802, + 9, + 182, + 1, + 183, + 1, + 183, + 1, + 183, + 1, + 183, + 1, + 183, + 1, + 183, + 1, + 183, + 1, + 183, + 3, + 183, + 2812, + 8, + 183, + 1, + 184, + 1, + 184, + 1, + 185, + 1, + 185, + 1, + 186, + 1, + 186, + 3, + 186, + 2820, + 8, + 186, + 1, + 187, + 1, + 187, + 1, + 188, + 1, + 188, + 1, + 188, + 1, + 188, + 3, + 188, + 2828, + 8, + 188, + 1, + 188, + 1, + 188, + 1, + 188, + 1, + 188, + 1, + 189, + 1, + 189, + 1, + 189, + 1, + 189, + 3, + 189, + 2838, + 8, + 189, + 1, + 189, + 1, + 189, + 1, + 189, + 1, + 189, + 1, + 190, + 1, + 190, + 1, + 190, + 1, + 190, + 3, + 190, + 2848, + 8, + 190, + 1, + 190, + 1, + 190, + 1, + 190, + 1, + 190, + 1, + 191, + 1, + 191, + 1, + 191, + 1, + 191, + 3, + 191, + 2858, + 8, + 191, + 1, + 191, + 1, + 191, + 1, + 191, + 1, + 191, + 1, + 192, + 1, + 192, + 1, + 192, + 1, + 192, + 3, + 192, + 2868, + 8, + 192, + 1, + 192, + 1, + 192, + 1, + 192, + 1, + 192, + 1, + 193, + 1, + 193, + 1, + 193, + 1, + 193, + 3, + 193, + 2878, + 8, + 193, + 1, + 193, + 1, + 193, + 1, + 193, + 1, + 193, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 194, + 3, + 194, + 2888, + 8, + 194, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 194, + 1, + 195, + 1, + 195, + 1, + 195, + 1, + 195, + 3, + 195, + 2900, + 8, + 195, + 1, + 195, + 1, + 195, + 1, + 195, + 1, + 195, + 1, + 195, + 1, + 195, + 1, + 196, + 1, + 196, + 1, + 196, + 1, + 196, + 3, + 196, + 2912, + 8, + 196, + 1, + 196, + 1, + 196, + 1, + 196, + 1, + 196, + 1, + 196, + 1, + 196, + 1, + 197, + 1, + 197, + 1, + 197, + 1, + 197, + 3, + 197, + 2924, + 8, + 197, + 1, + 197, + 1, + 197, + 1, + 197, + 1, + 197, + 1, + 197, + 1, + 197, + 3, + 197, + 2932, + 8, + 197, + 1, + 197, + 1, + 197, + 1, + 197, + 1, + 197, + 3, + 197, + 2938, + 8, + 197, + 1, + 198, + 1, + 198, + 1, + 198, + 1, + 198, + 3, + 198, + 2944, + 8, + 198, + 1, + 198, + 1, + 198, + 1, + 198, + 1, + 198, + 1, + 198, + 1, + 198, + 3, + 198, + 2952, + 8, + 198, + 1, + 198, + 1, + 198, + 1, + 198, + 1, + 198, + 3, + 198, + 2958, + 8, + 198, + 1, + 199, + 1, + 199, + 1, + 199, + 1, + 199, + 3, + 199, + 2964, + 8, + 199, + 1, + 199, + 1, + 199, + 1, + 199, + 1, + 199, + 1, + 200, + 1, + 200, + 1, + 200, + 1, + 200, + 3, + 200, + 2974, + 8, + 200, + 1, + 200, + 1, + 200, + 1, + 200, + 1, + 200, + 1, + 201, + 1, + 201, + 1, + 201, + 1, + 201, + 3, + 201, + 2984, + 8, + 201, + 1, + 201, + 1, + 201, + 1, + 201, + 1, + 201, + 1, + 202, + 1, + 202, + 1, + 202, + 1, + 202, + 3, + 202, + 2994, + 8, + 202, + 1, + 202, + 1, + 202, + 1, + 202, + 1, + 202, + 1, + 203, + 1, + 203, + 1, + 203, + 1, + 203, + 3, + 203, + 3004, + 8, + 203, + 1, + 203, + 1, + 203, + 1, + 203, + 1, + 203, + 1, + 204, + 1, + 204, + 1, + 204, + 1, + 204, + 3, + 204, + 3014, + 8, + 204, + 1, + 204, + 1, + 204, + 1, + 204, + 1, + 204, + 1, + 205, + 1, + 205, + 1, + 205, + 1, + 205, + 3, + 205, + 3024, + 8, + 205, + 1, + 205, + 1, + 205, + 1, + 205, + 1, + 205, + 1, + 206, + 1, + 206, + 1, + 206, + 1, + 206, + 3, + 206, + 3034, + 8, + 206, + 1, + 206, + 1, + 206, + 1, + 206, + 1, + 206, + 1, + 207, + 1, + 207, + 1, + 207, + 1, + 207, + 3, + 207, + 3044, + 8, + 207, + 1, + 207, + 1, + 207, + 1, + 207, + 1, + 207, + 1, + 208, + 1, + 208, + 1, + 208, + 1, + 208, + 1, + 209, + 1, + 209, + 1, + 209, + 1, + 209, + 1, + 210, + 1, + 210, + 1, + 210, + 1, + 210, + 1, + 211, + 1, + 211, + 1, + 211, + 1, + 211, + 1, + 212, + 1, + 212, + 1, + 212, + 1, + 212, + 1, + 212, + 1, + 212, + 1, + 212, + 1, + 212, + 3, + 212, + 3074, + 8, + 212, + 1, + 213, + 1, + 213, + 1, + 213, + 1, + 213, + 1, + 214, + 1, + 214, + 1, + 214, + 1, + 214, + 1, + 215, + 1, + 215, + 1, + 215, + 1, + 215, + 1, + 216, + 1, + 216, + 1, + 216, + 1, + 216, + 1, + 216, + 1, + 216, + 1, + 216, + 3, + 216, + 3095, + 8, + 216, + 1, + 217, + 1, + 217, + 1, + 217, + 3, + 217, + 3100, + 8, + 217, + 1, + 218, + 1, + 218, + 1, + 218, + 3, + 218, + 3105, + 8, + 218, + 1, + 219, + 1, + 219, + 1, + 219, + 3, + 219, + 3110, + 8, + 219, + 1, + 220, + 1, + 220, + 1, + 220, + 1, + 220, + 1, + 220, + 3, + 220, + 3117, + 8, + 220, + 1, + 221, + 1, + 221, + 1, + 221, + 1, + 221, + 1, + 221, + 1, + 221, + 1, + 221, + 1, + 221, + 1, + 221, + 3, + 221, + 3128, + 8, + 221, + 1, + 222, + 1, + 222, + 3, + 222, + 3132, + 8, + 222, + 1, + 223, + 1, + 223, + 1, + 223, + 3, + 223, + 3137, + 8, + 223, + 1, + 224, + 1, + 224, + 1, + 224, + 1, + 224, + 1, + 225, + 1, + 225, + 1, + 225, + 1, + 225, + 1, + 226, + 1, + 226, + 1, + 226, + 1, + 226, + 1, + 227, + 1, + 227, + 1, + 227, + 1, + 227, + 1, + 228, + 1, + 228, + 1, + 228, + 1, + 228, + 1, + 229, + 1, + 229, + 1, + 229, + 1, + 229, + 1, + 230, + 1, + 230, + 1, + 230, + 1, + 230, + 1, + 231, + 1, + 231, + 1, + 231, + 1, + 231, + 1, + 232, + 1, + 232, + 1, + 232, + 1, + 232, + 1, + 233, + 1, + 233, + 1, + 233, + 1, + 233, + 1, + 234, + 1, + 234, + 1, + 234, + 1, + 234, + 1, + 235, + 1, + 235, + 1, + 235, + 1, + 235, + 1, + 236, + 1, + 236, + 1, + 236, + 1, + 236, + 1, + 237, + 1, + 237, + 1, + 237, + 1, + 237, + 1, + 238, + 1, + 238, + 1, + 238, + 1, + 238, + 1, + 239, + 1, + 239, + 1, + 239, + 1, + 239, + 1, + 240, + 1, + 240, + 1, + 240, + 1, + 240, + 1, + 241, + 1, + 241, + 1, + 241, + 1, + 241, + 1, + 242, + 1, + 242, + 1, + 242, + 1, + 242, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 243, + 1, + 244, + 1, + 244, + 1, + 244, + 1, + 244, + 1, + 245, + 1, + 245, + 1, + 245, + 1, + 245, + 1, + 246, + 1, + 246, + 1, + 246, + 1, + 246, + 1, + 247, + 1, + 247, + 1, + 247, + 1, + 247, + 1, + 248, + 1, + 248, + 1, + 248, + 1, + 248, + 1, + 249, + 1, + 249, + 1, + 249, + 1, + 249, + 1, + 250, + 1, + 250, + 1, + 250, + 1, + 250, + 1, + 251, + 1, + 251, + 1, + 251, + 1, + 251, + 1, + 252, + 1, + 252, + 1, + 252, + 1, + 252, + 1, + 253, + 1, + 253, + 1, + 254, + 1, + 254, + 1, + 255, + 1, + 255, + 1, + 256, + 1, + 256, + 1, + 257, + 1, + 257, + 1, + 258, + 1, + 258, + 1, + 259, + 1, + 259, + 3, + 259, + 3269, + 8, + 259, + 1, + 260, + 1, + 260, + 3, + 260, + 3273, + 8, + 260, + 1, + 261, + 1, + 261, + 3, + 261, + 3277, + 8, + 261, + 1, + 262, + 1, + 262, + 3, + 262, + 3281, + 8, + 262, + 1, + 263, + 1, + 263, + 3, + 263, + 3285, + 8, + 263, + 1, + 264, + 1, + 264, + 1, + 264, + 5, + 264, + 3290, + 8, + 264, + 10, + 264, + 12, + 264, + 3293, + 9, + 264, + 3, + 264, + 3295, + 8, + 264, + 1, + 265, + 1, + 265, + 3, + 265, + 3299, + 8, + 265, + 1, + 266, + 1, + 266, + 3, + 266, + 3303, + 8, + 266, + 1, + 267, + 1, + 267, + 1, + 267, + 5, + 267, + 3308, + 8, + 267, + 10, + 267, + 12, + 267, + 3311, + 9, + 267, + 3, + 267, + 3313, + 8, + 267, + 1, + 268, + 1, + 268, + 3, + 268, + 3317, + 8, + 268, + 1, + 269, + 1, + 269, + 3, + 269, + 3321, + 8, + 269, + 1, + 270, + 1, + 270, + 3, + 270, + 3325, + 8, + 270, + 1, + 271, + 1, + 271, + 3, + 271, + 3329, + 8, + 271, + 1, + 272, + 3, + 272, + 3332, + 8, + 272, + 1, + 273, + 1, + 273, + 1, + 273, + 5, + 273, + 3337, + 8, + 273, + 10, + 273, + 12, + 273, + 3340, + 9, + 273, + 1, + 274, + 3, + 274, + 3343, + 8, + 274, + 1, + 275, + 1, + 275, + 1, + 275, + 5, + 275, + 3348, + 8, + 275, + 10, + 275, + 12, + 275, + 3351, + 9, + 275, + 1, + 276, + 3, + 276, + 3354, + 8, + 276, + 1, + 277, + 1, + 277, + 1, + 277, + 5, + 277, + 3359, + 8, + 277, + 10, + 277, + 12, + 277, + 3362, + 9, + 277, + 1, + 278, + 1, + 278, + 1, + 278, + 1, + 278, + 5, + 278, + 3368, + 8, + 278, + 10, + 278, + 12, + 278, + 3371, + 9, + 278, + 3, + 278, + 3373, + 8, + 278, + 1, + 278, + 1, + 278, + 1, + 279, + 3, + 279, + 3378, + 8, + 279, + 1, + 280, + 1, + 280, + 1, + 280, + 5, + 280, + 3383, + 8, + 280, + 10, + 280, + 12, + 280, + 3386, + 9, + 280, + 1, + 281, + 1, + 281, + 3, + 281, + 3390, + 8, + 281, + 1, + 282, + 1, + 282, + 1, + 282, + 1, + 282, + 1, + 282, + 1, + 282, + 1, + 282, + 1, + 282, + 1, + 282, + 1, + 282, + 3, + 282, + 3402, + 8, + 282, + 1, + 283, + 1, + 283, + 1, + 283, + 1, + 283, + 5, + 283, + 3408, + 8, + 283, + 10, + 283, + 12, + 283, + 3411, + 9, + 283, + 3, + 283, + 3413, + 8, + 283, + 1, + 283, + 1, + 283, + 1, + 284, + 1, + 284, + 1, + 284, + 5, + 284, + 3420, + 8, + 284, + 10, + 284, + 12, + 284, + 3423, + 9, + 284, + 3, + 284, + 3425, + 8, + 284, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 1, + 285, + 3, + 285, + 3446, + 8, + 285, + 1, + 286, + 1, + 286, + 1, + 286, + 1, + 286, + 1, + 286, + 1, + 286, + 1, + 286, + 5, + 286, + 3455, + 8, + 286, + 10, + 286, + 12, + 286, + 3458, + 9, + 286, + 1, + 286, + 1, + 286, + 3, + 286, + 3462, + 8, + 286, + 1, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 3, + 287, + 3469, + 8, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 3, + 287, + 3476, + 8, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 3, + 287, + 3483, + 8, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 3, + 287, + 3490, + 8, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 3, + 287, + 3497, + 8, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 3, + 287, + 3504, + 8, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 1, + 287, + 3, + 287, + 3511, + 8, + 287, + 1, + 287, + 1, + 287, + 3, + 287, + 3515, + 8, + 287, + 3, + 287, + 3517, + 8, + 287, + 1, + 288, + 1, + 288, + 1, + 288, + 1, + 288, + 1, + 289, + 1, + 289, + 1, + 290, + 1, + 290, + 1, + 291, + 1, + 291, + 1, + 292, + 1, + 292, + 1, + 292, + 3, + 292, + 3532, + 8, + 292, + 1, + 293, + 1, + 293, + 3, + 293, + 3536, + 8, + 293, + 1, + 294, + 1, + 294, + 1, + 295, + 1, + 295, + 1, + 295, + 1, + 295, + 1, + 295, + 1, + 295, + 1, + 295, + 1, + 295, + 1, + 295, + 1, + 295, + 1, + 295, + 1, + 295, + 1, + 295, + 1, + 295, + 1, + 295, + 1, + 295, + 3, + 295, + 3556, + 8, + 295, + 1, + 296, + 1, + 296, + 1, + 297, + 1, + 297, + 1, + 298, + 1, + 298, + 1, + 299, + 1, + 299, + 1, + 299, + 1, + 299, + 1, + 299, + 1, + 299, + 1, + 299, + 1, + 299, + 3, + 299, + 3572, + 8, + 299, + 1, + 300, + 1, + 300, + 1, + 301, + 1, + 301, + 1, + 302, + 1, + 302, + 1, + 303, + 1, + 303, + 1, + 303, + 0, + 4, + 2, + 6, + 50, + 364, + 304, + 0, + 2, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 26, + 28, + 30, + 32, + 34, + 36, + 38, + 40, + 42, + 44, + 46, + 48, + 50, + 52, + 54, + 56, + 58, + 60, + 62, + 64, + 66, + 68, + 70, + 72, + 74, + 76, + 78, + 80, + 82, + 84, + 86, + 88, + 90, + 92, + 94, + 96, + 98, + 100, + 102, + 104, + 106, + 108, + 110, + 112, + 114, + 116, + 118, + 120, + 122, + 124, + 126, + 128, + 130, + 132, + 134, + 136, + 138, + 140, + 142, + 144, + 146, + 148, + 150, + 152, + 154, + 156, + 158, + 160, + 162, + 164, + 166, + 168, + 170, + 172, + 174, + 176, + 178, + 180, + 182, + 184, + 186, + 188, + 190, + 192, + 194, + 196, + 198, + 200, + 202, + 204, + 206, + 208, + 210, + 212, + 214, + 216, + 218, + 220, + 222, + 224, + 226, + 228, + 230, + 232, + 234, + 236, + 238, + 240, + 242, + 244, + 246, + 248, + 250, + 252, + 254, + 256, + 258, + 260, + 262, + 264, + 266, + 268, + 270, + 272, + 274, + 276, + 278, + 280, + 282, + 284, + 286, + 288, + 290, + 292, + 294, + 296, + 298, + 300, + 302, + 304, + 306, + 308, + 310, + 312, + 314, + 316, + 318, + 320, + 322, + 324, + 326, + 328, + 330, + 332, + 334, + 336, + 338, + 340, + 342, + 344, + 346, + 348, + 350, + 352, + 354, + 356, + 358, + 360, + 362, + 364, + 366, + 368, + 370, + 372, + 374, + 376, + 378, + 380, + 382, + 384, + 386, + 388, + 390, + 392, + 394, + 396, + 398, + 400, + 402, + 404, + 406, + 408, + 410, + 412, + 414, + 416, + 418, + 420, + 422, + 424, + 426, + 428, + 430, + 432, + 434, + 436, + 438, + 440, + 442, + 444, + 446, + 448, + 450, + 452, + 454, + 456, + 458, + 460, + 462, + 464, + 466, + 468, + 470, + 472, + 474, + 476, + 478, + 480, + 482, + 484, + 486, + 488, + 490, + 492, + 494, + 496, + 498, + 500, + 502, + 504, + 506, + 508, + 510, + 512, + 514, + 516, + 518, + 520, + 522, + 524, + 526, + 528, + 530, + 532, + 534, + 536, + 538, + 540, + 542, + 544, + 546, + 548, + 550, + 552, + 554, + 556, + 558, + 560, + 562, + 564, + 566, + 568, + 570, + 572, + 574, + 576, + 578, + 580, + 582, + 584, + 586, + 588, + 590, + 592, + 594, + 596, + 598, + 600, + 602, + 604, + 606, + 0, + 8, + 2, + 0, + 181, + 181, + 237, + 237, + 4, + 0, + 89, + 89, + 108, + 108, + 111, + 111, + 236, + 236, + 5, + 0, + 19, + 19, + 72, + 72, + 93, + 93, + 158, + 158, + 214, + 214, + 1, + 0, + 254, + 255, + 2, + 0, + 148, + 148, + 254, + 255, + 2, + 0, + 66, + 66, + 226, + 226, + 2, + 0, + 99, + 99, + 253, + 253, + 2, + 0, + 2, + 250, + 266, + 266, + 3817, + 0, + 608, + 1, + 0, + 0, + 0, + 2, + 635, + 1, + 0, + 0, + 0, + 4, + 647, + 1, + 0, + 0, + 0, + 6, + 654, + 1, + 0, + 0, + 0, + 8, + 685, + 1, + 0, + 0, + 0, + 10, + 697, + 1, + 0, + 0, + 0, + 12, + 706, + 1, + 0, + 0, + 0, + 14, + 708, + 1, + 0, + 0, + 0, + 16, + 713, + 1, + 0, + 0, + 0, + 18, + 729, + 1, + 0, + 0, + 0, + 20, + 747, + 1, + 0, + 0, + 0, + 22, + 749, + 1, + 0, + 0, + 0, + 24, + 758, + 1, + 0, + 0, + 0, + 26, + 779, + 1, + 0, + 0, + 0, + 28, + 791, + 1, + 0, + 0, + 0, + 30, + 803, + 1, + 0, + 0, + 0, + 32, + 818, + 1, + 0, + 0, + 0, + 34, + 820, + 1, + 0, + 0, + 0, + 36, + 825, + 1, + 0, + 0, + 0, + 38, + 830, + 1, + 0, + 0, + 0, + 40, + 835, + 1, + 0, + 0, + 0, + 42, + 850, + 1, + 0, + 0, + 0, + 44, + 862, + 1, + 0, + 0, + 0, + 46, + 895, + 1, + 0, + 0, + 0, + 48, + 897, + 1, + 0, + 0, + 0, + 50, + 902, + 1, + 0, + 0, + 0, + 52, + 917, + 1, + 0, + 0, + 0, + 54, + 919, + 1, + 0, + 0, + 0, + 56, + 1057, + 1, + 0, + 0, + 0, + 58, + 1059, + 1, + 0, + 0, + 0, + 60, + 1064, + 1, + 0, + 0, + 0, + 62, + 1079, + 1, + 0, + 0, + 0, + 64, + 1094, + 1, + 0, + 0, + 0, + 66, + 1108, + 1, + 0, + 0, + 0, + 68, + 1110, + 1, + 0, + 0, + 0, + 70, + 1115, + 1, + 0, + 0, + 0, + 72, + 1120, + 1, + 0, + 0, + 0, + 74, + 1125, + 1, + 0, + 0, + 0, + 76, + 1134, + 1, + 0, + 0, + 0, + 78, + 1146, + 1, + 0, + 0, + 0, + 80, + 1161, + 1, + 0, + 0, + 0, + 82, + 1163, + 1, + 0, + 0, + 0, + 84, + 1168, + 1, + 0, + 0, + 0, + 86, + 1173, + 1, + 0, + 0, + 0, + 88, + 1177, + 1, + 0, + 0, + 0, + 90, + 1236, + 1, + 0, + 0, + 0, + 92, + 1266, + 1, + 0, + 0, + 0, + 94, + 1268, + 1, + 0, + 0, + 0, + 96, + 1319, + 1, + 0, + 0, + 0, + 98, + 1321, + 1, + 0, + 0, + 0, + 100, + 1326, + 1, + 0, + 0, + 0, + 102, + 1331, + 1, + 0, + 0, + 0, + 104, + 1350, + 1, + 0, + 0, + 0, + 106, + 1352, + 1, + 0, + 0, + 0, + 108, + 1357, + 1, + 0, + 0, + 0, + 110, + 1361, + 1, + 0, + 0, + 0, + 112, + 1374, + 1, + 0, + 0, + 0, + 114, + 1376, + 1, + 0, + 0, + 0, + 116, + 1380, + 1, + 0, + 0, + 0, + 118, + 1397, + 1, + 0, + 0, + 0, + 120, + 1413, + 1, + 0, + 0, + 0, + 122, + 1415, + 1, + 0, + 0, + 0, + 124, + 1420, + 1, + 0, + 0, + 0, + 126, + 1424, + 1, + 0, + 0, + 0, + 128, + 1429, + 1, + 0, + 0, + 0, + 130, + 1433, + 1, + 0, + 0, + 0, + 132, + 1437, + 1, + 0, + 0, + 0, + 134, + 1455, + 1, + 0, + 0, + 0, + 136, + 1465, + 1, + 0, + 0, + 0, + 138, + 1477, + 1, + 0, + 0, + 0, + 140, + 1479, + 1, + 0, + 0, + 0, + 142, + 1494, + 1, + 0, + 0, + 0, + 144, + 1496, + 1, + 0, + 0, + 0, + 146, + 1516, + 1, + 0, + 0, + 0, + 148, + 1526, + 1, + 0, + 0, + 0, + 150, + 1536, + 1, + 0, + 0, + 0, + 152, + 1603, + 1, + 0, + 0, + 0, + 154, + 1619, + 1, + 0, + 0, + 0, + 156, + 1635, + 1, + 0, + 0, + 0, + 158, + 1651, + 1, + 0, + 0, + 0, + 160, + 1653, + 1, + 0, + 0, + 0, + 162, + 1672, + 1, + 0, + 0, + 0, + 164, + 1674, + 1, + 0, + 0, + 0, + 166, + 1678, + 1, + 0, + 0, + 0, + 168, + 1682, + 1, + 0, + 0, + 0, + 170, + 1687, + 1, + 0, + 0, + 0, + 172, + 1692, + 1, + 0, + 0, + 0, + 174, + 1697, + 1, + 0, + 0, + 0, + 176, + 1701, + 1, + 0, + 0, + 0, + 178, + 1705, + 1, + 0, + 0, + 0, + 180, + 1720, + 1, + 0, + 0, + 0, + 182, + 1722, + 1, + 0, + 0, + 0, + 184, + 1726, + 1, + 0, + 0, + 0, + 186, + 1738, + 1, + 0, + 0, + 0, + 188, + 1752, + 1, + 0, + 0, + 0, + 190, + 1754, + 1, + 0, + 0, + 0, + 192, + 1767, + 1, + 0, + 0, + 0, + 194, + 1777, + 1, + 0, + 0, + 0, + 196, + 1779, + 1, + 0, + 0, + 0, + 198, + 1784, + 1, + 0, + 0, + 0, + 200, + 1789, + 1, + 0, + 0, + 0, + 202, + 1802, + 1, + 0, + 0, + 0, + 204, + 1812, + 1, + 0, + 0, + 0, + 206, + 1814, + 1, + 0, + 0, + 0, + 208, + 1832, + 1, + 0, + 0, + 0, + 210, + 1847, + 1, + 0, + 0, + 0, + 212, + 1857, + 1, + 0, + 0, + 0, + 214, + 1859, + 1, + 0, + 0, + 0, + 216, + 1864, + 1, + 0, + 0, + 0, + 218, + 1911, + 1, + 0, + 0, + 0, + 220, + 1913, + 1, + 0, + 0, + 0, + 222, + 1918, + 1, + 0, + 0, + 0, + 224, + 1931, + 1, + 0, + 0, + 0, + 226, + 1933, + 1, + 0, + 0, + 0, + 228, + 1937, + 1, + 0, + 0, + 0, + 230, + 1942, + 1, + 0, + 0, + 0, + 232, + 1947, + 1, + 0, + 0, + 0, + 234, + 1959, + 1, + 0, + 0, + 0, + 236, + 1961, + 1, + 0, + 0, + 0, + 238, + 1965, + 1, + 0, + 0, + 0, + 240, + 1969, + 1, + 0, + 0, + 0, + 242, + 1982, + 1, + 0, + 0, + 0, + 244, + 1984, + 1, + 0, + 0, + 0, + 246, + 1993, + 1, + 0, + 0, + 0, + 248, + 2034, + 1, + 0, + 0, + 0, + 250, + 2036, + 1, + 0, + 0, + 0, + 252, + 2057, + 1, + 0, + 0, + 0, + 254, + 2059, + 1, + 0, + 0, + 0, + 256, + 2075, + 1, + 0, + 0, + 0, + 258, + 2093, + 1, + 0, + 0, + 0, + 260, + 2095, + 1, + 0, + 0, + 0, + 262, + 2107, + 1, + 0, + 0, + 0, + 264, + 2117, + 1, + 0, + 0, + 0, + 266, + 2131, + 1, + 0, + 0, + 0, + 268, + 2186, + 1, + 0, + 0, + 0, + 270, + 2188, + 1, + 0, + 0, + 0, + 272, + 2192, + 1, + 0, + 0, + 0, + 274, + 2197, + 1, + 0, + 0, + 0, + 276, + 2213, + 1, + 0, + 0, + 0, + 278, + 2227, + 1, + 0, + 0, + 0, + 280, + 2229, + 1, + 0, + 0, + 0, + 282, + 2234, + 1, + 0, + 0, + 0, + 284, + 2267, + 1, + 0, + 0, + 0, + 286, + 2277, + 1, + 0, + 0, + 0, + 288, + 2299, + 1, + 0, + 0, + 0, + 290, + 2301, + 1, + 0, + 0, + 0, + 292, + 2306, + 1, + 0, + 0, + 0, + 294, + 2335, + 1, + 0, + 0, + 0, + 296, + 2337, + 1, + 0, + 0, + 0, + 298, + 2354, + 1, + 0, + 0, + 0, + 300, + 2364, + 1, + 0, + 0, + 0, + 302, + 2366, + 1, + 0, + 0, + 0, + 304, + 2379, + 1, + 0, + 0, + 0, + 306, + 2389, + 1, + 0, + 0, + 0, + 308, + 2391, + 1, + 0, + 0, + 0, + 310, + 2395, + 1, + 0, + 0, + 0, + 312, + 2410, + 1, + 0, + 0, + 0, + 314, + 2412, + 1, + 0, + 0, + 0, + 316, + 2430, + 1, + 0, + 0, + 0, + 318, + 2432, + 1, + 0, + 0, + 0, + 320, + 2454, + 1, + 0, + 0, + 0, + 322, + 2478, + 1, + 0, + 0, + 0, + 324, + 2480, + 1, + 0, + 0, + 0, + 326, + 2485, + 1, + 0, + 0, + 0, + 328, + 2495, + 1, + 0, + 0, + 0, + 330, + 2514, + 1, + 0, + 0, + 0, + 332, + 2527, + 1, + 0, + 0, + 0, + 334, + 2533, + 1, + 0, + 0, + 0, + 336, + 2537, + 1, + 0, + 0, + 0, + 338, + 2539, + 1, + 0, + 0, + 0, + 340, + 2553, + 1, + 0, + 0, + 0, + 342, + 2571, + 1, + 0, + 0, + 0, + 344, + 2585, + 1, + 0, + 0, + 0, + 346, + 2589, + 1, + 0, + 0, + 0, + 348, + 2591, + 1, + 0, + 0, + 0, + 350, + 2608, + 1, + 0, + 0, + 0, + 352, + 2652, + 1, + 0, + 0, + 0, + 354, + 2662, + 1, + 0, + 0, + 0, + 356, + 2680, + 1, + 0, + 0, + 0, + 358, + 2726, + 1, + 0, + 0, + 0, + 360, + 2736, + 1, + 0, + 0, + 0, + 362, + 2754, + 1, + 0, + 0, + 0, + 364, + 2777, + 1, + 0, + 0, + 0, + 366, + 2811, + 1, + 0, + 0, + 0, + 368, + 2813, + 1, + 0, + 0, + 0, + 370, + 2815, + 1, + 0, + 0, + 0, + 372, + 2819, + 1, + 0, + 0, + 0, + 374, + 2821, + 1, + 0, + 0, + 0, + 376, + 2827, + 1, + 0, + 0, + 0, + 378, + 2837, + 1, + 0, + 0, + 0, + 380, + 2847, + 1, + 0, + 0, + 0, + 382, + 2857, + 1, + 0, + 0, + 0, + 384, + 2867, + 1, + 0, + 0, + 0, + 386, + 2877, + 1, + 0, + 0, + 0, + 388, + 2887, + 1, + 0, + 0, + 0, + 390, + 2899, + 1, + 0, + 0, + 0, + 392, + 2911, + 1, + 0, + 0, + 0, + 394, + 2937, + 1, + 0, + 0, + 0, + 396, + 2957, + 1, + 0, + 0, + 0, + 398, + 2963, + 1, + 0, + 0, + 0, + 400, + 2973, + 1, + 0, + 0, + 0, + 402, + 2983, + 1, + 0, + 0, + 0, + 404, + 2993, + 1, + 0, + 0, + 0, + 406, + 3003, + 1, + 0, + 0, + 0, + 408, + 3013, + 1, + 0, + 0, + 0, + 410, + 3023, + 1, + 0, + 0, + 0, + 412, + 3033, + 1, + 0, + 0, + 0, + 414, + 3043, + 1, + 0, + 0, + 0, + 416, + 3049, + 1, + 0, + 0, + 0, + 418, + 3053, + 1, + 0, + 0, + 0, + 420, + 3057, + 1, + 0, + 0, + 0, + 422, + 3061, + 1, + 0, + 0, + 0, + 424, + 3073, + 1, + 0, + 0, + 0, + 426, + 3075, + 1, + 0, + 0, + 0, + 428, + 3079, + 1, + 0, + 0, + 0, + 430, + 3083, + 1, + 0, + 0, + 0, + 432, + 3094, + 1, + 0, + 0, + 0, + 434, + 3099, + 1, + 0, + 0, + 0, + 436, + 3104, + 1, + 0, + 0, + 0, + 438, + 3109, + 1, + 0, + 0, + 0, + 440, + 3116, + 1, + 0, + 0, + 0, + 442, + 3127, + 1, + 0, + 0, + 0, + 444, + 3131, + 1, + 0, + 0, + 0, + 446, + 3136, + 1, + 0, + 0, + 0, + 448, + 3138, + 1, + 0, + 0, + 0, + 450, + 3142, + 1, + 0, + 0, + 0, + 452, + 3146, + 1, + 0, + 0, + 0, + 454, + 3150, + 1, + 0, + 0, + 0, + 456, + 3154, + 1, + 0, + 0, + 0, + 458, + 3158, + 1, + 0, + 0, + 0, + 460, + 3162, + 1, + 0, + 0, + 0, + 462, + 3166, + 1, + 0, + 0, + 0, + 464, + 3170, + 1, + 0, + 0, + 0, + 466, + 3174, + 1, + 0, + 0, + 0, + 468, + 3178, + 1, + 0, + 0, + 0, + 470, + 3182, + 1, + 0, + 0, + 0, + 472, + 3186, + 1, + 0, + 0, + 0, + 474, + 3190, + 1, + 0, + 0, + 0, + 476, + 3194, + 1, + 0, + 0, + 0, + 478, + 3198, + 1, + 0, + 0, + 0, + 480, + 3202, + 1, + 0, + 0, + 0, + 482, + 3206, + 1, + 0, + 0, + 0, + 484, + 3210, + 1, + 0, + 0, + 0, + 486, + 3214, + 1, + 0, + 0, + 0, + 488, + 3218, + 1, + 0, + 0, + 0, + 490, + 3222, + 1, + 0, + 0, + 0, + 492, + 3226, + 1, + 0, + 0, + 0, + 494, + 3230, + 1, + 0, + 0, + 0, + 496, + 3234, + 1, + 0, + 0, + 0, + 498, + 3238, + 1, + 0, + 0, + 0, + 500, + 3242, + 1, + 0, + 0, + 0, + 502, + 3246, + 1, + 0, + 0, + 0, + 504, + 3250, + 1, + 0, + 0, + 0, + 506, + 3254, + 1, + 0, + 0, + 0, + 508, + 3256, + 1, + 0, + 0, + 0, + 510, + 3258, + 1, + 0, + 0, + 0, + 512, + 3260, + 1, + 0, + 0, + 0, + 514, + 3262, + 1, + 0, + 0, + 0, + 516, + 3264, + 1, + 0, + 0, + 0, + 518, + 3268, + 1, + 0, + 0, + 0, + 520, + 3272, + 1, + 0, + 0, + 0, + 522, + 3276, + 1, + 0, + 0, + 0, + 524, + 3280, + 1, + 0, + 0, + 0, + 526, + 3284, + 1, + 0, + 0, + 0, + 528, + 3294, + 1, + 0, + 0, + 0, + 530, + 3298, + 1, + 0, + 0, + 0, + 532, + 3302, + 1, + 0, + 0, + 0, + 534, + 3312, + 1, + 0, + 0, + 0, + 536, + 3316, + 1, + 0, + 0, + 0, + 538, + 3320, + 1, + 0, + 0, + 0, + 540, + 3324, + 1, + 0, + 0, + 0, + 542, + 3328, + 1, + 0, + 0, + 0, + 544, + 3331, + 1, + 0, + 0, + 0, + 546, + 3333, + 1, + 0, + 0, + 0, + 548, + 3342, + 1, + 0, + 0, + 0, + 550, + 3344, + 1, + 0, + 0, + 0, + 552, + 3353, + 1, + 0, + 0, + 0, + 554, + 3355, + 1, + 0, + 0, + 0, + 556, + 3363, + 1, + 0, + 0, + 0, + 558, + 3377, + 1, + 0, + 0, + 0, + 560, + 3379, + 1, + 0, + 0, + 0, + 562, + 3389, + 1, + 0, + 0, + 0, + 564, + 3401, + 1, + 0, + 0, + 0, + 566, + 3403, + 1, + 0, + 0, + 0, + 568, + 3424, + 1, + 0, + 0, + 0, + 570, + 3445, + 1, + 0, + 0, + 0, + 572, + 3461, + 1, + 0, + 0, + 0, + 574, + 3516, + 1, + 0, + 0, + 0, + 576, + 3518, + 1, + 0, + 0, + 0, + 578, + 3522, + 1, + 0, + 0, + 0, + 580, + 3524, + 1, + 0, + 0, + 0, + 582, + 3526, + 1, + 0, + 0, + 0, + 584, + 3531, + 1, + 0, + 0, + 0, + 586, + 3535, + 1, + 0, + 0, + 0, + 588, + 3537, + 1, + 0, + 0, + 0, + 590, + 3555, + 1, + 0, + 0, + 0, + 592, + 3557, + 1, + 0, + 0, + 0, + 594, + 3559, + 1, + 0, + 0, + 0, + 596, + 3561, + 1, + 0, + 0, + 0, + 598, + 3571, + 1, + 0, + 0, + 0, + 600, + 3573, + 1, + 0, + 0, + 0, + 602, + 3575, + 1, + 0, + 0, + 0, + 604, + 3577, + 1, + 0, + 0, + 0, + 606, + 3579, + 1, + 0, + 0, + 0, + 608, + 615, + 3, + 2, + 1, + 0, + 609, + 611, + 5, + 262, + 0, + 0, + 610, + 609, + 1, + 0, + 0, + 0, + 610, + 611, + 1, + 0, + 0, + 0, + 611, + 612, + 1, + 0, + 0, + 0, + 612, + 614, + 3, + 2, + 1, + 0, + 613, + 610, + 1, + 0, + 0, + 0, + 614, + 617, + 1, + 0, + 0, + 0, + 615, + 613, + 1, + 0, + 0, + 0, + 615, + 616, + 1, + 0, + 0, + 0, + 616, + 619, + 1, + 0, + 0, + 0, + 617, + 615, + 1, + 0, + 0, + 0, + 618, + 620, + 5, + 262, + 0, + 0, + 619, + 618, + 1, + 0, + 0, + 0, + 619, + 620, + 1, + 0, + 0, + 0, + 620, + 621, + 1, + 0, + 0, + 0, + 621, + 622, + 5, + 0, + 0, + 1, + 622, + 1, + 1, + 0, + 0, + 0, + 623, + 624, + 6, + 1, + -1, + 0, + 624, + 636, + 3, + 6, + 3, + 0, + 625, + 626, + 3, + 6, + 3, + 0, + 626, + 627, + 5, + 264, + 0, + 0, + 627, + 628, + 3, + 8, + 4, + 0, + 628, + 636, + 1, + 0, + 0, + 0, + 629, + 636, + 3, + 10, + 5, + 0, + 630, + 631, + 3, + 10, + 5, + 0, + 631, + 632, + 5, + 264, + 0, + 0, + 632, + 633, + 3, + 366, + 183, + 0, + 633, + 636, + 1, + 0, + 0, + 0, + 634, + 636, + 3, + 4, + 2, + 0, + 635, + 623, + 1, + 0, + 0, + 0, + 635, + 625, + 1, + 0, + 0, + 0, + 635, + 629, + 1, + 0, + 0, + 0, + 635, + 630, + 1, + 0, + 0, + 0, + 635, + 634, + 1, + 0, + 0, + 0, + 636, + 644, + 1, + 0, + 0, + 0, + 637, + 638, + 10, + 2, + 0, + 0, + 638, + 639, + 5, + 264, + 0, + 0, + 639, + 640, + 5, + 220, + 0, + 0, + 640, + 641, + 5, + 256, + 0, + 0, + 641, + 643, + 5, + 257, + 0, + 0, + 642, + 637, + 1, + 0, + 0, + 0, + 643, + 646, + 1, + 0, + 0, + 0, + 644, + 642, + 1, + 0, + 0, + 0, + 644, + 645, + 1, + 0, + 0, + 0, + 645, + 3, + 1, + 0, + 0, + 0, + 646, + 644, + 1, + 0, + 0, + 0, + 647, + 648, + 5, + 255, + 0, + 0, + 648, + 5, + 1, + 0, + 0, + 0, + 649, + 650, + 6, + 3, + -1, + 0, + 650, + 655, + 5, + 266, + 0, + 0, + 651, + 652, + 5, + 266, + 0, + 0, + 652, + 653, + 5, + 264, + 0, + 0, + 653, + 655, + 3, + 12, + 6, + 0, + 654, + 649, + 1, + 0, + 0, + 0, + 654, + 651, + 1, + 0, + 0, + 0, + 655, + 661, + 1, + 0, + 0, + 0, + 656, + 657, + 10, + 1, + 0, + 0, + 657, + 658, + 5, + 264, + 0, + 0, + 658, + 660, + 3, + 12, + 6, + 0, + 659, + 656, + 1, + 0, + 0, + 0, + 660, + 663, + 1, + 0, + 0, + 0, + 661, + 659, + 1, + 0, + 0, + 0, + 661, + 662, + 1, + 0, + 0, + 0, + 662, + 7, + 1, + 0, + 0, + 0, + 663, + 661, + 1, + 0, + 0, + 0, + 664, + 665, + 5, + 228, + 0, + 0, + 665, + 666, + 5, + 256, + 0, + 0, + 666, + 667, + 5, + 257, + 0, + 0, + 667, + 668, + 5, + 264, + 0, + 0, + 668, + 669, + 5, + 16, + 0, + 0, + 669, + 670, + 5, + 256, + 0, + 0, + 670, + 686, + 5, + 257, + 0, + 0, + 671, + 672, + 5, + 228, + 0, + 0, + 672, + 673, + 5, + 256, + 0, + 0, + 673, + 674, + 5, + 257, + 0, + 0, + 674, + 675, + 5, + 264, + 0, + 0, + 675, + 676, + 5, + 32, + 0, + 0, + 676, + 677, + 5, + 256, + 0, + 0, + 677, + 686, + 5, + 257, + 0, + 0, + 678, + 679, + 5, + 228, + 0, + 0, + 679, + 680, + 5, + 256, + 0, + 0, + 680, + 681, + 5, + 257, + 0, + 0, + 681, + 682, + 5, + 264, + 0, + 0, + 682, + 683, + 5, + 186, + 0, + 0, + 683, + 684, + 5, + 256, + 0, + 0, + 684, + 686, + 5, + 257, + 0, + 0, + 685, + 664, + 1, + 0, + 0, + 0, + 685, + 671, + 1, + 0, + 0, + 0, + 685, + 678, + 1, + 0, + 0, + 0, + 686, + 9, + 1, + 0, + 0, + 0, + 687, + 688, + 3, + 6, + 3, + 0, + 688, + 689, + 5, + 264, + 0, + 0, + 689, + 690, + 3, + 28, + 14, + 0, + 690, + 698, + 1, + 0, + 0, + 0, + 691, + 692, + 3, + 6, + 3, + 0, + 692, + 693, + 5, + 264, + 0, + 0, + 693, + 694, + 3, + 28, + 14, + 0, + 694, + 695, + 5, + 264, + 0, + 0, + 695, + 696, + 3, + 50, + 25, + 0, + 696, + 698, + 1, + 0, + 0, + 0, + 697, + 687, + 1, + 0, + 0, + 0, + 697, + 691, + 1, + 0, + 0, + 0, + 698, + 11, + 1, + 0, + 0, + 0, + 699, + 707, + 3, + 14, + 7, + 0, + 700, + 707, + 3, + 16, + 8, + 0, + 701, + 707, + 3, + 18, + 9, + 0, + 702, + 707, + 3, + 20, + 10, + 0, + 703, + 707, + 3, + 22, + 11, + 0, + 704, + 707, + 3, + 24, + 12, + 0, + 705, + 707, + 3, + 26, + 13, + 0, + 706, + 699, + 1, + 0, + 0, + 0, + 706, + 700, + 1, + 0, + 0, + 0, + 706, + 701, + 1, + 0, + 0, + 0, + 706, + 702, + 1, + 0, + 0, + 0, + 706, + 703, + 1, + 0, + 0, + 0, + 706, + 704, + 1, + 0, + 0, + 0, + 706, + 705, + 1, + 0, + 0, + 0, + 707, + 13, + 1, + 0, + 0, + 0, + 708, + 709, + 5, + 240, + 0, + 0, + 709, + 710, + 5, + 256, + 0, + 0, + 710, + 711, + 3, + 518, + 259, + 0, + 711, + 712, + 5, + 257, + 0, + 0, + 712, + 15, + 1, + 0, + 0, + 0, + 713, + 714, + 5, + 245, + 0, + 0, + 714, + 715, + 5, + 256, + 0, + 0, + 715, + 716, + 5, + 257, + 0, + 0, + 716, + 17, + 1, + 0, + 0, + 0, + 717, + 718, + 5, + 246, + 0, + 0, + 718, + 719, + 5, + 256, + 0, + 0, + 719, + 720, + 3, + 532, + 266, + 0, + 720, + 721, + 5, + 257, + 0, + 0, + 721, + 730, + 1, + 0, + 0, + 0, + 722, + 723, + 5, + 246, + 0, + 0, + 723, + 724, + 5, + 256, + 0, + 0, + 724, + 725, + 3, + 532, + 266, + 0, + 725, + 726, + 5, + 263, + 0, + 0, + 726, + 727, + 3, + 374, + 187, + 0, + 727, + 728, + 5, + 257, + 0, + 0, + 728, + 730, + 1, + 0, + 0, + 0, + 729, + 717, + 1, + 0, + 0, + 0, + 729, + 722, + 1, + 0, + 0, + 0, + 730, + 19, + 1, + 0, + 0, + 0, + 731, + 732, + 5, + 247, + 0, + 0, + 732, + 733, + 5, + 256, + 0, + 0, + 733, + 734, + 3, + 578, + 289, + 0, + 734, + 735, + 5, + 263, + 0, + 0, + 735, + 736, + 3, + 532, + 266, + 0, + 736, + 737, + 5, + 257, + 0, + 0, + 737, + 748, + 1, + 0, + 0, + 0, + 738, + 739, + 5, + 247, + 0, + 0, + 739, + 740, + 5, + 256, + 0, + 0, + 740, + 741, + 3, + 578, + 289, + 0, + 741, + 742, + 5, + 263, + 0, + 0, + 742, + 743, + 3, + 532, + 266, + 0, + 743, + 744, + 5, + 263, + 0, + 0, + 744, + 745, + 3, + 374, + 187, + 0, + 745, + 746, + 5, + 257, + 0, + 0, + 746, + 748, + 1, + 0, + 0, + 0, + 747, + 731, + 1, + 0, + 0, + 0, + 747, + 738, + 1, + 0, + 0, + 0, + 748, + 21, + 1, + 0, + 0, + 0, + 749, + 750, + 5, + 248, + 0, + 0, + 750, + 751, + 5, + 256, + 0, + 0, + 751, + 754, + 3, + 328, + 164, + 0, + 752, + 753, + 5, + 263, + 0, + 0, + 753, + 755, + 3, + 544, + 272, + 0, + 754, + 752, + 1, + 0, + 0, + 0, + 754, + 755, + 1, + 0, + 0, + 0, + 755, + 756, + 1, + 0, + 0, + 0, + 756, + 757, + 5, + 257, + 0, + 0, + 757, + 23, + 1, + 0, + 0, + 0, + 758, + 759, + 5, + 244, + 0, + 0, + 759, + 760, + 5, + 256, + 0, + 0, + 760, + 763, + 3, + 602, + 301, + 0, + 761, + 762, + 5, + 263, + 0, + 0, + 762, + 764, + 3, + 548, + 274, + 0, + 763, + 761, + 1, + 0, + 0, + 0, + 763, + 764, + 1, + 0, + 0, + 0, + 764, + 765, + 1, + 0, + 0, + 0, + 765, + 766, + 5, + 257, + 0, + 0, + 766, + 25, + 1, + 0, + 0, + 0, + 767, + 768, + 5, + 239, + 0, + 0, + 768, + 769, + 5, + 256, + 0, + 0, + 769, + 770, + 3, + 578, + 289, + 0, + 770, + 771, + 5, + 257, + 0, + 0, + 771, + 780, + 1, + 0, + 0, + 0, + 772, + 773, + 5, + 239, + 0, + 0, + 773, + 774, + 5, + 256, + 0, + 0, + 774, + 775, + 3, + 578, + 289, + 0, + 775, + 776, + 5, + 263, + 0, + 0, + 776, + 777, + 3, + 532, + 266, + 0, + 777, + 778, + 5, + 257, + 0, + 0, + 778, + 780, + 1, + 0, + 0, + 0, + 779, + 767, + 1, + 0, + 0, + 0, + 779, + 772, + 1, + 0, + 0, + 0, + 780, + 27, + 1, + 0, + 0, + 0, + 781, + 792, + 3, + 30, + 15, + 0, + 782, + 792, + 3, + 32, + 16, + 0, + 783, + 792, + 3, + 34, + 17, + 0, + 784, + 792, + 3, + 36, + 18, + 0, + 785, + 792, + 3, + 44, + 22, + 0, + 786, + 792, + 3, + 42, + 21, + 0, + 787, + 792, + 3, + 38, + 19, + 0, + 788, + 792, + 3, + 40, + 20, + 0, + 789, + 792, + 3, + 46, + 23, + 0, + 790, + 792, + 3, + 48, + 24, + 0, + 791, + 781, + 1, + 0, + 0, + 0, + 791, + 782, + 1, + 0, + 0, + 0, + 791, + 783, + 1, + 0, + 0, + 0, + 791, + 784, + 1, + 0, + 0, + 0, + 791, + 785, + 1, + 0, + 0, + 0, + 791, + 786, + 1, + 0, + 0, + 0, + 791, + 787, + 1, + 0, + 0, + 0, + 791, + 788, + 1, + 0, + 0, + 0, + 791, + 789, + 1, + 0, + 0, + 0, + 791, + 790, + 1, + 0, + 0, + 0, + 792, + 29, + 1, + 0, + 0, + 0, + 793, + 794, + 5, + 3, + 0, + 0, + 794, + 795, + 5, + 256, + 0, + 0, + 795, + 796, + 3, + 524, + 262, + 0, + 796, + 797, + 5, + 257, + 0, + 0, + 797, + 804, + 1, + 0, + 0, + 0, + 798, + 799, + 5, + 3, + 0, + 0, + 799, + 800, + 5, + 256, + 0, + 0, + 800, + 801, + 3, + 52, + 26, + 0, + 801, + 802, + 5, + 257, + 0, + 0, + 802, + 804, + 1, + 0, + 0, + 0, + 803, + 793, + 1, + 0, + 0, + 0, + 803, + 798, + 1, + 0, + 0, + 0, + 804, + 31, + 1, + 0, + 0, + 0, + 805, + 806, + 5, + 4, + 0, + 0, + 806, + 807, + 5, + 256, + 0, + 0, + 807, + 819, + 5, + 257, + 0, + 0, + 808, + 809, + 5, + 4, + 0, + 0, + 809, + 810, + 5, + 256, + 0, + 0, + 810, + 811, + 3, + 524, + 262, + 0, + 811, + 812, + 5, + 257, + 0, + 0, + 812, + 819, + 1, + 0, + 0, + 0, + 813, + 814, + 5, + 4, + 0, + 0, + 814, + 815, + 5, + 256, + 0, + 0, + 815, + 816, + 3, + 52, + 26, + 0, + 816, + 817, + 5, + 257, + 0, + 0, + 817, + 819, + 1, + 0, + 0, + 0, + 818, + 805, + 1, + 0, + 0, + 0, + 818, + 808, + 1, + 0, + 0, + 0, + 818, + 813, + 1, + 0, + 0, + 0, + 819, + 33, + 1, + 0, + 0, + 0, + 820, + 821, + 5, + 57, + 0, + 0, + 821, + 822, + 5, + 256, + 0, + 0, + 822, + 823, + 3, + 534, + 267, + 0, + 823, + 824, + 5, + 257, + 0, + 0, + 824, + 35, + 1, + 0, + 0, + 0, + 825, + 826, + 5, + 233, + 0, + 0, + 826, + 827, + 5, + 256, + 0, + 0, + 827, + 828, + 3, + 534, + 267, + 0, + 828, + 829, + 5, + 257, + 0, + 0, + 829, + 37, + 1, + 0, + 0, + 0, + 830, + 831, + 5, + 100, + 0, + 0, + 831, + 832, + 5, + 256, + 0, + 0, + 832, + 833, + 3, + 534, + 267, + 0, + 833, + 834, + 5, + 257, + 0, + 0, + 834, + 39, + 1, + 0, + 0, + 0, + 835, + 836, + 5, + 105, + 0, + 0, + 836, + 837, + 5, + 256, + 0, + 0, + 837, + 838, + 3, + 578, + 289, + 0, + 838, + 839, + 5, + 257, + 0, + 0, + 839, + 41, + 1, + 0, + 0, + 0, + 840, + 841, + 5, + 130, + 0, + 0, + 841, + 842, + 5, + 256, + 0, + 0, + 842, + 843, + 3, + 538, + 269, + 0, + 843, + 844, + 5, + 257, + 0, + 0, + 844, + 851, + 1, + 0, + 0, + 0, + 845, + 846, + 5, + 130, + 0, + 0, + 846, + 847, + 5, + 256, + 0, + 0, + 847, + 848, + 3, + 52, + 26, + 0, + 848, + 849, + 5, + 257, + 0, + 0, + 849, + 851, + 1, + 0, + 0, + 0, + 850, + 840, + 1, + 0, + 0, + 0, + 850, + 845, + 1, + 0, + 0, + 0, + 851, + 43, + 1, + 0, + 0, + 0, + 852, + 853, + 5, + 129, + 0, + 0, + 853, + 854, + 5, + 256, + 0, + 0, + 854, + 855, + 3, + 538, + 269, + 0, + 855, + 856, + 5, + 257, + 0, + 0, + 856, + 863, + 1, + 0, + 0, + 0, + 857, + 858, + 5, + 129, + 0, + 0, + 858, + 859, + 5, + 256, + 0, + 0, + 859, + 860, + 3, + 52, + 26, + 0, + 860, + 861, + 5, + 257, + 0, + 0, + 861, + 863, + 1, + 0, + 0, + 0, + 862, + 852, + 1, + 0, + 0, + 0, + 862, + 857, + 1, + 0, + 0, + 0, + 863, + 45, + 1, + 0, + 0, + 0, + 864, + 865, + 5, + 24, + 0, + 0, + 865, + 866, + 5, + 256, + 0, + 0, + 866, + 896, + 5, + 257, + 0, + 0, + 867, + 868, + 5, + 24, + 0, + 0, + 868, + 869, + 5, + 256, + 0, + 0, + 869, + 870, + 3, + 578, + 289, + 0, + 870, + 871, + 5, + 257, + 0, + 0, + 871, + 896, + 1, + 0, + 0, + 0, + 872, + 873, + 5, + 24, + 0, + 0, + 873, + 874, + 5, + 256, + 0, + 0, + 874, + 875, + 3, + 578, + 289, + 0, + 875, + 876, + 5, + 263, + 0, + 0, + 876, + 877, + 3, + 536, + 268, + 0, + 877, + 878, + 5, + 257, + 0, + 0, + 878, + 896, + 1, + 0, + 0, + 0, + 879, + 880, + 5, + 24, + 0, + 0, + 880, + 881, + 5, + 256, + 0, + 0, + 881, + 882, + 3, + 578, + 289, + 0, + 882, + 883, + 5, + 263, + 0, + 0, + 883, + 884, + 3, + 52, + 26, + 0, + 884, + 885, + 5, + 257, + 0, + 0, + 885, + 896, + 1, + 0, + 0, + 0, + 886, + 887, + 5, + 24, + 0, + 0, + 887, + 888, + 5, + 256, + 0, + 0, + 888, + 889, + 3, + 578, + 289, + 0, + 889, + 890, + 5, + 263, + 0, + 0, + 890, + 891, + 3, + 536, + 268, + 0, + 891, + 892, + 5, + 263, + 0, + 0, + 892, + 893, + 3, + 52, + 26, + 0, + 893, + 894, + 5, + 257, + 0, + 0, + 894, + 896, + 1, + 0, + 0, + 0, + 895, + 864, + 1, + 0, + 0, + 0, + 895, + 867, + 1, + 0, + 0, + 0, + 895, + 872, + 1, + 0, + 0, + 0, + 895, + 879, + 1, + 0, + 0, + 0, + 895, + 886, + 1, + 0, + 0, + 0, + 896, + 47, + 1, + 0, + 0, + 0, + 897, + 898, + 5, + 230, + 0, + 0, + 898, + 899, + 5, + 256, + 0, + 0, + 899, + 900, + 3, + 552, + 276, + 0, + 900, + 901, + 5, + 257, + 0, + 0, + 901, + 49, + 1, + 0, + 0, + 0, + 902, + 903, + 6, + 25, + -1, + 0, + 903, + 904, + 3, + 56, + 28, + 0, + 904, + 910, + 1, + 0, + 0, + 0, + 905, + 906, + 10, + 1, + 0, + 0, + 906, + 907, + 5, + 264, + 0, + 0, + 907, + 909, + 3, + 56, + 28, + 0, + 908, + 905, + 1, + 0, + 0, + 0, + 909, + 912, + 1, + 0, + 0, + 0, + 910, + 908, + 1, + 0, + 0, + 0, + 910, + 911, + 1, + 0, + 0, + 0, + 911, + 51, + 1, + 0, + 0, + 0, + 912, + 910, + 1, + 0, + 0, + 0, + 913, + 918, + 3, + 50, + 25, + 0, + 914, + 915, + 5, + 267, + 0, + 0, + 915, + 916, + 5, + 264, + 0, + 0, + 916, + 918, + 3, + 50, + 25, + 0, + 917, + 913, + 1, + 0, + 0, + 0, + 917, + 914, + 1, + 0, + 0, + 0, + 918, + 53, + 1, + 0, + 0, + 0, + 919, + 920, + 3, + 10, + 5, + 0, + 920, + 921, + 5, + 264, + 0, + 0, + 921, + 922, + 3, + 366, + 183, + 0, + 922, + 55, + 1, + 0, + 0, + 0, + 923, + 1058, + 3, + 58, + 29, + 0, + 924, + 1058, + 3, + 60, + 30, + 0, + 925, + 1058, + 3, + 62, + 31, + 0, + 926, + 1058, + 3, + 64, + 32, + 0, + 927, + 1058, + 3, + 210, + 105, + 0, + 928, + 1058, + 3, + 208, + 104, + 0, + 929, + 1058, + 3, + 66, + 33, + 0, + 930, + 1058, + 3, + 68, + 34, + 0, + 931, + 1058, + 3, + 70, + 35, + 0, + 932, + 1058, + 3, + 72, + 36, + 0, + 933, + 1058, + 3, + 74, + 37, + 0, + 934, + 1058, + 3, + 80, + 40, + 0, + 935, + 1058, + 3, + 82, + 41, + 0, + 936, + 1058, + 3, + 84, + 42, + 0, + 937, + 1058, + 3, + 86, + 43, + 0, + 938, + 1058, + 3, + 88, + 44, + 0, + 939, + 1058, + 3, + 90, + 45, + 0, + 940, + 1058, + 3, + 94, + 47, + 0, + 941, + 1058, + 3, + 96, + 48, + 0, + 942, + 1058, + 3, + 98, + 49, + 0, + 943, + 1058, + 3, + 100, + 50, + 0, + 944, + 1058, + 3, + 106, + 53, + 0, + 945, + 1058, + 3, + 108, + 54, + 0, + 946, + 1058, + 3, + 110, + 55, + 0, + 947, + 1058, + 3, + 112, + 56, + 0, + 948, + 1058, + 3, + 114, + 57, + 0, + 949, + 1058, + 3, + 120, + 60, + 0, + 950, + 1058, + 3, + 122, + 61, + 0, + 951, + 1058, + 3, + 124, + 62, + 0, + 952, + 1058, + 3, + 126, + 63, + 0, + 953, + 1058, + 3, + 128, + 64, + 0, + 954, + 1058, + 3, + 132, + 66, + 0, + 955, + 1058, + 3, + 134, + 67, + 0, + 956, + 1058, + 3, + 138, + 69, + 0, + 957, + 1058, + 3, + 140, + 70, + 0, + 958, + 1058, + 3, + 142, + 71, + 0, + 959, + 1058, + 3, + 146, + 73, + 0, + 960, + 1058, + 3, + 148, + 74, + 0, + 961, + 1058, + 3, + 150, + 75, + 0, + 962, + 1058, + 3, + 152, + 76, + 0, + 963, + 1058, + 3, + 154, + 77, + 0, + 964, + 1058, + 3, + 156, + 78, + 0, + 965, + 1058, + 3, + 158, + 79, + 0, + 966, + 1058, + 3, + 160, + 80, + 0, + 967, + 1058, + 3, + 162, + 81, + 0, + 968, + 1058, + 3, + 164, + 82, + 0, + 969, + 1058, + 3, + 166, + 83, + 0, + 970, + 1058, + 3, + 168, + 84, + 0, + 971, + 1058, + 3, + 170, + 85, + 0, + 972, + 1058, + 3, + 172, + 86, + 0, + 973, + 1058, + 3, + 174, + 87, + 0, + 974, + 1058, + 3, + 176, + 88, + 0, + 975, + 1058, + 3, + 178, + 89, + 0, + 976, + 1058, + 3, + 180, + 90, + 0, + 977, + 1058, + 3, + 182, + 91, + 0, + 978, + 1058, + 3, + 184, + 92, + 0, + 979, + 1058, + 3, + 188, + 94, + 0, + 980, + 1058, + 3, + 190, + 95, + 0, + 981, + 1058, + 3, + 192, + 96, + 0, + 982, + 1058, + 3, + 196, + 98, + 0, + 983, + 1058, + 3, + 198, + 99, + 0, + 984, + 1058, + 3, + 200, + 100, + 0, + 985, + 1058, + 3, + 202, + 101, + 0, + 986, + 1058, + 3, + 204, + 102, + 0, + 987, + 1058, + 3, + 212, + 106, + 0, + 988, + 1058, + 3, + 214, + 107, + 0, + 989, + 1058, + 3, + 216, + 108, + 0, + 990, + 1058, + 3, + 218, + 109, + 0, + 991, + 1058, + 3, + 220, + 110, + 0, + 992, + 1058, + 3, + 222, + 111, + 0, + 993, + 1058, + 3, + 224, + 112, + 0, + 994, + 1058, + 3, + 226, + 113, + 0, + 995, + 1058, + 3, + 228, + 114, + 0, + 996, + 1058, + 3, + 230, + 115, + 0, + 997, + 1058, + 3, + 232, + 116, + 0, + 998, + 1058, + 3, + 234, + 117, + 0, + 999, + 1058, + 3, + 236, + 118, + 0, + 1000, + 1058, + 3, + 238, + 119, + 0, + 1001, + 1058, + 3, + 242, + 121, + 0, + 1002, + 1058, + 3, + 244, + 122, + 0, + 1003, + 1058, + 3, + 246, + 123, + 0, + 1004, + 1058, + 3, + 248, + 124, + 0, + 1005, + 1058, + 3, + 250, + 125, + 0, + 1006, + 1058, + 3, + 252, + 126, + 0, + 1007, + 1058, + 3, + 254, + 127, + 0, + 1008, + 1058, + 3, + 256, + 128, + 0, + 1009, + 1058, + 3, + 264, + 132, + 0, + 1010, + 1058, + 3, + 266, + 133, + 0, + 1011, + 1058, + 3, + 268, + 134, + 0, + 1012, + 1058, + 3, + 102, + 51, + 0, + 1013, + 1058, + 3, + 240, + 120, + 0, + 1014, + 1058, + 3, + 206, + 103, + 0, + 1015, + 1058, + 3, + 270, + 135, + 0, + 1016, + 1058, + 3, + 272, + 136, + 0, + 1017, + 1058, + 3, + 274, + 137, + 0, + 1018, + 1058, + 3, + 276, + 138, + 0, + 1019, + 1058, + 3, + 280, + 140, + 0, + 1020, + 1058, + 3, + 282, + 141, + 0, + 1021, + 1058, + 3, + 286, + 143, + 0, + 1022, + 1058, + 3, + 288, + 144, + 0, + 1023, + 1058, + 3, + 136, + 68, + 0, + 1024, + 1058, + 3, + 290, + 145, + 0, + 1025, + 1058, + 3, + 292, + 146, + 0, + 1026, + 1058, + 3, + 294, + 147, + 0, + 1027, + 1058, + 3, + 296, + 148, + 0, + 1028, + 1058, + 3, + 302, + 151, + 0, + 1029, + 1058, + 3, + 304, + 152, + 0, + 1030, + 1058, + 3, + 308, + 154, + 0, + 1031, + 1058, + 3, + 310, + 155, + 0, + 1032, + 1058, + 3, + 312, + 156, + 0, + 1033, + 1058, + 3, + 314, + 157, + 0, + 1034, + 1058, + 3, + 316, + 158, + 0, + 1035, + 1058, + 3, + 318, + 159, + 0, + 1036, + 1058, + 3, + 320, + 160, + 0, + 1037, + 1058, + 3, + 322, + 161, + 0, + 1038, + 1058, + 3, + 324, + 162, + 0, + 1039, + 1058, + 3, + 130, + 65, + 0, + 1040, + 1058, + 3, + 92, + 46, + 0, + 1041, + 1058, + 3, + 104, + 52, + 0, + 1042, + 1058, + 3, + 78, + 39, + 0, + 1043, + 1058, + 3, + 144, + 72, + 0, + 1044, + 1058, + 3, + 300, + 150, + 0, + 1045, + 1058, + 3, + 298, + 149, + 0, + 1046, + 1058, + 3, + 186, + 93, + 0, + 1047, + 1058, + 3, + 306, + 153, + 0, + 1048, + 1058, + 3, + 194, + 97, + 0, + 1049, + 1058, + 3, + 262, + 131, + 0, + 1050, + 1058, + 3, + 260, + 130, + 0, + 1051, + 1058, + 3, + 258, + 129, + 0, + 1052, + 1058, + 3, + 278, + 139, + 0, + 1053, + 1058, + 3, + 284, + 142, + 0, + 1054, + 1058, + 3, + 76, + 38, + 0, + 1055, + 1058, + 3, + 116, + 58, + 0, + 1056, + 1058, + 3, + 118, + 59, + 0, + 1057, + 923, + 1, + 0, + 0, + 0, + 1057, + 924, + 1, + 0, + 0, + 0, + 1057, + 925, + 1, + 0, + 0, + 0, + 1057, + 926, + 1, + 0, + 0, + 0, + 1057, + 927, + 1, + 0, + 0, + 0, + 1057, + 928, + 1, + 0, + 0, + 0, + 1057, + 929, + 1, + 0, + 0, + 0, + 1057, + 930, + 1, + 0, + 0, + 0, + 1057, + 931, + 1, + 0, + 0, + 0, + 1057, + 932, + 1, + 0, + 0, + 0, + 1057, + 933, + 1, + 0, + 0, + 0, + 1057, + 934, + 1, + 0, + 0, + 0, + 1057, + 935, + 1, + 0, + 0, + 0, + 1057, + 936, + 1, + 0, + 0, + 0, + 1057, + 937, + 1, + 0, + 0, + 0, + 1057, + 938, + 1, + 0, + 0, + 0, + 1057, + 939, + 1, + 0, + 0, + 0, + 1057, + 940, + 1, + 0, + 0, + 0, + 1057, + 941, + 1, + 0, + 0, + 0, + 1057, + 942, + 1, + 0, + 0, + 0, + 1057, + 943, + 1, + 0, + 0, + 0, + 1057, + 944, + 1, + 0, + 0, + 0, + 1057, + 945, + 1, + 0, + 0, + 0, + 1057, + 946, + 1, + 0, + 0, + 0, + 1057, + 947, + 1, + 0, + 0, + 0, + 1057, + 948, + 1, + 0, + 0, + 0, + 1057, + 949, + 1, + 0, + 0, + 0, + 1057, + 950, + 1, + 0, + 0, + 0, + 1057, + 951, + 1, + 0, + 0, + 0, + 1057, + 952, + 1, + 0, + 0, + 0, + 1057, + 953, + 1, + 0, + 0, + 0, + 1057, + 954, + 1, + 0, + 0, + 0, + 1057, + 955, + 1, + 0, + 0, + 0, + 1057, + 956, + 1, + 0, + 0, + 0, + 1057, + 957, + 1, + 0, + 0, + 0, + 1057, + 958, + 1, + 0, + 0, + 0, + 1057, + 959, + 1, + 0, + 0, + 0, + 1057, + 960, + 1, + 0, + 0, + 0, + 1057, + 961, + 1, + 0, + 0, + 0, + 1057, + 962, + 1, + 0, + 0, + 0, + 1057, + 963, + 1, + 0, + 0, + 0, + 1057, + 964, + 1, + 0, + 0, + 0, + 1057, + 965, + 1, + 0, + 0, + 0, + 1057, + 966, + 1, + 0, + 0, + 0, + 1057, + 967, + 1, + 0, + 0, + 0, + 1057, + 968, + 1, + 0, + 0, + 0, + 1057, + 969, + 1, + 0, + 0, + 0, + 1057, + 970, + 1, + 0, + 0, + 0, + 1057, + 971, + 1, + 0, + 0, + 0, + 1057, + 972, + 1, + 0, + 0, + 0, + 1057, + 973, + 1, + 0, + 0, + 0, + 1057, + 974, + 1, + 0, + 0, + 0, + 1057, + 975, + 1, + 0, + 0, + 0, + 1057, + 976, + 1, + 0, + 0, + 0, + 1057, + 977, + 1, + 0, + 0, + 0, + 1057, + 978, + 1, + 0, + 0, + 0, + 1057, + 979, + 1, + 0, + 0, + 0, + 1057, + 980, + 1, + 0, + 0, + 0, + 1057, + 981, + 1, + 0, + 0, + 0, + 1057, + 982, + 1, + 0, + 0, + 0, + 1057, + 983, + 1, + 0, + 0, + 0, + 1057, + 984, + 1, + 0, + 0, + 0, + 1057, + 985, + 1, + 0, + 0, + 0, + 1057, + 986, + 1, + 0, + 0, + 0, + 1057, + 987, + 1, + 0, + 0, + 0, + 1057, + 988, + 1, + 0, + 0, + 0, + 1057, + 989, + 1, + 0, + 0, + 0, + 1057, + 990, + 1, + 0, + 0, + 0, + 1057, + 991, + 1, + 0, + 0, + 0, + 1057, + 992, + 1, + 0, + 0, + 0, + 1057, + 993, + 1, + 0, + 0, + 0, + 1057, + 994, + 1, + 0, + 0, + 0, + 1057, + 995, + 1, + 0, + 0, + 0, + 1057, + 996, + 1, + 0, + 0, + 0, + 1057, + 997, + 1, + 0, + 0, + 0, + 1057, + 998, + 1, + 0, + 0, + 0, + 1057, + 999, + 1, + 0, + 0, + 0, + 1057, + 1000, + 1, + 0, + 0, + 0, + 1057, + 1001, + 1, + 0, + 0, + 0, + 1057, + 1002, + 1, + 0, + 0, + 0, + 1057, + 1003, + 1, + 0, + 0, + 0, + 1057, + 1004, + 1, + 0, + 0, + 0, + 1057, + 1005, + 1, + 0, + 0, + 0, + 1057, + 1006, + 1, + 0, + 0, + 0, + 1057, + 1007, + 1, + 0, + 0, + 0, + 1057, + 1008, + 1, + 0, + 0, + 0, + 1057, + 1009, + 1, + 0, + 0, + 0, + 1057, + 1010, + 1, + 0, + 0, + 0, + 1057, + 1011, + 1, + 0, + 0, + 0, + 1057, + 1012, + 1, + 0, + 0, + 0, + 1057, + 1013, + 1, + 0, + 0, + 0, + 1057, + 1014, + 1, + 0, + 0, + 0, + 1057, + 1015, + 1, + 0, + 0, + 0, + 1057, + 1016, + 1, + 0, + 0, + 0, + 1057, + 1017, + 1, + 0, + 0, + 0, + 1057, + 1018, + 1, + 0, + 0, + 0, + 1057, + 1019, + 1, + 0, + 0, + 0, + 1057, + 1020, + 1, + 0, + 0, + 0, + 1057, + 1021, + 1, + 0, + 0, + 0, + 1057, + 1022, + 1, + 0, + 0, + 0, + 1057, + 1023, + 1, + 0, + 0, + 0, + 1057, + 1024, + 1, + 0, + 0, + 0, + 1057, + 1025, + 1, + 0, + 0, + 0, + 1057, + 1026, + 1, + 0, + 0, + 0, + 1057, + 1027, + 1, + 0, + 0, + 0, + 1057, + 1028, + 1, + 0, + 0, + 0, + 1057, + 1029, + 1, + 0, + 0, + 0, + 1057, + 1030, + 1, + 0, + 0, + 0, + 1057, + 1031, + 1, + 0, + 0, + 0, + 1057, + 1032, + 1, + 0, + 0, + 0, + 1057, + 1033, + 1, + 0, + 0, + 0, + 1057, + 1034, + 1, + 0, + 0, + 0, + 1057, + 1035, + 1, + 0, + 0, + 0, + 1057, + 1036, + 1, + 0, + 0, + 0, + 1057, + 1037, + 1, + 0, + 0, + 0, + 1057, + 1038, + 1, + 0, + 0, + 0, + 1057, + 1039, + 1, + 0, + 0, + 0, + 1057, + 1040, + 1, + 0, + 0, + 0, + 1057, + 1041, + 1, + 0, + 0, + 0, + 1057, + 1042, + 1, + 0, + 0, + 0, + 1057, + 1043, + 1, + 0, + 0, + 0, + 1057, + 1044, + 1, + 0, + 0, + 0, + 1057, + 1045, + 1, + 0, + 0, + 0, + 1057, + 1046, + 1, + 0, + 0, + 0, + 1057, + 1047, + 1, + 0, + 0, + 0, + 1057, + 1048, + 1, + 0, + 0, + 0, + 1057, + 1049, + 1, + 0, + 0, + 0, + 1057, + 1050, + 1, + 0, + 0, + 0, + 1057, + 1051, + 1, + 0, + 0, + 0, + 1057, + 1052, + 1, + 0, + 0, + 0, + 1057, + 1053, + 1, + 0, + 0, + 0, + 1057, + 1054, + 1, + 0, + 0, + 0, + 1057, + 1055, + 1, + 0, + 0, + 0, + 1057, + 1056, + 1, + 0, + 0, + 0, + 1058, + 57, + 1, + 0, + 0, + 0, + 1059, + 1060, + 5, + 233, + 0, + 0, + 1060, + 1061, + 5, + 256, + 0, + 0, + 1061, + 1062, + 3, + 534, + 267, + 0, + 1062, + 1063, + 5, + 257, + 0, + 0, + 1063, + 59, + 1, + 0, + 0, + 0, + 1064, + 1065, + 5, + 57, + 0, + 0, + 1065, + 1066, + 5, + 256, + 0, + 0, + 1066, + 1067, + 3, + 534, + 267, + 0, + 1067, + 1068, + 5, + 257, + 0, + 0, + 1068, + 61, + 1, + 0, + 0, + 0, + 1069, + 1070, + 5, + 3, + 0, + 0, + 1070, + 1071, + 5, + 256, + 0, + 0, + 1071, + 1072, + 3, + 524, + 262, + 0, + 1072, + 1073, + 5, + 257, + 0, + 0, + 1073, + 1080, + 1, + 0, + 0, + 0, + 1074, + 1075, + 5, + 3, + 0, + 0, + 1075, + 1076, + 5, + 256, + 0, + 0, + 1076, + 1077, + 3, + 52, + 26, + 0, + 1077, + 1078, + 5, + 257, + 0, + 0, + 1078, + 1080, + 1, + 0, + 0, + 0, + 1079, + 1069, + 1, + 0, + 0, + 0, + 1079, + 1074, + 1, + 0, + 0, + 0, + 1080, + 63, + 1, + 0, + 0, + 0, + 1081, + 1082, + 5, + 4, + 0, + 0, + 1082, + 1083, + 5, + 256, + 0, + 0, + 1083, + 1095, + 5, + 257, + 0, + 0, + 1084, + 1085, + 5, + 4, + 0, + 0, + 1085, + 1086, + 5, + 256, + 0, + 0, + 1086, + 1087, + 3, + 524, + 262, + 0, + 1087, + 1088, + 5, + 257, + 0, + 0, + 1088, + 1095, + 1, + 0, + 0, + 0, + 1089, + 1090, + 5, + 4, + 0, + 0, + 1090, + 1091, + 5, + 256, + 0, + 0, + 1091, + 1092, + 3, + 52, + 26, + 0, + 1092, + 1093, + 5, + 257, + 0, + 0, + 1093, + 1095, + 1, + 0, + 0, + 0, + 1094, + 1081, + 1, + 0, + 0, + 0, + 1094, + 1084, + 1, + 0, + 0, + 0, + 1094, + 1089, + 1, + 0, + 0, + 0, + 1095, + 65, + 1, + 0, + 0, + 0, + 1096, + 1097, + 5, + 5, + 0, + 0, + 1097, + 1098, + 5, + 256, + 0, + 0, + 1098, + 1099, + 3, + 332, + 166, + 0, + 1099, + 1100, + 5, + 263, + 0, + 0, + 1100, + 1101, + 3, + 578, + 289, + 0, + 1101, + 1102, + 5, + 257, + 0, + 0, + 1102, + 1109, + 1, + 0, + 0, + 0, + 1103, + 1104, + 5, + 5, + 0, + 0, + 1104, + 1105, + 5, + 256, + 0, + 0, + 1105, + 1106, + 3, + 578, + 289, + 0, + 1106, + 1107, + 5, + 257, + 0, + 0, + 1107, + 1109, + 1, + 0, + 0, + 0, + 1108, + 1096, + 1, + 0, + 0, + 0, + 1108, + 1103, + 1, + 0, + 0, + 0, + 1109, + 67, + 1, + 0, + 0, + 0, + 1110, + 1111, + 5, + 6, + 0, + 0, + 1111, + 1112, + 5, + 256, + 0, + 0, + 1112, + 1113, + 3, + 364, + 182, + 0, + 1113, + 1114, + 5, + 257, + 0, + 0, + 1114, + 69, + 1, + 0, + 0, + 0, + 1115, + 1116, + 5, + 7, + 0, + 0, + 1116, + 1117, + 5, + 256, + 0, + 0, + 1117, + 1118, + 3, + 552, + 276, + 0, + 1118, + 1119, + 5, + 257, + 0, + 0, + 1119, + 71, + 1, + 0, + 0, + 0, + 1120, + 1121, + 5, + 8, + 0, + 0, + 1121, + 1122, + 5, + 256, + 0, + 0, + 1122, + 1123, + 3, + 364, + 182, + 0, + 1123, + 1124, + 5, + 257, + 0, + 0, + 1124, + 73, + 1, + 0, + 0, + 0, + 1125, + 1126, + 5, + 9, + 0, + 0, + 1126, + 1127, + 5, + 256, + 0, + 0, + 1127, + 1130, + 3, + 578, + 289, + 0, + 1128, + 1129, + 5, + 263, + 0, + 0, + 1129, + 1131, + 3, + 568, + 284, + 0, + 1130, + 1128, + 1, + 0, + 0, + 0, + 1130, + 1131, + 1, + 0, + 0, + 0, + 1131, + 1132, + 1, + 0, + 0, + 0, + 1132, + 1133, + 5, + 257, + 0, + 0, + 1133, + 75, + 1, + 0, + 0, + 0, + 1134, + 1135, + 5, + 11, + 0, + 0, + 1135, + 1136, + 5, + 256, + 0, + 0, + 1136, + 1137, + 5, + 257, + 0, + 0, + 1137, + 77, + 1, + 0, + 0, + 0, + 1138, + 1139, + 5, + 12, + 0, + 0, + 1139, + 1140, + 5, + 256, + 0, + 0, + 1140, + 1147, + 5, + 257, + 0, + 0, + 1141, + 1142, + 5, + 12, + 0, + 0, + 1142, + 1143, + 5, + 256, + 0, + 0, + 1143, + 1144, + 3, + 332, + 166, + 0, + 1144, + 1145, + 5, + 257, + 0, + 0, + 1145, + 1147, + 1, + 0, + 0, + 0, + 1146, + 1138, + 1, + 0, + 0, + 0, + 1146, + 1141, + 1, + 0, + 0, + 0, + 1147, + 79, + 1, + 0, + 0, + 0, + 1148, + 1149, + 5, + 14, + 0, + 0, + 1149, + 1150, + 5, + 256, + 0, + 0, + 1150, + 1151, + 3, + 368, + 184, + 0, + 1151, + 1152, + 5, + 257, + 0, + 0, + 1152, + 1162, + 1, + 0, + 0, + 0, + 1153, + 1154, + 5, + 14, + 0, + 0, + 1154, + 1155, + 5, + 256, + 0, + 0, + 1155, + 1162, + 5, + 257, + 0, + 0, + 1156, + 1157, + 5, + 14, + 0, + 0, + 1157, + 1158, + 5, + 256, + 0, + 0, + 1158, + 1159, + 3, + 582, + 291, + 0, + 1159, + 1160, + 5, + 257, + 0, + 0, + 1160, + 1162, + 1, + 0, + 0, + 0, + 1161, + 1148, + 1, + 0, + 0, + 0, + 1161, + 1153, + 1, + 0, + 0, + 0, + 1161, + 1156, + 1, + 0, + 0, + 0, + 1162, + 81, + 1, + 0, + 0, + 0, + 1163, + 1164, + 5, + 18, + 0, + 0, + 1164, + 1165, + 5, + 256, + 0, + 0, + 1165, + 1166, + 3, + 528, + 264, + 0, + 1166, + 1167, + 5, + 257, + 0, + 0, + 1167, + 83, + 1, + 0, + 0, + 0, + 1168, + 1169, + 5, + 20, + 0, + 0, + 1169, + 1170, + 5, + 256, + 0, + 0, + 1170, + 1171, + 3, + 528, + 264, + 0, + 1171, + 1172, + 5, + 257, + 0, + 0, + 1172, + 85, + 1, + 0, + 0, + 0, + 1173, + 1174, + 5, + 21, + 0, + 0, + 1174, + 1175, + 5, + 256, + 0, + 0, + 1175, + 1176, + 5, + 257, + 0, + 0, + 1176, + 87, + 1, + 0, + 0, + 0, + 1177, + 1178, + 5, + 22, + 0, + 0, + 1178, + 1179, + 5, + 256, + 0, + 0, + 1179, + 1180, + 3, + 52, + 26, + 0, + 1180, + 1181, + 5, + 257, + 0, + 0, + 1181, + 89, + 1, + 0, + 0, + 0, + 1182, + 1183, + 5, + 23, + 0, + 0, + 1183, + 1184, + 5, + 256, + 0, + 0, + 1184, + 1185, + 3, + 370, + 185, + 0, + 1185, + 1186, + 5, + 257, + 0, + 0, + 1186, + 1237, + 1, + 0, + 0, + 0, + 1187, + 1188, + 5, + 23, + 0, + 0, + 1188, + 1189, + 5, + 256, + 0, + 0, + 1189, + 1237, + 5, + 257, + 0, + 0, + 1190, + 1191, + 5, + 23, + 0, + 0, + 1191, + 1192, + 5, + 256, + 0, + 0, + 1192, + 1193, + 3, + 372, + 186, + 0, + 1193, + 1194, + 5, + 257, + 0, + 0, + 1194, + 1237, + 1, + 0, + 0, + 0, + 1195, + 1196, + 5, + 23, + 0, + 0, + 1196, + 1197, + 5, + 256, + 0, + 0, + 1197, + 1198, + 3, + 372, + 186, + 0, + 1198, + 1199, + 5, + 263, + 0, + 0, + 1199, + 1200, + 3, + 370, + 185, + 0, + 1200, + 1201, + 5, + 257, + 0, + 0, + 1201, + 1237, + 1, + 0, + 0, + 0, + 1202, + 1203, + 5, + 23, + 0, + 0, + 1203, + 1204, + 5, + 256, + 0, + 0, + 1204, + 1205, + 3, + 344, + 172, + 0, + 1205, + 1206, + 5, + 257, + 0, + 0, + 1206, + 1237, + 1, + 0, + 0, + 0, + 1207, + 1208, + 5, + 23, + 0, + 0, + 1208, + 1209, + 5, + 256, + 0, + 0, + 1209, + 1210, + 3, + 578, + 289, + 0, + 1210, + 1211, + 5, + 257, + 0, + 0, + 1211, + 1237, + 1, + 0, + 0, + 0, + 1212, + 1213, + 5, + 23, + 0, + 0, + 1213, + 1214, + 5, + 256, + 0, + 0, + 1214, + 1215, + 3, + 578, + 289, + 0, + 1215, + 1216, + 5, + 263, + 0, + 0, + 1216, + 1217, + 3, + 370, + 185, + 0, + 1217, + 1218, + 5, + 257, + 0, + 0, + 1218, + 1237, + 1, + 0, + 0, + 0, + 1219, + 1220, + 5, + 23, + 0, + 0, + 1220, + 1221, + 5, + 256, + 0, + 0, + 1221, + 1222, + 3, + 336, + 168, + 0, + 1222, + 1223, + 5, + 257, + 0, + 0, + 1223, + 1237, + 1, + 0, + 0, + 0, + 1224, + 1225, + 5, + 23, + 0, + 0, + 1225, + 1226, + 5, + 256, + 0, + 0, + 1226, + 1227, + 3, + 52, + 26, + 0, + 1227, + 1228, + 5, + 257, + 0, + 0, + 1228, + 1237, + 1, + 0, + 0, + 0, + 1229, + 1230, + 5, + 23, + 0, + 0, + 1230, + 1231, + 5, + 256, + 0, + 0, + 1231, + 1232, + 3, + 52, + 26, + 0, + 1232, + 1233, + 5, + 263, + 0, + 0, + 1233, + 1234, + 3, + 370, + 185, + 0, + 1234, + 1235, + 5, + 257, + 0, + 0, + 1235, + 1237, + 1, + 0, + 0, + 0, + 1236, + 1182, + 1, + 0, + 0, + 0, + 1236, + 1187, + 1, + 0, + 0, + 0, + 1236, + 1190, + 1, + 0, + 0, + 0, + 1236, + 1195, + 1, + 0, + 0, + 0, + 1236, + 1202, + 1, + 0, + 0, + 0, + 1236, + 1207, + 1, + 0, + 0, + 0, + 1236, + 1212, + 1, + 0, + 0, + 0, + 1236, + 1219, + 1, + 0, + 0, + 0, + 1236, + 1224, + 1, + 0, + 0, + 0, + 1236, + 1229, + 1, + 0, + 0, + 0, + 1237, + 91, + 1, + 0, + 0, + 0, + 1238, + 1239, + 5, + 24, + 0, + 0, + 1239, + 1240, + 5, + 256, + 0, + 0, + 1240, + 1241, + 3, + 578, + 289, + 0, + 1241, + 1242, + 5, + 257, + 0, + 0, + 1242, + 1267, + 1, + 0, + 0, + 0, + 1243, + 1244, + 5, + 24, + 0, + 0, + 1244, + 1245, + 5, + 256, + 0, + 0, + 1245, + 1246, + 3, + 578, + 289, + 0, + 1246, + 1247, + 5, + 263, + 0, + 0, + 1247, + 1248, + 3, + 536, + 268, + 0, + 1248, + 1249, + 5, + 257, + 0, + 0, + 1249, + 1267, + 1, + 0, + 0, + 0, + 1250, + 1251, + 5, + 24, + 0, + 0, + 1251, + 1252, + 5, + 256, + 0, + 0, + 1252, + 1253, + 3, + 578, + 289, + 0, + 1253, + 1254, + 5, + 263, + 0, + 0, + 1254, + 1255, + 3, + 52, + 26, + 0, + 1255, + 1256, + 5, + 257, + 0, + 0, + 1256, + 1267, + 1, + 0, + 0, + 0, + 1257, + 1258, + 5, + 24, + 0, + 0, + 1258, + 1259, + 5, + 256, + 0, + 0, + 1259, + 1260, + 3, + 578, + 289, + 0, + 1260, + 1261, + 5, + 263, + 0, + 0, + 1261, + 1262, + 3, + 536, + 268, + 0, + 1262, + 1263, + 5, + 263, + 0, + 0, + 1263, + 1264, + 3, + 52, + 26, + 0, + 1264, + 1265, + 5, + 257, + 0, + 0, + 1265, + 1267, + 1, + 0, + 0, + 0, + 1266, + 1238, + 1, + 0, + 0, + 0, + 1266, + 1243, + 1, + 0, + 0, + 0, + 1266, + 1250, + 1, + 0, + 0, + 0, + 1266, + 1257, + 1, + 0, + 0, + 0, + 1267, + 93, + 1, + 0, + 0, + 0, + 1268, + 1269, + 5, + 25, + 0, + 0, + 1269, + 1270, + 5, + 256, + 0, + 0, + 1270, + 1273, + 3, + 578, + 289, + 0, + 1271, + 1272, + 5, + 263, + 0, + 0, + 1272, + 1274, + 3, + 568, + 284, + 0, + 1273, + 1271, + 1, + 0, + 0, + 0, + 1273, + 1274, + 1, + 0, + 0, + 0, + 1274, + 1275, + 1, + 0, + 0, + 0, + 1275, + 1276, + 5, + 257, + 0, + 0, + 1276, + 95, + 1, + 0, + 0, + 0, + 1277, + 1278, + 5, + 27, + 0, + 0, + 1278, + 1279, + 5, + 256, + 0, + 0, + 1279, + 1280, + 3, + 372, + 186, + 0, + 1280, + 1281, + 5, + 257, + 0, + 0, + 1281, + 1320, + 1, + 0, + 0, + 0, + 1282, + 1283, + 5, + 27, + 0, + 0, + 1283, + 1284, + 5, + 256, + 0, + 0, + 1284, + 1285, + 3, + 364, + 182, + 0, + 1285, + 1286, + 5, + 263, + 0, + 0, + 1286, + 1287, + 3, + 52, + 26, + 0, + 1287, + 1288, + 5, + 257, + 0, + 0, + 1288, + 1320, + 1, + 0, + 0, + 0, + 1289, + 1290, + 5, + 27, + 0, + 0, + 1290, + 1291, + 5, + 256, + 0, + 0, + 1291, + 1292, + 3, + 364, + 182, + 0, + 1292, + 1293, + 5, + 263, + 0, + 0, + 1293, + 1294, + 3, + 52, + 26, + 0, + 1294, + 1295, + 5, + 263, + 0, + 0, + 1295, + 1296, + 3, + 52, + 26, + 0, + 1296, + 1297, + 5, + 257, + 0, + 0, + 1297, + 1320, + 1, + 0, + 0, + 0, + 1298, + 1299, + 5, + 27, + 0, + 0, + 1299, + 1300, + 5, + 256, + 0, + 0, + 1300, + 1301, + 3, + 52, + 26, + 0, + 1301, + 1302, + 5, + 257, + 0, + 0, + 1302, + 1320, + 1, + 0, + 0, + 0, + 1303, + 1304, + 5, + 27, + 0, + 0, + 1304, + 1305, + 5, + 256, + 0, + 0, + 1305, + 1306, + 3, + 52, + 26, + 0, + 1306, + 1307, + 5, + 263, + 0, + 0, + 1307, + 1308, + 3, + 52, + 26, + 0, + 1308, + 1309, + 5, + 257, + 0, + 0, + 1309, + 1320, + 1, + 0, + 0, + 0, + 1310, + 1311, + 5, + 27, + 0, + 0, + 1311, + 1312, + 5, + 256, + 0, + 0, + 1312, + 1313, + 3, + 52, + 26, + 0, + 1313, + 1314, + 5, + 263, + 0, + 0, + 1314, + 1315, + 3, + 52, + 26, + 0, + 1315, + 1316, + 5, + 263, + 0, + 0, + 1316, + 1317, + 3, + 52, + 26, + 0, + 1317, + 1318, + 5, + 257, + 0, + 0, + 1318, + 1320, + 1, + 0, + 0, + 0, + 1319, + 1277, + 1, + 0, + 0, + 0, + 1319, + 1282, + 1, + 0, + 0, + 0, + 1319, + 1289, + 1, + 0, + 0, + 0, + 1319, + 1298, + 1, + 0, + 0, + 0, + 1319, + 1303, + 1, + 0, + 0, + 0, + 1319, + 1310, + 1, + 0, + 0, + 0, + 1320, + 97, + 1, + 0, + 0, + 0, + 1321, + 1322, + 5, + 28, + 0, + 0, + 1322, + 1323, + 5, + 256, + 0, + 0, + 1323, + 1324, + 3, + 552, + 276, + 0, + 1324, + 1325, + 5, + 257, + 0, + 0, + 1325, + 99, + 1, + 0, + 0, + 0, + 1326, + 1327, + 5, + 29, + 0, + 0, + 1327, + 1328, + 5, + 256, + 0, + 0, + 1328, + 1329, + 3, + 522, + 261, + 0, + 1329, + 1330, + 5, + 257, + 0, + 0, + 1330, + 101, + 1, + 0, + 0, + 0, + 1331, + 1332, + 5, + 31, + 0, + 0, + 1332, + 1333, + 5, + 256, + 0, + 0, + 1333, + 1334, + 3, + 532, + 266, + 0, + 1334, + 1335, + 5, + 257, + 0, + 0, + 1335, + 103, + 1, + 0, + 0, + 0, + 1336, + 1337, + 5, + 34, + 0, + 0, + 1337, + 1338, + 5, + 256, + 0, + 0, + 1338, + 1341, + 3, + 52, + 26, + 0, + 1339, + 1340, + 5, + 263, + 0, + 0, + 1340, + 1342, + 3, + 552, + 276, + 0, + 1341, + 1339, + 1, + 0, + 0, + 0, + 1341, + 1342, + 1, + 0, + 0, + 0, + 1342, + 1343, + 1, + 0, + 0, + 0, + 1343, + 1344, + 5, + 257, + 0, + 0, + 1344, + 1351, + 1, + 0, + 0, + 0, + 1345, + 1346, + 5, + 34, + 0, + 0, + 1346, + 1347, + 5, + 256, + 0, + 0, + 1347, + 1348, + 3, + 568, + 284, + 0, + 1348, + 1349, + 5, + 257, + 0, + 0, + 1349, + 1351, + 1, + 0, + 0, + 0, + 1350, + 1336, + 1, + 0, + 0, + 0, + 1350, + 1345, + 1, + 0, + 0, + 0, + 1351, + 105, + 1, + 0, + 0, + 0, + 1352, + 1353, + 5, + 35, + 0, + 0, + 1353, + 1354, + 5, + 256, + 0, + 0, + 1354, + 1355, + 3, + 524, + 262, + 0, + 1355, + 1356, + 5, + 257, + 0, + 0, + 1356, + 107, + 1, + 0, + 0, + 0, + 1357, + 1358, + 5, + 36, + 0, + 0, + 1358, + 1359, + 5, + 256, + 0, + 0, + 1359, + 1360, + 5, + 257, + 0, + 0, + 1360, + 109, + 1, + 0, + 0, + 0, + 1361, + 1362, + 5, + 38, + 0, + 0, + 1362, + 1363, + 5, + 256, + 0, + 0, + 1363, + 1364, + 3, + 532, + 266, + 0, + 1364, + 1365, + 5, + 257, + 0, + 0, + 1365, + 111, + 1, + 0, + 0, + 0, + 1366, + 1367, + 5, + 40, + 0, + 0, + 1367, + 1368, + 5, + 256, + 0, + 0, + 1368, + 1375, + 5, + 257, + 0, + 0, + 1369, + 1370, + 5, + 40, + 0, + 0, + 1370, + 1371, + 5, + 256, + 0, + 0, + 1371, + 1372, + 3, + 332, + 166, + 0, + 1372, + 1373, + 5, + 257, + 0, + 0, + 1373, + 1375, + 1, + 0, + 0, + 0, + 1374, + 1366, + 1, + 0, + 0, + 0, + 1374, + 1369, + 1, + 0, + 0, + 0, + 1375, + 113, + 1, + 0, + 0, + 0, + 1376, + 1377, + 5, + 41, + 0, + 0, + 1377, + 1378, + 5, + 256, + 0, + 0, + 1378, + 1379, + 5, + 257, + 0, + 0, + 1379, + 115, + 1, + 0, + 0, + 0, + 1380, + 1381, + 5, + 43, + 0, + 0, + 1381, + 1382, + 5, + 256, + 0, + 0, + 1382, + 1383, + 3, + 362, + 181, + 0, + 1383, + 1384, + 5, + 263, + 0, + 0, + 1384, + 1385, + 3, + 582, + 291, + 0, + 1385, + 1386, + 5, + 257, + 0, + 0, + 1386, + 117, + 1, + 0, + 0, + 0, + 1387, + 1388, + 5, + 44, + 0, + 0, + 1388, + 1389, + 5, + 256, + 0, + 0, + 1389, + 1390, + 3, + 52, + 26, + 0, + 1390, + 1391, + 5, + 257, + 0, + 0, + 1391, + 1398, + 1, + 0, + 0, + 0, + 1392, + 1393, + 5, + 44, + 0, + 0, + 1393, + 1394, + 5, + 256, + 0, + 0, + 1394, + 1395, + 3, + 590, + 295, + 0, + 1395, + 1396, + 5, + 257, + 0, + 0, + 1396, + 1398, + 1, + 0, + 0, + 0, + 1397, + 1387, + 1, + 0, + 0, + 0, + 1397, + 1392, + 1, + 0, + 0, + 0, + 1398, + 119, + 1, + 0, + 0, + 0, + 1399, + 1400, + 5, + 48, + 0, + 0, + 1400, + 1401, + 5, + 256, + 0, + 0, + 1401, + 1404, + 3, + 332, + 166, + 0, + 1402, + 1403, + 5, + 263, + 0, + 0, + 1403, + 1405, + 3, + 568, + 284, + 0, + 1404, + 1402, + 1, + 0, + 0, + 0, + 1404, + 1405, + 1, + 0, + 0, + 0, + 1405, + 1406, + 1, + 0, + 0, + 0, + 1406, + 1407, + 5, + 257, + 0, + 0, + 1407, + 1414, + 1, + 0, + 0, + 0, + 1408, + 1409, + 5, + 48, + 0, + 0, + 1409, + 1410, + 5, + 256, + 0, + 0, + 1410, + 1411, + 3, + 568, + 284, + 0, + 1411, + 1412, + 5, + 257, + 0, + 0, + 1412, + 1414, + 1, + 0, + 0, + 0, + 1413, + 1399, + 1, + 0, + 0, + 0, + 1413, + 1408, + 1, + 0, + 0, + 0, + 1414, + 121, + 1, + 0, + 0, + 0, + 1415, + 1416, + 5, + 50, + 0, + 0, + 1416, + 1417, + 5, + 256, + 0, + 0, + 1417, + 1418, + 3, + 532, + 266, + 0, + 1418, + 1419, + 5, + 257, + 0, + 0, + 1419, + 123, + 1, + 0, + 0, + 0, + 1420, + 1421, + 5, + 1, + 0, + 0, + 1421, + 1422, + 5, + 256, + 0, + 0, + 1422, + 1423, + 5, + 257, + 0, + 0, + 1423, + 125, + 1, + 0, + 0, + 0, + 1424, + 1425, + 5, + 52, + 0, + 0, + 1425, + 1426, + 5, + 256, + 0, + 0, + 1426, + 1427, + 3, + 532, + 266, + 0, + 1427, + 1428, + 5, + 257, + 0, + 0, + 1428, + 127, + 1, + 0, + 0, + 0, + 1429, + 1430, + 5, + 55, + 0, + 0, + 1430, + 1431, + 5, + 256, + 0, + 0, + 1431, + 1432, + 5, + 257, + 0, + 0, + 1432, + 129, + 1, + 0, + 0, + 0, + 1433, + 1434, + 5, + 60, + 0, + 0, + 1434, + 1435, + 5, + 256, + 0, + 0, + 1435, + 1436, + 5, + 257, + 0, + 0, + 1436, + 131, + 1, + 0, + 0, + 0, + 1437, + 1438, + 5, + 59, + 0, + 0, + 1438, + 1439, + 5, + 256, + 0, + 0, + 1439, + 1440, + 3, + 568, + 284, + 0, + 1440, + 1441, + 5, + 257, + 0, + 0, + 1441, + 133, + 1, + 0, + 0, + 0, + 1442, + 1443, + 5, + 61, + 0, + 0, + 1443, + 1444, + 5, + 256, + 0, + 0, + 1444, + 1456, + 5, + 257, + 0, + 0, + 1445, + 1446, + 5, + 61, + 0, + 0, + 1446, + 1447, + 5, + 256, + 0, + 0, + 1447, + 1448, + 3, + 364, + 182, + 0, + 1448, + 1449, + 5, + 257, + 0, + 0, + 1449, + 1456, + 1, + 0, + 0, + 0, + 1450, + 1451, + 5, + 61, + 0, + 0, + 1451, + 1452, + 5, + 256, + 0, + 0, + 1452, + 1453, + 3, + 52, + 26, + 0, + 1453, + 1454, + 5, + 257, + 0, + 0, + 1454, + 1456, + 1, + 0, + 0, + 0, + 1455, + 1442, + 1, + 0, + 0, + 0, + 1455, + 1445, + 1, + 0, + 0, + 0, + 1455, + 1450, + 1, + 0, + 0, + 0, + 1456, + 135, + 1, + 0, + 0, + 0, + 1457, + 1458, + 5, + 65, + 0, + 0, + 1458, + 1459, + 5, + 256, + 0, + 0, + 1459, + 1466, + 5, + 257, + 0, + 0, + 1460, + 1461, + 5, + 65, + 0, + 0, + 1461, + 1462, + 5, + 256, + 0, + 0, + 1462, + 1463, + 3, + 578, + 289, + 0, + 1463, + 1464, + 5, + 257, + 0, + 0, + 1464, + 1466, + 1, + 0, + 0, + 0, + 1465, + 1457, + 1, + 0, + 0, + 0, + 1465, + 1460, + 1, + 0, + 0, + 0, + 1466, + 137, + 1, + 0, + 0, + 0, + 1467, + 1468, + 5, + 67, + 0, + 0, + 1468, + 1469, + 5, + 256, + 0, + 0, + 1469, + 1470, + 3, + 364, + 182, + 0, + 1470, + 1471, + 5, + 257, + 0, + 0, + 1471, + 1478, + 1, + 0, + 0, + 0, + 1472, + 1473, + 5, + 67, + 0, + 0, + 1473, + 1474, + 5, + 256, + 0, + 0, + 1474, + 1475, + 3, + 52, + 26, + 0, + 1475, + 1476, + 5, + 257, + 0, + 0, + 1476, + 1478, + 1, + 0, + 0, + 0, + 1477, + 1467, + 1, + 0, + 0, + 0, + 1477, + 1472, + 1, + 0, + 0, + 0, + 1478, + 139, + 1, + 0, + 0, + 0, + 1479, + 1480, + 5, + 69, + 0, + 0, + 1480, + 1481, + 5, + 256, + 0, + 0, + 1481, + 1482, + 3, + 52, + 26, + 0, + 1482, + 1483, + 5, + 257, + 0, + 0, + 1483, + 141, + 1, + 0, + 0, + 0, + 1484, + 1485, + 5, + 70, + 0, + 0, + 1485, + 1486, + 5, + 256, + 0, + 0, + 1486, + 1495, + 5, + 257, + 0, + 0, + 1487, + 1488, + 5, + 70, + 0, + 0, + 1488, + 1489, + 5, + 256, + 0, + 0, + 1489, + 1490, + 3, + 532, + 266, + 0, + 1490, + 1491, + 5, + 263, + 0, + 0, + 1491, + 1492, + 3, + 374, + 187, + 0, + 1492, + 1493, + 5, + 257, + 0, + 0, + 1493, + 1495, + 1, + 0, + 0, + 0, + 1494, + 1484, + 1, + 0, + 0, + 0, + 1494, + 1487, + 1, + 0, + 0, + 0, + 1495, + 143, + 1, + 0, + 0, + 0, + 1496, + 1497, + 5, + 71, + 0, + 0, + 1497, + 1498, + 5, + 256, + 0, + 0, + 1498, + 1499, + 3, + 578, + 289, + 0, + 1499, + 1500, + 5, + 257, + 0, + 0, + 1500, + 145, + 1, + 0, + 0, + 0, + 1501, + 1502, + 5, + 72, + 0, + 0, + 1502, + 1503, + 5, + 256, + 0, + 0, + 1503, + 1504, + 3, + 578, + 289, + 0, + 1504, + 1505, + 5, + 257, + 0, + 0, + 1505, + 1517, + 1, + 0, + 0, + 0, + 1506, + 1507, + 5, + 72, + 0, + 0, + 1507, + 1508, + 5, + 256, + 0, + 0, + 1508, + 1509, + 3, + 542, + 271, + 0, + 1509, + 1510, + 5, + 257, + 0, + 0, + 1510, + 1517, + 1, + 0, + 0, + 0, + 1511, + 1512, + 5, + 72, + 0, + 0, + 1512, + 1513, + 5, + 256, + 0, + 0, + 1513, + 1514, + 3, + 52, + 26, + 0, + 1514, + 1515, + 5, + 257, + 0, + 0, + 1515, + 1517, + 1, + 0, + 0, + 0, + 1516, + 1501, + 1, + 0, + 0, + 0, + 1516, + 1506, + 1, + 0, + 0, + 0, + 1516, + 1511, + 1, + 0, + 0, + 0, + 1517, + 147, + 1, + 0, + 0, + 0, + 1518, + 1519, + 5, + 79, + 0, + 0, + 1519, + 1520, + 5, + 256, + 0, + 0, + 1520, + 1527, + 5, + 257, + 0, + 0, + 1521, + 1522, + 5, + 79, + 0, + 0, + 1522, + 1523, + 5, + 256, + 0, + 0, + 1523, + 1524, + 3, + 578, + 289, + 0, + 1524, + 1525, + 5, + 257, + 0, + 0, + 1525, + 1527, + 1, + 0, + 0, + 0, + 1526, + 1518, + 1, + 0, + 0, + 0, + 1526, + 1521, + 1, + 0, + 0, + 0, + 1527, + 149, + 1, + 0, + 0, + 0, + 1528, + 1529, + 5, + 78, + 0, + 0, + 1529, + 1530, + 5, + 256, + 0, + 0, + 1530, + 1537, + 5, + 257, + 0, + 0, + 1531, + 1532, + 5, + 78, + 0, + 0, + 1532, + 1533, + 5, + 256, + 0, + 0, + 1533, + 1534, + 3, + 578, + 289, + 0, + 1534, + 1535, + 5, + 257, + 0, + 0, + 1535, + 1537, + 1, + 0, + 0, + 0, + 1536, + 1528, + 1, + 0, + 0, + 0, + 1536, + 1531, + 1, + 0, + 0, + 0, + 1537, + 151, + 1, + 0, + 0, + 0, + 1538, + 1539, + 5, + 81, + 0, + 0, + 1539, + 1540, + 5, + 256, + 0, + 0, + 1540, + 1541, + 3, + 580, + 290, + 0, + 1541, + 1542, + 5, + 257, + 0, + 0, + 1542, + 1604, + 1, + 0, + 0, + 0, + 1543, + 1544, + 5, + 81, + 0, + 0, + 1544, + 1545, + 5, + 256, + 0, + 0, + 1545, + 1546, + 3, + 580, + 290, + 0, + 1546, + 1547, + 5, + 263, + 0, + 0, + 1547, + 1548, + 3, + 532, + 266, + 0, + 1548, + 1549, + 5, + 257, + 0, + 0, + 1549, + 1604, + 1, + 0, + 0, + 0, + 1550, + 1551, + 5, + 81, + 0, + 0, + 1551, + 1552, + 5, + 256, + 0, + 0, + 1552, + 1553, + 3, + 580, + 290, + 0, + 1553, + 1554, + 5, + 263, + 0, + 0, + 1554, + 1555, + 3, + 364, + 182, + 0, + 1555, + 1556, + 5, + 257, + 0, + 0, + 1556, + 1604, + 1, + 0, + 0, + 0, + 1557, + 1558, + 5, + 81, + 0, + 0, + 1558, + 1559, + 5, + 256, + 0, + 0, + 1559, + 1560, + 3, + 526, + 263, + 0, + 1560, + 1561, + 5, + 263, + 0, + 0, + 1561, + 1562, + 3, + 580, + 290, + 0, + 1562, + 1563, + 5, + 263, + 0, + 0, + 1563, + 1564, + 3, + 532, + 266, + 0, + 1564, + 1565, + 5, + 257, + 0, + 0, + 1565, + 1604, + 1, + 0, + 0, + 0, + 1566, + 1567, + 5, + 81, + 0, + 0, + 1567, + 1568, + 5, + 256, + 0, + 0, + 1568, + 1569, + 3, + 526, + 263, + 0, + 1569, + 1570, + 5, + 263, + 0, + 0, + 1570, + 1571, + 3, + 580, + 290, + 0, + 1571, + 1572, + 5, + 263, + 0, + 0, + 1572, + 1573, + 3, + 364, + 182, + 0, + 1573, + 1574, + 5, + 257, + 0, + 0, + 1574, + 1604, + 1, + 0, + 0, + 0, + 1575, + 1576, + 5, + 81, + 0, + 0, + 1576, + 1577, + 5, + 256, + 0, + 0, + 1577, + 1578, + 3, + 580, + 290, + 0, + 1578, + 1579, + 5, + 263, + 0, + 0, + 1579, + 1580, + 3, + 52, + 26, + 0, + 1580, + 1581, + 5, + 257, + 0, + 0, + 1581, + 1604, + 1, + 0, + 0, + 0, + 1582, + 1583, + 5, + 81, + 0, + 0, + 1583, + 1584, + 5, + 256, + 0, + 0, + 1584, + 1585, + 3, + 336, + 168, + 0, + 1585, + 1586, + 5, + 263, + 0, + 0, + 1586, + 1587, + 3, + 532, + 266, + 0, + 1587, + 1588, + 5, + 257, + 0, + 0, + 1588, + 1604, + 1, + 0, + 0, + 0, + 1589, + 1590, + 5, + 81, + 0, + 0, + 1590, + 1591, + 5, + 256, + 0, + 0, + 1591, + 1592, + 3, + 336, + 168, + 0, + 1592, + 1593, + 5, + 263, + 0, + 0, + 1593, + 1594, + 3, + 364, + 182, + 0, + 1594, + 1595, + 5, + 257, + 0, + 0, + 1595, + 1604, + 1, + 0, + 0, + 0, + 1596, + 1597, + 5, + 81, + 0, + 0, + 1597, + 1598, + 5, + 256, + 0, + 0, + 1598, + 1599, + 3, + 336, + 168, + 0, + 1599, + 1600, + 5, + 263, + 0, + 0, + 1600, + 1601, + 3, + 52, + 26, + 0, + 1601, + 1602, + 5, + 257, + 0, + 0, + 1602, + 1604, + 1, + 0, + 0, + 0, + 1603, + 1538, + 1, + 0, + 0, + 0, + 1603, + 1543, + 1, + 0, + 0, + 0, + 1603, + 1550, + 1, + 0, + 0, + 0, + 1603, + 1557, + 1, + 0, + 0, + 0, + 1603, + 1566, + 1, + 0, + 0, + 0, + 1603, + 1575, + 1, + 0, + 0, + 0, + 1603, + 1582, + 1, + 0, + 0, + 0, + 1603, + 1589, + 1, + 0, + 0, + 0, + 1603, + 1596, + 1, + 0, + 0, + 0, + 1604, + 153, + 1, + 0, + 0, + 0, + 1605, + 1606, + 5, + 82, + 0, + 0, + 1606, + 1607, + 5, + 256, + 0, + 0, + 1607, + 1610, + 3, + 532, + 266, + 0, + 1608, + 1609, + 5, + 263, + 0, + 0, + 1609, + 1611, + 3, + 534, + 267, + 0, + 1610, + 1608, + 1, + 0, + 0, + 0, + 1610, + 1611, + 1, + 0, + 0, + 0, + 1611, + 1612, + 1, + 0, + 0, + 0, + 1612, + 1613, + 5, + 257, + 0, + 0, + 1613, + 1620, + 1, + 0, + 0, + 0, + 1614, + 1615, + 5, + 82, + 0, + 0, + 1615, + 1616, + 5, + 256, + 0, + 0, + 1616, + 1617, + 3, + 364, + 182, + 0, + 1617, + 1618, + 5, + 257, + 0, + 0, + 1618, + 1620, + 1, + 0, + 0, + 0, + 1619, + 1605, + 1, + 0, + 0, + 0, + 1619, + 1614, + 1, + 0, + 0, + 0, + 1620, + 155, + 1, + 0, + 0, + 0, + 1621, + 1622, + 5, + 83, + 0, + 0, + 1622, + 1623, + 5, + 256, + 0, + 0, + 1623, + 1624, + 3, + 364, + 182, + 0, + 1624, + 1625, + 5, + 257, + 0, + 0, + 1625, + 1636, + 1, + 0, + 0, + 0, + 1626, + 1627, + 5, + 83, + 0, + 0, + 1627, + 1628, + 5, + 256, + 0, + 0, + 1628, + 1631, + 3, + 580, + 290, + 0, + 1629, + 1630, + 5, + 263, + 0, + 0, + 1630, + 1632, + 3, + 568, + 284, + 0, + 1631, + 1629, + 1, + 0, + 0, + 0, + 1631, + 1632, + 1, + 0, + 0, + 0, + 1632, + 1633, + 1, + 0, + 0, + 0, + 1633, + 1634, + 5, + 257, + 0, + 0, + 1634, + 1636, + 1, + 0, + 0, + 0, + 1635, + 1621, + 1, + 0, + 0, + 0, + 1635, + 1626, + 1, + 0, + 0, + 0, + 1636, + 157, + 1, + 0, + 0, + 0, + 1637, + 1638, + 5, + 84, + 0, + 0, + 1638, + 1639, + 5, + 256, + 0, + 0, + 1639, + 1640, + 3, + 364, + 182, + 0, + 1640, + 1641, + 5, + 257, + 0, + 0, + 1641, + 1652, + 1, + 0, + 0, + 0, + 1642, + 1643, + 5, + 84, + 0, + 0, + 1643, + 1644, + 5, + 256, + 0, + 0, + 1644, + 1647, + 3, + 526, + 263, + 0, + 1645, + 1646, + 5, + 263, + 0, + 0, + 1646, + 1648, + 3, + 528, + 264, + 0, + 1647, + 1645, + 1, + 0, + 0, + 0, + 1647, + 1648, + 1, + 0, + 0, + 0, + 1648, + 1649, + 1, + 0, + 0, + 0, + 1649, + 1650, + 5, + 257, + 0, + 0, + 1650, + 1652, + 1, + 0, + 0, + 0, + 1651, + 1637, + 1, + 0, + 0, + 0, + 1651, + 1642, + 1, + 0, + 0, + 0, + 1652, + 159, + 1, + 0, + 0, + 0, + 1653, + 1654, + 5, + 86, + 0, + 0, + 1654, + 1655, + 5, + 256, + 0, + 0, + 1655, + 1656, + 3, + 580, + 290, + 0, + 1656, + 1657, + 5, + 257, + 0, + 0, + 1657, + 161, + 1, + 0, + 0, + 0, + 1658, + 1659, + 5, + 87, + 0, + 0, + 1659, + 1660, + 5, + 256, + 0, + 0, + 1660, + 1663, + 3, + 532, + 266, + 0, + 1661, + 1662, + 5, + 263, + 0, + 0, + 1662, + 1664, + 3, + 534, + 267, + 0, + 1663, + 1661, + 1, + 0, + 0, + 0, + 1663, + 1664, + 1, + 0, + 0, + 0, + 1664, + 1665, + 1, + 0, + 0, + 0, + 1665, + 1666, + 5, + 257, + 0, + 0, + 1666, + 1673, + 1, + 0, + 0, + 0, + 1667, + 1668, + 5, + 87, + 0, + 0, + 1668, + 1669, + 5, + 256, + 0, + 0, + 1669, + 1670, + 3, + 364, + 182, + 0, + 1670, + 1671, + 5, + 257, + 0, + 0, + 1671, + 1673, + 1, + 0, + 0, + 0, + 1672, + 1658, + 1, + 0, + 0, + 0, + 1672, + 1667, + 1, + 0, + 0, + 0, + 1673, + 163, + 1, + 0, + 0, + 0, + 1674, + 1675, + 5, + 89, + 0, + 0, + 1675, + 1676, + 5, + 256, + 0, + 0, + 1676, + 1677, + 5, + 257, + 0, + 0, + 1677, + 165, + 1, + 0, + 0, + 0, + 1678, + 1679, + 5, + 90, + 0, + 0, + 1679, + 1680, + 5, + 256, + 0, + 0, + 1680, + 1681, + 5, + 257, + 0, + 0, + 1681, + 167, + 1, + 0, + 0, + 0, + 1682, + 1683, + 5, + 92, + 0, + 0, + 1683, + 1684, + 5, + 256, + 0, + 0, + 1684, + 1685, + 3, + 528, + 264, + 0, + 1685, + 1686, + 5, + 257, + 0, + 0, + 1686, + 169, + 1, + 0, + 0, + 0, + 1687, + 1688, + 5, + 94, + 0, + 0, + 1688, + 1689, + 5, + 256, + 0, + 0, + 1689, + 1690, + 3, + 528, + 264, + 0, + 1690, + 1691, + 5, + 257, + 0, + 0, + 1691, + 171, + 1, + 0, + 0, + 0, + 1692, + 1693, + 5, + 102, + 0, + 0, + 1693, + 1694, + 5, + 256, + 0, + 0, + 1694, + 1695, + 3, + 532, + 266, + 0, + 1695, + 1696, + 5, + 257, + 0, + 0, + 1696, + 173, + 1, + 0, + 0, + 0, + 1697, + 1698, + 5, + 103, + 0, + 0, + 1698, + 1699, + 5, + 256, + 0, + 0, + 1699, + 1700, + 5, + 257, + 0, + 0, + 1700, + 175, + 1, + 0, + 0, + 0, + 1701, + 1702, + 5, + 98, + 0, + 0, + 1702, + 1703, + 5, + 256, + 0, + 0, + 1703, + 1704, + 5, + 257, + 0, + 0, + 1704, + 177, + 1, + 0, + 0, + 0, + 1705, + 1706, + 5, + 100, + 0, + 0, + 1706, + 1707, + 5, + 256, + 0, + 0, + 1707, + 1708, + 3, + 534, + 267, + 0, + 1708, + 1709, + 5, + 257, + 0, + 0, + 1709, + 179, + 1, + 0, + 0, + 0, + 1710, + 1711, + 5, + 106, + 0, + 0, + 1711, + 1712, + 5, + 256, + 0, + 0, + 1712, + 1713, + 3, + 532, + 266, + 0, + 1713, + 1714, + 5, + 257, + 0, + 0, + 1714, + 1721, + 1, + 0, + 0, + 0, + 1715, + 1716, + 5, + 106, + 0, + 0, + 1716, + 1717, + 5, + 256, + 0, + 0, + 1717, + 1718, + 3, + 364, + 182, + 0, + 1718, + 1719, + 5, + 257, + 0, + 0, + 1719, + 1721, + 1, + 0, + 0, + 0, + 1720, + 1710, + 1, + 0, + 0, + 0, + 1720, + 1715, + 1, + 0, + 0, + 0, + 1721, + 181, + 1, + 0, + 0, + 0, + 1722, + 1723, + 5, + 108, + 0, + 0, + 1723, + 1724, + 5, + 256, + 0, + 0, + 1724, + 1725, + 5, + 257, + 0, + 0, + 1725, + 183, + 1, + 0, + 0, + 0, + 1726, + 1727, + 5, + 111, + 0, + 0, + 1727, + 1728, + 5, + 256, + 0, + 0, + 1728, + 1729, + 5, + 257, + 0, + 0, + 1729, + 185, + 1, + 0, + 0, + 0, + 1730, + 1731, + 5, + 113, + 0, + 0, + 1731, + 1732, + 5, + 256, + 0, + 0, + 1732, + 1739, + 5, + 257, + 0, + 0, + 1733, + 1734, + 5, + 113, + 0, + 0, + 1734, + 1735, + 5, + 256, + 0, + 0, + 1735, + 1736, + 3, + 332, + 166, + 0, + 1736, + 1737, + 5, + 257, + 0, + 0, + 1737, + 1739, + 1, + 0, + 0, + 0, + 1738, + 1730, + 1, + 0, + 0, + 0, + 1738, + 1733, + 1, + 0, + 0, + 0, + 1739, + 187, + 1, + 0, + 0, + 0, + 1740, + 1741, + 5, + 114, + 0, + 0, + 1741, + 1742, + 5, + 256, + 0, + 0, + 1742, + 1743, + 3, + 332, + 166, + 0, + 1743, + 1744, + 5, + 263, + 0, + 0, + 1744, + 1745, + 3, + 520, + 260, + 0, + 1745, + 1746, + 5, + 257, + 0, + 0, + 1746, + 1753, + 1, + 0, + 0, + 0, + 1747, + 1748, + 5, + 114, + 0, + 0, + 1748, + 1749, + 5, + 256, + 0, + 0, + 1749, + 1750, + 3, + 520, + 260, + 0, + 1750, + 1751, + 5, + 257, + 0, + 0, + 1751, + 1753, + 1, + 0, + 0, + 0, + 1752, + 1740, + 1, + 0, + 0, + 0, + 1752, + 1747, + 1, + 0, + 0, + 0, + 1753, + 189, + 1, + 0, + 0, + 0, + 1754, + 1755, + 5, + 116, + 0, + 0, + 1755, + 1756, + 5, + 256, + 0, + 0, + 1756, + 1757, + 3, + 52, + 26, + 0, + 1757, + 1758, + 5, + 257, + 0, + 0, + 1758, + 191, + 1, + 0, + 0, + 0, + 1759, + 1760, + 5, + 117, + 0, + 0, + 1760, + 1761, + 5, + 256, + 0, + 0, + 1761, + 1768, + 5, + 257, + 0, + 0, + 1762, + 1763, + 5, + 117, + 0, + 0, + 1763, + 1764, + 5, + 256, + 0, + 0, + 1764, + 1765, + 3, + 578, + 289, + 0, + 1765, + 1766, + 5, + 257, + 0, + 0, + 1766, + 1768, + 1, + 0, + 0, + 0, + 1767, + 1759, + 1, + 0, + 0, + 0, + 1767, + 1762, + 1, + 0, + 0, + 0, + 1768, + 193, + 1, + 0, + 0, + 0, + 1769, + 1770, + 5, + 120, + 0, + 0, + 1770, + 1771, + 5, + 256, + 0, + 0, + 1771, + 1778, + 5, + 257, + 0, + 0, + 1772, + 1773, + 5, + 120, + 0, + 0, + 1773, + 1774, + 5, + 256, + 0, + 0, + 1774, + 1775, + 3, + 332, + 166, + 0, + 1775, + 1776, + 5, + 257, + 0, + 0, + 1776, + 1778, + 1, + 0, + 0, + 0, + 1777, + 1769, + 1, + 0, + 0, + 0, + 1777, + 1772, + 1, + 0, + 0, + 0, + 1778, + 195, + 1, + 0, + 0, + 0, + 1779, + 1780, + 5, + 121, + 0, + 0, + 1780, + 1781, + 5, + 256, + 0, + 0, + 1781, + 1782, + 3, + 52, + 26, + 0, + 1782, + 1783, + 5, + 257, + 0, + 0, + 1783, + 197, + 1, + 0, + 0, + 0, + 1784, + 1785, + 5, + 122, + 0, + 0, + 1785, + 1786, + 5, + 256, + 0, + 0, + 1786, + 1787, + 3, + 552, + 276, + 0, + 1787, + 1788, + 5, + 257, + 0, + 0, + 1788, + 199, + 1, + 0, + 0, + 0, + 1789, + 1790, + 5, + 123, + 0, + 0, + 1790, + 1791, + 5, + 256, + 0, + 0, + 1791, + 1792, + 3, + 578, + 289, + 0, + 1792, + 1793, + 5, + 257, + 0, + 0, + 1793, + 201, + 1, + 0, + 0, + 0, + 1794, + 1795, + 5, + 124, + 0, + 0, + 1795, + 1796, + 5, + 256, + 0, + 0, + 1796, + 1803, + 5, + 257, + 0, + 0, + 1797, + 1798, + 5, + 124, + 0, + 0, + 1798, + 1799, + 5, + 256, + 0, + 0, + 1799, + 1800, + 3, + 332, + 166, + 0, + 1800, + 1801, + 5, + 257, + 0, + 0, + 1801, + 1803, + 1, + 0, + 0, + 0, + 1802, + 1794, + 1, + 0, + 0, + 0, + 1802, + 1797, + 1, + 0, + 0, + 0, + 1803, + 203, + 1, + 0, + 0, + 0, + 1804, + 1805, + 5, + 126, + 0, + 0, + 1805, + 1806, + 5, + 256, + 0, + 0, + 1806, + 1813, + 5, + 257, + 0, + 0, + 1807, + 1808, + 5, + 126, + 0, + 0, + 1808, + 1809, + 5, + 256, + 0, + 0, + 1809, + 1810, + 3, + 332, + 166, + 0, + 1810, + 1811, + 5, + 257, + 0, + 0, + 1811, + 1813, + 1, + 0, + 0, + 0, + 1812, + 1804, + 1, + 0, + 0, + 0, + 1812, + 1807, + 1, + 0, + 0, + 0, + 1813, + 205, + 1, + 0, + 0, + 0, + 1814, + 1815, + 5, + 128, + 0, + 0, + 1815, + 1816, + 5, + 256, + 0, + 0, + 1816, + 1817, + 3, + 532, + 266, + 0, + 1817, + 1818, + 5, + 257, + 0, + 0, + 1818, + 207, + 1, + 0, + 0, + 0, + 1819, + 1820, + 5, + 130, + 0, + 0, + 1820, + 1821, + 5, + 256, + 0, + 0, + 1821, + 1833, + 5, + 257, + 0, + 0, + 1822, + 1823, + 5, + 130, + 0, + 0, + 1823, + 1824, + 5, + 256, + 0, + 0, + 1824, + 1825, + 3, + 538, + 269, + 0, + 1825, + 1826, + 5, + 257, + 0, + 0, + 1826, + 1833, + 1, + 0, + 0, + 0, + 1827, + 1828, + 5, + 130, + 0, + 0, + 1828, + 1829, + 5, + 256, + 0, + 0, + 1829, + 1830, + 3, + 52, + 26, + 0, + 1830, + 1831, + 5, + 257, + 0, + 0, + 1831, + 1833, + 1, + 0, + 0, + 0, + 1832, + 1819, + 1, + 0, + 0, + 0, + 1832, + 1822, + 1, + 0, + 0, + 0, + 1832, + 1827, + 1, + 0, + 0, + 0, + 1833, + 209, + 1, + 0, + 0, + 0, + 1834, + 1835, + 5, + 129, + 0, + 0, + 1835, + 1836, + 5, + 256, + 0, + 0, + 1836, + 1848, + 5, + 257, + 0, + 0, + 1837, + 1838, + 5, + 129, + 0, + 0, + 1838, + 1839, + 5, + 256, + 0, + 0, + 1839, + 1840, + 3, + 538, + 269, + 0, + 1840, + 1841, + 5, + 257, + 0, + 0, + 1841, + 1848, + 1, + 0, + 0, + 0, + 1842, + 1843, + 5, + 129, + 0, + 0, + 1843, + 1844, + 5, + 256, + 0, + 0, + 1844, + 1845, + 3, + 52, + 26, + 0, + 1845, + 1846, + 5, + 257, + 0, + 0, + 1846, + 1848, + 1, + 0, + 0, + 0, + 1847, + 1834, + 1, + 0, + 0, + 0, + 1847, + 1837, + 1, + 0, + 0, + 0, + 1847, + 1842, + 1, + 0, + 0, + 0, + 1848, + 211, + 1, + 0, + 0, + 0, + 1849, + 1850, + 5, + 131, + 0, + 0, + 1850, + 1851, + 5, + 256, + 0, + 0, + 1851, + 1858, + 5, + 257, + 0, + 0, + 1852, + 1853, + 5, + 131, + 0, + 0, + 1853, + 1854, + 5, + 256, + 0, + 0, + 1854, + 1855, + 3, + 332, + 166, + 0, + 1855, + 1856, + 5, + 257, + 0, + 0, + 1856, + 1858, + 1, + 0, + 0, + 0, + 1857, + 1849, + 1, + 0, + 0, + 0, + 1857, + 1852, + 1, + 0, + 0, + 0, + 1858, + 213, + 1, + 0, + 0, + 0, + 1859, + 1860, + 5, + 139, + 0, + 0, + 1860, + 1861, + 5, + 256, + 0, + 0, + 1861, + 1862, + 3, + 364, + 182, + 0, + 1862, + 1863, + 5, + 257, + 0, + 0, + 1863, + 215, + 1, + 0, + 0, + 0, + 1864, + 1865, + 5, + 144, + 0, + 0, + 1865, + 1866, + 5, + 256, + 0, + 0, + 1866, + 1867, + 3, + 52, + 26, + 0, + 1867, + 1868, + 5, + 257, + 0, + 0, + 1868, + 217, + 1, + 0, + 0, + 0, + 1869, + 1870, + 5, + 152, + 0, + 0, + 1870, + 1871, + 5, + 256, + 0, + 0, + 1871, + 1872, + 3, + 364, + 182, + 0, + 1872, + 1873, + 5, + 263, + 0, + 0, + 1873, + 1874, + 3, + 52, + 26, + 0, + 1874, + 1875, + 5, + 257, + 0, + 0, + 1875, + 1912, + 1, + 0, + 0, + 0, + 1876, + 1877, + 5, + 152, + 0, + 0, + 1877, + 1878, + 5, + 256, + 0, + 0, + 1878, + 1879, + 3, + 342, + 171, + 0, + 1879, + 1880, + 5, + 263, + 0, + 0, + 1880, + 1881, + 3, + 538, + 269, + 0, + 1881, + 1882, + 5, + 257, + 0, + 0, + 1882, + 1912, + 1, + 0, + 0, + 0, + 1883, + 1884, + 5, + 152, + 0, + 0, + 1884, + 1885, + 5, + 256, + 0, + 0, + 1885, + 1886, + 3, + 342, + 171, + 0, + 1886, + 1887, + 5, + 263, + 0, + 0, + 1887, + 1888, + 3, + 538, + 269, + 0, + 1888, + 1889, + 5, + 263, + 0, + 0, + 1889, + 1890, + 3, + 352, + 176, + 0, + 1890, + 1891, + 5, + 257, + 0, + 0, + 1891, + 1912, + 1, + 0, + 0, + 0, + 1892, + 1893, + 5, + 152, + 0, + 0, + 1893, + 1894, + 5, + 256, + 0, + 0, + 1894, + 1895, + 3, + 342, + 171, + 0, + 1895, + 1896, + 5, + 263, + 0, + 0, + 1896, + 1897, + 3, + 52, + 26, + 0, + 1897, + 1898, + 5, + 257, + 0, + 0, + 1898, + 1912, + 1, + 0, + 0, + 0, + 1899, + 1900, + 5, + 152, + 0, + 0, + 1900, + 1901, + 5, + 256, + 0, + 0, + 1901, + 1902, + 3, + 532, + 266, + 0, + 1902, + 1903, + 5, + 263, + 0, + 0, + 1903, + 1904, + 3, + 52, + 26, + 0, + 1904, + 1905, + 5, + 257, + 0, + 0, + 1905, + 1912, + 1, + 0, + 0, + 0, + 1906, + 1907, + 5, + 152, + 0, + 0, + 1907, + 1908, + 5, + 256, + 0, + 0, + 1908, + 1909, + 3, + 52, + 26, + 0, + 1909, + 1910, + 5, + 257, + 0, + 0, + 1910, + 1912, + 1, + 0, + 0, + 0, + 1911, + 1869, + 1, + 0, + 0, + 0, + 1911, + 1876, + 1, + 0, + 0, + 0, + 1911, + 1883, + 1, + 0, + 0, + 0, + 1911, + 1892, + 1, + 0, + 0, + 0, + 1911, + 1899, + 1, + 0, + 0, + 0, + 1911, + 1906, + 1, + 0, + 0, + 0, + 1912, + 219, + 1, + 0, + 0, + 0, + 1913, + 1914, + 5, + 153, + 0, + 0, + 1914, + 1915, + 5, + 256, + 0, + 0, + 1915, + 1916, + 3, + 52, + 26, + 0, + 1916, + 1917, + 5, + 257, + 0, + 0, + 1917, + 221, + 1, + 0, + 0, + 0, + 1918, + 1919, + 5, + 156, + 0, + 0, + 1919, + 1920, + 5, + 256, + 0, + 0, + 1920, + 1921, + 3, + 552, + 276, + 0, + 1921, + 1922, + 5, + 257, + 0, + 0, + 1922, + 223, + 1, + 0, + 0, + 0, + 1923, + 1924, + 5, + 155, + 0, + 0, + 1924, + 1925, + 5, + 256, + 0, + 0, + 1925, + 1932, + 5, + 257, + 0, + 0, + 1926, + 1927, + 5, + 155, + 0, + 0, + 1927, + 1928, + 5, + 256, + 0, + 0, + 1928, + 1929, + 3, + 332, + 166, + 0, + 1929, + 1930, + 5, + 257, + 0, + 0, + 1930, + 1932, + 1, + 0, + 0, + 0, + 1931, + 1923, + 1, + 0, + 0, + 0, + 1931, + 1926, + 1, + 0, + 0, + 0, + 1932, + 225, + 1, + 0, + 0, + 0, + 1933, + 1934, + 5, + 157, + 0, + 0, + 1934, + 1935, + 5, + 256, + 0, + 0, + 1935, + 1936, + 5, + 257, + 0, + 0, + 1936, + 227, + 1, + 0, + 0, + 0, + 1937, + 1938, + 5, + 159, + 0, + 0, + 1938, + 1939, + 5, + 256, + 0, + 0, + 1939, + 1940, + 3, + 528, + 264, + 0, + 1940, + 1941, + 5, + 257, + 0, + 0, + 1941, + 229, + 1, + 0, + 0, + 0, + 1942, + 1943, + 5, + 160, + 0, + 0, + 1943, + 1944, + 5, + 256, + 0, + 0, + 1944, + 1945, + 3, + 528, + 264, + 0, + 1945, + 1946, + 5, + 257, + 0, + 0, + 1946, + 231, + 1, + 0, + 0, + 0, + 1947, + 1948, + 5, + 162, + 0, + 0, + 1948, + 1949, + 5, + 256, + 0, + 0, + 1949, + 1950, + 5, + 257, + 0, + 0, + 1950, + 233, + 1, + 0, + 0, + 0, + 1951, + 1952, + 5, + 165, + 0, + 0, + 1952, + 1953, + 5, + 256, + 0, + 0, + 1953, + 1960, + 5, + 257, + 0, + 0, + 1954, + 1955, + 5, + 165, + 0, + 0, + 1955, + 1956, + 5, + 256, + 0, + 0, + 1956, + 1957, + 3, + 522, + 261, + 0, + 1957, + 1958, + 5, + 257, + 0, + 0, + 1958, + 1960, + 1, + 0, + 0, + 0, + 1959, + 1951, + 1, + 0, + 0, + 0, + 1959, + 1954, + 1, + 0, + 0, + 0, + 1960, + 235, + 1, + 0, + 0, + 0, + 1961, + 1962, + 5, + 166, + 0, + 0, + 1962, + 1963, + 5, + 256, + 0, + 0, + 1963, + 1964, + 5, + 257, + 0, + 0, + 1964, + 237, + 1, + 0, + 0, + 0, + 1965, + 1966, + 5, + 168, + 0, + 0, + 1966, + 1967, + 5, + 256, + 0, + 0, + 1967, + 1968, + 5, + 257, + 0, + 0, + 1968, + 239, + 1, + 0, + 0, + 0, + 1969, + 1970, + 5, + 177, + 0, + 0, + 1970, + 1971, + 5, + 256, + 0, + 0, + 1971, + 1972, + 3, + 532, + 266, + 0, + 1972, + 1973, + 5, + 257, + 0, + 0, + 1973, + 241, + 1, + 0, + 0, + 0, + 1974, + 1975, + 5, + 171, + 0, + 0, + 1975, + 1976, + 5, + 256, + 0, + 0, + 1976, + 1983, + 5, + 257, + 0, + 0, + 1977, + 1978, + 5, + 171, + 0, + 0, + 1978, + 1979, + 5, + 256, + 0, + 0, + 1979, + 1980, + 3, + 578, + 289, + 0, + 1980, + 1981, + 5, + 257, + 0, + 0, + 1981, + 1983, + 1, + 0, + 0, + 0, + 1982, + 1974, + 1, + 0, + 0, + 0, + 1982, + 1977, + 1, + 0, + 0, + 0, + 1983, + 243, + 1, + 0, + 0, + 0, + 1984, + 1985, + 5, + 172, + 0, + 0, + 1985, + 1986, + 5, + 256, + 0, + 0, + 1986, + 1989, + 3, + 578, + 289, + 0, + 1987, + 1988, + 5, + 263, + 0, + 0, + 1988, + 1990, + 3, + 568, + 284, + 0, + 1989, + 1987, + 1, + 0, + 0, + 0, + 1989, + 1990, + 1, + 0, + 0, + 0, + 1990, + 1991, + 1, + 0, + 0, + 0, + 1991, + 1992, + 5, + 257, + 0, + 0, + 1992, + 245, + 1, + 0, + 0, + 0, + 1993, + 1994, + 5, + 173, + 0, + 0, + 1994, + 1995, + 5, + 256, + 0, + 0, + 1995, + 1996, + 3, + 568, + 284, + 0, + 1996, + 1997, + 5, + 257, + 0, + 0, + 1997, + 247, + 1, + 0, + 0, + 0, + 1998, + 1999, + 5, + 176, + 0, + 0, + 1999, + 2000, + 5, + 256, + 0, + 0, + 2000, + 2001, + 3, + 352, + 176, + 0, + 2001, + 2002, + 5, + 263, + 0, + 0, + 2002, + 2003, + 3, + 532, + 266, + 0, + 2003, + 2004, + 5, + 263, + 0, + 0, + 2004, + 2007, + 3, + 532, + 266, + 0, + 2005, + 2006, + 5, + 263, + 0, + 0, + 2006, + 2008, + 3, + 534, + 267, + 0, + 2007, + 2005, + 1, + 0, + 0, + 0, + 2007, + 2008, + 1, + 0, + 0, + 0, + 2008, + 2009, + 1, + 0, + 0, + 0, + 2009, + 2010, + 5, + 257, + 0, + 0, + 2010, + 2035, + 1, + 0, + 0, + 0, + 2011, + 2012, + 5, + 176, + 0, + 0, + 2012, + 2013, + 5, + 256, + 0, + 0, + 2013, + 2014, + 3, + 352, + 176, + 0, + 2014, + 2015, + 5, + 263, + 0, + 0, + 2015, + 2016, + 3, + 538, + 269, + 0, + 2016, + 2017, + 5, + 257, + 0, + 0, + 2017, + 2035, + 1, + 0, + 0, + 0, + 2018, + 2019, + 5, + 176, + 0, + 0, + 2019, + 2020, + 5, + 256, + 0, + 0, + 2020, + 2021, + 3, + 532, + 266, + 0, + 2021, + 2022, + 5, + 263, + 0, + 0, + 2022, + 2025, + 3, + 532, + 266, + 0, + 2023, + 2024, + 5, + 263, + 0, + 0, + 2024, + 2026, + 3, + 534, + 267, + 0, + 2025, + 2023, + 1, + 0, + 0, + 0, + 2025, + 2026, + 1, + 0, + 0, + 0, + 2026, + 2027, + 1, + 0, + 0, + 0, + 2027, + 2028, + 5, + 257, + 0, + 0, + 2028, + 2035, + 1, + 0, + 0, + 0, + 2029, + 2030, + 5, + 176, + 0, + 0, + 2030, + 2031, + 5, + 256, + 0, + 0, + 2031, + 2032, + 3, + 538, + 269, + 0, + 2032, + 2033, + 5, + 257, + 0, + 0, + 2033, + 2035, + 1, + 0, + 0, + 0, + 2034, + 1998, + 1, + 0, + 0, + 0, + 2034, + 2011, + 1, + 0, + 0, + 0, + 2034, + 2018, + 1, + 0, + 0, + 0, + 2034, + 2029, + 1, + 0, + 0, + 0, + 2035, + 249, + 1, + 0, + 0, + 0, + 2036, + 2037, + 5, + 174, + 0, + 0, + 2037, + 2038, + 5, + 256, + 0, + 0, + 2038, + 2039, + 3, + 568, + 284, + 0, + 2039, + 2040, + 5, + 257, + 0, + 0, + 2040, + 251, + 1, + 0, + 0, + 0, + 2041, + 2042, + 5, + 178, + 0, + 0, + 2042, + 2043, + 5, + 256, + 0, + 0, + 2043, + 2044, + 3, + 332, + 166, + 0, + 2044, + 2045, + 5, + 263, + 0, + 0, + 2045, + 2046, + 3, + 520, + 260, + 0, + 2046, + 2047, + 5, + 263, + 0, + 0, + 2047, + 2048, + 3, + 520, + 260, + 0, + 2048, + 2049, + 5, + 257, + 0, + 0, + 2049, + 2058, + 1, + 0, + 0, + 0, + 2050, + 2051, + 5, + 178, + 0, + 0, + 2051, + 2052, + 5, + 256, + 0, + 0, + 2052, + 2053, + 3, + 520, + 260, + 0, + 2053, + 2054, + 5, + 263, + 0, + 0, + 2054, + 2055, + 3, + 520, + 260, + 0, + 2055, + 2056, + 5, + 257, + 0, + 0, + 2056, + 2058, + 1, + 0, + 0, + 0, + 2057, + 2041, + 1, + 0, + 0, + 0, + 2057, + 2050, + 1, + 0, + 0, + 0, + 2058, + 253, + 1, + 0, + 0, + 0, + 2059, + 2060, + 5, + 179, + 0, + 0, + 2060, + 2061, + 5, + 256, + 0, + 0, + 2061, + 2062, + 5, + 257, + 0, + 0, + 2062, + 255, + 1, + 0, + 0, + 0, + 2063, + 2064, + 5, + 184, + 0, + 0, + 2064, + 2065, + 5, + 256, + 0, + 0, + 2065, + 2066, + 3, + 578, + 289, + 0, + 2066, + 2067, + 5, + 263, + 0, + 0, + 2067, + 2068, + 3, + 52, + 26, + 0, + 2068, + 2069, + 5, + 257, + 0, + 0, + 2069, + 2076, + 1, + 0, + 0, + 0, + 2070, + 2071, + 5, + 184, + 0, + 0, + 2071, + 2072, + 5, + 256, + 0, + 0, + 2072, + 2073, + 3, + 52, + 26, + 0, + 2073, + 2074, + 5, + 257, + 0, + 0, + 2074, + 2076, + 1, + 0, + 0, + 0, + 2075, + 2063, + 1, + 0, + 0, + 0, + 2075, + 2070, + 1, + 0, + 0, + 0, + 2076, + 257, + 1, + 0, + 0, + 0, + 2077, + 2078, + 5, + 183, + 0, + 0, + 2078, + 2079, + 5, + 256, + 0, + 0, + 2079, + 2080, + 3, + 580, + 290, + 0, + 2080, + 2081, + 5, + 263, + 0, + 0, + 2081, + 2082, + 3, + 580, + 290, + 0, + 2082, + 2083, + 5, + 257, + 0, + 0, + 2083, + 2094, + 1, + 0, + 0, + 0, + 2084, + 2085, + 5, + 183, + 0, + 0, + 2085, + 2086, + 5, + 256, + 0, + 0, + 2086, + 2087, + 3, + 332, + 166, + 0, + 2087, + 2088, + 5, + 263, + 0, + 0, + 2088, + 2089, + 3, + 580, + 290, + 0, + 2089, + 2090, + 5, + 263, + 0, + 0, + 2090, + 2091, + 3, + 580, + 290, + 0, + 2091, + 2092, + 5, + 257, + 0, + 0, + 2092, + 2094, + 1, + 0, + 0, + 0, + 2093, + 2077, + 1, + 0, + 0, + 0, + 2093, + 2084, + 1, + 0, + 0, + 0, + 2094, + 259, + 1, + 0, + 0, + 0, + 2095, + 2096, + 5, + 185, + 0, + 0, + 2096, + 2097, + 5, + 256, + 0, + 0, + 2097, + 2098, + 5, + 257, + 0, + 0, + 2098, + 261, + 1, + 0, + 0, + 0, + 2099, + 2100, + 5, + 187, + 0, + 0, + 2100, + 2101, + 5, + 256, + 0, + 0, + 2101, + 2108, + 5, + 257, + 0, + 0, + 2102, + 2103, + 5, + 187, + 0, + 0, + 2103, + 2104, + 5, + 256, + 0, + 0, + 2104, + 2105, + 3, + 332, + 166, + 0, + 2105, + 2106, + 5, + 257, + 0, + 0, + 2106, + 2108, + 1, + 0, + 0, + 0, + 2107, + 2099, + 1, + 0, + 0, + 0, + 2107, + 2102, + 1, + 0, + 0, + 0, + 2108, + 263, + 1, + 0, + 0, + 0, + 2109, + 2110, + 5, + 188, + 0, + 0, + 2110, + 2111, + 5, + 256, + 0, + 0, + 2111, + 2112, + 3, + 374, + 187, + 0, + 2112, + 2113, + 5, + 257, + 0, + 0, + 2113, + 2118, + 1, + 0, + 0, + 0, + 2114, + 2115, + 5, + 188, + 0, + 0, + 2115, + 2116, + 5, + 256, + 0, + 0, + 2116, + 2118, + 5, + 257, + 0, + 0, + 2117, + 2109, + 1, + 0, + 0, + 0, + 2117, + 2114, + 1, + 0, + 0, + 0, + 2118, + 265, + 1, + 0, + 0, + 0, + 2119, + 2120, + 5, + 189, + 0, + 0, + 2120, + 2121, + 5, + 256, + 0, + 0, + 2121, + 2122, + 3, + 332, + 166, + 0, + 2122, + 2123, + 5, + 263, + 0, + 0, + 2123, + 2124, + 3, + 582, + 291, + 0, + 2124, + 2125, + 5, + 257, + 0, + 0, + 2125, + 2132, + 1, + 0, + 0, + 0, + 2126, + 2127, + 5, + 189, + 0, + 0, + 2127, + 2128, + 5, + 256, + 0, + 0, + 2128, + 2129, + 3, + 582, + 291, + 0, + 2129, + 2130, + 5, + 257, + 0, + 0, + 2130, + 2132, + 1, + 0, + 0, + 0, + 2131, + 2119, + 1, + 0, + 0, + 0, + 2131, + 2126, + 1, + 0, + 0, + 0, + 2132, + 267, + 1, + 0, + 0, + 0, + 2133, + 2134, + 5, + 192, + 0, + 0, + 2134, + 2135, + 5, + 256, + 0, + 0, + 2135, + 2136, + 3, + 354, + 177, + 0, + 2136, + 2137, + 5, + 257, + 0, + 0, + 2137, + 2187, + 1, + 0, + 0, + 0, + 2138, + 2139, + 5, + 192, + 0, + 0, + 2139, + 2140, + 5, + 256, + 0, + 0, + 2140, + 2141, + 3, + 356, + 178, + 0, + 2141, + 2142, + 5, + 263, + 0, + 0, + 2142, + 2143, + 3, + 578, + 289, + 0, + 2143, + 2144, + 5, + 257, + 0, + 0, + 2144, + 2187, + 1, + 0, + 0, + 0, + 2145, + 2146, + 5, + 192, + 0, + 0, + 2146, + 2147, + 5, + 256, + 0, + 0, + 2147, + 2148, + 3, + 356, + 178, + 0, + 2148, + 2149, + 5, + 263, + 0, + 0, + 2149, + 2150, + 3, + 578, + 289, + 0, + 2150, + 2151, + 5, + 263, + 0, + 0, + 2151, + 2154, + 3, + 578, + 289, + 0, + 2152, + 2153, + 5, + 263, + 0, + 0, + 2153, + 2155, + 3, + 568, + 284, + 0, + 2154, + 2152, + 1, + 0, + 0, + 0, + 2154, + 2155, + 1, + 0, + 0, + 0, + 2155, + 2156, + 1, + 0, + 0, + 0, + 2156, + 2157, + 5, + 257, + 0, + 0, + 2157, + 2187, + 1, + 0, + 0, + 0, + 2158, + 2159, + 5, + 192, + 0, + 0, + 2159, + 2160, + 5, + 256, + 0, + 0, + 2160, + 2161, + 3, + 356, + 178, + 0, + 2161, + 2162, + 5, + 263, + 0, + 0, + 2162, + 2163, + 3, + 52, + 26, + 0, + 2163, + 2164, + 5, + 257, + 0, + 0, + 2164, + 2187, + 1, + 0, + 0, + 0, + 2165, + 2166, + 5, + 192, + 0, + 0, + 2166, + 2167, + 5, + 256, + 0, + 0, + 2167, + 2168, + 3, + 578, + 289, + 0, + 2168, + 2169, + 5, + 257, + 0, + 0, + 2169, + 2187, + 1, + 0, + 0, + 0, + 2170, + 2171, + 5, + 192, + 0, + 0, + 2171, + 2172, + 5, + 256, + 0, + 0, + 2172, + 2173, + 3, + 578, + 289, + 0, + 2173, + 2174, + 5, + 263, + 0, + 0, + 2174, + 2177, + 3, + 578, + 289, + 0, + 2175, + 2176, + 5, + 263, + 0, + 0, + 2176, + 2178, + 3, + 568, + 284, + 0, + 2177, + 2175, + 1, + 0, + 0, + 0, + 2177, + 2178, + 1, + 0, + 0, + 0, + 2178, + 2179, + 1, + 0, + 0, + 0, + 2179, + 2180, + 5, + 257, + 0, + 0, + 2180, + 2187, + 1, + 0, + 0, + 0, + 2181, + 2182, + 5, + 192, + 0, + 0, + 2182, + 2183, + 5, + 256, + 0, + 0, + 2183, + 2184, + 3, + 52, + 26, + 0, + 2184, + 2185, + 5, + 257, + 0, + 0, + 2185, + 2187, + 1, + 0, + 0, + 0, + 2186, + 2133, + 1, + 0, + 0, + 0, + 2186, + 2138, + 1, + 0, + 0, + 0, + 2186, + 2145, + 1, + 0, + 0, + 0, + 2186, + 2158, + 1, + 0, + 0, + 0, + 2186, + 2165, + 1, + 0, + 0, + 0, + 2186, + 2170, + 1, + 0, + 0, + 0, + 2186, + 2181, + 1, + 0, + 0, + 0, + 2187, + 269, + 1, + 0, + 0, + 0, + 2188, + 2189, + 5, + 195, + 0, + 0, + 2189, + 2190, + 5, + 256, + 0, + 0, + 2190, + 2191, + 5, + 257, + 0, + 0, + 2191, + 271, + 1, + 0, + 0, + 0, + 2192, + 2193, + 5, + 197, + 0, + 0, + 2193, + 2194, + 5, + 256, + 0, + 0, + 2194, + 2195, + 3, + 52, + 26, + 0, + 2195, + 2196, + 5, + 257, + 0, + 0, + 2196, + 273, + 1, + 0, + 0, + 0, + 2197, + 2198, + 5, + 198, + 0, + 0, + 2198, + 2199, + 5, + 256, + 0, + 0, + 2199, + 2200, + 5, + 257, + 0, + 0, + 2200, + 275, + 1, + 0, + 0, + 0, + 2201, + 2202, + 5, + 200, + 0, + 0, + 2202, + 2203, + 5, + 256, + 0, + 0, + 2203, + 2204, + 3, + 332, + 166, + 0, + 2204, + 2205, + 5, + 263, + 0, + 0, + 2205, + 2206, + 3, + 520, + 260, + 0, + 2206, + 2207, + 5, + 257, + 0, + 0, + 2207, + 2214, + 1, + 0, + 0, + 0, + 2208, + 2209, + 5, + 200, + 0, + 0, + 2209, + 2210, + 5, + 256, + 0, + 0, + 2210, + 2211, + 3, + 520, + 260, + 0, + 2211, + 2212, + 5, + 257, + 0, + 0, + 2212, + 2214, + 1, + 0, + 0, + 0, + 2213, + 2201, + 1, + 0, + 0, + 0, + 2213, + 2208, + 1, + 0, + 0, + 0, + 2214, + 277, + 1, + 0, + 0, + 0, + 2215, + 2216, + 5, + 201, + 0, + 0, + 2216, + 2217, + 5, + 256, + 0, + 0, + 2217, + 2218, + 3, + 580, + 290, + 0, + 2218, + 2219, + 5, + 257, + 0, + 0, + 2219, + 2228, + 1, + 0, + 0, + 0, + 2220, + 2221, + 5, + 201, + 0, + 0, + 2221, + 2222, + 5, + 256, + 0, + 0, + 2222, + 2223, + 3, + 332, + 166, + 0, + 2223, + 2224, + 5, + 263, + 0, + 0, + 2224, + 2225, + 3, + 580, + 290, + 0, + 2225, + 2226, + 5, + 257, + 0, + 0, + 2226, + 2228, + 1, + 0, + 0, + 0, + 2227, + 2215, + 1, + 0, + 0, + 0, + 2227, + 2220, + 1, + 0, + 0, + 0, + 2228, + 279, + 1, + 0, + 0, + 0, + 2229, + 2230, + 5, + 203, + 0, + 0, + 2230, + 2231, + 5, + 256, + 0, + 0, + 2231, + 2232, + 3, + 578, + 289, + 0, + 2232, + 2233, + 5, + 257, + 0, + 0, + 2233, + 281, + 1, + 0, + 0, + 0, + 2234, + 2235, + 5, + 204, + 0, + 0, + 2235, + 2236, + 5, + 256, + 0, + 0, + 2236, + 2237, + 3, + 578, + 289, + 0, + 2237, + 2238, + 5, + 257, + 0, + 0, + 2238, + 283, + 1, + 0, + 0, + 0, + 2239, + 2240, + 5, + 205, + 0, + 0, + 2240, + 2241, + 5, + 256, + 0, + 0, + 2241, + 2242, + 3, + 582, + 291, + 0, + 2242, + 2243, + 5, + 257, + 0, + 0, + 2243, + 2268, + 1, + 0, + 0, + 0, + 2244, + 2245, + 5, + 205, + 0, + 0, + 2245, + 2246, + 5, + 256, + 0, + 0, + 2246, + 2247, + 3, + 332, + 166, + 0, + 2247, + 2248, + 5, + 263, + 0, + 0, + 2248, + 2249, + 3, + 582, + 291, + 0, + 2249, + 2250, + 5, + 257, + 0, + 0, + 2250, + 2268, + 1, + 0, + 0, + 0, + 2251, + 2252, + 5, + 205, + 0, + 0, + 2252, + 2253, + 5, + 256, + 0, + 0, + 2253, + 2254, + 3, + 582, + 291, + 0, + 2254, + 2255, + 5, + 263, + 0, + 0, + 2255, + 2256, + 3, + 582, + 291, + 0, + 2256, + 2257, + 5, + 257, + 0, + 0, + 2257, + 2268, + 1, + 0, + 0, + 0, + 2258, + 2259, + 5, + 205, + 0, + 0, + 2259, + 2260, + 5, + 256, + 0, + 0, + 2260, + 2261, + 3, + 332, + 166, + 0, + 2261, + 2262, + 5, + 263, + 0, + 0, + 2262, + 2263, + 3, + 582, + 291, + 0, + 2263, + 2264, + 5, + 263, + 0, + 0, + 2264, + 2265, + 3, + 582, + 291, + 0, + 2265, + 2266, + 5, + 257, + 0, + 0, + 2266, + 2268, + 1, + 0, + 0, + 0, + 2267, + 2239, + 1, + 0, + 0, + 0, + 2267, + 2244, + 1, + 0, + 0, + 0, + 2267, + 2251, + 1, + 0, + 0, + 0, + 2267, + 2258, + 1, + 0, + 0, + 0, + 2268, + 285, + 1, + 0, + 0, + 0, + 2269, + 2270, + 5, + 206, + 0, + 0, + 2270, + 2271, + 5, + 256, + 0, + 0, + 2271, + 2278, + 5, + 257, + 0, + 0, + 2272, + 2273, + 5, + 206, + 0, + 0, + 2273, + 2274, + 5, + 256, + 0, + 0, + 2274, + 2275, + 3, + 332, + 166, + 0, + 2275, + 2276, + 5, + 257, + 0, + 0, + 2276, + 2278, + 1, + 0, + 0, + 0, + 2277, + 2269, + 1, + 0, + 0, + 0, + 2277, + 2272, + 1, + 0, + 0, + 0, + 2278, + 287, + 1, + 0, + 0, + 0, + 2279, + 2280, + 5, + 209, + 0, + 0, + 2280, + 2281, + 5, + 256, + 0, + 0, + 2281, + 2300, + 5, + 257, + 0, + 0, + 2282, + 2283, + 5, + 209, + 0, + 0, + 2283, + 2284, + 5, + 256, + 0, + 0, + 2284, + 2285, + 3, + 332, + 166, + 0, + 2285, + 2286, + 5, + 257, + 0, + 0, + 2286, + 2300, + 1, + 0, + 0, + 0, + 2287, + 2288, + 5, + 209, + 0, + 0, + 2288, + 2289, + 5, + 256, + 0, + 0, + 2289, + 2290, + 3, + 332, + 166, + 0, + 2290, + 2291, + 5, + 263, + 0, + 0, + 2291, + 2292, + 3, + 520, + 260, + 0, + 2292, + 2293, + 5, + 257, + 0, + 0, + 2293, + 2300, + 1, + 0, + 0, + 0, + 2294, + 2295, + 5, + 209, + 0, + 0, + 2295, + 2296, + 5, + 256, + 0, + 0, + 2296, + 2297, + 3, + 520, + 260, + 0, + 2297, + 2298, + 5, + 257, + 0, + 0, + 2298, + 2300, + 1, + 0, + 0, + 0, + 2299, + 2279, + 1, + 0, + 0, + 0, + 2299, + 2282, + 1, + 0, + 0, + 0, + 2299, + 2287, + 1, + 0, + 0, + 0, + 2299, + 2294, + 1, + 0, + 0, + 0, + 2300, + 289, + 1, + 0, + 0, + 0, + 2301, + 2302, + 5, + 212, + 0, + 0, + 2302, + 2303, + 5, + 256, + 0, + 0, + 2303, + 2304, + 3, + 582, + 291, + 0, + 2304, + 2305, + 5, + 257, + 0, + 0, + 2305, + 291, + 1, + 0, + 0, + 0, + 2306, + 2307, + 5, + 213, + 0, + 0, + 2307, + 2308, + 5, + 256, + 0, + 0, + 2308, + 2309, + 3, + 582, + 291, + 0, + 2309, + 2310, + 5, + 257, + 0, + 0, + 2310, + 293, + 1, + 0, + 0, + 0, + 2311, + 2312, + 5, + 214, + 0, + 0, + 2312, + 2313, + 5, + 256, + 0, + 0, + 2313, + 2316, + 3, + 346, + 173, + 0, + 2314, + 2315, + 5, + 263, + 0, + 0, + 2315, + 2317, + 3, + 568, + 284, + 0, + 2316, + 2314, + 1, + 0, + 0, + 0, + 2316, + 2317, + 1, + 0, + 0, + 0, + 2317, + 2318, + 1, + 0, + 0, + 0, + 2318, + 2319, + 5, + 257, + 0, + 0, + 2319, + 2336, + 1, + 0, + 0, + 0, + 2320, + 2321, + 5, + 214, + 0, + 0, + 2321, + 2322, + 5, + 256, + 0, + 0, + 2322, + 2323, + 3, + 578, + 289, + 0, + 2323, + 2324, + 5, + 257, + 0, + 0, + 2324, + 2336, + 1, + 0, + 0, + 0, + 2325, + 2326, + 5, + 214, + 0, + 0, + 2326, + 2327, + 5, + 256, + 0, + 0, + 2327, + 2328, + 3, + 542, + 271, + 0, + 2328, + 2329, + 5, + 257, + 0, + 0, + 2329, + 2336, + 1, + 0, + 0, + 0, + 2330, + 2331, + 5, + 214, + 0, + 0, + 2331, + 2332, + 5, + 256, + 0, + 0, + 2332, + 2333, + 3, + 52, + 26, + 0, + 2333, + 2334, + 5, + 257, + 0, + 0, + 2334, + 2336, + 1, + 0, + 0, + 0, + 2335, + 2311, + 1, + 0, + 0, + 0, + 2335, + 2320, + 1, + 0, + 0, + 0, + 2335, + 2325, + 1, + 0, + 0, + 0, + 2335, + 2330, + 1, + 0, + 0, + 0, + 2336, + 295, + 1, + 0, + 0, + 0, + 2337, + 2338, + 5, + 222, + 0, + 0, + 2338, + 2339, + 5, + 256, + 0, + 0, + 2339, + 2342, + 3, + 346, + 173, + 0, + 2340, + 2341, + 5, + 263, + 0, + 0, + 2341, + 2343, + 3, + 528, + 264, + 0, + 2342, + 2340, + 1, + 0, + 0, + 0, + 2342, + 2343, + 1, + 0, + 0, + 0, + 2343, + 2344, + 1, + 0, + 0, + 0, + 2344, + 2345, + 5, + 257, + 0, + 0, + 2345, + 297, + 1, + 0, + 0, + 0, + 2346, + 2347, + 5, + 218, + 0, + 0, + 2347, + 2348, + 5, + 256, + 0, + 0, + 2348, + 2355, + 5, + 257, + 0, + 0, + 2349, + 2350, + 5, + 218, + 0, + 0, + 2350, + 2351, + 5, + 256, + 0, + 0, + 2351, + 2352, + 3, + 332, + 166, + 0, + 2352, + 2353, + 5, + 257, + 0, + 0, + 2353, + 2355, + 1, + 0, + 0, + 0, + 2354, + 2346, + 1, + 0, + 0, + 0, + 2354, + 2349, + 1, + 0, + 0, + 0, + 2355, + 299, + 1, + 0, + 0, + 0, + 2356, + 2357, + 5, + 221, + 0, + 0, + 2357, + 2358, + 5, + 256, + 0, + 0, + 2358, + 2365, + 5, + 257, + 0, + 0, + 2359, + 2360, + 5, + 221, + 0, + 0, + 2360, + 2361, + 5, + 256, + 0, + 0, + 2361, + 2362, + 3, + 332, + 166, + 0, + 2362, + 2363, + 5, + 257, + 0, + 0, + 2363, + 2365, + 1, + 0, + 0, + 0, + 2364, + 2356, + 1, + 0, + 0, + 0, + 2364, + 2359, + 1, + 0, + 0, + 0, + 2365, + 301, + 1, + 0, + 0, + 0, + 2366, + 2367, + 5, + 223, + 0, + 0, + 2367, + 2368, + 5, + 256, + 0, + 0, + 2368, + 2369, + 3, + 346, + 173, + 0, + 2369, + 2370, + 5, + 257, + 0, + 0, + 2370, + 303, + 1, + 0, + 0, + 0, + 2371, + 2372, + 5, + 224, + 0, + 0, + 2372, + 2373, + 5, + 256, + 0, + 0, + 2373, + 2380, + 5, + 257, + 0, + 0, + 2374, + 2375, + 5, + 224, + 0, + 0, + 2375, + 2376, + 5, + 256, + 0, + 0, + 2376, + 2377, + 3, + 578, + 289, + 0, + 2377, + 2378, + 5, + 257, + 0, + 0, + 2378, + 2380, + 1, + 0, + 0, + 0, + 2379, + 2371, + 1, + 0, + 0, + 0, + 2379, + 2374, + 1, + 0, + 0, + 0, + 2380, + 305, + 1, + 0, + 0, + 0, + 2381, + 2382, + 5, + 225, + 0, + 0, + 2382, + 2383, + 5, + 256, + 0, + 0, + 2383, + 2390, + 5, + 257, + 0, + 0, + 2384, + 2385, + 5, + 225, + 0, + 0, + 2385, + 2386, + 5, + 256, + 0, + 0, + 2386, + 2387, + 3, + 332, + 166, + 0, + 2387, + 2388, + 5, + 257, + 0, + 0, + 2388, + 2390, + 1, + 0, + 0, + 0, + 2389, + 2381, + 1, + 0, + 0, + 0, + 2389, + 2384, + 1, + 0, + 0, + 0, + 2390, + 307, + 1, + 0, + 0, + 0, + 2391, + 2392, + 5, + 229, + 0, + 0, + 2392, + 2393, + 5, + 256, + 0, + 0, + 2393, + 2394, + 5, + 257, + 0, + 0, + 2394, + 309, + 1, + 0, + 0, + 0, + 2395, + 2396, + 5, + 230, + 0, + 0, + 2396, + 2397, + 5, + 256, + 0, + 0, + 2397, + 2398, + 3, + 552, + 276, + 0, + 2398, + 2399, + 5, + 257, + 0, + 0, + 2399, + 311, + 1, + 0, + 0, + 0, + 2400, + 2401, + 5, + 231, + 0, + 0, + 2401, + 2402, + 5, + 256, + 0, + 0, + 2402, + 2403, + 3, + 364, + 182, + 0, + 2403, + 2404, + 5, + 257, + 0, + 0, + 2404, + 2411, + 1, + 0, + 0, + 0, + 2405, + 2406, + 5, + 231, + 0, + 0, + 2406, + 2407, + 5, + 256, + 0, + 0, + 2407, + 2408, + 3, + 52, + 26, + 0, + 2408, + 2409, + 5, + 257, + 0, + 0, + 2409, + 2411, + 1, + 0, + 0, + 0, + 2410, + 2400, + 1, + 0, + 0, + 0, + 2410, + 2405, + 1, + 0, + 0, + 0, + 2411, + 313, + 1, + 0, + 0, + 0, + 2412, + 2413, + 5, + 236, + 0, + 0, + 2413, + 2414, + 5, + 256, + 0, + 0, + 2414, + 2415, + 5, + 257, + 0, + 0, + 2415, + 315, + 1, + 0, + 0, + 0, + 2416, + 2417, + 5, + 234, + 0, + 0, + 2417, + 2418, + 5, + 256, + 0, + 0, + 2418, + 2419, + 3, + 568, + 284, + 0, + 2419, + 2420, + 5, + 257, + 0, + 0, + 2420, + 2431, + 1, + 0, + 0, + 0, + 2421, + 2422, + 5, + 234, + 0, + 0, + 2422, + 2423, + 5, + 256, + 0, + 0, + 2423, + 2426, + 3, + 588, + 294, + 0, + 2424, + 2425, + 5, + 263, + 0, + 0, + 2425, + 2427, + 3, + 568, + 284, + 0, + 2426, + 2424, + 1, + 0, + 0, + 0, + 2426, + 2427, + 1, + 0, + 0, + 0, + 2427, + 2428, + 1, + 0, + 0, + 0, + 2428, + 2429, + 5, + 257, + 0, + 0, + 2429, + 2431, + 1, + 0, + 0, + 0, + 2430, + 2416, + 1, + 0, + 0, + 0, + 2430, + 2421, + 1, + 0, + 0, + 0, + 2431, + 317, + 1, + 0, + 0, + 0, + 2432, + 2433, + 5, + 235, + 0, + 0, + 2433, + 2434, + 5, + 256, + 0, + 0, + 2434, + 2435, + 3, + 568, + 284, + 0, + 2435, + 2436, + 5, + 257, + 0, + 0, + 2436, + 319, + 1, + 0, + 0, + 0, + 2437, + 2438, + 5, + 238, + 0, + 0, + 2438, + 2439, + 5, + 256, + 0, + 0, + 2439, + 2440, + 3, + 364, + 182, + 0, + 2440, + 2441, + 5, + 257, + 0, + 0, + 2441, + 2455, + 1, + 0, + 0, + 0, + 2442, + 2443, + 5, + 238, + 0, + 0, + 2443, + 2444, + 5, + 256, + 0, + 0, + 2444, + 2445, + 3, + 578, + 289, + 0, + 2445, + 2446, + 5, + 263, + 0, + 0, + 2446, + 2447, + 3, + 364, + 182, + 0, + 2447, + 2448, + 5, + 257, + 0, + 0, + 2448, + 2455, + 1, + 0, + 0, + 0, + 2449, + 2450, + 5, + 238, + 0, + 0, + 2450, + 2451, + 5, + 256, + 0, + 0, + 2451, + 2452, + 3, + 52, + 26, + 0, + 2452, + 2453, + 5, + 257, + 0, + 0, + 2453, + 2455, + 1, + 0, + 0, + 0, + 2454, + 2437, + 1, + 0, + 0, + 0, + 2454, + 2442, + 1, + 0, + 0, + 0, + 2454, + 2449, + 1, + 0, + 0, + 0, + 2455, + 321, + 1, + 0, + 0, + 0, + 2456, + 2457, + 5, + 239, + 0, + 0, + 2457, + 2460, + 5, + 256, + 0, + 0, + 2458, + 2461, + 3, + 432, + 216, + 0, + 2459, + 2461, + 3, + 578, + 289, + 0, + 2460, + 2458, + 1, + 0, + 0, + 0, + 2460, + 2459, + 1, + 0, + 0, + 0, + 2461, + 2462, + 1, + 0, + 0, + 0, + 2462, + 2463, + 5, + 257, + 0, + 0, + 2463, + 2479, + 1, + 0, + 0, + 0, + 2464, + 2465, + 5, + 239, + 0, + 0, + 2465, + 2468, + 5, + 256, + 0, + 0, + 2466, + 2469, + 3, + 432, + 216, + 0, + 2467, + 2469, + 3, + 578, + 289, + 0, + 2468, + 2466, + 1, + 0, + 0, + 0, + 2468, + 2467, + 1, + 0, + 0, + 0, + 2469, + 2470, + 1, + 0, + 0, + 0, + 2470, + 2474, + 5, + 263, + 0, + 0, + 2471, + 2475, + 3, + 442, + 221, + 0, + 2472, + 2475, + 3, + 446, + 223, + 0, + 2473, + 2475, + 3, + 532, + 266, + 0, + 2474, + 2471, + 1, + 0, + 0, + 0, + 2474, + 2472, + 1, + 0, + 0, + 0, + 2474, + 2473, + 1, + 0, + 0, + 0, + 2475, + 2476, + 1, + 0, + 0, + 0, + 2476, + 2477, + 5, + 257, + 0, + 0, + 2477, + 2479, + 1, + 0, + 0, + 0, + 2478, + 2456, + 1, + 0, + 0, + 0, + 2478, + 2464, + 1, + 0, + 0, + 0, + 2479, + 323, + 1, + 0, + 0, + 0, + 2480, + 2481, + 5, + 249, + 0, + 0, + 2481, + 2482, + 5, + 256, + 0, + 0, + 2482, + 2483, + 5, + 257, + 0, + 0, + 2483, + 325, + 1, + 0, + 0, + 0, + 2484, + 2486, + 5, + 146, + 0, + 0, + 2485, + 2484, + 1, + 0, + 0, + 0, + 2485, + 2486, + 1, + 0, + 0, + 0, + 2486, + 2487, + 1, + 0, + 0, + 0, + 2487, + 2488, + 7, + 0, + 0, + 0, + 2488, + 2489, + 5, + 256, + 0, + 0, + 2489, + 2490, + 3, + 532, + 266, + 0, + 2490, + 2491, + 5, + 263, + 0, + 0, + 2491, + 2492, + 3, + 524, + 262, + 0, + 2492, + 2493, + 5, + 257, + 0, + 0, + 2493, + 327, + 1, + 0, + 0, + 0, + 2494, + 2496, + 5, + 146, + 0, + 0, + 2495, + 2494, + 1, + 0, + 0, + 0, + 2495, + 2496, + 1, + 0, + 0, + 0, + 2496, + 2497, + 1, + 0, + 0, + 0, + 2497, + 2510, + 3, + 602, + 301, + 0, + 2498, + 2507, + 5, + 256, + 0, + 0, + 2499, + 2504, + 3, + 330, + 165, + 0, + 2500, + 2501, + 5, + 263, + 0, + 0, + 2501, + 2503, + 3, + 330, + 165, + 0, + 2502, + 2500, + 1, + 0, + 0, + 0, + 2503, + 2506, + 1, + 0, + 0, + 0, + 2504, + 2502, + 1, + 0, + 0, + 0, + 2504, + 2505, + 1, + 0, + 0, + 0, + 2505, + 2508, + 1, + 0, + 0, + 0, + 2506, + 2504, + 1, + 0, + 0, + 0, + 2507, + 2499, + 1, + 0, + 0, + 0, + 2507, + 2508, + 1, + 0, + 0, + 0, + 2508, + 2509, + 1, + 0, + 0, + 0, + 2509, + 2511, + 5, + 257, + 0, + 0, + 2510, + 2498, + 1, + 0, + 0, + 0, + 2510, + 2511, + 1, + 0, + 0, + 0, + 2511, + 329, + 1, + 0, + 0, + 0, + 2512, + 2515, + 3, + 606, + 303, + 0, + 2513, + 2515, + 3, + 600, + 300, + 0, + 2514, + 2512, + 1, + 0, + 0, + 0, + 2514, + 2513, + 1, + 0, + 0, + 0, + 2515, + 2516, + 1, + 0, + 0, + 0, + 2516, + 2517, + 5, + 265, + 0, + 0, + 2517, + 2518, + 3, + 532, + 266, + 0, + 2518, + 331, + 1, + 0, + 0, + 0, + 2519, + 2528, + 5, + 116, + 0, + 0, + 2520, + 2521, + 5, + 190, + 0, + 0, + 2521, + 2522, + 5, + 264, + 0, + 0, + 2522, + 2528, + 5, + 116, + 0, + 0, + 2523, + 2528, + 5, + 73, + 0, + 0, + 2524, + 2525, + 5, + 190, + 0, + 0, + 2525, + 2526, + 5, + 264, + 0, + 0, + 2526, + 2528, + 5, + 73, + 0, + 0, + 2527, + 2519, + 1, + 0, + 0, + 0, + 2527, + 2520, + 1, + 0, + 0, + 0, + 2527, + 2523, + 1, + 0, + 0, + 0, + 2527, + 2524, + 1, + 0, + 0, + 0, + 2528, + 333, + 1, + 0, + 0, + 0, + 2529, + 2534, + 5, + 147, + 0, + 0, + 2530, + 2531, + 5, + 15, + 0, + 0, + 2531, + 2532, + 5, + 264, + 0, + 0, + 2532, + 2534, + 5, + 147, + 0, + 0, + 2533, + 2529, + 1, + 0, + 0, + 0, + 2533, + 2530, + 1, + 0, + 0, + 0, + 2534, + 335, + 1, + 0, + 0, + 0, + 2535, + 2538, + 3, + 338, + 169, + 0, + 2536, + 2538, + 3, + 340, + 170, + 0, + 2537, + 2535, + 1, + 0, + 0, + 0, + 2537, + 2536, + 1, + 0, + 0, + 0, + 2538, + 337, + 1, + 0, + 0, + 0, + 2539, + 2540, + 7, + 1, + 0, + 0, + 2540, + 339, + 1, + 0, + 0, + 0, + 2541, + 2542, + 5, + 208, + 0, + 0, + 2542, + 2543, + 5, + 264, + 0, + 0, + 2543, + 2554, + 5, + 89, + 0, + 0, + 2544, + 2545, + 5, + 208, + 0, + 0, + 2545, + 2546, + 5, + 264, + 0, + 0, + 2546, + 2554, + 5, + 111, + 0, + 0, + 2547, + 2548, + 5, + 208, + 0, + 0, + 2548, + 2549, + 5, + 264, + 0, + 0, + 2549, + 2554, + 5, + 108, + 0, + 0, + 2550, + 2551, + 5, + 208, + 0, + 0, + 2551, + 2552, + 5, + 264, + 0, + 0, + 2552, + 2554, + 5, + 236, + 0, + 0, + 2553, + 2541, + 1, + 0, + 0, + 0, + 2553, + 2544, + 1, + 0, + 0, + 0, + 2553, + 2547, + 1, + 0, + 0, + 0, + 2553, + 2550, + 1, + 0, + 0, + 0, + 2554, + 341, + 1, + 0, + 0, + 0, + 2555, + 2572, + 5, + 149, + 0, + 0, + 2556, + 2557, + 5, + 127, + 0, + 0, + 2557, + 2558, + 5, + 264, + 0, + 0, + 2558, + 2572, + 5, + 149, + 0, + 0, + 2559, + 2572, + 5, + 150, + 0, + 0, + 2560, + 2561, + 5, + 127, + 0, + 0, + 2561, + 2562, + 5, + 264, + 0, + 0, + 2562, + 2572, + 5, + 150, + 0, + 0, + 2563, + 2572, + 5, + 162, + 0, + 0, + 2564, + 2565, + 5, + 127, + 0, + 0, + 2565, + 2566, + 5, + 264, + 0, + 0, + 2566, + 2572, + 5, + 162, + 0, + 0, + 2567, + 2572, + 5, + 103, + 0, + 0, + 2568, + 2569, + 5, + 127, + 0, + 0, + 2569, + 2570, + 5, + 264, + 0, + 0, + 2570, + 2572, + 5, + 103, + 0, + 0, + 2571, + 2555, + 1, + 0, + 0, + 0, + 2571, + 2556, + 1, + 0, + 0, + 0, + 2571, + 2559, + 1, + 0, + 0, + 0, + 2571, + 2560, + 1, + 0, + 0, + 0, + 2571, + 2563, + 1, + 0, + 0, + 0, + 2571, + 2564, + 1, + 0, + 0, + 0, + 2571, + 2567, + 1, + 0, + 0, + 0, + 2571, + 2568, + 1, + 0, + 0, + 0, + 2572, + 343, + 1, + 0, + 0, + 0, + 2573, + 2586, + 5, + 10, + 0, + 0, + 2574, + 2575, + 5, + 154, + 0, + 0, + 2575, + 2576, + 5, + 264, + 0, + 0, + 2576, + 2586, + 5, + 10, + 0, + 0, + 2577, + 2586, + 5, + 49, + 0, + 0, + 2578, + 2579, + 5, + 154, + 0, + 0, + 2579, + 2580, + 5, + 264, + 0, + 0, + 2580, + 2586, + 5, + 49, + 0, + 0, + 2581, + 2586, + 5, + 196, + 0, + 0, + 2582, + 2583, + 5, + 154, + 0, + 0, + 2583, + 2584, + 5, + 264, + 0, + 0, + 2584, + 2586, + 5, + 196, + 0, + 0, + 2585, + 2573, + 1, + 0, + 0, + 0, + 2585, + 2574, + 1, + 0, + 0, + 0, + 2585, + 2577, + 1, + 0, + 0, + 0, + 2585, + 2578, + 1, + 0, + 0, + 0, + 2585, + 2581, + 1, + 0, + 0, + 0, + 2585, + 2582, + 1, + 0, + 0, + 0, + 2586, + 345, + 1, + 0, + 0, + 0, + 2587, + 2590, + 3, + 348, + 174, + 0, + 2588, + 2590, + 3, + 350, + 175, + 0, + 2589, + 2587, + 1, + 0, + 0, + 0, + 2589, + 2588, + 1, + 0, + 0, + 0, + 2590, + 347, + 1, + 0, + 0, + 0, + 2591, + 2592, + 7, + 2, + 0, + 0, + 2592, + 349, + 1, + 0, + 0, + 0, + 2593, + 2594, + 5, + 51, + 0, + 0, + 2594, + 2595, + 5, + 264, + 0, + 0, + 2595, + 2609, + 5, + 93, + 0, + 0, + 2596, + 2597, + 5, + 51, + 0, + 0, + 2597, + 2598, + 5, + 264, + 0, + 0, + 2598, + 2609, + 5, + 72, + 0, + 0, + 2599, + 2600, + 5, + 51, + 0, + 0, + 2600, + 2601, + 5, + 264, + 0, + 0, + 2601, + 2609, + 5, + 158, + 0, + 0, + 2602, + 2603, + 5, + 51, + 0, + 0, + 2603, + 2604, + 5, + 264, + 0, + 0, + 2604, + 2609, + 5, + 214, + 0, + 0, + 2605, + 2606, + 5, + 51, + 0, + 0, + 2606, + 2607, + 5, + 264, + 0, + 0, + 2607, + 2609, + 5, + 19, + 0, + 0, + 2608, + 2593, + 1, + 0, + 0, + 0, + 2608, + 2596, + 1, + 0, + 0, + 0, + 2608, + 2599, + 1, + 0, + 0, + 0, + 2608, + 2602, + 1, + 0, + 0, + 0, + 2608, + 2605, + 1, + 0, + 0, + 0, + 2609, + 351, + 1, + 0, + 0, + 0, + 2610, + 2611, + 5, + 26, + 0, + 0, + 2611, + 2612, + 5, + 264, + 0, + 0, + 2612, + 2615, + 5, + 199, + 0, + 0, + 2613, + 2615, + 5, + 199, + 0, + 0, + 2614, + 2610, + 1, + 0, + 0, + 0, + 2614, + 2613, + 1, + 0, + 0, + 0, + 2615, + 2616, + 1, + 0, + 0, + 0, + 2616, + 2617, + 5, + 256, + 0, + 0, + 2617, + 2618, + 3, + 570, + 285, + 0, + 2618, + 2619, + 5, + 257, + 0, + 0, + 2619, + 2653, + 1, + 0, + 0, + 0, + 2620, + 2621, + 5, + 26, + 0, + 0, + 2621, + 2622, + 5, + 264, + 0, + 0, + 2622, + 2625, + 5, + 193, + 0, + 0, + 2623, + 2625, + 5, + 193, + 0, + 0, + 2624, + 2620, + 1, + 0, + 0, + 0, + 2624, + 2623, + 1, + 0, + 0, + 0, + 2625, + 2626, + 1, + 0, + 0, + 0, + 2626, + 2627, + 5, + 256, + 0, + 0, + 2627, + 2628, + 3, + 570, + 285, + 0, + 2628, + 2629, + 5, + 257, + 0, + 0, + 2629, + 2653, + 1, + 0, + 0, + 0, + 2630, + 2631, + 5, + 26, + 0, + 0, + 2631, + 2632, + 5, + 264, + 0, + 0, + 2632, + 2635, + 5, + 115, + 0, + 0, + 2633, + 2635, + 5, + 115, + 0, + 0, + 2634, + 2630, + 1, + 0, + 0, + 0, + 2634, + 2633, + 1, + 0, + 0, + 0, + 2635, + 2636, + 1, + 0, + 0, + 0, + 2636, + 2637, + 5, + 256, + 0, + 0, + 2637, + 2638, + 3, + 570, + 285, + 0, + 2638, + 2639, + 5, + 257, + 0, + 0, + 2639, + 2653, + 1, + 0, + 0, + 0, + 2640, + 2653, + 5, + 199, + 0, + 0, + 2641, + 2642, + 5, + 26, + 0, + 0, + 2642, + 2643, + 5, + 264, + 0, + 0, + 2643, + 2653, + 5, + 199, + 0, + 0, + 2644, + 2653, + 5, + 193, + 0, + 0, + 2645, + 2646, + 5, + 26, + 0, + 0, + 2646, + 2647, + 5, + 264, + 0, + 0, + 2647, + 2653, + 5, + 193, + 0, + 0, + 2648, + 2653, + 5, + 115, + 0, + 0, + 2649, + 2650, + 5, + 26, + 0, + 0, + 2650, + 2651, + 5, + 264, + 0, + 0, + 2651, + 2653, + 5, + 115, + 0, + 0, + 2652, + 2614, + 1, + 0, + 0, + 0, + 2652, + 2624, + 1, + 0, + 0, + 0, + 2652, + 2634, + 1, + 0, + 0, + 0, + 2652, + 2640, + 1, + 0, + 0, + 0, + 2652, + 2641, + 1, + 0, + 0, + 0, + 2652, + 2644, + 1, + 0, + 0, + 0, + 2652, + 2645, + 1, + 0, + 0, + 0, + 2652, + 2648, + 1, + 0, + 0, + 0, + 2652, + 2649, + 1, + 0, + 0, + 0, + 2653, + 353, + 1, + 0, + 0, + 0, + 2654, + 2663, + 5, + 109, + 0, + 0, + 2655, + 2656, + 5, + 30, + 0, + 0, + 2656, + 2657, + 5, + 264, + 0, + 0, + 2657, + 2663, + 5, + 109, + 0, + 0, + 2658, + 2663, + 5, + 235, + 0, + 0, + 2659, + 2660, + 5, + 30, + 0, + 0, + 2660, + 2661, + 5, + 264, + 0, + 0, + 2661, + 2663, + 5, + 235, + 0, + 0, + 2662, + 2654, + 1, + 0, + 0, + 0, + 2662, + 2655, + 1, + 0, + 0, + 0, + 2662, + 2658, + 1, + 0, + 0, + 0, + 2662, + 2659, + 1, + 0, + 0, + 0, + 2663, + 355, + 1, + 0, + 0, + 0, + 2664, + 2681, + 5, + 68, + 0, + 0, + 2665, + 2666, + 5, + 170, + 0, + 0, + 2666, + 2667, + 5, + 264, + 0, + 0, + 2667, + 2681, + 5, + 68, + 0, + 0, + 2668, + 2681, + 5, + 112, + 0, + 0, + 2669, + 2670, + 5, + 170, + 0, + 0, + 2670, + 2671, + 5, + 264, + 0, + 0, + 2671, + 2681, + 5, + 112, + 0, + 0, + 2672, + 2681, + 5, + 6, + 0, + 0, + 2673, + 2674, + 5, + 170, + 0, + 0, + 2674, + 2675, + 5, + 264, + 0, + 0, + 2675, + 2681, + 5, + 6, + 0, + 0, + 2676, + 2681, + 5, + 134, + 0, + 0, + 2677, + 2678, + 5, + 170, + 0, + 0, + 2678, + 2679, + 5, + 264, + 0, + 0, + 2679, + 2681, + 5, + 134, + 0, + 0, + 2680, + 2664, + 1, + 0, + 0, + 0, + 2680, + 2665, + 1, + 0, + 0, + 0, + 2680, + 2668, + 1, + 0, + 0, + 0, + 2680, + 2669, + 1, + 0, + 0, + 0, + 2680, + 2672, + 1, + 0, + 0, + 0, + 2680, + 2673, + 1, + 0, + 0, + 0, + 2680, + 2676, + 1, + 0, + 0, + 0, + 2680, + 2677, + 1, + 0, + 0, + 0, + 2681, + 357, + 1, + 0, + 0, + 0, + 2682, + 2727, + 5, + 2, + 0, + 0, + 2683, + 2684, + 5, + 151, + 0, + 0, + 2684, + 2685, + 5, + 264, + 0, + 0, + 2685, + 2727, + 5, + 2, + 0, + 0, + 2686, + 2727, + 5, + 7, + 0, + 0, + 2687, + 2688, + 5, + 151, + 0, + 0, + 2688, + 2689, + 5, + 264, + 0, + 0, + 2689, + 2727, + 5, + 7, + 0, + 0, + 2690, + 2727, + 5, + 13, + 0, + 0, + 2691, + 2692, + 5, + 151, + 0, + 0, + 2692, + 2693, + 5, + 264, + 0, + 0, + 2693, + 2727, + 5, + 13, + 0, + 0, + 2694, + 2727, + 5, + 54, + 0, + 0, + 2695, + 2696, + 5, + 151, + 0, + 0, + 2696, + 2697, + 5, + 264, + 0, + 0, + 2697, + 2727, + 5, + 54, + 0, + 0, + 2698, + 2727, + 5, + 124, + 0, + 0, + 2699, + 2700, + 5, + 151, + 0, + 0, + 2700, + 2701, + 5, + 264, + 0, + 0, + 2701, + 2727, + 5, + 124, + 0, + 0, + 2702, + 2727, + 5, + 131, + 0, + 0, + 2703, + 2704, + 5, + 151, + 0, + 0, + 2704, + 2705, + 5, + 264, + 0, + 0, + 2705, + 2727, + 5, + 131, + 0, + 0, + 2706, + 2727, + 5, + 133, + 0, + 0, + 2707, + 2708, + 5, + 151, + 0, + 0, + 2708, + 2709, + 5, + 264, + 0, + 0, + 2709, + 2727, + 5, + 133, + 0, + 0, + 2710, + 2727, + 5, + 135, + 0, + 0, + 2711, + 2712, + 5, + 151, + 0, + 0, + 2712, + 2713, + 5, + 264, + 0, + 0, + 2713, + 2727, + 5, + 135, + 0, + 0, + 2714, + 2727, + 5, + 156, + 0, + 0, + 2715, + 2716, + 5, + 151, + 0, + 0, + 2716, + 2717, + 5, + 264, + 0, + 0, + 2717, + 2727, + 5, + 156, + 0, + 0, + 2718, + 2727, + 5, + 206, + 0, + 0, + 2719, + 2720, + 5, + 151, + 0, + 0, + 2720, + 2721, + 5, + 264, + 0, + 0, + 2721, + 2727, + 5, + 206, + 0, + 0, + 2722, + 2727, + 5, + 207, + 0, + 0, + 2723, + 2724, + 5, + 151, + 0, + 0, + 2724, + 2725, + 5, + 264, + 0, + 0, + 2725, + 2727, + 5, + 207, + 0, + 0, + 2726, + 2682, + 1, + 0, + 0, + 0, + 2726, + 2683, + 1, + 0, + 0, + 0, + 2726, + 2686, + 1, + 0, + 0, + 0, + 2726, + 2687, + 1, + 0, + 0, + 0, + 2726, + 2690, + 1, + 0, + 0, + 0, + 2726, + 2691, + 1, + 0, + 0, + 0, + 2726, + 2694, + 1, + 0, + 0, + 0, + 2726, + 2695, + 1, + 0, + 0, + 0, + 2726, + 2698, + 1, + 0, + 0, + 0, + 2726, + 2699, + 1, + 0, + 0, + 0, + 2726, + 2702, + 1, + 0, + 0, + 0, + 2726, + 2703, + 1, + 0, + 0, + 0, + 2726, + 2706, + 1, + 0, + 0, + 0, + 2726, + 2707, + 1, + 0, + 0, + 0, + 2726, + 2710, + 1, + 0, + 0, + 0, + 2726, + 2711, + 1, + 0, + 0, + 0, + 2726, + 2714, + 1, + 0, + 0, + 0, + 2726, + 2715, + 1, + 0, + 0, + 0, + 2726, + 2718, + 1, + 0, + 0, + 0, + 2726, + 2719, + 1, + 0, + 0, + 0, + 2726, + 2722, + 1, + 0, + 0, + 0, + 2726, + 2723, + 1, + 0, + 0, + 0, + 2727, + 359, + 1, + 0, + 0, + 0, + 2728, + 2737, + 5, + 8, + 0, + 0, + 2729, + 2730, + 5, + 169, + 0, + 0, + 2730, + 2731, + 5, + 264, + 0, + 0, + 2731, + 2737, + 5, + 8, + 0, + 0, + 2732, + 2737, + 5, + 139, + 0, + 0, + 2733, + 2734, + 5, + 169, + 0, + 0, + 2734, + 2735, + 5, + 264, + 0, + 0, + 2735, + 2737, + 5, + 139, + 0, + 0, + 2736, + 2728, + 1, + 0, + 0, + 0, + 2736, + 2729, + 1, + 0, + 0, + 0, + 2736, + 2732, + 1, + 0, + 0, + 0, + 2736, + 2733, + 1, + 0, + 0, + 0, + 2737, + 361, + 1, + 0, + 0, + 0, + 2738, + 2755, + 5, + 191, + 0, + 0, + 2739, + 2740, + 5, + 56, + 0, + 0, + 2740, + 2741, + 5, + 264, + 0, + 0, + 2741, + 2755, + 5, + 191, + 0, + 0, + 2742, + 2755, + 5, + 132, + 0, + 0, + 2743, + 2744, + 5, + 56, + 0, + 0, + 2744, + 2745, + 5, + 264, + 0, + 0, + 2745, + 2755, + 5, + 132, + 0, + 0, + 2746, + 2755, + 5, + 88, + 0, + 0, + 2747, + 2748, + 5, + 56, + 0, + 0, + 2748, + 2749, + 5, + 264, + 0, + 0, + 2749, + 2755, + 5, + 88, + 0, + 0, + 2750, + 2755, + 5, + 42, + 0, + 0, + 2751, + 2752, + 5, + 56, + 0, + 0, + 2752, + 2753, + 5, + 264, + 0, + 0, + 2753, + 2755, + 5, + 42, + 0, + 0, + 2754, + 2738, + 1, + 0, + 0, + 0, + 2754, + 2739, + 1, + 0, + 0, + 0, + 2754, + 2742, + 1, + 0, + 0, + 0, + 2754, + 2743, + 1, + 0, + 0, + 0, + 2754, + 2746, + 1, + 0, + 0, + 0, + 2754, + 2747, + 1, + 0, + 0, + 0, + 2754, + 2750, + 1, + 0, + 0, + 0, + 2754, + 2751, + 1, + 0, + 0, + 0, + 2755, + 363, + 1, + 0, + 0, + 0, + 2756, + 2757, + 6, + 182, + -1, + 0, + 2757, + 2778, + 3, + 376, + 188, + 0, + 2758, + 2778, + 3, + 378, + 189, + 0, + 2759, + 2778, + 3, + 380, + 190, + 0, + 2760, + 2778, + 3, + 382, + 191, + 0, + 2761, + 2778, + 3, + 384, + 192, + 0, + 2762, + 2778, + 3, + 386, + 193, + 0, + 2763, + 2778, + 3, + 388, + 194, + 0, + 2764, + 2778, + 3, + 390, + 195, + 0, + 2765, + 2778, + 3, + 392, + 196, + 0, + 2766, + 2778, + 3, + 394, + 197, + 0, + 2767, + 2778, + 3, + 396, + 198, + 0, + 2768, + 2778, + 3, + 398, + 199, + 0, + 2769, + 2778, + 3, + 404, + 202, + 0, + 2770, + 2778, + 3, + 406, + 203, + 0, + 2771, + 2778, + 3, + 408, + 204, + 0, + 2772, + 2778, + 3, + 410, + 205, + 0, + 2773, + 2778, + 3, + 400, + 200, + 0, + 2774, + 2778, + 3, + 402, + 201, + 0, + 2775, + 2778, + 3, + 412, + 206, + 0, + 2776, + 2778, + 3, + 414, + 207, + 0, + 2777, + 2756, + 1, + 0, + 0, + 0, + 2777, + 2758, + 1, + 0, + 0, + 0, + 2777, + 2759, + 1, + 0, + 0, + 0, + 2777, + 2760, + 1, + 0, + 0, + 0, + 2777, + 2761, + 1, + 0, + 0, + 0, + 2777, + 2762, + 1, + 0, + 0, + 0, + 2777, + 2763, + 1, + 0, + 0, + 0, + 2777, + 2764, + 1, + 0, + 0, + 0, + 2777, + 2765, + 1, + 0, + 0, + 0, + 2777, + 2766, + 1, + 0, + 0, + 0, + 2777, + 2767, + 1, + 0, + 0, + 0, + 2777, + 2768, + 1, + 0, + 0, + 0, + 2777, + 2769, + 1, + 0, + 0, + 0, + 2777, + 2770, + 1, + 0, + 0, + 0, + 2777, + 2771, + 1, + 0, + 0, + 0, + 2777, + 2772, + 1, + 0, + 0, + 0, + 2777, + 2773, + 1, + 0, + 0, + 0, + 2777, + 2774, + 1, + 0, + 0, + 0, + 2777, + 2775, + 1, + 0, + 0, + 0, + 2777, + 2776, + 1, + 0, + 0, + 0, + 2778, + 2800, + 1, + 0, + 0, + 0, + 2779, + 2780, + 10, + 3, + 0, + 0, + 2780, + 2781, + 5, + 264, + 0, + 0, + 2781, + 2782, + 5, + 7, + 0, + 0, + 2782, + 2783, + 5, + 256, + 0, + 0, + 2783, + 2784, + 3, + 364, + 182, + 0, + 2784, + 2785, + 5, + 257, + 0, + 0, + 2785, + 2799, + 1, + 0, + 0, + 0, + 2786, + 2787, + 10, + 2, + 0, + 0, + 2787, + 2788, + 5, + 264, + 0, + 0, + 2788, + 2789, + 5, + 156, + 0, + 0, + 2789, + 2790, + 5, + 256, + 0, + 0, + 2790, + 2791, + 3, + 364, + 182, + 0, + 2791, + 2792, + 5, + 257, + 0, + 0, + 2792, + 2799, + 1, + 0, + 0, + 0, + 2793, + 2794, + 10, + 1, + 0, + 0, + 2794, + 2795, + 5, + 264, + 0, + 0, + 2795, + 2796, + 5, + 137, + 0, + 0, + 2796, + 2797, + 5, + 256, + 0, + 0, + 2797, + 2799, + 5, + 257, + 0, + 0, + 2798, + 2779, + 1, + 0, + 0, + 0, + 2798, + 2786, + 1, + 0, + 0, + 0, + 2798, + 2793, + 1, + 0, + 0, + 0, + 2799, + 2802, + 1, + 0, + 0, + 0, + 2800, + 2798, + 1, + 0, + 0, + 0, + 2800, + 2801, + 1, + 0, + 0, + 0, + 2801, + 365, + 1, + 0, + 0, + 0, + 2802, + 2800, + 1, + 0, + 0, + 0, + 2803, + 2812, + 3, + 416, + 208, + 0, + 2804, + 2812, + 3, + 420, + 210, + 0, + 2805, + 2812, + 3, + 418, + 209, + 0, + 2806, + 2812, + 3, + 422, + 211, + 0, + 2807, + 2812, + 3, + 424, + 212, + 0, + 2808, + 2812, + 3, + 426, + 213, + 0, + 2809, + 2812, + 3, + 428, + 214, + 0, + 2810, + 2812, + 3, + 430, + 215, + 0, + 2811, + 2803, + 1, + 0, + 0, + 0, + 2811, + 2804, + 1, + 0, + 0, + 0, + 2811, + 2805, + 1, + 0, + 0, + 0, + 2811, + 2806, + 1, + 0, + 0, + 0, + 2811, + 2807, + 1, + 0, + 0, + 0, + 2811, + 2808, + 1, + 0, + 0, + 0, + 2811, + 2809, + 1, + 0, + 0, + 0, + 2811, + 2810, + 1, + 0, + 0, + 0, + 2812, + 367, + 1, + 0, + 0, + 0, + 2813, + 2814, + 3, + 334, + 167, + 0, + 2814, + 369, + 1, + 0, + 0, + 0, + 2815, + 2816, + 3, + 344, + 172, + 0, + 2816, + 371, + 1, + 0, + 0, + 0, + 2817, + 2820, + 3, + 336, + 168, + 0, + 2818, + 2820, + 3, + 354, + 177, + 0, + 2819, + 2817, + 1, + 0, + 0, + 0, + 2819, + 2818, + 1, + 0, + 0, + 0, + 2820, + 373, + 1, + 0, + 0, + 0, + 2821, + 2822, + 3, + 358, + 179, + 0, + 2822, + 375, + 1, + 0, + 0, + 0, + 2823, + 2824, + 5, + 163, + 0, + 0, + 2824, + 2825, + 5, + 264, + 0, + 0, + 2825, + 2828, + 5, + 63, + 0, + 0, + 2826, + 2828, + 5, + 63, + 0, + 0, + 2827, + 2823, + 1, + 0, + 0, + 0, + 2827, + 2826, + 1, + 0, + 0, + 0, + 2828, + 2829, + 1, + 0, + 0, + 0, + 2829, + 2830, + 5, + 256, + 0, + 0, + 2830, + 2831, + 3, + 532, + 266, + 0, + 2831, + 2832, + 5, + 257, + 0, + 0, + 2832, + 377, + 1, + 0, + 0, + 0, + 2833, + 2834, + 5, + 163, + 0, + 0, + 2834, + 2835, + 5, + 264, + 0, + 0, + 2835, + 2838, + 5, + 145, + 0, + 0, + 2836, + 2838, + 5, + 145, + 0, + 0, + 2837, + 2833, + 1, + 0, + 0, + 0, + 2837, + 2836, + 1, + 0, + 0, + 0, + 2838, + 2839, + 1, + 0, + 0, + 0, + 2839, + 2840, + 5, + 256, + 0, + 0, + 2840, + 2841, + 3, + 532, + 266, + 0, + 2841, + 2842, + 5, + 257, + 0, + 0, + 2842, + 379, + 1, + 0, + 0, + 0, + 2843, + 2844, + 5, + 163, + 0, + 0, + 2844, + 2845, + 5, + 264, + 0, + 0, + 2845, + 2848, + 5, + 118, + 0, + 0, + 2846, + 2848, + 5, + 118, + 0, + 0, + 2847, + 2843, + 1, + 0, + 0, + 0, + 2847, + 2846, + 1, + 0, + 0, + 0, + 2848, + 2849, + 1, + 0, + 0, + 0, + 2849, + 2850, + 5, + 256, + 0, + 0, + 2850, + 2851, + 3, + 532, + 266, + 0, + 2851, + 2852, + 5, + 257, + 0, + 0, + 2852, + 381, + 1, + 0, + 0, + 0, + 2853, + 2854, + 5, + 163, + 0, + 0, + 2854, + 2855, + 5, + 264, + 0, + 0, + 2855, + 2858, + 5, + 119, + 0, + 0, + 2856, + 2858, + 5, + 119, + 0, + 0, + 2857, + 2853, + 1, + 0, + 0, + 0, + 2857, + 2856, + 1, + 0, + 0, + 0, + 2858, + 2859, + 1, + 0, + 0, + 0, + 2859, + 2860, + 5, + 256, + 0, + 0, + 2860, + 2861, + 3, + 532, + 266, + 0, + 2861, + 2862, + 5, + 257, + 0, + 0, + 2862, + 383, + 1, + 0, + 0, + 0, + 2863, + 2864, + 5, + 163, + 0, + 0, + 2864, + 2865, + 5, + 264, + 0, + 0, + 2865, + 2868, + 5, + 74, + 0, + 0, + 2866, + 2868, + 5, + 74, + 0, + 0, + 2867, + 2863, + 1, + 0, + 0, + 0, + 2867, + 2866, + 1, + 0, + 0, + 0, + 2868, + 2869, + 1, + 0, + 0, + 0, + 2869, + 2870, + 5, + 256, + 0, + 0, + 2870, + 2871, + 3, + 532, + 266, + 0, + 2871, + 2872, + 5, + 257, + 0, + 0, + 2872, + 385, + 1, + 0, + 0, + 0, + 2873, + 2874, + 5, + 163, + 0, + 0, + 2874, + 2875, + 5, + 264, + 0, + 0, + 2875, + 2878, + 5, + 75, + 0, + 0, + 2876, + 2878, + 5, + 75, + 0, + 0, + 2877, + 2873, + 1, + 0, + 0, + 0, + 2877, + 2876, + 1, + 0, + 0, + 0, + 2878, + 2879, + 1, + 0, + 0, + 0, + 2879, + 2880, + 5, + 256, + 0, + 0, + 2880, + 2881, + 3, + 532, + 266, + 0, + 2881, + 2882, + 5, + 257, + 0, + 0, + 2882, + 387, + 1, + 0, + 0, + 0, + 2883, + 2884, + 5, + 163, + 0, + 0, + 2884, + 2885, + 5, + 264, + 0, + 0, + 2885, + 2888, + 5, + 101, + 0, + 0, + 2886, + 2888, + 5, + 101, + 0, + 0, + 2887, + 2883, + 1, + 0, + 0, + 0, + 2887, + 2886, + 1, + 0, + 0, + 0, + 2888, + 2889, + 1, + 0, + 0, + 0, + 2889, + 2890, + 5, + 256, + 0, + 0, + 2890, + 2891, + 3, + 532, + 266, + 0, + 2891, + 2892, + 5, + 263, + 0, + 0, + 2892, + 2893, + 3, + 532, + 266, + 0, + 2893, + 2894, + 5, + 257, + 0, + 0, + 2894, + 389, + 1, + 0, + 0, + 0, + 2895, + 2896, + 5, + 163, + 0, + 0, + 2896, + 2897, + 5, + 264, + 0, + 0, + 2897, + 2900, + 5, + 161, + 0, + 0, + 2898, + 2900, + 5, + 161, + 0, + 0, + 2899, + 2895, + 1, + 0, + 0, + 0, + 2899, + 2898, + 1, + 0, + 0, + 0, + 2900, + 2901, + 1, + 0, + 0, + 0, + 2901, + 2902, + 5, + 256, + 0, + 0, + 2902, + 2903, + 3, + 532, + 266, + 0, + 2903, + 2904, + 5, + 263, + 0, + 0, + 2904, + 2905, + 3, + 532, + 266, + 0, + 2905, + 2906, + 5, + 257, + 0, + 0, + 2906, + 391, + 1, + 0, + 0, + 0, + 2907, + 2908, + 5, + 163, + 0, + 0, + 2908, + 2909, + 5, + 264, + 0, + 0, + 2909, + 2912, + 5, + 17, + 0, + 0, + 2910, + 2912, + 5, + 17, + 0, + 0, + 2911, + 2907, + 1, + 0, + 0, + 0, + 2911, + 2910, + 1, + 0, + 0, + 0, + 2912, + 2913, + 1, + 0, + 0, + 0, + 2913, + 2914, + 5, + 256, + 0, + 0, + 2914, + 2915, + 3, + 532, + 266, + 0, + 2915, + 2916, + 5, + 263, + 0, + 0, + 2916, + 2917, + 3, + 532, + 266, + 0, + 2917, + 2918, + 5, + 257, + 0, + 0, + 2918, + 393, + 1, + 0, + 0, + 0, + 2919, + 2920, + 5, + 163, + 0, + 0, + 2920, + 2921, + 5, + 264, + 0, + 0, + 2921, + 2924, + 5, + 241, + 0, + 0, + 2922, + 2924, + 5, + 241, + 0, + 0, + 2923, + 2919, + 1, + 0, + 0, + 0, + 2923, + 2922, + 1, + 0, + 0, + 0, + 2924, + 2925, + 1, + 0, + 0, + 0, + 2925, + 2926, + 5, + 256, + 0, + 0, + 2926, + 2938, + 5, + 257, + 0, + 0, + 2927, + 2928, + 5, + 163, + 0, + 0, + 2928, + 2929, + 5, + 264, + 0, + 0, + 2929, + 2932, + 5, + 241, + 0, + 0, + 2930, + 2932, + 5, + 241, + 0, + 0, + 2931, + 2927, + 1, + 0, + 0, + 0, + 2931, + 2930, + 1, + 0, + 0, + 0, + 2932, + 2933, + 1, + 0, + 0, + 0, + 2933, + 2934, + 5, + 256, + 0, + 0, + 2934, + 2935, + 3, + 534, + 267, + 0, + 2935, + 2936, + 5, + 257, + 0, + 0, + 2936, + 2938, + 1, + 0, + 0, + 0, + 2937, + 2923, + 1, + 0, + 0, + 0, + 2937, + 2931, + 1, + 0, + 0, + 0, + 2938, + 395, + 1, + 0, + 0, + 0, + 2939, + 2940, + 5, + 163, + 0, + 0, + 2940, + 2941, + 5, + 264, + 0, + 0, + 2941, + 2944, + 5, + 243, + 0, + 0, + 2942, + 2944, + 5, + 243, + 0, + 0, + 2943, + 2939, + 1, + 0, + 0, + 0, + 2943, + 2942, + 1, + 0, + 0, + 0, + 2944, + 2945, + 1, + 0, + 0, + 0, + 2945, + 2946, + 5, + 256, + 0, + 0, + 2946, + 2958, + 5, + 257, + 0, + 0, + 2947, + 2948, + 5, + 163, + 0, + 0, + 2948, + 2949, + 5, + 264, + 0, + 0, + 2949, + 2952, + 5, + 243, + 0, + 0, + 2950, + 2952, + 5, + 243, + 0, + 0, + 2951, + 2947, + 1, + 0, + 0, + 0, + 2951, + 2950, + 1, + 0, + 0, + 0, + 2952, + 2953, + 1, + 0, + 0, + 0, + 2953, + 2954, + 5, + 256, + 0, + 0, + 2954, + 2955, + 3, + 534, + 267, + 0, + 2955, + 2956, + 5, + 257, + 0, + 0, + 2956, + 2958, + 1, + 0, + 0, + 0, + 2957, + 2943, + 1, + 0, + 0, + 0, + 2957, + 2951, + 1, + 0, + 0, + 0, + 2958, + 397, + 1, + 0, + 0, + 0, + 2959, + 2960, + 5, + 163, + 0, + 0, + 2960, + 2961, + 5, + 264, + 0, + 0, + 2961, + 2964, + 5, + 144, + 0, + 0, + 2962, + 2964, + 5, + 144, + 0, + 0, + 2963, + 2959, + 1, + 0, + 0, + 0, + 2963, + 2962, + 1, + 0, + 0, + 0, + 2964, + 2965, + 1, + 0, + 0, + 0, + 2965, + 2966, + 5, + 256, + 0, + 0, + 2966, + 2967, + 3, + 364, + 182, + 0, + 2967, + 2968, + 5, + 257, + 0, + 0, + 2968, + 399, + 1, + 0, + 0, + 0, + 2969, + 2970, + 5, + 211, + 0, + 0, + 2970, + 2971, + 5, + 264, + 0, + 0, + 2971, + 2974, + 5, + 39, + 0, + 0, + 2972, + 2974, + 5, + 39, + 0, + 0, + 2973, + 2969, + 1, + 0, + 0, + 0, + 2973, + 2972, + 1, + 0, + 0, + 0, + 2974, + 2975, + 1, + 0, + 0, + 0, + 2975, + 2976, + 5, + 256, + 0, + 0, + 2976, + 2977, + 3, + 524, + 262, + 0, + 2977, + 2978, + 5, + 257, + 0, + 0, + 2978, + 401, + 1, + 0, + 0, + 0, + 2979, + 2980, + 5, + 211, + 0, + 0, + 2980, + 2981, + 5, + 264, + 0, + 0, + 2981, + 2984, + 5, + 141, + 0, + 0, + 2982, + 2984, + 5, + 141, + 0, + 0, + 2983, + 2979, + 1, + 0, + 0, + 0, + 2983, + 2982, + 1, + 0, + 0, + 0, + 2984, + 2985, + 1, + 0, + 0, + 0, + 2985, + 2986, + 5, + 256, + 0, + 0, + 2986, + 2987, + 3, + 524, + 262, + 0, + 2987, + 2988, + 5, + 257, + 0, + 0, + 2988, + 403, + 1, + 0, + 0, + 0, + 2989, + 2990, + 5, + 211, + 0, + 0, + 2990, + 2991, + 5, + 264, + 0, + 0, + 2991, + 2994, + 5, + 202, + 0, + 0, + 2992, + 2994, + 5, + 202, + 0, + 0, + 2993, + 2989, + 1, + 0, + 0, + 0, + 2993, + 2992, + 1, + 0, + 0, + 0, + 2994, + 2995, + 1, + 0, + 0, + 0, + 2995, + 2996, + 5, + 256, + 0, + 0, + 2996, + 2997, + 3, + 524, + 262, + 0, + 2997, + 2998, + 5, + 257, + 0, + 0, + 2998, + 405, + 1, + 0, + 0, + 0, + 2999, + 3000, + 5, + 211, + 0, + 0, + 3000, + 3001, + 5, + 264, + 0, + 0, + 3001, + 3004, + 5, + 143, + 0, + 0, + 3002, + 3004, + 5, + 143, + 0, + 0, + 3003, + 2999, + 1, + 0, + 0, + 0, + 3003, + 3002, + 1, + 0, + 0, + 0, + 3004, + 3005, + 1, + 0, + 0, + 0, + 3005, + 3006, + 5, + 256, + 0, + 0, + 3006, + 3007, + 3, + 524, + 262, + 0, + 3007, + 3008, + 5, + 257, + 0, + 0, + 3008, + 407, + 1, + 0, + 0, + 0, + 3009, + 3010, + 5, + 211, + 0, + 0, + 3010, + 3011, + 5, + 264, + 0, + 0, + 3011, + 3014, + 5, + 62, + 0, + 0, + 3012, + 3014, + 5, + 62, + 0, + 0, + 3013, + 3009, + 1, + 0, + 0, + 0, + 3013, + 3012, + 1, + 0, + 0, + 0, + 3014, + 3015, + 1, + 0, + 0, + 0, + 3015, + 3016, + 5, + 256, + 0, + 0, + 3016, + 3017, + 3, + 524, + 262, + 0, + 3017, + 3018, + 5, + 257, + 0, + 0, + 3018, + 409, + 1, + 0, + 0, + 0, + 3019, + 3020, + 5, + 211, + 0, + 0, + 3020, + 3021, + 5, + 264, + 0, + 0, + 3021, + 3024, + 5, + 142, + 0, + 0, + 3022, + 3024, + 5, + 142, + 0, + 0, + 3023, + 3019, + 1, + 0, + 0, + 0, + 3023, + 3022, + 1, + 0, + 0, + 0, + 3024, + 3025, + 1, + 0, + 0, + 0, + 3025, + 3026, + 5, + 256, + 0, + 0, + 3026, + 3027, + 3, + 524, + 262, + 0, + 3027, + 3028, + 5, + 257, + 0, + 0, + 3028, + 411, + 1, + 0, + 0, + 0, + 3029, + 3030, + 5, + 211, + 0, + 0, + 3030, + 3031, + 5, + 264, + 0, + 0, + 3031, + 3034, + 5, + 182, + 0, + 0, + 3032, + 3034, + 5, + 182, + 0, + 0, + 3033, + 3029, + 1, + 0, + 0, + 0, + 3033, + 3032, + 1, + 0, + 0, + 0, + 3034, + 3035, + 1, + 0, + 0, + 0, + 3035, + 3036, + 5, + 256, + 0, + 0, + 3036, + 3037, + 3, + 524, + 262, + 0, + 3037, + 3038, + 5, + 257, + 0, + 0, + 3038, + 413, + 1, + 0, + 0, + 0, + 3039, + 3040, + 5, + 211, + 0, + 0, + 3040, + 3041, + 5, + 264, + 0, + 0, + 3041, + 3044, + 5, + 140, + 0, + 0, + 3042, + 3044, + 5, + 140, + 0, + 0, + 3043, + 3039, + 1, + 0, + 0, + 0, + 3043, + 3042, + 1, + 0, + 0, + 0, + 3044, + 3045, + 1, + 0, + 0, + 0, + 3045, + 3046, + 5, + 256, + 0, + 0, + 3046, + 3047, + 3, + 524, + 262, + 0, + 3047, + 3048, + 5, + 257, + 0, + 0, + 3048, + 415, + 1, + 0, + 0, + 0, + 3049, + 3050, + 5, + 64, + 0, + 0, + 3050, + 3051, + 5, + 256, + 0, + 0, + 3051, + 3052, + 5, + 257, + 0, + 0, + 3052, + 417, + 1, + 0, + 0, + 0, + 3053, + 3054, + 5, + 85, + 0, + 0, + 3054, + 3055, + 5, + 256, + 0, + 0, + 3055, + 3056, + 5, + 257, + 0, + 0, + 3056, + 419, + 1, + 0, + 0, + 0, + 3057, + 3058, + 5, + 107, + 0, + 0, + 3058, + 3059, + 5, + 256, + 0, + 0, + 3059, + 3060, + 5, + 257, + 0, + 0, + 3060, + 421, + 1, + 0, + 0, + 0, + 3061, + 3062, + 5, + 227, + 0, + 0, + 3062, + 3063, + 5, + 256, + 0, + 0, + 3063, + 3064, + 5, + 257, + 0, + 0, + 3064, + 423, + 1, + 0, + 0, + 0, + 3065, + 3066, + 5, + 138, + 0, + 0, + 3066, + 3067, + 5, + 256, + 0, + 0, + 3067, + 3074, + 5, + 257, + 0, + 0, + 3068, + 3069, + 5, + 138, + 0, + 0, + 3069, + 3070, + 5, + 256, + 0, + 0, + 3070, + 3071, + 3, + 582, + 291, + 0, + 3071, + 3072, + 5, + 257, + 0, + 0, + 3072, + 3074, + 1, + 0, + 0, + 0, + 3073, + 3065, + 1, + 0, + 0, + 0, + 3073, + 3068, + 1, + 0, + 0, + 0, + 3074, + 425, + 1, + 0, + 0, + 0, + 3075, + 3076, + 5, + 217, + 0, + 0, + 3076, + 3077, + 5, + 256, + 0, + 0, + 3077, + 3078, + 5, + 257, + 0, + 0, + 3078, + 427, + 1, + 0, + 0, + 0, + 3079, + 3080, + 5, + 219, + 0, + 0, + 3080, + 3081, + 5, + 256, + 0, + 0, + 3081, + 3082, + 5, + 257, + 0, + 0, + 3082, + 429, + 1, + 0, + 0, + 0, + 3083, + 3084, + 5, + 215, + 0, + 0, + 3084, + 3085, + 5, + 256, + 0, + 0, + 3085, + 3086, + 5, + 257, + 0, + 0, + 3086, + 431, + 1, + 0, + 0, + 0, + 3087, + 3095, + 3, + 440, + 220, + 0, + 3088, + 3095, + 3, + 434, + 217, + 0, + 3089, + 3095, + 3, + 436, + 218, + 0, + 3090, + 3095, + 3, + 438, + 219, + 0, + 3091, + 3095, + 3, + 444, + 222, + 0, + 3092, + 3095, + 3, + 476, + 238, + 0, + 3093, + 3095, + 3, + 490, + 245, + 0, + 3094, + 3087, + 1, + 0, + 0, + 0, + 3094, + 3088, + 1, + 0, + 0, + 0, + 3094, + 3089, + 1, + 0, + 0, + 0, + 3094, + 3090, + 1, + 0, + 0, + 0, + 3094, + 3091, + 1, + 0, + 0, + 0, + 3094, + 3092, + 1, + 0, + 0, + 0, + 3094, + 3093, + 1, + 0, + 0, + 0, + 3095, + 433, + 1, + 0, + 0, + 0, + 3096, + 3100, + 3, + 448, + 224, + 0, + 3097, + 3100, + 3, + 450, + 225, + 0, + 3098, + 3100, + 3, + 452, + 226, + 0, + 3099, + 3096, + 1, + 0, + 0, + 0, + 3099, + 3097, + 1, + 0, + 0, + 0, + 3099, + 3098, + 1, + 0, + 0, + 0, + 3100, + 435, + 1, + 0, + 0, + 0, + 3101, + 3105, + 3, + 454, + 227, + 0, + 3102, + 3105, + 3, + 456, + 228, + 0, + 3103, + 3105, + 3, + 458, + 229, + 0, + 3104, + 3101, + 1, + 0, + 0, + 0, + 3104, + 3102, + 1, + 0, + 0, + 0, + 3104, + 3103, + 1, + 0, + 0, + 0, + 3105, + 437, + 1, + 0, + 0, + 0, + 3106, + 3110, + 3, + 460, + 230, + 0, + 3107, + 3110, + 3, + 462, + 231, + 0, + 3108, + 3110, + 3, + 464, + 232, + 0, + 3109, + 3106, + 1, + 0, + 0, + 0, + 3109, + 3107, + 1, + 0, + 0, + 0, + 3109, + 3108, + 1, + 0, + 0, + 0, + 3110, + 439, + 1, + 0, + 0, + 0, + 3111, + 3117, + 3, + 466, + 233, + 0, + 3112, + 3117, + 3, + 468, + 234, + 0, + 3113, + 3117, + 3, + 470, + 235, + 0, + 3114, + 3117, + 3, + 472, + 236, + 0, + 3115, + 3117, + 3, + 474, + 237, + 0, + 3116, + 3111, + 1, + 0, + 0, + 0, + 3116, + 3112, + 1, + 0, + 0, + 0, + 3116, + 3113, + 1, + 0, + 0, + 0, + 3116, + 3114, + 1, + 0, + 0, + 0, + 3116, + 3115, + 1, + 0, + 0, + 0, + 3117, + 441, + 1, + 0, + 0, + 0, + 3118, + 3128, + 3, + 476, + 238, + 0, + 3119, + 3128, + 3, + 478, + 239, + 0, + 3120, + 3128, + 3, + 480, + 240, + 0, + 3121, + 3128, + 3, + 482, + 241, + 0, + 3122, + 3128, + 3, + 484, + 242, + 0, + 3123, + 3128, + 3, + 486, + 243, + 0, + 3124, + 3128, + 3, + 488, + 244, + 0, + 3125, + 3128, + 3, + 492, + 246, + 0, + 3126, + 3128, + 3, + 494, + 247, + 0, + 3127, + 3118, + 1, + 0, + 0, + 0, + 3127, + 3119, + 1, + 0, + 0, + 0, + 3127, + 3120, + 1, + 0, + 0, + 0, + 3127, + 3121, + 1, + 0, + 0, + 0, + 3127, + 3122, + 1, + 0, + 0, + 0, + 3127, + 3123, + 1, + 0, + 0, + 0, + 3127, + 3124, + 1, + 0, + 0, + 0, + 3127, + 3125, + 1, + 0, + 0, + 0, + 3127, + 3126, + 1, + 0, + 0, + 0, + 3128, + 443, + 1, + 0, + 0, + 0, + 3129, + 3132, + 3, + 496, + 248, + 0, + 3130, + 3132, + 3, + 498, + 249, + 0, + 3131, + 3129, + 1, + 0, + 0, + 0, + 3131, + 3130, + 1, + 0, + 0, + 0, + 3132, + 445, + 1, + 0, + 0, + 0, + 3133, + 3137, + 3, + 500, + 250, + 0, + 3134, + 3137, + 3, + 502, + 251, + 0, + 3135, + 3137, + 3, + 504, + 252, + 0, + 3136, + 3133, + 1, + 0, + 0, + 0, + 3136, + 3134, + 1, + 0, + 0, + 0, + 3136, + 3135, + 1, + 0, + 0, + 0, + 3137, + 447, + 1, + 0, + 0, + 0, + 3138, + 3139, + 3, + 506, + 253, + 0, + 3139, + 3140, + 5, + 264, + 0, + 0, + 3140, + 3141, + 5, + 33, + 0, + 0, + 3141, + 449, + 1, + 0, + 0, + 0, + 3142, + 3143, + 3, + 506, + 253, + 0, + 3143, + 3144, + 5, + 264, + 0, + 0, + 3144, + 3145, + 5, + 58, + 0, + 0, + 3145, + 451, + 1, + 0, + 0, + 0, + 3146, + 3147, + 3, + 506, + 253, + 0, + 3147, + 3148, + 5, + 264, + 0, + 0, + 3148, + 3149, + 5, + 175, + 0, + 0, + 3149, + 453, + 1, + 0, + 0, + 0, + 3150, + 3151, + 3, + 508, + 254, + 0, + 3151, + 3152, + 5, + 264, + 0, + 0, + 3152, + 3153, + 5, + 58, + 0, + 0, + 3153, + 455, + 1, + 0, + 0, + 0, + 3154, + 3155, + 3, + 508, + 254, + 0, + 3155, + 3156, + 5, + 264, + 0, + 0, + 3156, + 3157, + 5, + 213, + 0, + 0, + 3157, + 457, + 1, + 0, + 0, + 0, + 3158, + 3159, + 3, + 508, + 254, + 0, + 3159, + 3160, + 5, + 264, + 0, + 0, + 3160, + 3161, + 5, + 175, + 0, + 0, + 3161, + 459, + 1, + 0, + 0, + 0, + 3162, + 3163, + 3, + 510, + 255, + 0, + 3163, + 3164, + 5, + 264, + 0, + 0, + 3164, + 3165, + 5, + 58, + 0, + 0, + 3165, + 461, + 1, + 0, + 0, + 0, + 3166, + 3167, + 3, + 510, + 255, + 0, + 3167, + 3168, + 5, + 264, + 0, + 0, + 3168, + 3169, + 5, + 213, + 0, + 0, + 3169, + 463, + 1, + 0, + 0, + 0, + 3170, + 3171, + 3, + 510, + 255, + 0, + 3171, + 3172, + 5, + 264, + 0, + 0, + 3172, + 3173, + 5, + 175, + 0, + 0, + 3173, + 465, + 1, + 0, + 0, + 0, + 3174, + 3175, + 3, + 512, + 256, + 0, + 3175, + 3176, + 5, + 264, + 0, + 0, + 3176, + 3177, + 5, + 210, + 0, + 0, + 3177, + 467, + 1, + 0, + 0, + 0, + 3178, + 3179, + 3, + 512, + 256, + 0, + 3179, + 3180, + 5, + 264, + 0, + 0, + 3180, + 3181, + 5, + 58, + 0, + 0, + 3181, + 469, + 1, + 0, + 0, + 0, + 3182, + 3183, + 3, + 512, + 256, + 0, + 3183, + 3184, + 5, + 264, + 0, + 0, + 3184, + 3185, + 5, + 53, + 0, + 0, + 3185, + 471, + 1, + 0, + 0, + 0, + 3186, + 3187, + 3, + 512, + 256, + 0, + 3187, + 3188, + 5, + 264, + 0, + 0, + 3188, + 3189, + 5, + 125, + 0, + 0, + 3189, + 473, + 1, + 0, + 0, + 0, + 3190, + 3191, + 3, + 512, + 256, + 0, + 3191, + 3192, + 5, + 264, + 0, + 0, + 3192, + 3193, + 5, + 95, + 0, + 0, + 3193, + 475, + 1, + 0, + 0, + 0, + 3194, + 3195, + 3, + 514, + 257, + 0, + 3195, + 3196, + 5, + 264, + 0, + 0, + 3196, + 3197, + 5, + 216, + 0, + 0, + 3197, + 477, + 1, + 0, + 0, + 0, + 3198, + 3199, + 3, + 514, + 257, + 0, + 3199, + 3200, + 5, + 264, + 0, + 0, + 3200, + 3201, + 5, + 139, + 0, + 0, + 3201, + 479, + 1, + 0, + 0, + 0, + 3202, + 3203, + 3, + 514, + 257, + 0, + 3203, + 3204, + 5, + 264, + 0, + 0, + 3204, + 3205, + 5, + 91, + 0, + 0, + 3205, + 481, + 1, + 0, + 0, + 0, + 3206, + 3207, + 3, + 514, + 257, + 0, + 3207, + 3208, + 5, + 264, + 0, + 0, + 3208, + 3209, + 5, + 110, + 0, + 0, + 3209, + 483, + 1, + 0, + 0, + 0, + 3210, + 3211, + 3, + 514, + 257, + 0, + 3211, + 3212, + 5, + 264, + 0, + 0, + 3212, + 3213, + 5, + 109, + 0, + 0, + 3213, + 485, + 1, + 0, + 0, + 0, + 3214, + 3215, + 3, + 514, + 257, + 0, + 3215, + 3216, + 5, + 264, + 0, + 0, + 3216, + 3217, + 5, + 235, + 0, + 0, + 3217, + 487, + 1, + 0, + 0, + 0, + 3218, + 3219, + 3, + 514, + 257, + 0, + 3219, + 3220, + 5, + 264, + 0, + 0, + 3220, + 3221, + 5, + 6, + 0, + 0, + 3221, + 489, + 1, + 0, + 0, + 0, + 3222, + 3223, + 3, + 514, + 257, + 0, + 3223, + 3224, + 5, + 264, + 0, + 0, + 3224, + 3225, + 5, + 97, + 0, + 0, + 3225, + 491, + 1, + 0, + 0, + 0, + 3226, + 3227, + 3, + 514, + 257, + 0, + 3227, + 3228, + 5, + 264, + 0, + 0, + 3228, + 3229, + 5, + 115, + 0, + 0, + 3229, + 493, + 1, + 0, + 0, + 0, + 3230, + 3231, + 3, + 514, + 257, + 0, + 3231, + 3232, + 5, + 264, + 0, + 0, + 3232, + 3233, + 5, + 121, + 0, + 0, + 3233, + 495, + 1, + 0, + 0, + 0, + 3234, + 3235, + 3, + 516, + 258, + 0, + 3235, + 3236, + 5, + 264, + 0, + 0, + 3236, + 3237, + 5, + 180, + 0, + 0, + 3237, + 497, + 1, + 0, + 0, + 0, + 3238, + 3239, + 3, + 516, + 258, + 0, + 3239, + 3240, + 5, + 264, + 0, + 0, + 3240, + 3241, + 5, + 250, + 0, + 0, + 3241, + 499, + 1, + 0, + 0, + 0, + 3242, + 3243, + 3, + 516, + 258, + 0, + 3243, + 3244, + 5, + 264, + 0, + 0, + 3244, + 3245, + 5, + 80, + 0, + 0, + 3245, + 501, + 1, + 0, + 0, + 0, + 3246, + 3247, + 3, + 516, + 258, + 0, + 3247, + 3248, + 5, + 264, + 0, + 0, + 3248, + 3249, + 5, + 77, + 0, + 0, + 3249, + 503, + 1, + 0, + 0, + 0, + 3250, + 3251, + 3, + 516, + 258, + 0, + 3251, + 3252, + 5, + 264, + 0, + 0, + 3252, + 3253, + 5, + 76, + 0, + 0, + 3253, + 505, + 1, + 0, + 0, + 0, + 3254, + 3255, + 5, + 37, + 0, + 0, + 3255, + 507, + 1, + 0, + 0, + 0, + 3256, + 3257, + 5, + 164, + 0, + 0, + 3257, + 509, + 1, + 0, + 0, + 0, + 3258, + 3259, + 5, + 167, + 0, + 0, + 3259, + 511, + 1, + 0, + 0, + 0, + 3260, + 3261, + 5, + 194, + 0, + 0, + 3261, + 513, + 1, + 0, + 0, + 0, + 3262, + 3263, + 5, + 242, + 0, + 0, + 3263, + 515, + 1, + 0, + 0, + 0, + 3264, + 3265, + 5, + 104, + 0, + 0, + 3265, + 517, + 1, + 0, + 0, + 0, + 3266, + 3269, + 3, + 588, + 294, + 0, + 3267, + 3269, + 3, + 604, + 302, + 0, + 3268, + 3266, + 1, + 0, + 0, + 0, + 3268, + 3267, + 1, + 0, + 0, + 0, + 3269, + 519, + 1, + 0, + 0, + 0, + 3270, + 3273, + 3, + 582, + 291, + 0, + 3271, + 3273, + 3, + 604, + 302, + 0, + 3272, + 3270, + 1, + 0, + 0, + 0, + 3272, + 3271, + 1, + 0, + 0, + 0, + 3273, + 521, + 1, + 0, + 0, + 0, + 3274, + 3277, + 3, + 584, + 292, + 0, + 3275, + 3277, + 3, + 604, + 302, + 0, + 3276, + 3274, + 1, + 0, + 0, + 0, + 3276, + 3275, + 1, + 0, + 0, + 0, + 3277, + 523, + 1, + 0, + 0, + 0, + 3278, + 3281, + 3, + 578, + 289, + 0, + 3279, + 3281, + 3, + 604, + 302, + 0, + 3280, + 3278, + 1, + 0, + 0, + 0, + 3280, + 3279, + 1, + 0, + 0, + 0, + 3281, + 525, + 1, + 0, + 0, + 0, + 3282, + 3285, + 3, + 580, + 290, + 0, + 3283, + 3285, + 3, + 604, + 302, + 0, + 3284, + 3282, + 1, + 0, + 0, + 0, + 3284, + 3283, + 1, + 0, + 0, + 0, + 3285, + 527, + 1, + 0, + 0, + 0, + 3286, + 3291, + 3, + 526, + 263, + 0, + 3287, + 3288, + 5, + 263, + 0, + 0, + 3288, + 3290, + 3, + 526, + 263, + 0, + 3289, + 3287, + 1, + 0, + 0, + 0, + 3290, + 3293, + 1, + 0, + 0, + 0, + 3291, + 3289, + 1, + 0, + 0, + 0, + 3291, + 3292, + 1, + 0, + 0, + 0, + 3292, + 3295, + 1, + 0, + 0, + 0, + 3293, + 3291, + 1, + 0, + 0, + 0, + 3294, + 3286, + 1, + 0, + 0, + 0, + 3294, + 3295, + 1, + 0, + 0, + 0, + 3295, + 529, + 1, + 0, + 0, + 0, + 3296, + 3299, + 3, + 590, + 295, + 0, + 3297, + 3299, + 3, + 604, + 302, + 0, + 3298, + 3296, + 1, + 0, + 0, + 0, + 3298, + 3297, + 1, + 0, + 0, + 0, + 3299, + 531, + 1, + 0, + 0, + 0, + 3300, + 3303, + 3, + 570, + 285, + 0, + 3301, + 3303, + 3, + 604, + 302, + 0, + 3302, + 3300, + 1, + 0, + 0, + 0, + 3302, + 3301, + 1, + 0, + 0, + 0, + 3303, + 533, + 1, + 0, + 0, + 0, + 3304, + 3309, + 3, + 532, + 266, + 0, + 3305, + 3306, + 5, + 263, + 0, + 0, + 3306, + 3308, + 3, + 532, + 266, + 0, + 3307, + 3305, + 1, + 0, + 0, + 0, + 3308, + 3311, + 1, + 0, + 0, + 0, + 3309, + 3307, + 1, + 0, + 0, + 0, + 3309, + 3310, + 1, + 0, + 0, + 0, + 3310, + 3313, + 1, + 0, + 0, + 0, + 3311, + 3309, + 1, + 0, + 0, + 0, + 3312, + 3304, + 1, + 0, + 0, + 0, + 3312, + 3313, + 1, + 0, + 0, + 0, + 3313, + 535, + 1, + 0, + 0, + 0, + 3314, + 3317, + 3, + 572, + 286, + 0, + 3315, + 3317, + 3, + 604, + 302, + 0, + 3316, + 3314, + 1, + 0, + 0, + 0, + 3316, + 3315, + 1, + 0, + 0, + 0, + 3317, + 537, + 1, + 0, + 0, + 0, + 3318, + 3321, + 3, + 562, + 281, + 0, + 3319, + 3321, + 3, + 604, + 302, + 0, + 3320, + 3318, + 1, + 0, + 0, + 0, + 3320, + 3319, + 1, + 0, + 0, + 0, + 3321, + 539, + 1, + 0, + 0, + 0, + 3322, + 3325, + 3, + 572, + 286, + 0, + 3323, + 3325, + 3, + 592, + 296, + 0, + 3324, + 3322, + 1, + 0, + 0, + 0, + 3324, + 3323, + 1, + 0, + 0, + 0, + 3325, + 541, + 1, + 0, + 0, + 0, + 3326, + 3329, + 3, + 326, + 163, + 0, + 3327, + 3329, + 3, + 604, + 302, + 0, + 3328, + 3326, + 1, + 0, + 0, + 0, + 3328, + 3327, + 1, + 0, + 0, + 0, + 3329, + 543, + 1, + 0, + 0, + 0, + 3330, + 3332, + 3, + 546, + 273, + 0, + 3331, + 3330, + 1, + 0, + 0, + 0, + 3331, + 3332, + 1, + 0, + 0, + 0, + 3332, + 545, + 1, + 0, + 0, + 0, + 3333, + 3338, + 3, + 328, + 164, + 0, + 3334, + 3335, + 5, + 263, + 0, + 0, + 3335, + 3337, + 3, + 328, + 164, + 0, + 3336, + 3334, + 1, + 0, + 0, + 0, + 3337, + 3340, + 1, + 0, + 0, + 0, + 3338, + 3336, + 1, + 0, + 0, + 0, + 3338, + 3339, + 1, + 0, + 0, + 0, + 3339, + 547, + 1, + 0, + 0, + 0, + 3340, + 3338, + 1, + 0, + 0, + 0, + 3341, + 3343, + 3, + 550, + 275, + 0, + 3342, + 3341, + 1, + 0, + 0, + 0, + 3342, + 3343, + 1, + 0, + 0, + 0, + 3343, + 549, + 1, + 0, + 0, + 0, + 3344, + 3349, + 3, + 602, + 301, + 0, + 3345, + 3346, + 5, + 263, + 0, + 0, + 3346, + 3348, + 3, + 602, + 301, + 0, + 3347, + 3345, + 1, + 0, + 0, + 0, + 3348, + 3351, + 1, + 0, + 0, + 0, + 3349, + 3347, + 1, + 0, + 0, + 0, + 3349, + 3350, + 1, + 0, + 0, + 0, + 3350, + 551, + 1, + 0, + 0, + 0, + 3351, + 3349, + 1, + 0, + 0, + 0, + 3352, + 3354, + 3, + 554, + 277, + 0, + 3353, + 3352, + 1, + 0, + 0, + 0, + 3353, + 3354, + 1, + 0, + 0, + 0, + 3354, + 553, + 1, + 0, + 0, + 0, + 3355, + 3360, + 3, + 52, + 26, + 0, + 3356, + 3357, + 5, + 263, + 0, + 0, + 3357, + 3359, + 3, + 52, + 26, + 0, + 3358, + 3356, + 1, + 0, + 0, + 0, + 3359, + 3362, + 1, + 0, + 0, + 0, + 3360, + 3358, + 1, + 0, + 0, + 0, + 3360, + 3361, + 1, + 0, + 0, + 0, + 3361, + 555, + 1, + 0, + 0, + 0, + 3362, + 3360, + 1, + 0, + 0, + 0, + 3363, + 3372, + 5, + 260, + 0, + 0, + 3364, + 3369, + 3, + 570, + 285, + 0, + 3365, + 3366, + 5, + 263, + 0, + 0, + 3366, + 3368, + 3, + 570, + 285, + 0, + 3367, + 3365, + 1, + 0, + 0, + 0, + 3368, + 3371, + 1, + 0, + 0, + 0, + 3369, + 3367, + 1, + 0, + 0, + 0, + 3369, + 3370, + 1, + 0, + 0, + 0, + 3370, + 3373, + 1, + 0, + 0, + 0, + 3371, + 3369, + 1, + 0, + 0, + 0, + 3372, + 3364, + 1, + 0, + 0, + 0, + 3372, + 3373, + 1, + 0, + 0, + 0, + 3373, + 3374, + 1, + 0, + 0, + 0, + 3374, + 3375, + 5, + 261, + 0, + 0, + 3375, + 557, + 1, + 0, + 0, + 0, + 3376, + 3378, + 3, + 560, + 280, + 0, + 3377, + 3376, + 1, + 0, + 0, + 0, + 3377, + 3378, + 1, + 0, + 0, + 0, + 3378, + 559, + 1, + 0, + 0, + 0, + 3379, + 3384, + 3, + 570, + 285, + 0, + 3380, + 3381, + 5, + 263, + 0, + 0, + 3381, + 3383, + 3, + 570, + 285, + 0, + 3382, + 3380, + 1, + 0, + 0, + 0, + 3383, + 3386, + 1, + 0, + 0, + 0, + 3384, + 3382, + 1, + 0, + 0, + 0, + 3384, + 3385, + 1, + 0, + 0, + 0, + 3385, + 561, + 1, + 0, + 0, + 0, + 3386, + 3384, + 1, + 0, + 0, + 0, + 3387, + 3390, + 3, + 572, + 286, + 0, + 3388, + 3390, + 3, + 592, + 296, + 0, + 3389, + 3387, + 1, + 0, + 0, + 0, + 3389, + 3388, + 1, + 0, + 0, + 0, + 3390, + 563, + 1, + 0, + 0, + 0, + 3391, + 3392, + 3, + 582, + 291, + 0, + 3392, + 3393, + 5, + 264, + 0, + 0, + 3393, + 3394, + 5, + 264, + 0, + 0, + 3394, + 3395, + 3, + 582, + 291, + 0, + 3395, + 3402, + 1, + 0, + 0, + 0, + 3396, + 3397, + 3, + 578, + 289, + 0, + 3397, + 3398, + 5, + 264, + 0, + 0, + 3398, + 3399, + 5, + 264, + 0, + 0, + 3399, + 3400, + 3, + 578, + 289, + 0, + 3400, + 3402, + 1, + 0, + 0, + 0, + 3401, + 3391, + 1, + 0, + 0, + 0, + 3401, + 3396, + 1, + 0, + 0, + 0, + 3402, + 565, + 1, + 0, + 0, + 0, + 3403, + 3412, + 5, + 258, + 0, + 0, + 3404, + 3409, + 3, + 570, + 285, + 0, + 3405, + 3406, + 5, + 263, + 0, + 0, + 3406, + 3408, + 3, + 570, + 285, + 0, + 3407, + 3405, + 1, + 0, + 0, + 0, + 3408, + 3411, + 1, + 0, + 0, + 0, + 3409, + 3407, + 1, + 0, + 0, + 0, + 3409, + 3410, + 1, + 0, + 0, + 0, + 3410, + 3413, + 1, + 0, + 0, + 0, + 3411, + 3409, + 1, + 0, + 0, + 0, + 3412, + 3404, + 1, + 0, + 0, + 0, + 3412, + 3413, + 1, + 0, + 0, + 0, + 3413, + 3414, + 1, + 0, + 0, + 0, + 3414, + 3415, + 5, + 259, + 0, + 0, + 3415, + 567, + 1, + 0, + 0, + 0, + 3416, + 3421, + 3, + 580, + 290, + 0, + 3417, + 3418, + 5, + 263, + 0, + 0, + 3418, + 3420, + 3, + 580, + 290, + 0, + 3419, + 3417, + 1, + 0, + 0, + 0, + 3420, + 3423, + 1, + 0, + 0, + 0, + 3421, + 3419, + 1, + 0, + 0, + 0, + 3421, + 3422, + 1, + 0, + 0, + 0, + 3422, + 3425, + 1, + 0, + 0, + 0, + 3423, + 3421, + 1, + 0, + 0, + 0, + 3424, + 3416, + 1, + 0, + 0, + 0, + 3424, + 3425, + 1, + 0, + 0, + 0, + 3425, + 569, + 1, + 0, + 0, + 0, + 3426, + 3446, + 3, + 586, + 293, + 0, + 3427, + 3446, + 3, + 588, + 294, + 0, + 3428, + 3446, + 3, + 578, + 289, + 0, + 3429, + 3446, + 3, + 590, + 295, + 0, + 3430, + 3446, + 3, + 592, + 296, + 0, + 3431, + 3446, + 3, + 336, + 168, + 0, + 3432, + 3446, + 3, + 352, + 176, + 0, + 3433, + 3446, + 3, + 346, + 173, + 0, + 3434, + 3446, + 3, + 342, + 171, + 0, + 3435, + 3446, + 3, + 360, + 180, + 0, + 3436, + 3446, + 3, + 362, + 181, + 0, + 3437, + 3446, + 3, + 326, + 163, + 0, + 3438, + 3446, + 3, + 566, + 283, + 0, + 3439, + 3446, + 3, + 556, + 278, + 0, + 3440, + 3446, + 3, + 564, + 282, + 0, + 3441, + 3446, + 3, + 52, + 26, + 0, + 3442, + 3446, + 3, + 54, + 27, + 0, + 3443, + 3446, + 3, + 598, + 299, + 0, + 3444, + 3446, + 3, + 572, + 286, + 0, + 3445, + 3426, + 1, + 0, + 0, + 0, + 3445, + 3427, + 1, + 0, + 0, + 0, + 3445, + 3428, + 1, + 0, + 0, + 0, + 3445, + 3429, + 1, + 0, + 0, + 0, + 3445, + 3430, + 1, + 0, + 0, + 0, + 3445, + 3431, + 1, + 0, + 0, + 0, + 3445, + 3432, + 1, + 0, + 0, + 0, + 3445, + 3433, + 1, + 0, + 0, + 0, + 3445, + 3434, + 1, + 0, + 0, + 0, + 3445, + 3435, + 1, + 0, + 0, + 0, + 3445, + 3436, + 1, + 0, + 0, + 0, + 3445, + 3437, + 1, + 0, + 0, + 0, + 3445, + 3438, + 1, + 0, + 0, + 0, + 3445, + 3439, + 1, + 0, + 0, + 0, + 3445, + 3440, + 1, + 0, + 0, + 0, + 3445, + 3441, + 1, + 0, + 0, + 0, + 3445, + 3442, + 1, + 0, + 0, + 0, + 3445, + 3443, + 1, + 0, + 0, + 0, + 3445, + 3444, + 1, + 0, + 0, + 0, + 3446, + 571, + 1, + 0, + 0, + 0, + 3447, + 3448, + 5, + 260, + 0, + 0, + 3448, + 3449, + 5, + 265, + 0, + 0, + 3449, + 3462, + 5, + 261, + 0, + 0, + 3450, + 3451, + 5, + 260, + 0, + 0, + 3451, + 3456, + 3, + 576, + 288, + 0, + 3452, + 3453, + 5, + 263, + 0, + 0, + 3453, + 3455, + 3, + 576, + 288, + 0, + 3454, + 3452, + 1, + 0, + 0, + 0, + 3455, + 3458, + 1, + 0, + 0, + 0, + 3456, + 3454, + 1, + 0, + 0, + 0, + 3456, + 3457, + 1, + 0, + 0, + 0, + 3457, + 3459, + 1, + 0, + 0, + 0, + 3458, + 3456, + 1, + 0, + 0, + 0, + 3459, + 3460, + 5, + 261, + 0, + 0, + 3460, + 3462, + 1, + 0, + 0, + 0, + 3461, + 3447, + 1, + 0, + 0, + 0, + 3461, + 3450, + 1, + 0, + 0, + 0, + 3462, + 573, + 1, + 0, + 0, + 0, + 3463, + 3464, + 5, + 256, + 0, + 0, + 3464, + 3465, + 3, + 336, + 168, + 0, + 3465, + 3466, + 5, + 257, + 0, + 0, + 3466, + 3469, + 1, + 0, + 0, + 0, + 3467, + 3469, + 3, + 340, + 170, + 0, + 3468, + 3463, + 1, + 0, + 0, + 0, + 3468, + 3467, + 1, + 0, + 0, + 0, + 3469, + 3517, + 1, + 0, + 0, + 0, + 3470, + 3471, + 5, + 256, + 0, + 0, + 3471, + 3472, + 3, + 346, + 173, + 0, + 3472, + 3473, + 5, + 257, + 0, + 0, + 3473, + 3476, + 1, + 0, + 0, + 0, + 3474, + 3476, + 3, + 350, + 175, + 0, + 3475, + 3470, + 1, + 0, + 0, + 0, + 3475, + 3474, + 1, + 0, + 0, + 0, + 3476, + 3517, + 1, + 0, + 0, + 0, + 3477, + 3478, + 5, + 256, + 0, + 0, + 3478, + 3479, + 3, + 566, + 283, + 0, + 3479, + 3480, + 5, + 257, + 0, + 0, + 3480, + 3483, + 1, + 0, + 0, + 0, + 3481, + 3483, + 3, + 566, + 283, + 0, + 3482, + 3477, + 1, + 0, + 0, + 0, + 3482, + 3481, + 1, + 0, + 0, + 0, + 3483, + 3517, + 1, + 0, + 0, + 0, + 3484, + 3485, + 5, + 256, + 0, + 0, + 3485, + 3486, + 3, + 556, + 278, + 0, + 3486, + 3487, + 5, + 257, + 0, + 0, + 3487, + 3490, + 1, + 0, + 0, + 0, + 3488, + 3490, + 3, + 556, + 278, + 0, + 3489, + 3484, + 1, + 0, + 0, + 0, + 3489, + 3488, + 1, + 0, + 0, + 0, + 3490, + 3517, + 1, + 0, + 0, + 0, + 3491, + 3492, + 5, + 256, + 0, + 0, + 3492, + 3493, + 3, + 572, + 286, + 0, + 3493, + 3494, + 5, + 257, + 0, + 0, + 3494, + 3497, + 1, + 0, + 0, + 0, + 3495, + 3497, + 3, + 572, + 286, + 0, + 3496, + 3491, + 1, + 0, + 0, + 0, + 3496, + 3495, + 1, + 0, + 0, + 0, + 3497, + 3517, + 1, + 0, + 0, + 0, + 3498, + 3499, + 5, + 256, + 0, + 0, + 3499, + 3500, + 3, + 578, + 289, + 0, + 3500, + 3501, + 5, + 257, + 0, + 0, + 3501, + 3504, + 1, + 0, + 0, + 0, + 3502, + 3504, + 3, + 578, + 289, + 0, + 3503, + 3498, + 1, + 0, + 0, + 0, + 3503, + 3502, + 1, + 0, + 0, + 0, + 3504, + 3517, + 1, + 0, + 0, + 0, + 3505, + 3506, + 5, + 256, + 0, + 0, + 3506, + 3507, + 3, + 586, + 293, + 0, + 3507, + 3508, + 5, + 257, + 0, + 0, + 3508, + 3511, + 1, + 0, + 0, + 0, + 3509, + 3511, + 3, + 586, + 293, + 0, + 3510, + 3505, + 1, + 0, + 0, + 0, + 3510, + 3509, + 1, + 0, + 0, + 0, + 3511, + 3517, + 1, + 0, + 0, + 0, + 3512, + 3515, + 3, + 606, + 303, + 0, + 3513, + 3515, + 3, + 600, + 300, + 0, + 3514, + 3512, + 1, + 0, + 0, + 0, + 3514, + 3513, + 1, + 0, + 0, + 0, + 3515, + 3517, + 1, + 0, + 0, + 0, + 3516, + 3468, + 1, + 0, + 0, + 0, + 3516, + 3475, + 1, + 0, + 0, + 0, + 3516, + 3482, + 1, + 0, + 0, + 0, + 3516, + 3489, + 1, + 0, + 0, + 0, + 3516, + 3496, + 1, + 0, + 0, + 0, + 3516, + 3503, + 1, + 0, + 0, + 0, + 3516, + 3510, + 1, + 0, + 0, + 0, + 3516, + 3514, + 1, + 0, + 0, + 0, + 3517, + 575, + 1, + 0, + 0, + 0, + 3518, + 3519, + 3, + 574, + 287, + 0, + 3519, + 3520, + 5, + 265, + 0, + 0, + 3520, + 3521, + 3, + 570, + 285, + 0, + 3521, + 577, + 1, + 0, + 0, + 0, + 3522, + 3523, + 7, + 3, + 0, + 0, + 3523, + 579, + 1, + 0, + 0, + 0, + 3524, + 3525, + 7, + 4, + 0, + 0, + 3525, + 581, + 1, + 0, + 0, + 0, + 3526, + 3527, + 5, + 251, + 0, + 0, + 3527, + 583, + 1, + 0, + 0, + 0, + 3528, + 3532, + 5, + 252, + 0, + 0, + 3529, + 3532, + 3, + 596, + 298, + 0, + 3530, + 3532, + 3, + 594, + 297, + 0, + 3531, + 3528, + 1, + 0, + 0, + 0, + 3531, + 3529, + 1, + 0, + 0, + 0, + 3531, + 3530, + 1, + 0, + 0, + 0, + 3532, + 585, + 1, + 0, + 0, + 0, + 3533, + 3536, + 3, + 582, + 291, + 0, + 3534, + 3536, + 3, + 584, + 292, + 0, + 3535, + 3533, + 1, + 0, + 0, + 0, + 3535, + 3534, + 1, + 0, + 0, + 0, + 3536, + 587, + 1, + 0, + 0, + 0, + 3537, + 3538, + 7, + 5, + 0, + 0, + 3538, + 589, + 1, + 0, + 0, + 0, + 3539, + 3540, + 5, + 45, + 0, + 0, + 3540, + 3541, + 5, + 256, + 0, + 0, + 3541, + 3542, + 3, + 524, + 262, + 0, + 3542, + 3543, + 5, + 257, + 0, + 0, + 3543, + 3556, + 1, + 0, + 0, + 0, + 3544, + 3545, + 5, + 45, + 0, + 0, + 3545, + 3546, + 5, + 256, + 0, + 0, + 3546, + 3556, + 5, + 257, + 0, + 0, + 3547, + 3548, + 5, + 46, + 0, + 0, + 3548, + 3549, + 5, + 256, + 0, + 0, + 3549, + 3550, + 3, + 524, + 262, + 0, + 3550, + 3551, + 5, + 257, + 0, + 0, + 3551, + 3556, + 1, + 0, + 0, + 0, + 3552, + 3553, + 5, + 46, + 0, + 0, + 3553, + 3554, + 5, + 256, + 0, + 0, + 3554, + 3556, + 5, + 257, + 0, + 0, + 3555, + 3539, + 1, + 0, + 0, + 0, + 3555, + 3544, + 1, + 0, + 0, + 0, + 3555, + 3547, + 1, + 0, + 0, + 0, + 3555, + 3552, + 1, + 0, + 0, + 0, + 3556, + 591, + 1, + 0, + 0, + 0, + 3557, + 3558, + 5, + 148, + 0, + 0, + 3558, + 593, + 1, + 0, + 0, + 0, + 3559, + 3560, + 5, + 136, + 0, + 0, + 3560, + 595, + 1, + 0, + 0, + 0, + 3561, + 3562, + 7, + 6, + 0, + 0, + 3562, + 597, + 1, + 0, + 0, + 0, + 3563, + 3564, + 5, + 232, + 0, + 0, + 3564, + 3565, + 5, + 256, + 0, + 0, + 3565, + 3572, + 5, + 257, + 0, + 0, + 3566, + 3567, + 5, + 232, + 0, + 0, + 3567, + 3568, + 5, + 256, + 0, + 0, + 3568, + 3569, + 3, + 578, + 289, + 0, + 3569, + 3570, + 5, + 257, + 0, + 0, + 3570, + 3572, + 1, + 0, + 0, + 0, + 3571, + 3563, + 1, + 0, + 0, + 0, + 3571, + 3566, + 1, + 0, + 0, + 0, + 3572, + 599, + 1, + 0, + 0, + 0, + 3573, + 3574, + 5, + 270, + 0, + 0, + 3574, + 601, + 1, + 0, + 0, + 0, + 3575, + 3576, + 5, + 270, + 0, + 0, + 3576, + 603, + 1, + 0, + 0, + 0, + 3577, + 3578, + 5, + 270, + 0, + 0, + 3578, + 605, + 1, + 0, + 0, + 0, + 3579, + 3580, + 7, + 7, + 0, + 0, + 3580, + 607, + 1, + 0, + 0, + 0, + 211, + 610, + 615, + 619, + 635, + 644, + 654, + 661, + 685, + 697, + 706, + 729, + 747, + 754, + 763, + 779, + 791, + 803, + 818, + 850, + 862, + 895, + 910, + 917, + 1057, + 1079, + 1094, + 1108, + 1130, + 1146, + 1161, + 1236, + 1266, + 1273, + 1319, + 1341, + 1350, + 1374, + 1397, + 1404, + 1413, + 1455, + 1465, + 1477, + 1494, + 1516, + 1526, + 1536, + 1603, + 1610, + 1619, + 1631, + 1635, + 1647, + 1651, + 1663, + 1672, + 1720, + 1738, + 1752, + 1767, + 1777, + 1802, + 1812, + 1832, + 1847, + 1857, + 1911, + 1931, + 1959, + 1982, + 1989, + 2007, + 2025, + 2034, + 2057, + 2075, + 2093, + 2107, + 2117, + 2131, + 2154, + 2177, + 2186, + 2213, + 2227, + 2267, + 2277, + 2299, + 2316, + 2335, + 2342, + 2354, + 2364, + 2379, + 2389, + 2410, + 2426, + 2430, + 2454, + 2460, + 2468, + 2474, + 2478, + 2485, + 2495, + 2504, + 2507, + 2510, + 2514, + 2527, + 2533, + 2537, + 2553, + 2571, + 2585, + 2589, + 2608, + 2614, + 2624, + 2634, + 2652, + 2662, + 2680, + 2726, + 2736, + 2754, + 2777, + 2798, + 2800, + 2811, + 2819, + 2827, + 2837, + 2847, + 2857, + 2867, + 2877, + 2887, + 2899, + 2911, + 2923, + 2931, + 2937, + 2943, + 2951, + 2957, + 2963, + 2973, + 2983, + 2993, + 3003, + 3013, + 3023, + 3033, + 3043, + 3073, + 3094, + 3099, + 3104, + 3109, + 3116, + 3127, + 3131, + 3136, + 3268, + 3272, + 3276, + 3280, + 3284, + 3291, + 3294, + 3298, + 3302, + 3309, + 3312, + 3316, + 3320, + 3324, + 3328, + 3331, + 3338, + 3342, + 3349, + 3353, + 3360, + 3369, + 3372, + 3377, + 3384, + 3389, + 3401, + 3409, + 3412, + 3421, + 3424, + 3445, + 3456, + 3461, + 3468, + 3475, + 3482, + 3489, + 3496, + 3503, + 3510, + 3514, + 3516, + 3531, + 3535, + 3555, + 3571, + ] + + +class GremlinParser(Parser): + grammarFileName = "Gremlin.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] + + sharedContextCache = PredictionContextCache() + + literalNames = [ + "", + "'discard'", + "'addAll'", + "'addE'", + "'addV'", + "'aggregate'", + "'all'", + "'and'", + "'any'", + "'as'", + "'asc'", + "'asDate'", + "'asString'", + "'assign'", + "'barrier'", + "'Barrier'", + "'begin'", + "'between'", + "'both'", + "'BOTH'", + "'bothE'", + "'bothV'", + "'branch'", + "'by'", + "'call'", + "'cap'", + "'Cardinality'", + "'choose'", + "'coalesce'", + "'coin'", + "'Column'", + "'combine'", + "'commit'", + "'component'", + "'concat'", + "'conjoin'", + "'connectedComponent'", + "'ConnectedComponent'", + "'constant'", + "'containing'", + "'count'", + "'cyclicPath'", + "'day'", + "'dateAdd'", + "'dateDiff'", + "'datetime'", + "'DateTime'", + "'decr'", + "'dedup'", + "'desc'", + "'difference'", + "'Direction'", + "'disjunct'", + "'distance'", + "'div'", + "'drop'", + "'DT'", + "'E'", + "'edges'", + "'elementMap'", + "'element'", + "'emit'", + "'endingWith'", + "'eq'", + "'explain'", + "'fail'", + "'false'", + "'filter'", + "'first'", + "'flatMap'", + "'fold'", + "'format'", + "'from'", + "'global'", + "'gt'", + "'gte'", + "'graphml'", + "'graphson'", + "'groupCount'", + "'group'", + "'gryo'", + "'has'", + "'hasId'", + "'hasKey'", + "'hasLabel'", + "'hasNext'", + "'hasNot'", + "'hasValue'", + "'hour'", + "'id'", + "'identity'", + "'ids'", + "'in'", + "'IN'", + "'inE'", + "'includeEdges'", + "'incr'", + "'indexer'", + "'index'", + "'Infinity'", + "'inject'", + "'inside'", + "'intersect'", + "'inV'", + "'IO'", + "'io'", + "'is'", + "'iterate'", + "'key'", + "'keys'", + "'labels'", + "'label'", + "'last'", + "'length'", + "'limit'", + "'list'", + "'local'", + "'loops'", + "'lt'", + "'lte'", + "'lTrim'", + "'map'", + "'match'", + "'math'", + "'max'", + "'maxDistance'", + "'mean'", + "'Merge'", + "'merge'", + "'mergeE'", + "'mergeV'", + "'min'", + "'minute'", + "'minus'", + "'mixed'", + "'mult'", + "'NaN'", + "'negate'", + "'next'", + "'none'", + "'notRegex'", + "'notContaining'", + "'notEndingWith'", + "'notStartingWith'", + "'not'", + "'neq'", + "'new'", + "'normSack'", + "'null'", + "'onCreate'", + "'onMatch'", + "'Operator'", + "'option'", + "'optional'", + "'Order'", + "'order'", + "'or'", + "'otherV'", + "'OUT'", + "'out'", + "'outE'", + "'outside'", + "'outV'", + "'P'", + "'PageRank'", + "'pageRank'", + "'path'", + "'PeerPressure'", + "'peerPressure'", + "'Pick'", + "'Pop'", + "'profile'", + "'project'", + "'properties'", + "'propertyMap'", + "'propertyName'", + "'property'", + "'product'", + "'range'", + "'read'", + "'reader'", + "'ReferenceVertex'", + "'regex'", + "'replace'", + "'repeat'", + "'reverse'", + "'rollback'", + "'rTrim'", + "'sack'", + "'sample'", + "'Scope'", + "'second'", + "'select'", + "'set'", + "'ShortestPath'", + "'shortestPath'", + "'shuffle'", + "'sideEffect'", + "'simplePath'", + "'single'", + "'skip'", + "'split'", + "'startingWith'", + "'store'", + "'subgraph'", + "'substring'", + "'sum'", + "'sumLong'", + "'T'", + "'tail'", + "'target'", + "'TextP'", + "'timeLimit'", + "'times'", + "'to'", + "'toBulkSet'", + "'tokens'", + "'toList'", + "'toLower'", + "'toSet'", + "'toString'", + "'toUpper'", + "'toE'", + "'toV'", + "'tree'", + "'trim'", + "'true'", + "'tryNext'", + "'tx'", + "'unfold'", + "'union'", + "'until'", + "'UUID'", + "'V'", + "'valueMap'", + "'values'", + "'value'", + "'Vertex'", + "'where'", + "'with'", + "'withBulk'", + "'within'", + "'WithOptions'", + "'without'", + "'withoutStrategies'", + "'withPath'", + "'withSack'", + "'withSideEffect'", + "'withStrategies'", + "'write'", + "'writer'", + "", + "", + "", + "", + "", + "'('", + "')'", + "'{'", + "'}'", + "'['", + "']'", + "';'", + "','", + "'.'", + "':'", + "'g'", + "'__'", + ] + + symbolicNames = [ + "", + "", + "K_ADDALL", + "K_ADDE", + "K_ADDV", + "K_AGGREGATE", + "K_ALL", + "K_AND", + "K_ANY", + "K_AS", + "K_ASC", + "K_ASDATE", + "K_ASSTRING", + "K_ASSIGN", + "K_BARRIER", + "K_BARRIERU", + "K_BEGIN", + "K_BETWEEN", + "K_BOTH", + "K_BOTHU", + "K_BOTHE", + "K_BOTHV", + "K_BRANCH", + "K_BY", + "K_CALL", + "K_CAP", + "K_CARDINALITY", + "K_CHOOSE", + "K_COALESCE", + "K_COIN", + "K_COLUMN", + "K_COMBINE", + "K_COMMIT", + "K_COMPONENT", + "K_CONCAT", + "K_CONJOIN", + "K_CONNECTEDCOMPONENT", + "K_CONNECTEDCOMPONENTU", + "K_CONSTANT", + "K_CONTAINING", + "K_COUNT", + "K_CYCLICPATH", + "K_DAY", + "K_DATEADD", + "K_DATEDIFF", + "K_DATETIME", + "K_DATETIMEU", + "K_DECR", + "K_DEDUP", + "K_DESC", + "K_DIFFERENCE", + "K_DIRECTION", + "K_DISJUNCT", + "K_DISTANCE", + "K_DIV", + "K_DROP", + "K_DT", + "K_E", + "K_EDGES", + "K_ELEMENTMAP", + "K_ELEMENT", + "K_EMIT", + "K_ENDINGWITH", + "K_EQ", + "K_EXPLAIN", + "K_FAIL", + "K_FALSE", + "K_FILTER", + "K_FIRST", + "K_FLATMAP", + "K_FOLD", + "K_FORMAT", + "K_FROM", + "K_GLOBAL", + "K_GT", + "K_GTE", + "K_GRAPHML", + "K_GRAPHSON", + "K_GROUPCOUNT", + "K_GROUP", + "K_GRYO", + "K_HAS", + "K_HASID", + "K_HASKEY", + "K_HASLABEL", + "K_HASNEXT", + "K_HASNOT", + "K_HASVALUE", + "K_HOUR", + "K_ID", + "K_IDENTITY", + "K_IDS", + "K_IN", + "K_INU", + "K_INE", + "K_INCLUDEEDGES", + "K_INCR", + "K_INDEXER", + "K_INDEX", + "K_INFINITY", + "K_INJECT", + "K_INSIDE", + "K_INTERSECT", + "K_INV", + "K_IOU", + "K_IO", + "K_IS", + "K_ITERATE", + "K_KEY", + "K_KEYS", + "K_LABELS", + "K_LABEL", + "K_LAST", + "K_LENGTH", + "K_LIMIT", + "K_LIST", + "K_LOCAL", + "K_LOOPS", + "K_LT", + "K_LTE", + "K_LTRIM", + "K_MAP", + "K_MATCH", + "K_MATH", + "K_MAX", + "K_MAXDISTANCE", + "K_MEAN", + "K_MERGEU", + "K_MERGE", + "K_MERGEE", + "K_MERGEV", + "K_MIN", + "K_MINUTE", + "K_MINUS", + "K_MIXED", + "K_MULT", + "K_NAN", + "K_NEGATE", + "K_NEXT", + "K_NONE", + "K_NOTREGEX", + "K_NOTCONTAINING", + "K_NOTENDINGWITH", + "K_NOTSTARTINGWITH", + "K_NOT", + "K_NEQ", + "K_NEW", + "K_NORMSACK", + "K_NULL", + "K_ONCREATE", + "K_ONMATCH", + "K_OPERATOR", + "K_OPTION", + "K_OPTIONAL", + "K_ORDERU", + "K_ORDER", + "K_OR", + "K_OTHERV", + "K_OUTU", + "K_OUT", + "K_OUTE", + "K_OUTSIDE", + "K_OUTV", + "K_P", + "K_PAGERANKU", + "K_PAGERANK", + "K_PATH", + "K_PEERPRESSUREU", + "K_PEERPRESSURE", + "K_PICK", + "K_POP", + "K_PROFILE", + "K_PROJECT", + "K_PROPERTIES", + "K_PROPERTYMAP", + "K_PROPERTYNAME", + "K_PROPERTY", + "K_PRODUCT", + "K_RANGE", + "K_READ", + "K_READER", + "K_REFERENCEVERTEX", + "K_REGEX", + "K_REPLACE", + "K_REPEAT", + "K_REVERSE", + "K_ROLLBACK", + "K_RTRIM", + "K_SACK", + "K_SAMPLE", + "K_SCOPE", + "K_SECOND", + "K_SELECT", + "K_SET", + "K_SHORTESTPATHU", + "K_SHORTESTPATH", + "K_SHUFFLE", + "K_SIDEEFFECT", + "K_SIMPLEPATH", + "K_SINGLE", + "K_SKIP", + "K_SPLIT", + "K_STARTINGWITH", + "K_STORE", + "K_SUBGRAPH", + "K_SUBSTRING", + "K_SUM", + "K_SUMLONG", + "K_T", + "K_TAIL", + "K_TARGET", + "K_TEXTP", + "K_TIMELIMIT", + "K_TIMES", + "K_TO", + "K_TOBULKSET", + "K_TOKENS", + "K_TOLIST", + "K_TOLOWER", + "K_TOSET", + "K_TOSTRING", + "K_TOUPPER", + "K_TOE", + "K_TOV", + "K_TREE", + "K_TRIM", + "K_TRUE", + "K_TRYNEXT", + "K_TX", + "K_UNFOLD", + "K_UNION", + "K_UNTIL", + "K_UUID", + "K_V", + "K_VALUEMAP", + "K_VALUES", + "K_VALUE", + "K_VERTEX", + "K_WHERE", + "K_WITH", + "K_WITHBULK", + "K_WITHIN", + "K_WITHOPTOPTIONS", + "K_WITHOUT", + "K_WITHOUTSTRATEGIES", + "K_WITHPATH", + "K_WITHSACK", + "K_WITHSIDEEFFECT", + "K_WITHSTRATEGIES", + "K_WRITE", + "K_WRITER", + "IntegerLiteral", + "FloatingPointLiteral", + "SignedInfLiteral", + "NonEmptyStringLiteral", + "EmptyStringLiteral", + "LPAREN", + "RPAREN", + "LBRACE", + "RBRACE", + "LBRACK", + "RBRACK", + "SEMI", + "COMMA", + "DOT", + "COLON", + "TRAVERSAL_ROOT", + "ANON_TRAVERSAL_ROOT", + "WS", + "LINE_COMMENT", + "Identifier", + ] + + RULE_queryList = 0 + RULE_query = 1 + RULE_emptyQuery = 2 + RULE_traversalSource = 3 + RULE_transactionPart = 4 + RULE_rootTraversal = 5 + RULE_traversalSourceSelfMethod = 6 + RULE_traversalSourceSelfMethod_withBulk = 7 + RULE_traversalSourceSelfMethod_withPath = 8 + RULE_traversalSourceSelfMethod_withSack = 9 + RULE_traversalSourceSelfMethod_withSideEffect = 10 + RULE_traversalSourceSelfMethod_withStrategies = 11 + RULE_traversalSourceSelfMethod_withoutStrategies = 12 + RULE_traversalSourceSelfMethod_with = 13 + RULE_traversalSourceSpawnMethod = 14 + RULE_traversalSourceSpawnMethod_addE = 15 + RULE_traversalSourceSpawnMethod_addV = 16 + RULE_traversalSourceSpawnMethod_E = 17 + RULE_traversalSourceSpawnMethod_V = 18 + RULE_traversalSourceSpawnMethod_inject = 19 + RULE_traversalSourceSpawnMethod_io = 20 + RULE_traversalSourceSpawnMethod_mergeV = 21 + RULE_traversalSourceSpawnMethod_mergeE = 22 + RULE_traversalSourceSpawnMethod_call = 23 + RULE_traversalSourceSpawnMethod_union = 24 + RULE_chainedTraversal = 25 + RULE_nestedTraversal = 26 + RULE_terminatedTraversal = 27 + RULE_traversalMethod = 28 + RULE_traversalMethod_V = 29 + RULE_traversalMethod_E = 30 + RULE_traversalMethod_addE = 31 + RULE_traversalMethod_addV = 32 + RULE_traversalMethod_aggregate = 33 + RULE_traversalMethod_all = 34 + RULE_traversalMethod_and = 35 + RULE_traversalMethod_any = 36 + RULE_traversalMethod_as = 37 + RULE_traversalMethod_asDate = 38 + RULE_traversalMethod_asString = 39 + RULE_traversalMethod_barrier = 40 + RULE_traversalMethod_both = 41 + RULE_traversalMethod_bothE = 42 + RULE_traversalMethod_bothV = 43 + RULE_traversalMethod_branch = 44 + RULE_traversalMethod_by = 45 + RULE_traversalMethod_call = 46 + RULE_traversalMethod_cap = 47 + RULE_traversalMethod_choose = 48 + RULE_traversalMethod_coalesce = 49 + RULE_traversalMethod_coin = 50 + RULE_traversalMethod_combine = 51 + RULE_traversalMethod_concat = 52 + RULE_traversalMethod_conjoin = 53 + RULE_traversalMethod_connectedComponent = 54 + RULE_traversalMethod_constant = 55 + RULE_traversalMethod_count = 56 + RULE_traversalMethod_cyclicPath = 57 + RULE_traversalMethod_dateAdd = 58 + RULE_traversalMethod_dateDiff = 59 + RULE_traversalMethod_dedup = 60 + RULE_traversalMethod_difference = 61 + RULE_traversalMethod_discard = 62 + RULE_traversalMethod_disjunct = 63 + RULE_traversalMethod_drop = 64 + RULE_traversalMethod_element = 65 + RULE_traversalMethod_elementMap = 66 + RULE_traversalMethod_emit = 67 + RULE_traversalMethod_fail = 68 + RULE_traversalMethod_filter = 69 + RULE_traversalMethod_flatMap = 70 + RULE_traversalMethod_fold = 71 + RULE_traversalMethod_format = 72 + RULE_traversalMethod_from = 73 + RULE_traversalMethod_group = 74 + RULE_traversalMethod_groupCount = 75 + RULE_traversalMethod_has = 76 + RULE_traversalMethod_hasId = 77 + RULE_traversalMethod_hasKey = 78 + RULE_traversalMethod_hasLabel = 79 + RULE_traversalMethod_hasNot = 80 + RULE_traversalMethod_hasValue = 81 + RULE_traversalMethod_id = 82 + RULE_traversalMethod_identity = 83 + RULE_traversalMethod_in = 84 + RULE_traversalMethod_inE = 85 + RULE_traversalMethod_intersect = 86 + RULE_traversalMethod_inV = 87 + RULE_traversalMethod_index = 88 + RULE_traversalMethod_inject = 89 + RULE_traversalMethod_is = 90 + RULE_traversalMethod_key = 91 + RULE_traversalMethod_label = 92 + RULE_traversalMethod_length = 93 + RULE_traversalMethod_limit = 94 + RULE_traversalMethod_local = 95 + RULE_traversalMethod_loops = 96 + RULE_traversalMethod_lTrim = 97 + RULE_traversalMethod_map = 98 + RULE_traversalMethod_match = 99 + RULE_traversalMethod_math = 100 + RULE_traversalMethod_max = 101 + RULE_traversalMethod_mean = 102 + RULE_traversalMethod_merge = 103 + RULE_traversalMethod_mergeV = 104 + RULE_traversalMethod_mergeE = 105 + RULE_traversalMethod_min = 106 + RULE_traversalMethod_none = 107 + RULE_traversalMethod_not = 108 + RULE_traversalMethod_option = 109 + RULE_traversalMethod_optional = 110 + RULE_traversalMethod_or = 111 + RULE_traversalMethod_order = 112 + RULE_traversalMethod_otherV = 113 + RULE_traversalMethod_out = 114 + RULE_traversalMethod_outE = 115 + RULE_traversalMethod_outV = 116 + RULE_traversalMethod_pageRank = 117 + RULE_traversalMethod_path = 118 + RULE_traversalMethod_peerPressure = 119 + RULE_traversalMethod_product = 120 + RULE_traversalMethod_profile = 121 + RULE_traversalMethod_project = 122 + RULE_traversalMethod_properties = 123 + RULE_traversalMethod_property = 124 + RULE_traversalMethod_propertyMap = 125 + RULE_traversalMethod_range = 126 + RULE_traversalMethod_read = 127 + RULE_traversalMethod_repeat = 128 + RULE_traversalMethod_replace = 129 + RULE_traversalMethod_reverse = 130 + RULE_traversalMethod_rTrim = 131 + RULE_traversalMethod_sack = 132 + RULE_traversalMethod_sample = 133 + RULE_traversalMethod_select = 134 + RULE_traversalMethod_shortestPath = 135 + RULE_traversalMethod_sideEffect = 136 + RULE_traversalMethod_simplePath = 137 + RULE_traversalMethod_skip = 138 + RULE_traversalMethod_split = 139 + RULE_traversalMethod_store = 140 + RULE_traversalMethod_subgraph = 141 + RULE_traversalMethod_substring = 142 + RULE_traversalMethod_sum = 143 + RULE_traversalMethod_tail = 144 + RULE_traversalMethod_timeLimit = 145 + RULE_traversalMethod_times = 146 + RULE_traversalMethod_to = 147 + RULE_traversalMethod_toE = 148 + RULE_traversalMethod_toLower = 149 + RULE_traversalMethod_toUpper = 150 + RULE_traversalMethod_toV = 151 + RULE_traversalMethod_tree = 152 + RULE_traversalMethod_trim = 153 + RULE_traversalMethod_unfold = 154 + RULE_traversalMethod_union = 155 + RULE_traversalMethod_until = 156 + RULE_traversalMethod_value = 157 + RULE_traversalMethod_valueMap = 158 + RULE_traversalMethod_values = 159 + RULE_traversalMethod_where = 160 + RULE_traversalMethod_with = 161 + RULE_traversalMethod_write = 162 + RULE_structureVertexLiteral = 163 + RULE_traversalStrategy = 164 + RULE_configuration = 165 + RULE_traversalScope = 166 + RULE_traversalBarrier = 167 + RULE_traversalT = 168 + RULE_traversalTShort = 169 + RULE_traversalTLong = 170 + RULE_traversalMerge = 171 + RULE_traversalOrder = 172 + RULE_traversalDirection = 173 + RULE_traversalDirectionShort = 174 + RULE_traversalDirectionLong = 175 + RULE_traversalCardinality = 176 + RULE_traversalColumn = 177 + RULE_traversalPop = 178 + RULE_traversalOperator = 179 + RULE_traversalPick = 180 + RULE_traversalDT = 181 + RULE_traversalPredicate = 182 + RULE_traversalTerminalMethod = 183 + RULE_traversalSackMethod = 184 + RULE_traversalComparator = 185 + RULE_traversalFunction = 186 + RULE_traversalBiFunction = 187 + RULE_traversalPredicate_eq = 188 + RULE_traversalPredicate_neq = 189 + RULE_traversalPredicate_lt = 190 + RULE_traversalPredicate_lte = 191 + RULE_traversalPredicate_gt = 192 + RULE_traversalPredicate_gte = 193 + RULE_traversalPredicate_inside = 194 + RULE_traversalPredicate_outside = 195 + RULE_traversalPredicate_between = 196 + RULE_traversalPredicate_within = 197 + RULE_traversalPredicate_without = 198 + RULE_traversalPredicate_not = 199 + RULE_traversalPredicate_containing = 200 + RULE_traversalPredicate_notContaining = 201 + RULE_traversalPredicate_startingWith = 202 + RULE_traversalPredicate_notStartingWith = 203 + RULE_traversalPredicate_endingWith = 204 + RULE_traversalPredicate_notEndingWith = 205 + RULE_traversalPredicate_regex = 206 + RULE_traversalPredicate_notRegex = 207 + RULE_traversalTerminalMethod_explain = 208 + RULE_traversalTerminalMethod_hasNext = 209 + RULE_traversalTerminalMethod_iterate = 210 + RULE_traversalTerminalMethod_tryNext = 211 + RULE_traversalTerminalMethod_next = 212 + RULE_traversalTerminalMethod_toList = 213 + RULE_traversalTerminalMethod_toSet = 214 + RULE_traversalTerminalMethod_toBulkSet = 215 + RULE_withOptionKeys = 216 + RULE_connectedComponentConstants = 217 + RULE_pageRankConstants = 218 + RULE_peerPressureConstants = 219 + RULE_shortestPathConstants = 220 + RULE_withOptionsValues = 221 + RULE_ioOptionsKeys = 222 + RULE_ioOptionsValues = 223 + RULE_connectedComponentConstants_component = 224 + RULE_connectedComponentConstants_edges = 225 + RULE_connectedComponentConstants_propertyName = 226 + RULE_pageRankConstants_edges = 227 + RULE_pageRankConstants_times = 228 + RULE_pageRankConstants_propertyName = 229 + RULE_peerPressureConstants_edges = 230 + RULE_peerPressureConstants_times = 231 + RULE_peerPressureConstants_propertyName = 232 + RULE_shortestPathConstants_target = 233 + RULE_shortestPathConstants_edges = 234 + RULE_shortestPathConstants_distance = 235 + RULE_shortestPathConstants_maxDistance = 236 + RULE_shortestPathConstants_includeEdges = 237 + RULE_withOptionsConstants_tokens = 238 + RULE_withOptionsConstants_none = 239 + RULE_withOptionsConstants_ids = 240 + RULE_withOptionsConstants_labels = 241 + RULE_withOptionsConstants_keys = 242 + RULE_withOptionsConstants_values = 243 + RULE_withOptionsConstants_all = 244 + RULE_withOptionsConstants_indexer = 245 + RULE_withOptionsConstants_list = 246 + RULE_withOptionsConstants_map = 247 + RULE_ioOptionsConstants_reader = 248 + RULE_ioOptionsConstants_writer = 249 + RULE_ioOptionsConstants_gryo = 250 + RULE_ioOptionsConstants_graphson = 251 + RULE_ioOptionsConstants_graphml = 252 + RULE_connectedComponentStringConstant = 253 + RULE_pageRankStringConstant = 254 + RULE_peerPressureStringConstant = 255 + RULE_shortestPathStringConstant = 256 + RULE_withOptionsStringConstant = 257 + RULE_ioOptionsStringConstant = 258 + RULE_booleanArgument = 259 + RULE_integerArgument = 260 + RULE_floatArgument = 261 + RULE_stringArgument = 262 + RULE_stringNullableArgument = 263 + RULE_stringNullableArgumentVarargs = 264 + RULE_dateArgument = 265 + RULE_genericArgument = 266 + RULE_genericArgumentVarargs = 267 + RULE_genericMapArgument = 268 + RULE_genericMapNullableArgument = 269 + RULE_nullableGenericLiteralMap = 270 + RULE_structureVertexArgument = 271 + RULE_traversalStrategyVarargs = 272 + RULE_traversalStrategyExpr = 273 + RULE_classTypeList = 274 + RULE_classTypeExpr = 275 + RULE_nestedTraversalList = 276 + RULE_nestedTraversalExpr = 277 + RULE_genericCollectionLiteral = 278 + RULE_genericLiteralVarargs = 279 + RULE_genericLiteralExpr = 280 + RULE_genericMapNullableLiteral = 281 + RULE_genericRangeLiteral = 282 + RULE_genericSetLiteral = 283 + RULE_stringNullableLiteralVarargs = 284 + RULE_genericLiteral = 285 + RULE_genericMapLiteral = 286 + RULE_mapKey = 287 + RULE_mapEntry = 288 + RULE_stringLiteral = 289 + RULE_stringNullableLiteral = 290 + RULE_integerLiteral = 291 + RULE_floatLiteral = 292 + RULE_numericLiteral = 293 + RULE_booleanLiteral = 294 + RULE_dateLiteral = 295 + RULE_nullLiteral = 296 + RULE_nanLiteral = 297 + RULE_infLiteral = 298 + RULE_uuidLiteral = 299 + RULE_nakedKey = 300 + RULE_classType = 301 + RULE_variable = 302 + RULE_keyword = 303 + + ruleNames = [ + "queryList", + "query", + "emptyQuery", + "traversalSource", + "transactionPart", + "rootTraversal", + "traversalSourceSelfMethod", + "traversalSourceSelfMethod_withBulk", + "traversalSourceSelfMethod_withPath", + "traversalSourceSelfMethod_withSack", + "traversalSourceSelfMethod_withSideEffect", + "traversalSourceSelfMethod_withStrategies", + "traversalSourceSelfMethod_withoutStrategies", + "traversalSourceSelfMethod_with", + "traversalSourceSpawnMethod", + "traversalSourceSpawnMethod_addE", + "traversalSourceSpawnMethod_addV", + "traversalSourceSpawnMethod_E", + "traversalSourceSpawnMethod_V", + "traversalSourceSpawnMethod_inject", + "traversalSourceSpawnMethod_io", + "traversalSourceSpawnMethod_mergeV", + "traversalSourceSpawnMethod_mergeE", + "traversalSourceSpawnMethod_call", + "traversalSourceSpawnMethod_union", + "chainedTraversal", + "nestedTraversal", + "terminatedTraversal", + "traversalMethod", + "traversalMethod_V", + "traversalMethod_E", + "traversalMethod_addE", + "traversalMethod_addV", + "traversalMethod_aggregate", + "traversalMethod_all", + "traversalMethod_and", + "traversalMethod_any", + "traversalMethod_as", + "traversalMethod_asDate", + "traversalMethod_asString", + "traversalMethod_barrier", + "traversalMethod_both", + "traversalMethod_bothE", + "traversalMethod_bothV", + "traversalMethod_branch", + "traversalMethod_by", + "traversalMethod_call", + "traversalMethod_cap", + "traversalMethod_choose", + "traversalMethod_coalesce", + "traversalMethod_coin", + "traversalMethod_combine", + "traversalMethod_concat", + "traversalMethod_conjoin", + "traversalMethod_connectedComponent", + "traversalMethod_constant", + "traversalMethod_count", + "traversalMethod_cyclicPath", + "traversalMethod_dateAdd", + "traversalMethod_dateDiff", + "traversalMethod_dedup", + "traversalMethod_difference", + "traversalMethod_discard", + "traversalMethod_disjunct", + "traversalMethod_drop", + "traversalMethod_element", + "traversalMethod_elementMap", + "traversalMethod_emit", + "traversalMethod_fail", + "traversalMethod_filter", + "traversalMethod_flatMap", + "traversalMethod_fold", + "traversalMethod_format", + "traversalMethod_from", + "traversalMethod_group", + "traversalMethod_groupCount", + "traversalMethod_has", + "traversalMethod_hasId", + "traversalMethod_hasKey", + "traversalMethod_hasLabel", + "traversalMethod_hasNot", + "traversalMethod_hasValue", + "traversalMethod_id", + "traversalMethod_identity", + "traversalMethod_in", + "traversalMethod_inE", + "traversalMethod_intersect", + "traversalMethod_inV", + "traversalMethod_index", + "traversalMethod_inject", + "traversalMethod_is", + "traversalMethod_key", + "traversalMethod_label", + "traversalMethod_length", + "traversalMethod_limit", + "traversalMethod_local", + "traversalMethod_loops", + "traversalMethod_lTrim", + "traversalMethod_map", + "traversalMethod_match", + "traversalMethod_math", + "traversalMethod_max", + "traversalMethod_mean", + "traversalMethod_merge", + "traversalMethod_mergeV", + "traversalMethod_mergeE", + "traversalMethod_min", + "traversalMethod_none", + "traversalMethod_not", + "traversalMethod_option", + "traversalMethod_optional", + "traversalMethod_or", + "traversalMethod_order", + "traversalMethod_otherV", + "traversalMethod_out", + "traversalMethod_outE", + "traversalMethod_outV", + "traversalMethod_pageRank", + "traversalMethod_path", + "traversalMethod_peerPressure", + "traversalMethod_product", + "traversalMethod_profile", + "traversalMethod_project", + "traversalMethod_properties", + "traversalMethod_property", + "traversalMethod_propertyMap", + "traversalMethod_range", + "traversalMethod_read", + "traversalMethod_repeat", + "traversalMethod_replace", + "traversalMethod_reverse", + "traversalMethod_rTrim", + "traversalMethod_sack", + "traversalMethod_sample", + "traversalMethod_select", + "traversalMethod_shortestPath", + "traversalMethod_sideEffect", + "traversalMethod_simplePath", + "traversalMethod_skip", + "traversalMethod_split", + "traversalMethod_store", + "traversalMethod_subgraph", + "traversalMethod_substring", + "traversalMethod_sum", + "traversalMethod_tail", + "traversalMethod_timeLimit", + "traversalMethod_times", + "traversalMethod_to", + "traversalMethod_toE", + "traversalMethod_toLower", + "traversalMethod_toUpper", + "traversalMethod_toV", + "traversalMethod_tree", + "traversalMethod_trim", + "traversalMethod_unfold", + "traversalMethod_union", + "traversalMethod_until", + "traversalMethod_value", + "traversalMethod_valueMap", + "traversalMethod_values", + "traversalMethod_where", + "traversalMethod_with", + "traversalMethod_write", + "structureVertexLiteral", + "traversalStrategy", + "configuration", + "traversalScope", + "traversalBarrier", + "traversalT", + "traversalTShort", + "traversalTLong", + "traversalMerge", + "traversalOrder", + "traversalDirection", + "traversalDirectionShort", + "traversalDirectionLong", + "traversalCardinality", + "traversalColumn", + "traversalPop", + "traversalOperator", + "traversalPick", + "traversalDT", + "traversalPredicate", + "traversalTerminalMethod", + "traversalSackMethod", + "traversalComparator", + "traversalFunction", + "traversalBiFunction", + "traversalPredicate_eq", + "traversalPredicate_neq", + "traversalPredicate_lt", + "traversalPredicate_lte", + "traversalPredicate_gt", + "traversalPredicate_gte", + "traversalPredicate_inside", + "traversalPredicate_outside", + "traversalPredicate_between", + "traversalPredicate_within", + "traversalPredicate_without", + "traversalPredicate_not", + "traversalPredicate_containing", + "traversalPredicate_notContaining", + "traversalPredicate_startingWith", + "traversalPredicate_notStartingWith", + "traversalPredicate_endingWith", + "traversalPredicate_notEndingWith", + "traversalPredicate_regex", + "traversalPredicate_notRegex", + "traversalTerminalMethod_explain", + "traversalTerminalMethod_hasNext", + "traversalTerminalMethod_iterate", + "traversalTerminalMethod_tryNext", + "traversalTerminalMethod_next", + "traversalTerminalMethod_toList", + "traversalTerminalMethod_toSet", + "traversalTerminalMethod_toBulkSet", + "withOptionKeys", + "connectedComponentConstants", + "pageRankConstants", + "peerPressureConstants", + "shortestPathConstants", + "withOptionsValues", + "ioOptionsKeys", + "ioOptionsValues", + "connectedComponentConstants_component", + "connectedComponentConstants_edges", + "connectedComponentConstants_propertyName", + "pageRankConstants_edges", + "pageRankConstants_times", + "pageRankConstants_propertyName", + "peerPressureConstants_edges", + "peerPressureConstants_times", + "peerPressureConstants_propertyName", + "shortestPathConstants_target", + "shortestPathConstants_edges", + "shortestPathConstants_distance", + "shortestPathConstants_maxDistance", + "shortestPathConstants_includeEdges", + "withOptionsConstants_tokens", + "withOptionsConstants_none", + "withOptionsConstants_ids", + "withOptionsConstants_labels", + "withOptionsConstants_keys", + "withOptionsConstants_values", + "withOptionsConstants_all", + "withOptionsConstants_indexer", + "withOptionsConstants_list", + "withOptionsConstants_map", + "ioOptionsConstants_reader", + "ioOptionsConstants_writer", + "ioOptionsConstants_gryo", + "ioOptionsConstants_graphson", + "ioOptionsConstants_graphml", + "connectedComponentStringConstant", + "pageRankStringConstant", + "peerPressureStringConstant", + "shortestPathStringConstant", + "withOptionsStringConstant", + "ioOptionsStringConstant", + "booleanArgument", + "integerArgument", + "floatArgument", + "stringArgument", + "stringNullableArgument", + "stringNullableArgumentVarargs", + "dateArgument", + "genericArgument", + "genericArgumentVarargs", + "genericMapArgument", + "genericMapNullableArgument", + "nullableGenericLiteralMap", + "structureVertexArgument", + "traversalStrategyVarargs", + "traversalStrategyExpr", + "classTypeList", + "classTypeExpr", + "nestedTraversalList", + "nestedTraversalExpr", + "genericCollectionLiteral", + "genericLiteralVarargs", + "genericLiteralExpr", + "genericMapNullableLiteral", + "genericRangeLiteral", + "genericSetLiteral", + "stringNullableLiteralVarargs", + "genericLiteral", + "genericMapLiteral", + "mapKey", + "mapEntry", + "stringLiteral", + "stringNullableLiteral", + "integerLiteral", + "floatLiteral", + "numericLiteral", + "booleanLiteral", + "dateLiteral", + "nullLiteral", + "nanLiteral", + "infLiteral", + "uuidLiteral", + "nakedKey", + "classType", + "variable", + "keyword", + ] + + EOF = Token.EOF + T__0 = 1 + K_ADDALL = 2 + K_ADDE = 3 + K_ADDV = 4 + K_AGGREGATE = 5 + K_ALL = 6 + K_AND = 7 + K_ANY = 8 + K_AS = 9 + K_ASC = 10 + K_ASDATE = 11 + K_ASSTRING = 12 + K_ASSIGN = 13 + K_BARRIER = 14 + K_BARRIERU = 15 + K_BEGIN = 16 + K_BETWEEN = 17 + K_BOTH = 18 + K_BOTHU = 19 + K_BOTHE = 20 + K_BOTHV = 21 + K_BRANCH = 22 + K_BY = 23 + K_CALL = 24 + K_CAP = 25 + K_CARDINALITY = 26 + K_CHOOSE = 27 + K_COALESCE = 28 + K_COIN = 29 + K_COLUMN = 30 + K_COMBINE = 31 + K_COMMIT = 32 + K_COMPONENT = 33 + K_CONCAT = 34 + K_CONJOIN = 35 + K_CONNECTEDCOMPONENT = 36 + K_CONNECTEDCOMPONENTU = 37 + K_CONSTANT = 38 + K_CONTAINING = 39 + K_COUNT = 40 + K_CYCLICPATH = 41 + K_DAY = 42 + K_DATEADD = 43 + K_DATEDIFF = 44 + K_DATETIME = 45 + K_DATETIMEU = 46 + K_DECR = 47 + K_DEDUP = 48 + K_DESC = 49 + K_DIFFERENCE = 50 + K_DIRECTION = 51 + K_DISJUNCT = 52 + K_DISTANCE = 53 + K_DIV = 54 + K_DROP = 55 + K_DT = 56 + K_E = 57 + K_EDGES = 58 + K_ELEMENTMAP = 59 + K_ELEMENT = 60 + K_EMIT = 61 + K_ENDINGWITH = 62 + K_EQ = 63 + K_EXPLAIN = 64 + K_FAIL = 65 + K_FALSE = 66 + K_FILTER = 67 + K_FIRST = 68 + K_FLATMAP = 69 + K_FOLD = 70 + K_FORMAT = 71 + K_FROM = 72 + K_GLOBAL = 73 + K_GT = 74 + K_GTE = 75 + K_GRAPHML = 76 + K_GRAPHSON = 77 + K_GROUPCOUNT = 78 + K_GROUP = 79 + K_GRYO = 80 + K_HAS = 81 + K_HASID = 82 + K_HASKEY = 83 + K_HASLABEL = 84 + K_HASNEXT = 85 + K_HASNOT = 86 + K_HASVALUE = 87 + K_HOUR = 88 + K_ID = 89 + K_IDENTITY = 90 + K_IDS = 91 + K_IN = 92 + K_INU = 93 + K_INE = 94 + K_INCLUDEEDGES = 95 + K_INCR = 96 + K_INDEXER = 97 + K_INDEX = 98 + K_INFINITY = 99 + K_INJECT = 100 + K_INSIDE = 101 + K_INTERSECT = 102 + K_INV = 103 + K_IOU = 104 + K_IO = 105 + K_IS = 106 + K_ITERATE = 107 + K_KEY = 108 + K_KEYS = 109 + K_LABELS = 110 + K_LABEL = 111 + K_LAST = 112 + K_LENGTH = 113 + K_LIMIT = 114 + K_LIST = 115 + K_LOCAL = 116 + K_LOOPS = 117 + K_LT = 118 + K_LTE = 119 + K_LTRIM = 120 + K_MAP = 121 + K_MATCH = 122 + K_MATH = 123 + K_MAX = 124 + K_MAXDISTANCE = 125 + K_MEAN = 126 + K_MERGEU = 127 + K_MERGE = 128 + K_MERGEE = 129 + K_MERGEV = 130 + K_MIN = 131 + K_MINUTE = 132 + K_MINUS = 133 + K_MIXED = 134 + K_MULT = 135 + K_NAN = 136 + K_NEGATE = 137 + K_NEXT = 138 + K_NONE = 139 + K_NOTREGEX = 140 + K_NOTCONTAINING = 141 + K_NOTENDINGWITH = 142 + K_NOTSTARTINGWITH = 143 + K_NOT = 144 + K_NEQ = 145 + K_NEW = 146 + K_NORMSACK = 147 + K_NULL = 148 + K_ONCREATE = 149 + K_ONMATCH = 150 + K_OPERATOR = 151 + K_OPTION = 152 + K_OPTIONAL = 153 + K_ORDERU = 154 + K_ORDER = 155 + K_OR = 156 + K_OTHERV = 157 + K_OUTU = 158 + K_OUT = 159 + K_OUTE = 160 + K_OUTSIDE = 161 + K_OUTV = 162 + K_P = 163 + K_PAGERANKU = 164 + K_PAGERANK = 165 + K_PATH = 166 + K_PEERPRESSUREU = 167 + K_PEERPRESSURE = 168 + K_PICK = 169 + K_POP = 170 + K_PROFILE = 171 + K_PROJECT = 172 + K_PROPERTIES = 173 + K_PROPERTYMAP = 174 + K_PROPERTYNAME = 175 + K_PROPERTY = 176 + K_PRODUCT = 177 + K_RANGE = 178 + K_READ = 179 + K_READER = 180 + K_REFERENCEVERTEX = 181 + K_REGEX = 182 + K_REPLACE = 183 + K_REPEAT = 184 + K_REVERSE = 185 + K_ROLLBACK = 186 + K_RTRIM = 187 + K_SACK = 188 + K_SAMPLE = 189 + K_SCOPE = 190 + K_SECOND = 191 + K_SELECT = 192 + K_SET = 193 + K_SHORTESTPATHU = 194 + K_SHORTESTPATH = 195 + K_SHUFFLE = 196 + K_SIDEEFFECT = 197 + K_SIMPLEPATH = 198 + K_SINGLE = 199 + K_SKIP = 200 + K_SPLIT = 201 + K_STARTINGWITH = 202 + K_STORE = 203 + K_SUBGRAPH = 204 + K_SUBSTRING = 205 + K_SUM = 206 + K_SUMLONG = 207 + K_T = 208 + K_TAIL = 209 + K_TARGET = 210 + K_TEXTP = 211 + K_TIMELIMIT = 212 + K_TIMES = 213 + K_TO = 214 + K_TOBULKSET = 215 + K_TOKENS = 216 + K_TOLIST = 217 + K_TOLOWER = 218 + K_TOSET = 219 + K_TOSTRING = 220 + K_TOUPPER = 221 + K_TOE = 222 + K_TOV = 223 + K_TREE = 224 + K_TRIM = 225 + K_TRUE = 226 + K_TRYNEXT = 227 + K_TX = 228 + K_UNFOLD = 229 + K_UNION = 230 + K_UNTIL = 231 + K_UUID = 232 + K_V = 233 + K_VALUEMAP = 234 + K_VALUES = 235 + K_VALUE = 236 + K_VERTEX = 237 + K_WHERE = 238 + K_WITH = 239 + K_WITHBULK = 240 + K_WITHIN = 241 + K_WITHOPTOPTIONS = 242 + K_WITHOUT = 243 + K_WITHOUTSTRATEGIES = 244 + K_WITHPATH = 245 + K_WITHSACK = 246 + K_WITHSIDEEFFECT = 247 + K_WITHSTRATEGIES = 248 + K_WRITE = 249 + K_WRITER = 250 + IntegerLiteral = 251 + FloatingPointLiteral = 252 + SignedInfLiteral = 253 + NonEmptyStringLiteral = 254 + EmptyStringLiteral = 255 + LPAREN = 256 + RPAREN = 257 + LBRACE = 258 + RBRACE = 259 + LBRACK = 260 + RBRACK = 261 + SEMI = 262 + COMMA = 263 + DOT = 264 + COLON = 265 + TRAVERSAL_ROOT = 266 + ANON_TRAVERSAL_ROOT = 267 + WS = 268 + LINE_COMMENT = 269 + Identifier = 270 + + def __init__(self, input: TokenStream, output: TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.13.1") + self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._predicates = None + + class QueryListContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def query(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.QueryContext) + else: + return self.getTypedRuleContext(GremlinParser.QueryContext, i) + + def EOF(self): + return self.getToken(GremlinParser.EOF, 0) + + def SEMI(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.SEMI) + else: + return self.getToken(GremlinParser.SEMI, i) + + def getRuleIndex(self): + return GremlinParser.RULE_queryList + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterQueryList"): + listener.enterQueryList(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitQueryList"): + listener.exitQueryList(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitQueryList"): + return visitor.visitQueryList(self) + else: + return visitor.visitChildren(self) + + def queryList(self): + + localctx = GremlinParser.QueryListContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_queryList) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 608 + self.query(0) + self.state = 615 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 1, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 610 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 262: + self.state = 609 + self.match(GremlinParser.SEMI) + + self.state = 612 + self.query(0) + self.state = 617 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 1, self._ctx) + + self.state = 619 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 262: + self.state = 618 + self.match(GremlinParser.SEMI) + + self.state = 621 + self.match(GremlinParser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class QueryContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalSource(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def transactionPart(self): + return self.getTypedRuleContext(GremlinParser.TransactionPartContext, 0) + + def rootTraversal(self): + return self.getTypedRuleContext(GremlinParser.RootTraversalContext, 0) + + def traversalTerminalMethod(self): + return self.getTypedRuleContext(GremlinParser.TraversalTerminalMethodContext, 0) + + def emptyQuery(self): + return self.getTypedRuleContext(GremlinParser.EmptyQueryContext, 0) + + def query(self): + return self.getTypedRuleContext(GremlinParser.QueryContext, 0) + + def K_TOSTRING(self): + return self.getToken(GremlinParser.K_TOSTRING, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_query + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterQuery"): + listener.enterQuery(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitQuery"): + listener.exitQuery(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitQuery"): + return visitor.visitQuery(self) + else: + return visitor.visitChildren(self) + + def query(self, _p: int = 0): + _parentctx = self._ctx + _parentState = self.state + localctx = GremlinParser.QueryContext(self, self._ctx, _parentState) + _prevctx = localctx + _startState = 2 + self.enterRecursionRule(localctx, 2, self.RULE_query, _p) + try: + self.enterOuterAlt(localctx, 1) + self.state = 635 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 3, self._ctx) + if la_ == 1: + self.state = 624 + self.traversalSource(0) + pass + + elif la_ == 2: + self.state = 625 + self.traversalSource(0) + self.state = 626 + self.match(GremlinParser.DOT) + self.state = 627 + self.transactionPart() + pass + + elif la_ == 3: + self.state = 629 + self.rootTraversal() + pass + + elif la_ == 4: + self.state = 630 + self.rootTraversal() + self.state = 631 + self.match(GremlinParser.DOT) + self.state = 632 + self.traversalTerminalMethod() + pass + + elif la_ == 5: + self.state = 634 + self.emptyQuery() + pass + + self._ctx.stop = self._input.LT(-1) + self.state = 644 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 4, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + if self._parseListeners is not None: + self.triggerExitRuleEvent() + _prevctx = localctx + localctx = GremlinParser.QueryContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_query) + self.state = 637 + if not self.precpred(self._ctx, 2): + from antlr4.error.Errors import FailedPredicateException + + raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") + self.state = 638 + self.match(GremlinParser.DOT) + self.state = 639 + self.match(GremlinParser.K_TOSTRING) + self.state = 640 + self.match(GremlinParser.LPAREN) + self.state = 641 + self.match(GremlinParser.RPAREN) + self.state = 646 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 4, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.unrollRecursionContexts(_parentctx) + return localctx + + class EmptyQueryContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def EmptyStringLiteral(self): + return self.getToken(GremlinParser.EmptyStringLiteral, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_emptyQuery + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterEmptyQuery"): + listener.enterEmptyQuery(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitEmptyQuery"): + listener.exitEmptyQuery(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitEmptyQuery"): + return visitor.visitEmptyQuery(self) + else: + return visitor.visitChildren(self) + + def emptyQuery(self): + + localctx = GremlinParser.EmptyQueryContext(self, self._ctx, self.state) + self.enterRule(localctx, 4, self.RULE_emptyQuery) + try: + self.enterOuterAlt(localctx, 1) + self.state = 647 + self.match(GremlinParser.EmptyStringLiteral) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def TRAVERSAL_ROOT(self): + return self.getToken(GremlinParser.TRAVERSAL_ROOT, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def traversalSourceSelfMethod(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSelfMethodContext, 0) + + def traversalSource(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSource + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSource"): + listener.enterTraversalSource(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSource"): + listener.exitTraversalSource(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSource"): + return visitor.visitTraversalSource(self) + else: + return visitor.visitChildren(self) + + def traversalSource(self, _p: int = 0): + _parentctx = self._ctx + _parentState = self.state + localctx = GremlinParser.TraversalSourceContext(self, self._ctx, _parentState) + _prevctx = localctx + _startState = 6 + self.enterRecursionRule(localctx, 6, self.RULE_traversalSource, _p) + try: + self.enterOuterAlt(localctx, 1) + self.state = 654 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 5, self._ctx) + if la_ == 1: + self.state = 650 + self.match(GremlinParser.TRAVERSAL_ROOT) + pass + + elif la_ == 2: + self.state = 651 + self.match(GremlinParser.TRAVERSAL_ROOT) + self.state = 652 + self.match(GremlinParser.DOT) + self.state = 653 + self.traversalSourceSelfMethod() + pass + + self._ctx.stop = self._input.LT(-1) + self.state = 661 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 6, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + if self._parseListeners is not None: + self.triggerExitRuleEvent() + _prevctx = localctx + localctx = GremlinParser.TraversalSourceContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_traversalSource) + self.state = 656 + if not self.precpred(self._ctx, 1): + from antlr4.error.Errors import FailedPredicateException + + raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") + self.state = 657 + self.match(GremlinParser.DOT) + self.state = 658 + self.traversalSourceSelfMethod() + self.state = 663 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 6, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.unrollRecursionContexts(_parentctx) + return localctx + + class TransactionPartContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_TX(self): + return self.getToken(GremlinParser.K_TX, 0) + + def LPAREN(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.LPAREN) + else: + return self.getToken(GremlinParser.LPAREN, i) + + def RPAREN(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.RPAREN) + else: + return self.getToken(GremlinParser.RPAREN, i) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_BEGIN(self): + return self.getToken(GremlinParser.K_BEGIN, 0) + + def K_COMMIT(self): + return self.getToken(GremlinParser.K_COMMIT, 0) + + def K_ROLLBACK(self): + return self.getToken(GremlinParser.K_ROLLBACK, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_transactionPart + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTransactionPart"): + listener.enterTransactionPart(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTransactionPart"): + listener.exitTransactionPart(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTransactionPart"): + return visitor.visitTransactionPart(self) + else: + return visitor.visitChildren(self) + + def transactionPart(self): + + localctx = GremlinParser.TransactionPartContext(self, self._ctx, self.state) + self.enterRule(localctx, 8, self.RULE_transactionPart) + try: + self.state = 685 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 7, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 664 + self.match(GremlinParser.K_TX) + self.state = 665 + self.match(GremlinParser.LPAREN) + self.state = 666 + self.match(GremlinParser.RPAREN) + self.state = 667 + self.match(GremlinParser.DOT) + self.state = 668 + self.match(GremlinParser.K_BEGIN) + self.state = 669 + self.match(GremlinParser.LPAREN) + self.state = 670 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 671 + self.match(GremlinParser.K_TX) + self.state = 672 + self.match(GremlinParser.LPAREN) + self.state = 673 + self.match(GremlinParser.RPAREN) + self.state = 674 + self.match(GremlinParser.DOT) + self.state = 675 + self.match(GremlinParser.K_COMMIT) + self.state = 676 + self.match(GremlinParser.LPAREN) + self.state = 677 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 678 + self.match(GremlinParser.K_TX) + self.state = 679 + self.match(GremlinParser.LPAREN) + self.state = 680 + self.match(GremlinParser.RPAREN) + self.state = 681 + self.match(GremlinParser.DOT) + self.state = 682 + self.match(GremlinParser.K_ROLLBACK) + self.state = 683 + self.match(GremlinParser.LPAREN) + self.state = 684 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class RootTraversalContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalSource(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceContext, 0) + + def DOT(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.DOT) + else: + return self.getToken(GremlinParser.DOT, i) + + def traversalSourceSpawnMethod(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSpawnMethodContext, 0) + + def chainedTraversal(self): + return self.getTypedRuleContext(GremlinParser.ChainedTraversalContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_rootTraversal + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterRootTraversal"): + listener.enterRootTraversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitRootTraversal"): + listener.exitRootTraversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRootTraversal"): + return visitor.visitRootTraversal(self) + else: + return visitor.visitChildren(self) + + def rootTraversal(self): + + localctx = GremlinParser.RootTraversalContext(self, self._ctx, self.state) + self.enterRule(localctx, 10, self.RULE_rootTraversal) + try: + self.state = 697 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 8, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 687 + self.traversalSource(0) + self.state = 688 + self.match(GremlinParser.DOT) + self.state = 689 + self.traversalSourceSpawnMethod() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 691 + self.traversalSource(0) + self.state = 692 + self.match(GremlinParser.DOT) + self.state = 693 + self.traversalSourceSpawnMethod() + self.state = 694 + self.match(GremlinParser.DOT) + self.state = 695 + self.chainedTraversal(0) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSelfMethodContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalSourceSelfMethod_withBulk(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSelfMethod_withBulkContext, 0) + + def traversalSourceSelfMethod_withPath(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSelfMethod_withPathContext, 0) + + def traversalSourceSelfMethod_withSack(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSelfMethod_withSackContext, 0) + + def traversalSourceSelfMethod_withSideEffect(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSelfMethod_withSideEffectContext, 0) + + def traversalSourceSelfMethod_withStrategies(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSelfMethod_withStrategiesContext, 0) + + def traversalSourceSelfMethod_withoutStrategies(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSelfMethod_withoutStrategiesContext, 0) + + def traversalSourceSelfMethod_with(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSelfMethod_withContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSelfMethod + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSelfMethod"): + listener.enterTraversalSourceSelfMethod(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSelfMethod"): + listener.exitTraversalSourceSelfMethod(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSelfMethod"): + return visitor.visitTraversalSourceSelfMethod(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSelfMethod(self): + + localctx = GremlinParser.TraversalSourceSelfMethodContext(self, self._ctx, self.state) + self.enterRule(localctx, 12, self.RULE_traversalSourceSelfMethod) + try: + self.state = 706 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [240]: + self.enterOuterAlt(localctx, 1) + self.state = 699 + self.traversalSourceSelfMethod_withBulk() + pass + elif token in [245]: + self.enterOuterAlt(localctx, 2) + self.state = 700 + self.traversalSourceSelfMethod_withPath() + pass + elif token in [246]: + self.enterOuterAlt(localctx, 3) + self.state = 701 + self.traversalSourceSelfMethod_withSack() + pass + elif token in [247]: + self.enterOuterAlt(localctx, 4) + self.state = 702 + self.traversalSourceSelfMethod_withSideEffect() + pass + elif token in [248]: + self.enterOuterAlt(localctx, 5) + self.state = 703 + self.traversalSourceSelfMethod_withStrategies() + pass + elif token in [244]: + self.enterOuterAlt(localctx, 6) + self.state = 704 + self.traversalSourceSelfMethod_withoutStrategies() + pass + elif token in [239]: + self.enterOuterAlt(localctx, 7) + self.state = 705 + self.traversalSourceSelfMethod_with() + 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 TraversalSourceSelfMethod_withBulkContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_WITHBULK(self): + return self.getToken(GremlinParser.K_WITHBULK, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def booleanArgument(self): + return self.getTypedRuleContext(GremlinParser.BooleanArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSelfMethod_withBulk + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSelfMethod_withBulk"): + listener.enterTraversalSourceSelfMethod_withBulk(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSelfMethod_withBulk"): + listener.exitTraversalSourceSelfMethod_withBulk(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSelfMethod_withBulk"): + return visitor.visitTraversalSourceSelfMethod_withBulk(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSelfMethod_withBulk(self): + + localctx = GremlinParser.TraversalSourceSelfMethod_withBulkContext(self, self._ctx, self.state) + self.enterRule(localctx, 14, self.RULE_traversalSourceSelfMethod_withBulk) + try: + self.enterOuterAlt(localctx, 1) + self.state = 708 + self.match(GremlinParser.K_WITHBULK) + self.state = 709 + self.match(GremlinParser.LPAREN) + self.state = 710 + self.booleanArgument() + self.state = 711 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSelfMethod_withPathContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_WITHPATH(self): + return self.getToken(GremlinParser.K_WITHPATH, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSelfMethod_withPath + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSelfMethod_withPath"): + listener.enterTraversalSourceSelfMethod_withPath(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSelfMethod_withPath"): + listener.exitTraversalSourceSelfMethod_withPath(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSelfMethod_withPath"): + return visitor.visitTraversalSourceSelfMethod_withPath(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSelfMethod_withPath(self): + + localctx = GremlinParser.TraversalSourceSelfMethod_withPathContext(self, self._ctx, self.state) + self.enterRule(localctx, 16, self.RULE_traversalSourceSelfMethod_withPath) + try: + self.enterOuterAlt(localctx, 1) + self.state = 713 + self.match(GremlinParser.K_WITHPATH) + self.state = 714 + self.match(GremlinParser.LPAREN) + self.state = 715 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSelfMethod_withSackContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_WITHSACK(self): + return self.getToken(GremlinParser.K_WITHSACK, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def traversalBiFunction(self): + return self.getTypedRuleContext(GremlinParser.TraversalBiFunctionContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSelfMethod_withSack + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSelfMethod_withSack"): + listener.enterTraversalSourceSelfMethod_withSack(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSelfMethod_withSack"): + listener.exitTraversalSourceSelfMethod_withSack(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSelfMethod_withSack"): + return visitor.visitTraversalSourceSelfMethod_withSack(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSelfMethod_withSack(self): + + localctx = GremlinParser.TraversalSourceSelfMethod_withSackContext(self, self._ctx, self.state) + self.enterRule(localctx, 18, self.RULE_traversalSourceSelfMethod_withSack) + try: + self.state = 729 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 10, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 717 + self.match(GremlinParser.K_WITHSACK) + self.state = 718 + self.match(GremlinParser.LPAREN) + self.state = 719 + self.genericArgument() + self.state = 720 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 722 + self.match(GremlinParser.K_WITHSACK) + self.state = 723 + self.match(GremlinParser.LPAREN) + self.state = 724 + self.genericArgument() + self.state = 725 + self.match(GremlinParser.COMMA) + self.state = 726 + self.traversalBiFunction() + self.state = 727 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSelfMethod_withSideEffectContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_WITHSIDEEFFECT(self): + return self.getToken(GremlinParser.K_WITHSIDEEFFECT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def traversalBiFunction(self): + return self.getTypedRuleContext(GremlinParser.TraversalBiFunctionContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSelfMethod_withSideEffect + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSelfMethod_withSideEffect"): + listener.enterTraversalSourceSelfMethod_withSideEffect(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSelfMethod_withSideEffect"): + listener.exitTraversalSourceSelfMethod_withSideEffect(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSelfMethod_withSideEffect"): + return visitor.visitTraversalSourceSelfMethod_withSideEffect(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSelfMethod_withSideEffect(self): + + localctx = GremlinParser.TraversalSourceSelfMethod_withSideEffectContext(self, self._ctx, self.state) + self.enterRule(localctx, 20, self.RULE_traversalSourceSelfMethod_withSideEffect) + try: + self.state = 747 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 11, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 731 + self.match(GremlinParser.K_WITHSIDEEFFECT) + self.state = 732 + self.match(GremlinParser.LPAREN) + self.state = 733 + self.stringLiteral() + self.state = 734 + self.match(GremlinParser.COMMA) + self.state = 735 + self.genericArgument() + self.state = 736 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 738 + self.match(GremlinParser.K_WITHSIDEEFFECT) + self.state = 739 + self.match(GremlinParser.LPAREN) + self.state = 740 + self.stringLiteral() + self.state = 741 + self.match(GremlinParser.COMMA) + self.state = 742 + self.genericArgument() + self.state = 743 + self.match(GremlinParser.COMMA) + self.state = 744 + self.traversalBiFunction() + self.state = 745 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSelfMethod_withStrategiesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_WITHSTRATEGIES(self): + return self.getToken(GremlinParser.K_WITHSTRATEGIES, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalStrategy(self): + return self.getTypedRuleContext(GremlinParser.TraversalStrategyContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def traversalStrategyVarargs(self): + return self.getTypedRuleContext(GremlinParser.TraversalStrategyVarargsContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSelfMethod_withStrategies + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSelfMethod_withStrategies"): + listener.enterTraversalSourceSelfMethod_withStrategies(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSelfMethod_withStrategies"): + listener.exitTraversalSourceSelfMethod_withStrategies(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSelfMethod_withStrategies"): + return visitor.visitTraversalSourceSelfMethod_withStrategies(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSelfMethod_withStrategies(self): + + localctx = GremlinParser.TraversalSourceSelfMethod_withStrategiesContext(self, self._ctx, self.state) + self.enterRule(localctx, 22, self.RULE_traversalSourceSelfMethod_withStrategies) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 749 + self.match(GremlinParser.K_WITHSTRATEGIES) + self.state = 750 + self.match(GremlinParser.LPAREN) + self.state = 751 + self.traversalStrategy() + self.state = 754 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 752 + self.match(GremlinParser.COMMA) + self.state = 753 + self.traversalStrategyVarargs() + + self.state = 756 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSelfMethod_withoutStrategiesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_WITHOUTSTRATEGIES(self): + return self.getToken(GremlinParser.K_WITHOUTSTRATEGIES, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def classType(self): + return self.getTypedRuleContext(GremlinParser.ClassTypeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def classTypeList(self): + return self.getTypedRuleContext(GremlinParser.ClassTypeListContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSelfMethod_withoutStrategies + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSelfMethod_withoutStrategies"): + listener.enterTraversalSourceSelfMethod_withoutStrategies(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSelfMethod_withoutStrategies"): + listener.exitTraversalSourceSelfMethod_withoutStrategies(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSelfMethod_withoutStrategies"): + return visitor.visitTraversalSourceSelfMethod_withoutStrategies(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSelfMethod_withoutStrategies(self): + + localctx = GremlinParser.TraversalSourceSelfMethod_withoutStrategiesContext(self, self._ctx, self.state) + self.enterRule(localctx, 24, self.RULE_traversalSourceSelfMethod_withoutStrategies) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 758 + self.match(GremlinParser.K_WITHOUTSTRATEGIES) + self.state = 759 + self.match(GremlinParser.LPAREN) + self.state = 760 + self.classType() + self.state = 763 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 761 + self.match(GremlinParser.COMMA) + self.state = 762 + self.classTypeList() + + self.state = 765 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSelfMethod_withContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_WITH(self): + return self.getToken(GremlinParser.K_WITH, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSelfMethod_with + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSelfMethod_with"): + listener.enterTraversalSourceSelfMethod_with(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSelfMethod_with"): + listener.exitTraversalSourceSelfMethod_with(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSelfMethod_with"): + return visitor.visitTraversalSourceSelfMethod_with(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSelfMethod_with(self): + + localctx = GremlinParser.TraversalSourceSelfMethod_withContext(self, self._ctx, self.state) + self.enterRule(localctx, 26, self.RULE_traversalSourceSelfMethod_with) + try: + self.state = 779 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 14, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 767 + self.match(GremlinParser.K_WITH) + self.state = 768 + self.match(GremlinParser.LPAREN) + self.state = 769 + self.stringLiteral() + self.state = 770 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 772 + self.match(GremlinParser.K_WITH) + self.state = 773 + self.match(GremlinParser.LPAREN) + self.state = 774 + self.stringLiteral() + self.state = 775 + self.match(GremlinParser.COMMA) + self.state = 776 + self.genericArgument() + self.state = 777 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSpawnMethodContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalSourceSpawnMethod_addE(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSpawnMethod_addEContext, 0) + + def traversalSourceSpawnMethod_addV(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSpawnMethod_addVContext, 0) + + def traversalSourceSpawnMethod_E(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSpawnMethod_EContext, 0) + + def traversalSourceSpawnMethod_V(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSpawnMethod_VContext, 0) + + def traversalSourceSpawnMethod_mergeE(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSpawnMethod_mergeEContext, 0) + + def traversalSourceSpawnMethod_mergeV(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSpawnMethod_mergeVContext, 0) + + def traversalSourceSpawnMethod_inject(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSpawnMethod_injectContext, 0) + + def traversalSourceSpawnMethod_io(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSpawnMethod_ioContext, 0) + + def traversalSourceSpawnMethod_call(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSpawnMethod_callContext, 0) + + def traversalSourceSpawnMethod_union(self): + return self.getTypedRuleContext(GremlinParser.TraversalSourceSpawnMethod_unionContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSpawnMethod + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod"): + listener.enterTraversalSourceSpawnMethod(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod"): + listener.exitTraversalSourceSpawnMethod(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod"): + return visitor.visitTraversalSourceSpawnMethod(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSpawnMethod(self): + + localctx = GremlinParser.TraversalSourceSpawnMethodContext(self, self._ctx, self.state) + self.enterRule(localctx, 28, self.RULE_traversalSourceSpawnMethod) + try: + self.state = 791 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [3]: + self.enterOuterAlt(localctx, 1) + self.state = 781 + self.traversalSourceSpawnMethod_addE() + pass + elif token in [4]: + self.enterOuterAlt(localctx, 2) + self.state = 782 + self.traversalSourceSpawnMethod_addV() + pass + elif token in [57]: + self.enterOuterAlt(localctx, 3) + self.state = 783 + self.traversalSourceSpawnMethod_E() + pass + elif token in [233]: + self.enterOuterAlt(localctx, 4) + self.state = 784 + self.traversalSourceSpawnMethod_V() + pass + elif token in [129]: + self.enterOuterAlt(localctx, 5) + self.state = 785 + self.traversalSourceSpawnMethod_mergeE() + pass + elif token in [130]: + self.enterOuterAlt(localctx, 6) + self.state = 786 + self.traversalSourceSpawnMethod_mergeV() + pass + elif token in [100]: + self.enterOuterAlt(localctx, 7) + self.state = 787 + self.traversalSourceSpawnMethod_inject() + pass + elif token in [105]: + self.enterOuterAlt(localctx, 8) + self.state = 788 + self.traversalSourceSpawnMethod_io() + pass + elif token in [24]: + self.enterOuterAlt(localctx, 9) + self.state = 789 + self.traversalSourceSpawnMethod_call() + pass + elif token in [230]: + self.enterOuterAlt(localctx, 10) + self.state = 790 + self.traversalSourceSpawnMethod_union() + 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 TraversalSourceSpawnMethod_addEContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_ADDE(self): + return self.getToken(GremlinParser.K_ADDE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringArgument(self): + return self.getTypedRuleContext(GremlinParser.StringArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSpawnMethod_addE + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_addE"): + listener.enterTraversalSourceSpawnMethod_addE(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_addE"): + listener.exitTraversalSourceSpawnMethod_addE(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_addE"): + return visitor.visitTraversalSourceSpawnMethod_addE(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSpawnMethod_addE(self): + + localctx = GremlinParser.TraversalSourceSpawnMethod_addEContext(self, self._ctx, self.state) + self.enterRule(localctx, 30, self.RULE_traversalSourceSpawnMethod_addE) + try: + self.state = 803 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 16, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 793 + self.match(GremlinParser.K_ADDE) + self.state = 794 + self.match(GremlinParser.LPAREN) + self.state = 795 + self.stringArgument() + self.state = 796 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 798 + self.match(GremlinParser.K_ADDE) + self.state = 799 + self.match(GremlinParser.LPAREN) + self.state = 800 + self.nestedTraversal() + self.state = 801 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSpawnMethod_addVContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_ADDV(self): + return self.getToken(GremlinParser.K_ADDV, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def stringArgument(self): + return self.getTypedRuleContext(GremlinParser.StringArgumentContext, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSpawnMethod_addV + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_addV"): + listener.enterTraversalSourceSpawnMethod_addV(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_addV"): + listener.exitTraversalSourceSpawnMethod_addV(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_addV"): + return visitor.visitTraversalSourceSpawnMethod_addV(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSpawnMethod_addV(self): + + localctx = GremlinParser.TraversalSourceSpawnMethod_addVContext(self, self._ctx, self.state) + self.enterRule(localctx, 32, self.RULE_traversalSourceSpawnMethod_addV) + try: + self.state = 818 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 17, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 805 + self.match(GremlinParser.K_ADDV) + self.state = 806 + self.match(GremlinParser.LPAREN) + self.state = 807 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 808 + self.match(GremlinParser.K_ADDV) + self.state = 809 + self.match(GremlinParser.LPAREN) + self.state = 810 + self.stringArgument() + self.state = 811 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 813 + self.match(GremlinParser.K_ADDV) + self.state = 814 + self.match(GremlinParser.LPAREN) + self.state = 815 + self.nestedTraversal() + self.state = 816 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSpawnMethod_EContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_E(self): + return self.getToken(GremlinParser.K_E, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSpawnMethod_E + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_E"): + listener.enterTraversalSourceSpawnMethod_E(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_E"): + listener.exitTraversalSourceSpawnMethod_E(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_E"): + return visitor.visitTraversalSourceSpawnMethod_E(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSpawnMethod_E(self): + + localctx = GremlinParser.TraversalSourceSpawnMethod_EContext(self, self._ctx, self.state) + self.enterRule(localctx, 34, self.RULE_traversalSourceSpawnMethod_E) + try: + self.enterOuterAlt(localctx, 1) + self.state = 820 + self.match(GremlinParser.K_E) + self.state = 821 + self.match(GremlinParser.LPAREN) + self.state = 822 + self.genericArgumentVarargs() + self.state = 823 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSpawnMethod_VContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_V(self): + return self.getToken(GremlinParser.K_V, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSpawnMethod_V + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_V"): + listener.enterTraversalSourceSpawnMethod_V(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_V"): + listener.exitTraversalSourceSpawnMethod_V(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_V"): + return visitor.visitTraversalSourceSpawnMethod_V(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSpawnMethod_V(self): + + localctx = GremlinParser.TraversalSourceSpawnMethod_VContext(self, self._ctx, self.state) + self.enterRule(localctx, 36, self.RULE_traversalSourceSpawnMethod_V) + try: + self.enterOuterAlt(localctx, 1) + self.state = 825 + self.match(GremlinParser.K_V) + self.state = 826 + self.match(GremlinParser.LPAREN) + self.state = 827 + self.genericArgumentVarargs() + self.state = 828 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSpawnMethod_injectContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_INJECT(self): + return self.getToken(GremlinParser.K_INJECT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSpawnMethod_inject + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_inject"): + listener.enterTraversalSourceSpawnMethod_inject(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_inject"): + listener.exitTraversalSourceSpawnMethod_inject(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_inject"): + return visitor.visitTraversalSourceSpawnMethod_inject(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSpawnMethod_inject(self): + + localctx = GremlinParser.TraversalSourceSpawnMethod_injectContext(self, self._ctx, self.state) + self.enterRule(localctx, 38, self.RULE_traversalSourceSpawnMethod_inject) + try: + self.enterOuterAlt(localctx, 1) + self.state = 830 + self.match(GremlinParser.K_INJECT) + self.state = 831 + self.match(GremlinParser.LPAREN) + self.state = 832 + self.genericArgumentVarargs() + self.state = 833 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSpawnMethod_ioContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_IO(self): + return self.getToken(GremlinParser.K_IO, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSpawnMethod_io + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_io"): + listener.enterTraversalSourceSpawnMethod_io(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_io"): + listener.exitTraversalSourceSpawnMethod_io(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_io"): + return visitor.visitTraversalSourceSpawnMethod_io(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSpawnMethod_io(self): + + localctx = GremlinParser.TraversalSourceSpawnMethod_ioContext(self, self._ctx, self.state) + self.enterRule(localctx, 40, self.RULE_traversalSourceSpawnMethod_io) + try: + self.enterOuterAlt(localctx, 1) + self.state = 835 + self.match(GremlinParser.K_IO) + self.state = 836 + self.match(GremlinParser.LPAREN) + self.state = 837 + self.stringLiteral() + self.state = 838 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSpawnMethod_mergeVContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSpawnMethod_mergeV + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalSourceSpawnMethod_mergeV_TraversalContext(TraversalSourceSpawnMethod_mergeVContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a GremlinParser.TraversalSourceSpawnMethod_mergeVContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MERGEV(self): + return self.getToken(GremlinParser.K_MERGEV, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_mergeV_Traversal"): + listener.enterTraversalSourceSpawnMethod_mergeV_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_mergeV_Traversal"): + listener.exitTraversalSourceSpawnMethod_mergeV_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_mergeV_Traversal"): + return visitor.visitTraversalSourceSpawnMethod_mergeV_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalSourceSpawnMethod_mergeV_MapContext(TraversalSourceSpawnMethod_mergeVContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a GremlinParser.TraversalSourceSpawnMethod_mergeVContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MERGEV(self): + return self.getToken(GremlinParser.K_MERGEV, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericMapNullableArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericMapNullableArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_mergeV_Map"): + listener.enterTraversalSourceSpawnMethod_mergeV_Map(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_mergeV_Map"): + listener.exitTraversalSourceSpawnMethod_mergeV_Map(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_mergeV_Map"): + return visitor.visitTraversalSourceSpawnMethod_mergeV_Map(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSpawnMethod_mergeV(self): + + localctx = GremlinParser.TraversalSourceSpawnMethod_mergeVContext(self, self._ctx, self.state) + self.enterRule(localctx, 42, self.RULE_traversalSourceSpawnMethod_mergeV) + try: + self.state = 850 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 18, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalSourceSpawnMethod_mergeV_MapContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 840 + self.match(GremlinParser.K_MERGEV) + self.state = 841 + self.match(GremlinParser.LPAREN) + self.state = 842 + self.genericMapNullableArgument() + self.state = 843 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalSourceSpawnMethod_mergeV_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 845 + self.match(GremlinParser.K_MERGEV) + self.state = 846 + self.match(GremlinParser.LPAREN) + self.state = 847 + self.nestedTraversal() + self.state = 848 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSpawnMethod_mergeEContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSpawnMethod_mergeE + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalSourceSpawnMethod_mergeE_TraversalContext(TraversalSourceSpawnMethod_mergeEContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a GremlinParser.TraversalSourceSpawnMethod_mergeEContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MERGEE(self): + return self.getToken(GremlinParser.K_MERGEE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_mergeE_Traversal"): + listener.enterTraversalSourceSpawnMethod_mergeE_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_mergeE_Traversal"): + listener.exitTraversalSourceSpawnMethod_mergeE_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_mergeE_Traversal"): + return visitor.visitTraversalSourceSpawnMethod_mergeE_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalSourceSpawnMethod_mergeE_MapContext(TraversalSourceSpawnMethod_mergeEContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a GremlinParser.TraversalSourceSpawnMethod_mergeEContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MERGEE(self): + return self.getToken(GremlinParser.K_MERGEE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericMapNullableArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericMapNullableArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_mergeE_Map"): + listener.enterTraversalSourceSpawnMethod_mergeE_Map(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_mergeE_Map"): + listener.exitTraversalSourceSpawnMethod_mergeE_Map(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_mergeE_Map"): + return visitor.visitTraversalSourceSpawnMethod_mergeE_Map(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSpawnMethod_mergeE(self): + + localctx = GremlinParser.TraversalSourceSpawnMethod_mergeEContext(self, self._ctx, self.state) + self.enterRule(localctx, 44, self.RULE_traversalSourceSpawnMethod_mergeE) + try: + self.state = 862 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 19, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalSourceSpawnMethod_mergeE_MapContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 852 + self.match(GremlinParser.K_MERGEE) + self.state = 853 + self.match(GremlinParser.LPAREN) + self.state = 854 + self.genericMapNullableArgument() + self.state = 855 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalSourceSpawnMethod_mergeE_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 857 + self.match(GremlinParser.K_MERGEE) + self.state = 858 + self.match(GremlinParser.LPAREN) + self.state = 859 + self.nestedTraversal() + self.state = 860 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSpawnMethod_callContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSpawnMethod_call + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalSourceSpawnMethod_call_emptyContext(TraversalSourceSpawnMethod_callContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a GremlinParser.TraversalSourceSpawnMethod_callContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CALL(self): + return self.getToken(GremlinParser.K_CALL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_call_empty"): + listener.enterTraversalSourceSpawnMethod_call_empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_call_empty"): + listener.exitTraversalSourceSpawnMethod_call_empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_call_empty"): + return visitor.visitTraversalSourceSpawnMethod_call_empty(self) + else: + return visitor.visitChildren(self) + + class TraversalSourceSpawnMethod_call_string_traversalContext(TraversalSourceSpawnMethod_callContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a GremlinParser.TraversalSourceSpawnMethod_callContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CALL(self): + return self.getToken(GremlinParser.K_CALL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_call_string_traversal"): + listener.enterTraversalSourceSpawnMethod_call_string_traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_call_string_traversal"): + listener.exitTraversalSourceSpawnMethod_call_string_traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_call_string_traversal"): + return visitor.visitTraversalSourceSpawnMethod_call_string_traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalSourceSpawnMethod_call_string_mapContext(TraversalSourceSpawnMethod_callContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a GremlinParser.TraversalSourceSpawnMethod_callContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CALL(self): + return self.getToken(GremlinParser.K_CALL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def genericMapArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericMapArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_call_string_map"): + listener.enterTraversalSourceSpawnMethod_call_string_map(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_call_string_map"): + listener.exitTraversalSourceSpawnMethod_call_string_map(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_call_string_map"): + return visitor.visitTraversalSourceSpawnMethod_call_string_map(self) + else: + return visitor.visitChildren(self) + + class TraversalSourceSpawnMethod_call_stringContext(TraversalSourceSpawnMethod_callContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a GremlinParser.TraversalSourceSpawnMethod_callContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CALL(self): + return self.getToken(GremlinParser.K_CALL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_call_string"): + listener.enterTraversalSourceSpawnMethod_call_string(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_call_string"): + listener.exitTraversalSourceSpawnMethod_call_string(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_call_string"): + return visitor.visitTraversalSourceSpawnMethod_call_string(self) + else: + return visitor.visitChildren(self) + + class TraversalSourceSpawnMethod_call_string_map_traversalContext(TraversalSourceSpawnMethod_callContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a GremlinParser.TraversalSourceSpawnMethod_callContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CALL(self): + return self.getToken(GremlinParser.K_CALL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def genericMapArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericMapArgumentContext, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_call_string_map_traversal"): + listener.enterTraversalSourceSpawnMethod_call_string_map_traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_call_string_map_traversal"): + listener.exitTraversalSourceSpawnMethod_call_string_map_traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_call_string_map_traversal"): + return visitor.visitTraversalSourceSpawnMethod_call_string_map_traversal(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSpawnMethod_call(self): + + localctx = GremlinParser.TraversalSourceSpawnMethod_callContext(self, self._ctx, self.state) + self.enterRule(localctx, 46, self.RULE_traversalSourceSpawnMethod_call) + try: + self.state = 895 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 20, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalSourceSpawnMethod_call_emptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 864 + self.match(GremlinParser.K_CALL) + self.state = 865 + self.match(GremlinParser.LPAREN) + self.state = 866 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalSourceSpawnMethod_call_stringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 867 + self.match(GremlinParser.K_CALL) + self.state = 868 + self.match(GremlinParser.LPAREN) + self.state = 869 + self.stringLiteral() + self.state = 870 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalSourceSpawnMethod_call_string_mapContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 872 + self.match(GremlinParser.K_CALL) + self.state = 873 + self.match(GremlinParser.LPAREN) + self.state = 874 + self.stringLiteral() + self.state = 875 + self.match(GremlinParser.COMMA) + self.state = 876 + self.genericMapArgument() + self.state = 877 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 4: + localctx = GremlinParser.TraversalSourceSpawnMethod_call_string_traversalContext(self, localctx) + self.enterOuterAlt(localctx, 4) + self.state = 879 + self.match(GremlinParser.K_CALL) + self.state = 880 + self.match(GremlinParser.LPAREN) + self.state = 881 + self.stringLiteral() + self.state = 882 + self.match(GremlinParser.COMMA) + self.state = 883 + self.nestedTraversal() + self.state = 884 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 5: + localctx = GremlinParser.TraversalSourceSpawnMethod_call_string_map_traversalContext(self, localctx) + self.enterOuterAlt(localctx, 5) + self.state = 886 + self.match(GremlinParser.K_CALL) + self.state = 887 + self.match(GremlinParser.LPAREN) + self.state = 888 + self.stringLiteral() + self.state = 889 + self.match(GremlinParser.COMMA) + self.state = 890 + self.genericMapArgument() + self.state = 891 + self.match(GremlinParser.COMMA) + self.state = 892 + self.nestedTraversal() + self.state = 893 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalSourceSpawnMethod_unionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_UNION(self): + return self.getToken(GremlinParser.K_UNION, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversalList(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalListContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSourceSpawnMethod_union + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSourceSpawnMethod_union"): + listener.enterTraversalSourceSpawnMethod_union(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSourceSpawnMethod_union"): + listener.exitTraversalSourceSpawnMethod_union(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSourceSpawnMethod_union"): + return visitor.visitTraversalSourceSpawnMethod_union(self) + else: + return visitor.visitChildren(self) + + def traversalSourceSpawnMethod_union(self): + + localctx = GremlinParser.TraversalSourceSpawnMethod_unionContext(self, self._ctx, self.state) + self.enterRule(localctx, 48, self.RULE_traversalSourceSpawnMethod_union) + try: + self.enterOuterAlt(localctx, 1) + self.state = 897 + self.match(GremlinParser.K_UNION) + self.state = 898 + self.match(GremlinParser.LPAREN) + self.state = 899 + self.nestedTraversalList() + self.state = 900 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ChainedTraversalContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalMethod(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethodContext, 0) + + def chainedTraversal(self): + return self.getTypedRuleContext(GremlinParser.ChainedTraversalContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_chainedTraversal + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterChainedTraversal"): + listener.enterChainedTraversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitChainedTraversal"): + listener.exitChainedTraversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitChainedTraversal"): + return visitor.visitChainedTraversal(self) + else: + return visitor.visitChildren(self) + + def chainedTraversal(self, _p: int = 0): + _parentctx = self._ctx + _parentState = self.state + localctx = GremlinParser.ChainedTraversalContext(self, self._ctx, _parentState) + _prevctx = localctx + _startState = 50 + self.enterRecursionRule(localctx, 50, self.RULE_chainedTraversal, _p) + try: + self.enterOuterAlt(localctx, 1) + self.state = 903 + self.traversalMethod() + self._ctx.stop = self._input.LT(-1) + self.state = 910 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 21, self._ctx) + while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER: + if _alt == 1: + if self._parseListeners is not None: + self.triggerExitRuleEvent() + _prevctx = localctx + localctx = GremlinParser.ChainedTraversalContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_chainedTraversal) + self.state = 905 + if not self.precpred(self._ctx, 1): + from antlr4.error.Errors import FailedPredicateException + + raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") + self.state = 906 + self.match(GremlinParser.DOT) + self.state = 907 + self.traversalMethod() + self.state = 912 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 21, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.unrollRecursionContexts(_parentctx) + return localctx + + class NestedTraversalContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def chainedTraversal(self): + return self.getTypedRuleContext(GremlinParser.ChainedTraversalContext, 0) + + def ANON_TRAVERSAL_ROOT(self): + return self.getToken(GremlinParser.ANON_TRAVERSAL_ROOT, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_nestedTraversal + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNestedTraversal"): + listener.enterNestedTraversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNestedTraversal"): + listener.exitNestedTraversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNestedTraversal"): + return visitor.visitNestedTraversal(self) + else: + return visitor.visitChildren(self) + + def nestedTraversal(self): + + localctx = GremlinParser.NestedTraversalContext(self, self._ctx, self.state) + self.enterRule(localctx, 52, self.RULE_nestedTraversal) + try: + self.state = 917 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [ + 1, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 11, + 12, + 14, + 18, + 20, + 21, + 22, + 23, + 24, + 25, + 27, + 28, + 29, + 31, + 34, + 35, + 36, + 38, + 40, + 41, + 43, + 44, + 48, + 50, + 52, + 55, + 57, + 59, + 60, + 61, + 65, + 67, + 69, + 70, + 71, + 72, + 78, + 79, + 81, + 82, + 83, + 84, + 86, + 87, + 89, + 90, + 92, + 94, + 98, + 100, + 102, + 103, + 106, + 108, + 111, + 113, + 114, + 116, + 117, + 120, + 121, + 122, + 123, + 124, + 126, + 128, + 129, + 130, + 131, + 139, + 144, + 152, + 153, + 155, + 156, + 157, + 159, + 160, + 162, + 165, + 166, + 168, + 171, + 172, + 173, + 174, + 176, + 177, + 178, + 179, + 183, + 184, + 185, + 187, + 188, + 189, + 192, + 195, + 197, + 198, + 200, + 201, + 203, + 204, + 205, + 206, + 209, + 212, + 213, + 214, + 218, + 221, + 222, + 223, + 224, + 225, + 229, + 230, + 231, + 233, + 234, + 235, + 236, + 238, + 239, + 249, + ]: + self.enterOuterAlt(localctx, 1) + self.state = 913 + self.chainedTraversal(0) + pass + elif token in [267]: + self.enterOuterAlt(localctx, 2) + self.state = 914 + self.match(GremlinParser.ANON_TRAVERSAL_ROOT) + self.state = 915 + self.match(GremlinParser.DOT) + self.state = 916 + self.chainedTraversal(0) + 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 TerminatedTraversalContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def rootTraversal(self): + return self.getTypedRuleContext(GremlinParser.RootTraversalContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def traversalTerminalMethod(self): + return self.getTypedRuleContext(GremlinParser.TraversalTerminalMethodContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_terminatedTraversal + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTerminatedTraversal"): + listener.enterTerminatedTraversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTerminatedTraversal"): + listener.exitTerminatedTraversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTerminatedTraversal"): + return visitor.visitTerminatedTraversal(self) + else: + return visitor.visitChildren(self) + + def terminatedTraversal(self): + + localctx = GremlinParser.TerminatedTraversalContext(self, self._ctx, self.state) + self.enterRule(localctx, 54, self.RULE_terminatedTraversal) + try: + self.enterOuterAlt(localctx, 1) + self.state = 919 + self.rootTraversal() + self.state = 920 + self.match(GremlinParser.DOT) + self.state = 921 + self.traversalTerminalMethod() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethodContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalMethod_V(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_VContext, 0) + + def traversalMethod_E(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_EContext, 0) + + def traversalMethod_addE(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_addEContext, 0) + + def traversalMethod_addV(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_addVContext, 0) + + def traversalMethod_mergeE(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_mergeEContext, 0) + + def traversalMethod_mergeV(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_mergeVContext, 0) + + def traversalMethod_aggregate(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_aggregateContext, 0) + + def traversalMethod_all(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_allContext, 0) + + def traversalMethod_and(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_andContext, 0) + + def traversalMethod_any(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_anyContext, 0) + + def traversalMethod_as(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_asContext, 0) + + def traversalMethod_barrier(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_barrierContext, 0) + + def traversalMethod_both(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_bothContext, 0) + + def traversalMethod_bothE(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_bothEContext, 0) + + def traversalMethod_bothV(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_bothVContext, 0) + + def traversalMethod_branch(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_branchContext, 0) + + def traversalMethod_by(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_byContext, 0) + + def traversalMethod_cap(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_capContext, 0) + + def traversalMethod_choose(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_chooseContext, 0) + + def traversalMethod_coalesce(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_coalesceContext, 0) + + def traversalMethod_coin(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_coinContext, 0) + + def traversalMethod_conjoin(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_conjoinContext, 0) + + def traversalMethod_connectedComponent(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_connectedComponentContext, 0) + + def traversalMethod_constant(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_constantContext, 0) + + def traversalMethod_count(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_countContext, 0) + + def traversalMethod_cyclicPath(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_cyclicPathContext, 0) + + def traversalMethod_dedup(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_dedupContext, 0) + + def traversalMethod_difference(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_differenceContext, 0) + + def traversalMethod_discard(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_discardContext, 0) + + def traversalMethod_disjunct(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_disjunctContext, 0) + + def traversalMethod_drop(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_dropContext, 0) + + def traversalMethod_elementMap(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_elementMapContext, 0) + + def traversalMethod_emit(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_emitContext, 0) + + def traversalMethod_filter(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_filterContext, 0) + + def traversalMethod_flatMap(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_flatMapContext, 0) + + def traversalMethod_fold(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_foldContext, 0) + + def traversalMethod_from(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_fromContext, 0) + + def traversalMethod_group(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_groupContext, 0) + + def traversalMethod_groupCount(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_groupCountContext, 0) + + def traversalMethod_has(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_hasContext, 0) + + def traversalMethod_hasId(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_hasIdContext, 0) + + def traversalMethod_hasKey(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_hasKeyContext, 0) + + def traversalMethod_hasLabel(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_hasLabelContext, 0) + + def traversalMethod_hasNot(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_hasNotContext, 0) + + def traversalMethod_hasValue(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_hasValueContext, 0) + + def traversalMethod_id(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_idContext, 0) + + def traversalMethod_identity(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_identityContext, 0) + + def traversalMethod_in(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_inContext, 0) + + def traversalMethod_inE(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_inEContext, 0) + + def traversalMethod_intersect(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_intersectContext, 0) + + def traversalMethod_inV(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_inVContext, 0) + + def traversalMethod_index(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_indexContext, 0) + + def traversalMethod_inject(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_injectContext, 0) + + def traversalMethod_is(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_isContext, 0) + + def traversalMethod_key(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_keyContext, 0) + + def traversalMethod_label(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_labelContext, 0) + + def traversalMethod_limit(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_limitContext, 0) + + def traversalMethod_local(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_localContext, 0) + + def traversalMethod_loops(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_loopsContext, 0) + + def traversalMethod_map(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_mapContext, 0) + + def traversalMethod_match(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_matchContext, 0) + + def traversalMethod_math(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_mathContext, 0) + + def traversalMethod_max(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_maxContext, 0) + + def traversalMethod_mean(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_meanContext, 0) + + def traversalMethod_min(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_minContext, 0) + + def traversalMethod_none(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_noneContext, 0) + + def traversalMethod_not(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_notContext, 0) + + def traversalMethod_option(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_optionContext, 0) + + def traversalMethod_optional(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_optionalContext, 0) + + def traversalMethod_or(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_orContext, 0) + + def traversalMethod_order(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_orderContext, 0) + + def traversalMethod_otherV(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_otherVContext, 0) + + def traversalMethod_out(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_outContext, 0) + + def traversalMethod_outE(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_outEContext, 0) + + def traversalMethod_outV(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_outVContext, 0) + + def traversalMethod_pageRank(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_pageRankContext, 0) + + def traversalMethod_path(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_pathContext, 0) + + def traversalMethod_peerPressure(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_peerPressureContext, 0) + + def traversalMethod_profile(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_profileContext, 0) + + def traversalMethod_project(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_projectContext, 0) + + def traversalMethod_properties(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_propertiesContext, 0) + + def traversalMethod_property(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_propertyContext, 0) + + def traversalMethod_propertyMap(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_propertyMapContext, 0) + + def traversalMethod_range(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_rangeContext, 0) + + def traversalMethod_read(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_readContext, 0) + + def traversalMethod_repeat(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_repeatContext, 0) + + def traversalMethod_sack(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_sackContext, 0) + + def traversalMethod_sample(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_sampleContext, 0) + + def traversalMethod_select(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_selectContext, 0) + + def traversalMethod_combine(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_combineContext, 0) + + def traversalMethod_product(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_productContext, 0) + + def traversalMethod_merge(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_mergeContext, 0) + + def traversalMethod_shortestPath(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_shortestPathContext, 0) + + def traversalMethod_sideEffect(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_sideEffectContext, 0) + + def traversalMethod_simplePath(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_simplePathContext, 0) + + def traversalMethod_skip(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_skipContext, 0) + + def traversalMethod_store(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_storeContext, 0) + + def traversalMethod_subgraph(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_subgraphContext, 0) + + def traversalMethod_sum(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_sumContext, 0) + + def traversalMethod_tail(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_tailContext, 0) + + def traversalMethod_fail(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_failContext, 0) + + def traversalMethod_timeLimit(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_timeLimitContext, 0) + + def traversalMethod_times(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_timesContext, 0) + + def traversalMethod_to(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_toContext, 0) + + def traversalMethod_toE(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_toEContext, 0) + + def traversalMethod_toV(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_toVContext, 0) + + def traversalMethod_tree(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_treeContext, 0) + + def traversalMethod_unfold(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_unfoldContext, 0) + + def traversalMethod_union(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_unionContext, 0) + + def traversalMethod_until(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_untilContext, 0) + + def traversalMethod_value(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_valueContext, 0) + + def traversalMethod_valueMap(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_valueMapContext, 0) + + def traversalMethod_values(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_valuesContext, 0) + + def traversalMethod_where(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_whereContext, 0) + + def traversalMethod_with(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_withContext, 0) + + def traversalMethod_write(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_writeContext, 0) + + def traversalMethod_element(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_elementContext, 0) + + def traversalMethod_call(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_callContext, 0) + + def traversalMethod_concat(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_concatContext, 0) + + def traversalMethod_asString(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_asStringContext, 0) + + def traversalMethod_format(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_formatContext, 0) + + def traversalMethod_toUpper(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_toUpperContext, 0) + + def traversalMethod_toLower(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_toLowerContext, 0) + + def traversalMethod_length(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_lengthContext, 0) + + def traversalMethod_trim(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_trimContext, 0) + + def traversalMethod_lTrim(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_lTrimContext, 0) + + def traversalMethod_rTrim(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_rTrimContext, 0) + + def traversalMethod_reverse(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_reverseContext, 0) + + def traversalMethod_replace(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_replaceContext, 0) + + def traversalMethod_split(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_splitContext, 0) + + def traversalMethod_substring(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_substringContext, 0) + + def traversalMethod_asDate(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_asDateContext, 0) + + def traversalMethod_dateAdd(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_dateAddContext, 0) + + def traversalMethod_dateDiff(self): + return self.getTypedRuleContext(GremlinParser.TraversalMethod_dateDiffContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod"): + listener.enterTraversalMethod(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod"): + listener.exitTraversalMethod(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod"): + return visitor.visitTraversalMethod(self) + else: + return visitor.visitChildren(self) + + def traversalMethod(self): + + localctx = GremlinParser.TraversalMethodContext(self, self._ctx, self.state) + self.enterRule(localctx, 56, self.RULE_traversalMethod) + try: + self.state = 1057 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [233]: + self.enterOuterAlt(localctx, 1) + self.state = 923 + self.traversalMethod_V() + pass + elif token in [57]: + self.enterOuterAlt(localctx, 2) + self.state = 924 + self.traversalMethod_E() + pass + elif token in [3]: + self.enterOuterAlt(localctx, 3) + self.state = 925 + self.traversalMethod_addE() + pass + elif token in [4]: + self.enterOuterAlt(localctx, 4) + self.state = 926 + self.traversalMethod_addV() + pass + elif token in [129]: + self.enterOuterAlt(localctx, 5) + self.state = 927 + self.traversalMethod_mergeE() + pass + elif token in [130]: + self.enterOuterAlt(localctx, 6) + self.state = 928 + self.traversalMethod_mergeV() + pass + elif token in [5]: + self.enterOuterAlt(localctx, 7) + self.state = 929 + self.traversalMethod_aggregate() + pass + elif token in [6]: + self.enterOuterAlt(localctx, 8) + self.state = 930 + self.traversalMethod_all() + pass + elif token in [7]: + self.enterOuterAlt(localctx, 9) + self.state = 931 + self.traversalMethod_and() + pass + elif token in [8]: + self.enterOuterAlt(localctx, 10) + self.state = 932 + self.traversalMethod_any() + pass + elif token in [9]: + self.enterOuterAlt(localctx, 11) + self.state = 933 + self.traversalMethod_as() + pass + elif token in [14]: + self.enterOuterAlt(localctx, 12) + self.state = 934 + self.traversalMethod_barrier() + pass + elif token in [18]: + self.enterOuterAlt(localctx, 13) + self.state = 935 + self.traversalMethod_both() + pass + elif token in [20]: + self.enterOuterAlt(localctx, 14) + self.state = 936 + self.traversalMethod_bothE() + pass + elif token in [21]: + self.enterOuterAlt(localctx, 15) + self.state = 937 + self.traversalMethod_bothV() + pass + elif token in [22]: + self.enterOuterAlt(localctx, 16) + self.state = 938 + self.traversalMethod_branch() + pass + elif token in [23]: + self.enterOuterAlt(localctx, 17) + self.state = 939 + self.traversalMethod_by() + pass + elif token in [25]: + self.enterOuterAlt(localctx, 18) + self.state = 940 + self.traversalMethod_cap() + pass + elif token in [27]: + self.enterOuterAlt(localctx, 19) + self.state = 941 + self.traversalMethod_choose() + pass + elif token in [28]: + self.enterOuterAlt(localctx, 20) + self.state = 942 + self.traversalMethod_coalesce() + pass + elif token in [29]: + self.enterOuterAlt(localctx, 21) + self.state = 943 + self.traversalMethod_coin() + pass + elif token in [35]: + self.enterOuterAlt(localctx, 22) + self.state = 944 + self.traversalMethod_conjoin() + pass + elif token in [36]: + self.enterOuterAlt(localctx, 23) + self.state = 945 + self.traversalMethod_connectedComponent() + pass + elif token in [38]: + self.enterOuterAlt(localctx, 24) + self.state = 946 + self.traversalMethod_constant() + pass + elif token in [40]: + self.enterOuterAlt(localctx, 25) + self.state = 947 + self.traversalMethod_count() + pass + elif token in [41]: + self.enterOuterAlt(localctx, 26) + self.state = 948 + self.traversalMethod_cyclicPath() + pass + elif token in [48]: + self.enterOuterAlt(localctx, 27) + self.state = 949 + self.traversalMethod_dedup() + pass + elif token in [50]: + self.enterOuterAlt(localctx, 28) + self.state = 950 + self.traversalMethod_difference() + pass + elif token in [1]: + self.enterOuterAlt(localctx, 29) + self.state = 951 + self.traversalMethod_discard() + pass + elif token in [52]: + self.enterOuterAlt(localctx, 30) + self.state = 952 + self.traversalMethod_disjunct() + pass + elif token in [55]: + self.enterOuterAlt(localctx, 31) + self.state = 953 + self.traversalMethod_drop() + pass + elif token in [59]: + self.enterOuterAlt(localctx, 32) + self.state = 954 + self.traversalMethod_elementMap() + pass + elif token in [61]: + self.enterOuterAlt(localctx, 33) + self.state = 955 + self.traversalMethod_emit() + pass + elif token in [67]: + self.enterOuterAlt(localctx, 34) + self.state = 956 + self.traversalMethod_filter() + pass + elif token in [69]: + self.enterOuterAlt(localctx, 35) + self.state = 957 + self.traversalMethod_flatMap() + pass + elif token in [70]: + self.enterOuterAlt(localctx, 36) + self.state = 958 + self.traversalMethod_fold() + pass + elif token in [72]: + self.enterOuterAlt(localctx, 37) + self.state = 959 + self.traversalMethod_from() + pass + elif token in [79]: + self.enterOuterAlt(localctx, 38) + self.state = 960 + self.traversalMethod_group() + pass + elif token in [78]: + self.enterOuterAlt(localctx, 39) + self.state = 961 + self.traversalMethod_groupCount() + pass + elif token in [81]: + self.enterOuterAlt(localctx, 40) + self.state = 962 + self.traversalMethod_has() + pass + elif token in [82]: + self.enterOuterAlt(localctx, 41) + self.state = 963 + self.traversalMethod_hasId() + pass + elif token in [83]: + self.enterOuterAlt(localctx, 42) + self.state = 964 + self.traversalMethod_hasKey() + pass + elif token in [84]: + self.enterOuterAlt(localctx, 43) + self.state = 965 + self.traversalMethod_hasLabel() + pass + elif token in [86]: + self.enterOuterAlt(localctx, 44) + self.state = 966 + self.traversalMethod_hasNot() + pass + elif token in [87]: + self.enterOuterAlt(localctx, 45) + self.state = 967 + self.traversalMethod_hasValue() + pass + elif token in [89]: + self.enterOuterAlt(localctx, 46) + self.state = 968 + self.traversalMethod_id() + pass + elif token in [90]: + self.enterOuterAlt(localctx, 47) + self.state = 969 + self.traversalMethod_identity() + pass + elif token in [92]: + self.enterOuterAlt(localctx, 48) + self.state = 970 + self.traversalMethod_in() + pass + elif token in [94]: + self.enterOuterAlt(localctx, 49) + self.state = 971 + self.traversalMethod_inE() + pass + elif token in [102]: + self.enterOuterAlt(localctx, 50) + self.state = 972 + self.traversalMethod_intersect() + pass + elif token in [103]: + self.enterOuterAlt(localctx, 51) + self.state = 973 + self.traversalMethod_inV() + pass + elif token in [98]: + self.enterOuterAlt(localctx, 52) + self.state = 974 + self.traversalMethod_index() + pass + elif token in [100]: + self.enterOuterAlt(localctx, 53) + self.state = 975 + self.traversalMethod_inject() + pass + elif token in [106]: + self.enterOuterAlt(localctx, 54) + self.state = 976 + self.traversalMethod_is() + pass + elif token in [108]: + self.enterOuterAlt(localctx, 55) + self.state = 977 + self.traversalMethod_key() + pass + elif token in [111]: + self.enterOuterAlt(localctx, 56) + self.state = 978 + self.traversalMethod_label() + pass + elif token in [114]: + self.enterOuterAlt(localctx, 57) + self.state = 979 + self.traversalMethod_limit() + pass + elif token in [116]: + self.enterOuterAlt(localctx, 58) + self.state = 980 + self.traversalMethod_local() + pass + elif token in [117]: + self.enterOuterAlt(localctx, 59) + self.state = 981 + self.traversalMethod_loops() + pass + elif token in [121]: + self.enterOuterAlt(localctx, 60) + self.state = 982 + self.traversalMethod_map() + pass + elif token in [122]: + self.enterOuterAlt(localctx, 61) + self.state = 983 + self.traversalMethod_match() + pass + elif token in [123]: + self.enterOuterAlt(localctx, 62) + self.state = 984 + self.traversalMethod_math() + pass + elif token in [124]: + self.enterOuterAlt(localctx, 63) + self.state = 985 + self.traversalMethod_max() + pass + elif token in [126]: + self.enterOuterAlt(localctx, 64) + self.state = 986 + self.traversalMethod_mean() + pass + elif token in [131]: + self.enterOuterAlt(localctx, 65) + self.state = 987 + self.traversalMethod_min() + pass + elif token in [139]: + self.enterOuterAlt(localctx, 66) + self.state = 988 + self.traversalMethod_none() + pass + elif token in [144]: + self.enterOuterAlt(localctx, 67) + self.state = 989 + self.traversalMethod_not() + pass + elif token in [152]: + self.enterOuterAlt(localctx, 68) + self.state = 990 + self.traversalMethod_option() + pass + elif token in [153]: + self.enterOuterAlt(localctx, 69) + self.state = 991 + self.traversalMethod_optional() + pass + elif token in [156]: + self.enterOuterAlt(localctx, 70) + self.state = 992 + self.traversalMethod_or() + pass + elif token in [155]: + self.enterOuterAlt(localctx, 71) + self.state = 993 + self.traversalMethod_order() + pass + elif token in [157]: + self.enterOuterAlt(localctx, 72) + self.state = 994 + self.traversalMethod_otherV() + pass + elif token in [159]: + self.enterOuterAlt(localctx, 73) + self.state = 995 + self.traversalMethod_out() + pass + elif token in [160]: + self.enterOuterAlt(localctx, 74) + self.state = 996 + self.traversalMethod_outE() + pass + elif token in [162]: + self.enterOuterAlt(localctx, 75) + self.state = 997 + self.traversalMethod_outV() + pass + elif token in [165]: + self.enterOuterAlt(localctx, 76) + self.state = 998 + self.traversalMethod_pageRank() + pass + elif token in [166]: + self.enterOuterAlt(localctx, 77) + self.state = 999 + self.traversalMethod_path() + pass + elif token in [168]: + self.enterOuterAlt(localctx, 78) + self.state = 1000 + self.traversalMethod_peerPressure() + pass + elif token in [171]: + self.enterOuterAlt(localctx, 79) + self.state = 1001 + self.traversalMethod_profile() + pass + elif token in [172]: + self.enterOuterAlt(localctx, 80) + self.state = 1002 + self.traversalMethod_project() + pass + elif token in [173]: + self.enterOuterAlt(localctx, 81) + self.state = 1003 + self.traversalMethod_properties() + pass + elif token in [176]: + self.enterOuterAlt(localctx, 82) + self.state = 1004 + self.traversalMethod_property() + pass + elif token in [174]: + self.enterOuterAlt(localctx, 83) + self.state = 1005 + self.traversalMethod_propertyMap() + pass + elif token in [178]: + self.enterOuterAlt(localctx, 84) + self.state = 1006 + self.traversalMethod_range() + pass + elif token in [179]: + self.enterOuterAlt(localctx, 85) + self.state = 1007 + self.traversalMethod_read() + pass + elif token in [184]: + self.enterOuterAlt(localctx, 86) + self.state = 1008 + self.traversalMethod_repeat() + pass + elif token in [188]: + self.enterOuterAlt(localctx, 87) + self.state = 1009 + self.traversalMethod_sack() + pass + elif token in [189]: + self.enterOuterAlt(localctx, 88) + self.state = 1010 + self.traversalMethod_sample() + pass + elif token in [192]: + self.enterOuterAlt(localctx, 89) + self.state = 1011 + self.traversalMethod_select() + pass + elif token in [31]: + self.enterOuterAlt(localctx, 90) + self.state = 1012 + self.traversalMethod_combine() + pass + elif token in [177]: + self.enterOuterAlt(localctx, 91) + self.state = 1013 + self.traversalMethod_product() + pass + elif token in [128]: + self.enterOuterAlt(localctx, 92) + self.state = 1014 + self.traversalMethod_merge() + pass + elif token in [195]: + self.enterOuterAlt(localctx, 93) + self.state = 1015 + self.traversalMethod_shortestPath() + pass + elif token in [197]: + self.enterOuterAlt(localctx, 94) + self.state = 1016 + self.traversalMethod_sideEffect() + pass + elif token in [198]: + self.enterOuterAlt(localctx, 95) + self.state = 1017 + self.traversalMethod_simplePath() + pass + elif token in [200]: + self.enterOuterAlt(localctx, 96) + self.state = 1018 + self.traversalMethod_skip() + pass + elif token in [203]: + self.enterOuterAlt(localctx, 97) + self.state = 1019 + self.traversalMethod_store() + pass + elif token in [204]: + self.enterOuterAlt(localctx, 98) + self.state = 1020 + self.traversalMethod_subgraph() + pass + elif token in [206]: + self.enterOuterAlt(localctx, 99) + self.state = 1021 + self.traversalMethod_sum() + pass + elif token in [209]: + self.enterOuterAlt(localctx, 100) + self.state = 1022 + self.traversalMethod_tail() + pass + elif token in [65]: + self.enterOuterAlt(localctx, 101) + self.state = 1023 + self.traversalMethod_fail() + pass + elif token in [212]: + self.enterOuterAlt(localctx, 102) + self.state = 1024 + self.traversalMethod_timeLimit() + pass + elif token in [213]: + self.enterOuterAlt(localctx, 103) + self.state = 1025 + self.traversalMethod_times() + pass + elif token in [214]: + self.enterOuterAlt(localctx, 104) + self.state = 1026 + self.traversalMethod_to() + pass + elif token in [222]: + self.enterOuterAlt(localctx, 105) + self.state = 1027 + self.traversalMethod_toE() + pass + elif token in [223]: + self.enterOuterAlt(localctx, 106) + self.state = 1028 + self.traversalMethod_toV() + pass + elif token in [224]: + self.enterOuterAlt(localctx, 107) + self.state = 1029 + self.traversalMethod_tree() + pass + elif token in [229]: + self.enterOuterAlt(localctx, 108) + self.state = 1030 + self.traversalMethod_unfold() + pass + elif token in [230]: + self.enterOuterAlt(localctx, 109) + self.state = 1031 + self.traversalMethod_union() + pass + elif token in [231]: + self.enterOuterAlt(localctx, 110) + self.state = 1032 + self.traversalMethod_until() + pass + elif token in [236]: + self.enterOuterAlt(localctx, 111) + self.state = 1033 + self.traversalMethod_value() + pass + elif token in [234]: + self.enterOuterAlt(localctx, 112) + self.state = 1034 + self.traversalMethod_valueMap() + pass + elif token in [235]: + self.enterOuterAlt(localctx, 113) + self.state = 1035 + self.traversalMethod_values() + pass + elif token in [238]: + self.enterOuterAlt(localctx, 114) + self.state = 1036 + self.traversalMethod_where() + pass + elif token in [239]: + self.enterOuterAlt(localctx, 115) + self.state = 1037 + self.traversalMethod_with() + pass + elif token in [249]: + self.enterOuterAlt(localctx, 116) + self.state = 1038 + self.traversalMethod_write() + pass + elif token in [60]: + self.enterOuterAlt(localctx, 117) + self.state = 1039 + self.traversalMethod_element() + pass + elif token in [24]: + self.enterOuterAlt(localctx, 118) + self.state = 1040 + self.traversalMethod_call() + pass + elif token in [34]: + self.enterOuterAlt(localctx, 119) + self.state = 1041 + self.traversalMethod_concat() + pass + elif token in [12]: + self.enterOuterAlt(localctx, 120) + self.state = 1042 + self.traversalMethod_asString() + pass + elif token in [71]: + self.enterOuterAlt(localctx, 121) + self.state = 1043 + self.traversalMethod_format() + pass + elif token in [221]: + self.enterOuterAlt(localctx, 122) + self.state = 1044 + self.traversalMethod_toUpper() + pass + elif token in [218]: + self.enterOuterAlt(localctx, 123) + self.state = 1045 + self.traversalMethod_toLower() + pass + elif token in [113]: + self.enterOuterAlt(localctx, 124) + self.state = 1046 + self.traversalMethod_length() + pass + elif token in [225]: + self.enterOuterAlt(localctx, 125) + self.state = 1047 + self.traversalMethod_trim() + pass + elif token in [120]: + self.enterOuterAlt(localctx, 126) + self.state = 1048 + self.traversalMethod_lTrim() + pass + elif token in [187]: + self.enterOuterAlt(localctx, 127) + self.state = 1049 + self.traversalMethod_rTrim() + pass + elif token in [185]: + self.enterOuterAlt(localctx, 128) + self.state = 1050 + self.traversalMethod_reverse() + pass + elif token in [183]: + self.enterOuterAlt(localctx, 129) + self.state = 1051 + self.traversalMethod_replace() + pass + elif token in [201]: + self.enterOuterAlt(localctx, 130) + self.state = 1052 + self.traversalMethod_split() + pass + elif token in [205]: + self.enterOuterAlt(localctx, 131) + self.state = 1053 + self.traversalMethod_substring() + pass + elif token in [11]: + self.enterOuterAlt(localctx, 132) + self.state = 1054 + self.traversalMethod_asDate() + pass + elif token in [43]: + self.enterOuterAlt(localctx, 133) + self.state = 1055 + self.traversalMethod_dateAdd() + pass + elif token in [44]: + self.enterOuterAlt(localctx, 134) + self.state = 1056 + self.traversalMethod_dateDiff() + 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 TraversalMethod_VContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_V(self): + return self.getToken(GremlinParser.K_V, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_V + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_V"): + listener.enterTraversalMethod_V(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_V"): + listener.exitTraversalMethod_V(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_V"): + return visitor.visitTraversalMethod_V(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_V(self): + + localctx = GremlinParser.TraversalMethod_VContext(self, self._ctx, self.state) + self.enterRule(localctx, 58, self.RULE_traversalMethod_V) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1059 + self.match(GremlinParser.K_V) + self.state = 1060 + self.match(GremlinParser.LPAREN) + self.state = 1061 + self.genericArgumentVarargs() + self.state = 1062 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_EContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_E(self): + return self.getToken(GremlinParser.K_E, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_E + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_E"): + listener.enterTraversalMethod_E(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_E"): + listener.exitTraversalMethod_E(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_E"): + return visitor.visitTraversalMethod_E(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_E(self): + + localctx = GremlinParser.TraversalMethod_EContext(self, self._ctx, self.state) + self.enterRule(localctx, 60, self.RULE_traversalMethod_E) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1064 + self.match(GremlinParser.K_E) + self.state = 1065 + self.match(GremlinParser.LPAREN) + self.state = 1066 + self.genericArgumentVarargs() + self.state = 1067 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_addEContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_addE + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_addE_TraversalContext(TraversalMethod_addEContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_addEContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_ADDE(self): + return self.getToken(GremlinParser.K_ADDE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_addE_Traversal"): + listener.enterTraversalMethod_addE_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_addE_Traversal"): + listener.exitTraversalMethod_addE_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_addE_Traversal"): + return visitor.visitTraversalMethod_addE_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_addE_StringContext(TraversalMethod_addEContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_addEContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_ADDE(self): + return self.getToken(GremlinParser.K_ADDE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringArgument(self): + return self.getTypedRuleContext(GremlinParser.StringArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_addE_String"): + listener.enterTraversalMethod_addE_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_addE_String"): + listener.exitTraversalMethod_addE_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_addE_String"): + return visitor.visitTraversalMethod_addE_String(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_addE(self): + + localctx = GremlinParser.TraversalMethod_addEContext(self, self._ctx, self.state) + self.enterRule(localctx, 62, self.RULE_traversalMethod_addE) + try: + self.state = 1079 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 24, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_addE_StringContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1069 + self.match(GremlinParser.K_ADDE) + self.state = 1070 + self.match(GremlinParser.LPAREN) + self.state = 1071 + self.stringArgument() + self.state = 1072 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_addE_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1074 + self.match(GremlinParser.K_ADDE) + self.state = 1075 + self.match(GremlinParser.LPAREN) + self.state = 1076 + self.nestedTraversal() + self.state = 1077 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_addVContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_addV + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_addV_EmptyContext(TraversalMethod_addVContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_addVContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_ADDV(self): + return self.getToken(GremlinParser.K_ADDV, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_addV_Empty"): + listener.enterTraversalMethod_addV_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_addV_Empty"): + listener.exitTraversalMethod_addV_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_addV_Empty"): + return visitor.visitTraversalMethod_addV_Empty(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_addV_StringContext(TraversalMethod_addVContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_addVContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_ADDV(self): + return self.getToken(GremlinParser.K_ADDV, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringArgument(self): + return self.getTypedRuleContext(GremlinParser.StringArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_addV_String"): + listener.enterTraversalMethod_addV_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_addV_String"): + listener.exitTraversalMethod_addV_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_addV_String"): + return visitor.visitTraversalMethod_addV_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_addV_TraversalContext(TraversalMethod_addVContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_addVContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_ADDV(self): + return self.getToken(GremlinParser.K_ADDV, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_addV_Traversal"): + listener.enterTraversalMethod_addV_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_addV_Traversal"): + listener.exitTraversalMethod_addV_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_addV_Traversal"): + return visitor.visitTraversalMethod_addV_Traversal(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_addV(self): + + localctx = GremlinParser.TraversalMethod_addVContext(self, self._ctx, self.state) + self.enterRule(localctx, 64, self.RULE_traversalMethod_addV) + try: + self.state = 1094 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 25, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_addV_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1081 + self.match(GremlinParser.K_ADDV) + self.state = 1082 + self.match(GremlinParser.LPAREN) + self.state = 1083 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_addV_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1084 + self.match(GremlinParser.K_ADDV) + self.state = 1085 + self.match(GremlinParser.LPAREN) + self.state = 1086 + self.stringArgument() + self.state = 1087 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_addV_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 1089 + self.match(GremlinParser.K_ADDV) + self.state = 1090 + self.match(GremlinParser.LPAREN) + self.state = 1091 + self.nestedTraversal() + self.state = 1092 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_aggregateContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_aggregate + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_aggregate_StringContext(TraversalMethod_aggregateContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_aggregateContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_AGGREGATE(self): + return self.getToken(GremlinParser.K_AGGREGATE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_aggregate_String"): + listener.enterTraversalMethod_aggregate_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_aggregate_String"): + listener.exitTraversalMethod_aggregate_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_aggregate_String"): + return visitor.visitTraversalMethod_aggregate_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_aggregate_Scope_StringContext(TraversalMethod_aggregateContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_aggregateContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_AGGREGATE(self): + return self.getToken(GremlinParser.K_AGGREGATE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_aggregate_Scope_String"): + listener.enterTraversalMethod_aggregate_Scope_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_aggregate_Scope_String"): + listener.exitTraversalMethod_aggregate_Scope_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_aggregate_Scope_String"): + return visitor.visitTraversalMethod_aggregate_Scope_String(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_aggregate(self): + + localctx = GremlinParser.TraversalMethod_aggregateContext(self, self._ctx, self.state) + self.enterRule(localctx, 66, self.RULE_traversalMethod_aggregate) + try: + self.state = 1108 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 26, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_aggregate_Scope_StringContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1096 + self.match(GremlinParser.K_AGGREGATE) + self.state = 1097 + self.match(GremlinParser.LPAREN) + self.state = 1098 + self.traversalScope() + self.state = 1099 + self.match(GremlinParser.COMMA) + self.state = 1100 + self.stringLiteral() + self.state = 1101 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_aggregate_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1103 + self.match(GremlinParser.K_AGGREGATE) + self.state = 1104 + self.match(GremlinParser.LPAREN) + self.state = 1105 + self.stringLiteral() + self.state = 1106 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_allContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_all + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_all_PContext(TraversalMethod_allContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_allContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_ALL(self): + return self.getToken(GremlinParser.K_ALL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_all_P"): + listener.enterTraversalMethod_all_P(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_all_P"): + listener.exitTraversalMethod_all_P(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_all_P"): + return visitor.visitTraversalMethod_all_P(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_all(self): + + localctx = GremlinParser.TraversalMethod_allContext(self, self._ctx, self.state) + self.enterRule(localctx, 68, self.RULE_traversalMethod_all) + try: + localctx = GremlinParser.TraversalMethod_all_PContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1110 + self.match(GremlinParser.K_ALL) + self.state = 1111 + self.match(GremlinParser.LPAREN) + self.state = 1112 + self.traversalPredicate(0) + self.state = 1113 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_andContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_AND(self): + return self.getToken(GremlinParser.K_AND, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversalList(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalListContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_and + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_and"): + listener.enterTraversalMethod_and(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_and"): + listener.exitTraversalMethod_and(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_and"): + return visitor.visitTraversalMethod_and(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_and(self): + + localctx = GremlinParser.TraversalMethod_andContext(self, self._ctx, self.state) + self.enterRule(localctx, 70, self.RULE_traversalMethod_and) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1115 + self.match(GremlinParser.K_AND) + self.state = 1116 + self.match(GremlinParser.LPAREN) + self.state = 1117 + self.nestedTraversalList() + self.state = 1118 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_anyContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_any + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_any_PContext(TraversalMethod_anyContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_anyContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_ANY(self): + return self.getToken(GremlinParser.K_ANY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_any_P"): + listener.enterTraversalMethod_any_P(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_any_P"): + listener.exitTraversalMethod_any_P(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_any_P"): + return visitor.visitTraversalMethod_any_P(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_any(self): + + localctx = GremlinParser.TraversalMethod_anyContext(self, self._ctx, self.state) + self.enterRule(localctx, 72, self.RULE_traversalMethod_any) + try: + localctx = GremlinParser.TraversalMethod_any_PContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1120 + self.match(GremlinParser.K_ANY) + self.state = 1121 + self.match(GremlinParser.LPAREN) + self.state = 1122 + self.traversalPredicate(0) + self.state = 1123 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_asContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_AS(self): + return self.getToken(GremlinParser.K_AS, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_as + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_as"): + listener.enterTraversalMethod_as(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_as"): + listener.exitTraversalMethod_as(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_as"): + return visitor.visitTraversalMethod_as(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_as(self): + + localctx = GremlinParser.TraversalMethod_asContext(self, self._ctx, self.state) + self.enterRule(localctx, 74, self.RULE_traversalMethod_as) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1125 + self.match(GremlinParser.K_AS) + self.state = 1126 + self.match(GremlinParser.LPAREN) + self.state = 1127 + self.stringLiteral() + self.state = 1130 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 1128 + self.match(GremlinParser.COMMA) + self.state = 1129 + self.stringNullableLiteralVarargs() + + self.state = 1132 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_asDateContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_ASDATE(self): + return self.getToken(GremlinParser.K_ASDATE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_asDate + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_asDate"): + listener.enterTraversalMethod_asDate(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_asDate"): + listener.exitTraversalMethod_asDate(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_asDate"): + return visitor.visitTraversalMethod_asDate(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_asDate(self): + + localctx = GremlinParser.TraversalMethod_asDateContext(self, self._ctx, self.state) + self.enterRule(localctx, 76, self.RULE_traversalMethod_asDate) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1134 + self.match(GremlinParser.K_ASDATE) + self.state = 1135 + self.match(GremlinParser.LPAREN) + self.state = 1136 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_asStringContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_asString + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_asString_EmptyContext(TraversalMethod_asStringContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_asStringContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_ASSTRING(self): + return self.getToken(GremlinParser.K_ASSTRING, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_asString_Empty"): + listener.enterTraversalMethod_asString_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_asString_Empty"): + listener.exitTraversalMethod_asString_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_asString_Empty"): + return visitor.visitTraversalMethod_asString_Empty(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_asString_ScopeContext(TraversalMethod_asStringContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_asStringContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_ASSTRING(self): + return self.getToken(GremlinParser.K_ASSTRING, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_asString_Scope"): + listener.enterTraversalMethod_asString_Scope(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_asString_Scope"): + listener.exitTraversalMethod_asString_Scope(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_asString_Scope"): + return visitor.visitTraversalMethod_asString_Scope(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_asString(self): + + localctx = GremlinParser.TraversalMethod_asStringContext(self, self._ctx, self.state) + self.enterRule(localctx, 78, self.RULE_traversalMethod_asString) + try: + self.state = 1146 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 28, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_asString_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1138 + self.match(GremlinParser.K_ASSTRING) + self.state = 1139 + self.match(GremlinParser.LPAREN) + self.state = 1140 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_asString_ScopeContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1141 + self.match(GremlinParser.K_ASSTRING) + self.state = 1142 + self.match(GremlinParser.LPAREN) + self.state = 1143 + self.traversalScope() + self.state = 1144 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_barrierContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_barrier + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_barrier_ConsumerContext(TraversalMethod_barrierContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_barrierContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_BARRIER(self): + return self.getToken(GremlinParser.K_BARRIER, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalSackMethod(self): + return self.getTypedRuleContext(GremlinParser.TraversalSackMethodContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_barrier_Consumer"): + listener.enterTraversalMethod_barrier_Consumer(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_barrier_Consumer"): + listener.exitTraversalMethod_barrier_Consumer(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_barrier_Consumer"): + return visitor.visitTraversalMethod_barrier_Consumer(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_barrier_intContext(TraversalMethod_barrierContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_barrierContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_BARRIER(self): + return self.getToken(GremlinParser.K_BARRIER, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(GremlinParser.IntegerLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_barrier_int"): + listener.enterTraversalMethod_barrier_int(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_barrier_int"): + listener.exitTraversalMethod_barrier_int(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_barrier_int"): + return visitor.visitTraversalMethod_barrier_int(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_barrier_EmptyContext(TraversalMethod_barrierContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_barrierContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_BARRIER(self): + return self.getToken(GremlinParser.K_BARRIER, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_barrier_Empty"): + listener.enterTraversalMethod_barrier_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_barrier_Empty"): + listener.exitTraversalMethod_barrier_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_barrier_Empty"): + return visitor.visitTraversalMethod_barrier_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_barrier(self): + + localctx = GremlinParser.TraversalMethod_barrierContext(self, self._ctx, self.state) + self.enterRule(localctx, 80, self.RULE_traversalMethod_barrier) + try: + self.state = 1161 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 29, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_barrier_ConsumerContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1148 + self.match(GremlinParser.K_BARRIER) + self.state = 1149 + self.match(GremlinParser.LPAREN) + self.state = 1150 + self.traversalSackMethod() + self.state = 1151 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_barrier_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1153 + self.match(GremlinParser.K_BARRIER) + self.state = 1154 + self.match(GremlinParser.LPAREN) + self.state = 1155 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_barrier_intContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 1156 + self.match(GremlinParser.K_BARRIER) + self.state = 1157 + self.match(GremlinParser.LPAREN) + self.state = 1158 + self.integerLiteral() + self.state = 1159 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_bothContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_BOTH(self): + return self.getToken(GremlinParser.K_BOTH, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableArgumentVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_both + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_both"): + listener.enterTraversalMethod_both(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_both"): + listener.exitTraversalMethod_both(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_both"): + return visitor.visitTraversalMethod_both(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_both(self): + + localctx = GremlinParser.TraversalMethod_bothContext(self, self._ctx, self.state) + self.enterRule(localctx, 82, self.RULE_traversalMethod_both) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1163 + self.match(GremlinParser.K_BOTH) + self.state = 1164 + self.match(GremlinParser.LPAREN) + self.state = 1165 + self.stringNullableArgumentVarargs() + self.state = 1166 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_bothEContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_BOTHE(self): + return self.getToken(GremlinParser.K_BOTHE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableArgumentVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_bothE + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_bothE"): + listener.enterTraversalMethod_bothE(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_bothE"): + listener.exitTraversalMethod_bothE(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_bothE"): + return visitor.visitTraversalMethod_bothE(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_bothE(self): + + localctx = GremlinParser.TraversalMethod_bothEContext(self, self._ctx, self.state) + self.enterRule(localctx, 84, self.RULE_traversalMethod_bothE) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1168 + self.match(GremlinParser.K_BOTHE) + self.state = 1169 + self.match(GremlinParser.LPAREN) + self.state = 1170 + self.stringNullableArgumentVarargs() + self.state = 1171 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_bothVContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_BOTHV(self): + return self.getToken(GremlinParser.K_BOTHV, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_bothV + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_bothV"): + listener.enterTraversalMethod_bothV(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_bothV"): + listener.exitTraversalMethod_bothV(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_bothV"): + return visitor.visitTraversalMethod_bothV(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_bothV(self): + + localctx = GremlinParser.TraversalMethod_bothVContext(self, self._ctx, self.state) + self.enterRule(localctx, 86, self.RULE_traversalMethod_bothV) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1173 + self.match(GremlinParser.K_BOTHV) + self.state = 1174 + self.match(GremlinParser.LPAREN) + self.state = 1175 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_branchContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_BRANCH(self): + return self.getToken(GremlinParser.K_BRANCH, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_branch + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_branch"): + listener.enterTraversalMethod_branch(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_branch"): + listener.exitTraversalMethod_branch(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_branch"): + return visitor.visitTraversalMethod_branch(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_branch(self): + + localctx = GremlinParser.TraversalMethod_branchContext(self, self._ctx, self.state) + self.enterRule(localctx, 88, self.RULE_traversalMethod_branch) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1177 + self.match(GremlinParser.K_BRANCH) + self.state = 1178 + self.match(GremlinParser.LPAREN) + self.state = 1179 + self.nestedTraversal() + self.state = 1180 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_byContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_by + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_by_StringContext(TraversalMethod_byContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_byContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_BY(self): + return self.getToken(GremlinParser.K_BY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_by_String"): + listener.enterTraversalMethod_by_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_by_String"): + listener.exitTraversalMethod_by_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_by_String"): + return visitor.visitTraversalMethod_by_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_by_String_ComparatorContext(TraversalMethod_byContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_byContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_BY(self): + return self.getToken(GremlinParser.K_BY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def traversalComparator(self): + return self.getTypedRuleContext(GremlinParser.TraversalComparatorContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_by_String_Comparator"): + listener.enterTraversalMethod_by_String_Comparator(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_by_String_Comparator"): + listener.exitTraversalMethod_by_String_Comparator(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_by_String_Comparator"): + return visitor.visitTraversalMethod_by_String_Comparator(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_by_FunctionContext(TraversalMethod_byContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_byContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_BY(self): + return self.getToken(GremlinParser.K_BY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalFunction(self): + return self.getTypedRuleContext(GremlinParser.TraversalFunctionContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_by_Function"): + listener.enterTraversalMethod_by_Function(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_by_Function"): + listener.exitTraversalMethod_by_Function(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_by_Function"): + return visitor.visitTraversalMethod_by_Function(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_by_TraversalContext(TraversalMethod_byContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_byContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_BY(self): + return self.getToken(GremlinParser.K_BY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_by_Traversal"): + listener.enterTraversalMethod_by_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_by_Traversal"): + listener.exitTraversalMethod_by_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_by_Traversal"): + return visitor.visitTraversalMethod_by_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_by_EmptyContext(TraversalMethod_byContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_byContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_BY(self): + return self.getToken(GremlinParser.K_BY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_by_Empty"): + listener.enterTraversalMethod_by_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_by_Empty"): + listener.exitTraversalMethod_by_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_by_Empty"): + return visitor.visitTraversalMethod_by_Empty(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_by_ComparatorContext(TraversalMethod_byContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_byContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_BY(self): + return self.getToken(GremlinParser.K_BY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalComparator(self): + return self.getTypedRuleContext(GremlinParser.TraversalComparatorContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_by_Comparator"): + listener.enterTraversalMethod_by_Comparator(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_by_Comparator"): + listener.exitTraversalMethod_by_Comparator(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_by_Comparator"): + return visitor.visitTraversalMethod_by_Comparator(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_by_OrderContext(TraversalMethod_byContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_byContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_BY(self): + return self.getToken(GremlinParser.K_BY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalOrder(self): + return self.getTypedRuleContext(GremlinParser.TraversalOrderContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_by_Order"): + listener.enterTraversalMethod_by_Order(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_by_Order"): + listener.exitTraversalMethod_by_Order(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_by_Order"): + return visitor.visitTraversalMethod_by_Order(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_by_Function_ComparatorContext(TraversalMethod_byContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_byContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_BY(self): + return self.getToken(GremlinParser.K_BY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalFunction(self): + return self.getTypedRuleContext(GremlinParser.TraversalFunctionContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def traversalComparator(self): + return self.getTypedRuleContext(GremlinParser.TraversalComparatorContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_by_Function_Comparator"): + listener.enterTraversalMethod_by_Function_Comparator(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_by_Function_Comparator"): + listener.exitTraversalMethod_by_Function_Comparator(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_by_Function_Comparator"): + return visitor.visitTraversalMethod_by_Function_Comparator(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_by_TContext(TraversalMethod_byContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_byContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_BY(self): + return self.getToken(GremlinParser.K_BY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalT(self): + return self.getTypedRuleContext(GremlinParser.TraversalTContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_by_T"): + listener.enterTraversalMethod_by_T(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_by_T"): + listener.exitTraversalMethod_by_T(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_by_T"): + return visitor.visitTraversalMethod_by_T(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_by_Traversal_ComparatorContext(TraversalMethod_byContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_byContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_BY(self): + return self.getToken(GremlinParser.K_BY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def traversalComparator(self): + return self.getTypedRuleContext(GremlinParser.TraversalComparatorContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_by_Traversal_Comparator"): + listener.enterTraversalMethod_by_Traversal_Comparator(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_by_Traversal_Comparator"): + listener.exitTraversalMethod_by_Traversal_Comparator(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_by_Traversal_Comparator"): + return visitor.visitTraversalMethod_by_Traversal_Comparator(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_by(self): + + localctx = GremlinParser.TraversalMethod_byContext(self, self._ctx, self.state) + self.enterRule(localctx, 90, self.RULE_traversalMethod_by) + try: + self.state = 1236 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 30, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_by_ComparatorContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1182 + self.match(GremlinParser.K_BY) + self.state = 1183 + self.match(GremlinParser.LPAREN) + self.state = 1184 + self.traversalComparator() + self.state = 1185 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_by_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1187 + self.match(GremlinParser.K_BY) + self.state = 1188 + self.match(GremlinParser.LPAREN) + self.state = 1189 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_by_FunctionContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 1190 + self.match(GremlinParser.K_BY) + self.state = 1191 + self.match(GremlinParser.LPAREN) + self.state = 1192 + self.traversalFunction() + self.state = 1193 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 4: + localctx = GremlinParser.TraversalMethod_by_Function_ComparatorContext(self, localctx) + self.enterOuterAlt(localctx, 4) + self.state = 1195 + self.match(GremlinParser.K_BY) + self.state = 1196 + self.match(GremlinParser.LPAREN) + self.state = 1197 + self.traversalFunction() + self.state = 1198 + self.match(GremlinParser.COMMA) + self.state = 1199 + self.traversalComparator() + self.state = 1200 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 5: + localctx = GremlinParser.TraversalMethod_by_OrderContext(self, localctx) + self.enterOuterAlt(localctx, 5) + self.state = 1202 + self.match(GremlinParser.K_BY) + self.state = 1203 + self.match(GremlinParser.LPAREN) + self.state = 1204 + self.traversalOrder() + self.state = 1205 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 6: + localctx = GremlinParser.TraversalMethod_by_StringContext(self, localctx) + self.enterOuterAlt(localctx, 6) + self.state = 1207 + self.match(GremlinParser.K_BY) + self.state = 1208 + self.match(GremlinParser.LPAREN) + self.state = 1209 + self.stringLiteral() + self.state = 1210 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 7: + localctx = GremlinParser.TraversalMethod_by_String_ComparatorContext(self, localctx) + self.enterOuterAlt(localctx, 7) + self.state = 1212 + self.match(GremlinParser.K_BY) + self.state = 1213 + self.match(GremlinParser.LPAREN) + self.state = 1214 + self.stringLiteral() + self.state = 1215 + self.match(GremlinParser.COMMA) + self.state = 1216 + self.traversalComparator() + self.state = 1217 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 8: + localctx = GremlinParser.TraversalMethod_by_TContext(self, localctx) + self.enterOuterAlt(localctx, 8) + self.state = 1219 + self.match(GremlinParser.K_BY) + self.state = 1220 + self.match(GremlinParser.LPAREN) + self.state = 1221 + self.traversalT() + self.state = 1222 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 9: + localctx = GremlinParser.TraversalMethod_by_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 9) + self.state = 1224 + self.match(GremlinParser.K_BY) + self.state = 1225 + self.match(GremlinParser.LPAREN) + self.state = 1226 + self.nestedTraversal() + self.state = 1227 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 10: + localctx = GremlinParser.TraversalMethod_by_Traversal_ComparatorContext(self, localctx) + self.enterOuterAlt(localctx, 10) + self.state = 1229 + self.match(GremlinParser.K_BY) + self.state = 1230 + self.match(GremlinParser.LPAREN) + self.state = 1231 + self.nestedTraversal() + self.state = 1232 + self.match(GremlinParser.COMMA) + self.state = 1233 + self.traversalComparator() + self.state = 1234 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_callContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_call + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_call_string_mapContext(TraversalMethod_callContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_callContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CALL(self): + return self.getToken(GremlinParser.K_CALL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def genericMapArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericMapArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_call_string_map"): + listener.enterTraversalMethod_call_string_map(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_call_string_map"): + listener.exitTraversalMethod_call_string_map(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_call_string_map"): + return visitor.visitTraversalMethod_call_string_map(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_call_string_map_traversalContext(TraversalMethod_callContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_callContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CALL(self): + return self.getToken(GremlinParser.K_CALL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def genericMapArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericMapArgumentContext, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_call_string_map_traversal"): + listener.enterTraversalMethod_call_string_map_traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_call_string_map_traversal"): + listener.exitTraversalMethod_call_string_map_traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_call_string_map_traversal"): + return visitor.visitTraversalMethod_call_string_map_traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_call_string_traversalContext(TraversalMethod_callContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_callContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CALL(self): + return self.getToken(GremlinParser.K_CALL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_call_string_traversal"): + listener.enterTraversalMethod_call_string_traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_call_string_traversal"): + listener.exitTraversalMethod_call_string_traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_call_string_traversal"): + return visitor.visitTraversalMethod_call_string_traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_call_stringContext(TraversalMethod_callContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_callContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CALL(self): + return self.getToken(GremlinParser.K_CALL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_call_string"): + listener.enterTraversalMethod_call_string(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_call_string"): + listener.exitTraversalMethod_call_string(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_call_string"): + return visitor.visitTraversalMethod_call_string(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_call(self): + + localctx = GremlinParser.TraversalMethod_callContext(self, self._ctx, self.state) + self.enterRule(localctx, 92, self.RULE_traversalMethod_call) + try: + self.state = 1266 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 31, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_call_stringContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1238 + self.match(GremlinParser.K_CALL) + self.state = 1239 + self.match(GremlinParser.LPAREN) + self.state = 1240 + self.stringLiteral() + self.state = 1241 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_call_string_mapContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1243 + self.match(GremlinParser.K_CALL) + self.state = 1244 + self.match(GremlinParser.LPAREN) + self.state = 1245 + self.stringLiteral() + self.state = 1246 + self.match(GremlinParser.COMMA) + self.state = 1247 + self.genericMapArgument() + self.state = 1248 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_call_string_traversalContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 1250 + self.match(GremlinParser.K_CALL) + self.state = 1251 + self.match(GremlinParser.LPAREN) + self.state = 1252 + self.stringLiteral() + self.state = 1253 + self.match(GremlinParser.COMMA) + self.state = 1254 + self.nestedTraversal() + self.state = 1255 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 4: + localctx = GremlinParser.TraversalMethod_call_string_map_traversalContext(self, localctx) + self.enterOuterAlt(localctx, 4) + self.state = 1257 + self.match(GremlinParser.K_CALL) + self.state = 1258 + self.match(GremlinParser.LPAREN) + self.state = 1259 + self.stringLiteral() + self.state = 1260 + self.match(GremlinParser.COMMA) + self.state = 1261 + self.genericMapArgument() + self.state = 1262 + self.match(GremlinParser.COMMA) + self.state = 1263 + self.nestedTraversal() + self.state = 1264 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_capContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_CAP(self): + return self.getToken(GremlinParser.K_CAP, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_cap + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_cap"): + listener.enterTraversalMethod_cap(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_cap"): + listener.exitTraversalMethod_cap(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_cap"): + return visitor.visitTraversalMethod_cap(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_cap(self): + + localctx = GremlinParser.TraversalMethod_capContext(self, self._ctx, self.state) + self.enterRule(localctx, 94, self.RULE_traversalMethod_cap) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1268 + self.match(GremlinParser.K_CAP) + self.state = 1269 + self.match(GremlinParser.LPAREN) + self.state = 1270 + self.stringLiteral() + self.state = 1273 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 1271 + self.match(GremlinParser.COMMA) + self.state = 1272 + self.stringNullableLiteralVarargs() + + self.state = 1275 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_chooseContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_choose + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_choose_TraversalContext(TraversalMethod_chooseContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_chooseContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CHOOSE(self): + return self.getToken(GremlinParser.K_CHOOSE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_choose_Traversal"): + listener.enterTraversalMethod_choose_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_choose_Traversal"): + listener.exitTraversalMethod_choose_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_choose_Traversal"): + return visitor.visitTraversalMethod_choose_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_choose_FunctionContext(TraversalMethod_chooseContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_chooseContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CHOOSE(self): + return self.getToken(GremlinParser.K_CHOOSE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalFunction(self): + return self.getTypedRuleContext(GremlinParser.TraversalFunctionContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_choose_Function"): + listener.enterTraversalMethod_choose_Function(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_choose_Function"): + listener.exitTraversalMethod_choose_Function(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_choose_Function"): + return visitor.visitTraversalMethod_choose_Function(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_choose_Traversal_TraversalContext(TraversalMethod_chooseContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_chooseContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CHOOSE(self): + return self.getToken(GremlinParser.K_CHOOSE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.NestedTraversalContext) + else: + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, i) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_choose_Traversal_Traversal"): + listener.enterTraversalMethod_choose_Traversal_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_choose_Traversal_Traversal"): + listener.exitTraversalMethod_choose_Traversal_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_choose_Traversal_Traversal"): + return visitor.visitTraversalMethod_choose_Traversal_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_choose_Predicate_TraversalContext(TraversalMethod_chooseContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_chooseContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CHOOSE(self): + return self.getToken(GremlinParser.K_CHOOSE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_choose_Predicate_Traversal"): + listener.enterTraversalMethod_choose_Predicate_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_choose_Predicate_Traversal"): + listener.exitTraversalMethod_choose_Predicate_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_choose_Predicate_Traversal"): + return visitor.visitTraversalMethod_choose_Predicate_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_choose_Predicate_Traversal_TraversalContext(TraversalMethod_chooseContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_chooseContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CHOOSE(self): + return self.getToken(GremlinParser.K_CHOOSE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def nestedTraversal(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.NestedTraversalContext) + else: + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, i) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_choose_Predicate_Traversal_Traversal"): + listener.enterTraversalMethod_choose_Predicate_Traversal_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_choose_Predicate_Traversal_Traversal"): + listener.exitTraversalMethod_choose_Predicate_Traversal_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_choose_Predicate_Traversal_Traversal"): + return visitor.visitTraversalMethod_choose_Predicate_Traversal_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_choose_Traversal_Traversal_TraversalContext(TraversalMethod_chooseContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_chooseContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CHOOSE(self): + return self.getToken(GremlinParser.K_CHOOSE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.NestedTraversalContext) + else: + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, i) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_choose_Traversal_Traversal_Traversal"): + listener.enterTraversalMethod_choose_Traversal_Traversal_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_choose_Traversal_Traversal_Traversal"): + listener.exitTraversalMethod_choose_Traversal_Traversal_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_choose_Traversal_Traversal_Traversal"): + return visitor.visitTraversalMethod_choose_Traversal_Traversal_Traversal(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_choose(self): + + localctx = GremlinParser.TraversalMethod_chooseContext(self, self._ctx, self.state) + self.enterRule(localctx, 96, self.RULE_traversalMethod_choose) + try: + self.state = 1319 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 33, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_choose_FunctionContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1277 + self.match(GremlinParser.K_CHOOSE) + self.state = 1278 + self.match(GremlinParser.LPAREN) + self.state = 1279 + self.traversalFunction() + self.state = 1280 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_choose_Predicate_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1282 + self.match(GremlinParser.K_CHOOSE) + self.state = 1283 + self.match(GremlinParser.LPAREN) + self.state = 1284 + self.traversalPredicate(0) + self.state = 1285 + self.match(GremlinParser.COMMA) + self.state = 1286 + self.nestedTraversal() + self.state = 1287 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_choose_Predicate_Traversal_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 1289 + self.match(GremlinParser.K_CHOOSE) + self.state = 1290 + self.match(GremlinParser.LPAREN) + self.state = 1291 + self.traversalPredicate(0) + self.state = 1292 + self.match(GremlinParser.COMMA) + self.state = 1293 + self.nestedTraversal() + self.state = 1294 + self.match(GremlinParser.COMMA) + self.state = 1295 + self.nestedTraversal() + self.state = 1296 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 4: + localctx = GremlinParser.TraversalMethod_choose_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 4) + self.state = 1298 + self.match(GremlinParser.K_CHOOSE) + self.state = 1299 + self.match(GremlinParser.LPAREN) + self.state = 1300 + self.nestedTraversal() + self.state = 1301 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 5: + localctx = GremlinParser.TraversalMethod_choose_Traversal_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 5) + self.state = 1303 + self.match(GremlinParser.K_CHOOSE) + self.state = 1304 + self.match(GremlinParser.LPAREN) + self.state = 1305 + self.nestedTraversal() + self.state = 1306 + self.match(GremlinParser.COMMA) + self.state = 1307 + self.nestedTraversal() + self.state = 1308 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 6: + localctx = GremlinParser.TraversalMethod_choose_Traversal_Traversal_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 6) + self.state = 1310 + self.match(GremlinParser.K_CHOOSE) + self.state = 1311 + self.match(GremlinParser.LPAREN) + self.state = 1312 + self.nestedTraversal() + self.state = 1313 + self.match(GremlinParser.COMMA) + self.state = 1314 + self.nestedTraversal() + self.state = 1315 + self.match(GremlinParser.COMMA) + self.state = 1316 + self.nestedTraversal() + self.state = 1317 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_coalesceContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_COALESCE(self): + return self.getToken(GremlinParser.K_COALESCE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversalList(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalListContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_coalesce + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_coalesce"): + listener.enterTraversalMethod_coalesce(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_coalesce"): + listener.exitTraversalMethod_coalesce(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_coalesce"): + return visitor.visitTraversalMethod_coalesce(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_coalesce(self): + + localctx = GremlinParser.TraversalMethod_coalesceContext(self, self._ctx, self.state) + self.enterRule(localctx, 98, self.RULE_traversalMethod_coalesce) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1321 + self.match(GremlinParser.K_COALESCE) + self.state = 1322 + self.match(GremlinParser.LPAREN) + self.state = 1323 + self.nestedTraversalList() + self.state = 1324 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_coinContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_COIN(self): + return self.getToken(GremlinParser.K_COIN, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def floatArgument(self): + return self.getTypedRuleContext(GremlinParser.FloatArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_coin + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_coin"): + listener.enterTraversalMethod_coin(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_coin"): + listener.exitTraversalMethod_coin(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_coin"): + return visitor.visitTraversalMethod_coin(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_coin(self): + + localctx = GremlinParser.TraversalMethod_coinContext(self, self._ctx, self.state) + self.enterRule(localctx, 100, self.RULE_traversalMethod_coin) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1326 + self.match(GremlinParser.K_COIN) + self.state = 1327 + self.match(GremlinParser.LPAREN) + self.state = 1328 + self.floatArgument() + self.state = 1329 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_combineContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_combine + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_combine_ObjectContext(TraversalMethod_combineContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_combineContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_COMBINE(self): + return self.getToken(GremlinParser.K_COMBINE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_combine_Object"): + listener.enterTraversalMethod_combine_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_combine_Object"): + listener.exitTraversalMethod_combine_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_combine_Object"): + return visitor.visitTraversalMethod_combine_Object(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_combine(self): + + localctx = GremlinParser.TraversalMethod_combineContext(self, self._ctx, self.state) + self.enterRule(localctx, 102, self.RULE_traversalMethod_combine) + try: + localctx = GremlinParser.TraversalMethod_combine_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1331 + self.match(GremlinParser.K_COMBINE) + self.state = 1332 + self.match(GremlinParser.LPAREN) + self.state = 1333 + self.genericArgument() + self.state = 1334 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_concatContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_concat + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_concat_Traversal_TraversalContext(TraversalMethod_concatContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_concatContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CONCAT(self): + return self.getToken(GremlinParser.K_CONCAT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def nestedTraversalList(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalListContext, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_concat_Traversal_Traversal"): + listener.enterTraversalMethod_concat_Traversal_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_concat_Traversal_Traversal"): + listener.exitTraversalMethod_concat_Traversal_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_concat_Traversal_Traversal"): + return visitor.visitTraversalMethod_concat_Traversal_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_concat_StringContext(TraversalMethod_concatContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_concatContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CONCAT(self): + return self.getToken(GremlinParser.K_CONCAT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_concat_String"): + listener.enterTraversalMethod_concat_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_concat_String"): + listener.exitTraversalMethod_concat_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_concat_String"): + return visitor.visitTraversalMethod_concat_String(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_concat(self): + + localctx = GremlinParser.TraversalMethod_concatContext(self, self._ctx, self.state) + self.enterRule(localctx, 104, self.RULE_traversalMethod_concat) + self._la = 0 # Token type + try: + self.state = 1350 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 35, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_concat_Traversal_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1336 + self.match(GremlinParser.K_CONCAT) + self.state = 1337 + self.match(GremlinParser.LPAREN) + self.state = 1338 + self.nestedTraversal() + self.state = 1341 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 1339 + self.match(GremlinParser.COMMA) + self.state = 1340 + self.nestedTraversalList() + + self.state = 1343 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_concat_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1345 + self.match(GremlinParser.K_CONCAT) + self.state = 1346 + self.match(GremlinParser.LPAREN) + self.state = 1347 + self.stringNullableLiteralVarargs() + self.state = 1348 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_conjoinContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_conjoin + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_conjoin_StringContext(TraversalMethod_conjoinContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_conjoinContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_CONJOIN(self): + return self.getToken(GremlinParser.K_CONJOIN, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringArgument(self): + return self.getTypedRuleContext(GremlinParser.StringArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_conjoin_String"): + listener.enterTraversalMethod_conjoin_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_conjoin_String"): + listener.exitTraversalMethod_conjoin_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_conjoin_String"): + return visitor.visitTraversalMethod_conjoin_String(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_conjoin(self): + + localctx = GremlinParser.TraversalMethod_conjoinContext(self, self._ctx, self.state) + self.enterRule(localctx, 106, self.RULE_traversalMethod_conjoin) + try: + localctx = GremlinParser.TraversalMethod_conjoin_StringContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1352 + self.match(GremlinParser.K_CONJOIN) + self.state = 1353 + self.match(GremlinParser.LPAREN) + self.state = 1354 + self.stringArgument() + self.state = 1355 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_connectedComponentContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_CONNECTEDCOMPONENT(self): + return self.getToken(GremlinParser.K_CONNECTEDCOMPONENT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_connectedComponent + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_connectedComponent"): + listener.enterTraversalMethod_connectedComponent(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_connectedComponent"): + listener.exitTraversalMethod_connectedComponent(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_connectedComponent"): + return visitor.visitTraversalMethod_connectedComponent(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_connectedComponent(self): + + localctx = GremlinParser.TraversalMethod_connectedComponentContext(self, self._ctx, self.state) + self.enterRule(localctx, 108, self.RULE_traversalMethod_connectedComponent) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1357 + self.match(GremlinParser.K_CONNECTEDCOMPONENT) + self.state = 1358 + self.match(GremlinParser.LPAREN) + self.state = 1359 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_constantContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_CONSTANT(self): + return self.getToken(GremlinParser.K_CONSTANT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_constant + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_constant"): + listener.enterTraversalMethod_constant(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_constant"): + listener.exitTraversalMethod_constant(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_constant"): + return visitor.visitTraversalMethod_constant(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_constant(self): + + localctx = GremlinParser.TraversalMethod_constantContext(self, self._ctx, self.state) + self.enterRule(localctx, 110, self.RULE_traversalMethod_constant) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1361 + self.match(GremlinParser.K_CONSTANT) + self.state = 1362 + self.match(GremlinParser.LPAREN) + self.state = 1363 + self.genericArgument() + self.state = 1364 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_countContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_count + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_count_ScopeContext(TraversalMethod_countContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_countContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_COUNT(self): + return self.getToken(GremlinParser.K_COUNT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_count_Scope"): + listener.enterTraversalMethod_count_Scope(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_count_Scope"): + listener.exitTraversalMethod_count_Scope(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_count_Scope"): + return visitor.visitTraversalMethod_count_Scope(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_count_EmptyContext(TraversalMethod_countContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_countContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_COUNT(self): + return self.getToken(GremlinParser.K_COUNT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_count_Empty"): + listener.enterTraversalMethod_count_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_count_Empty"): + listener.exitTraversalMethod_count_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_count_Empty"): + return visitor.visitTraversalMethod_count_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_count(self): + + localctx = GremlinParser.TraversalMethod_countContext(self, self._ctx, self.state) + self.enterRule(localctx, 112, self.RULE_traversalMethod_count) + try: + self.state = 1374 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 36, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_count_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1366 + self.match(GremlinParser.K_COUNT) + self.state = 1367 + self.match(GremlinParser.LPAREN) + self.state = 1368 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_count_ScopeContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1369 + self.match(GremlinParser.K_COUNT) + self.state = 1370 + self.match(GremlinParser.LPAREN) + self.state = 1371 + self.traversalScope() + self.state = 1372 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_cyclicPathContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_CYCLICPATH(self): + return self.getToken(GremlinParser.K_CYCLICPATH, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_cyclicPath + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_cyclicPath"): + listener.enterTraversalMethod_cyclicPath(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_cyclicPath"): + listener.exitTraversalMethod_cyclicPath(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_cyclicPath"): + return visitor.visitTraversalMethod_cyclicPath(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_cyclicPath(self): + + localctx = GremlinParser.TraversalMethod_cyclicPathContext(self, self._ctx, self.state) + self.enterRule(localctx, 114, self.RULE_traversalMethod_cyclicPath) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1376 + self.match(GremlinParser.K_CYCLICPATH) + self.state = 1377 + self.match(GremlinParser.LPAREN) + self.state = 1378 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_dateAddContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_DATEADD(self): + return self.getToken(GremlinParser.K_DATEADD, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalDT(self): + return self.getTypedRuleContext(GremlinParser.TraversalDTContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(GremlinParser.IntegerLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_dateAdd + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_dateAdd"): + listener.enterTraversalMethod_dateAdd(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_dateAdd"): + listener.exitTraversalMethod_dateAdd(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_dateAdd"): + return visitor.visitTraversalMethod_dateAdd(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_dateAdd(self): + + localctx = GremlinParser.TraversalMethod_dateAddContext(self, self._ctx, self.state) + self.enterRule(localctx, 116, self.RULE_traversalMethod_dateAdd) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1380 + self.match(GremlinParser.K_DATEADD) + self.state = 1381 + self.match(GremlinParser.LPAREN) + self.state = 1382 + self.traversalDT() + self.state = 1383 + self.match(GremlinParser.COMMA) + self.state = 1384 + self.integerLiteral() + self.state = 1385 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_dateDiffContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_dateDiff + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_dateDiff_TraversalContext(TraversalMethod_dateDiffContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_dateDiffContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_DATEDIFF(self): + return self.getToken(GremlinParser.K_DATEDIFF, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_dateDiff_Traversal"): + listener.enterTraversalMethod_dateDiff_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_dateDiff_Traversal"): + listener.exitTraversalMethod_dateDiff_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_dateDiff_Traversal"): + return visitor.visitTraversalMethod_dateDiff_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_dateDiff_DateContext(TraversalMethod_dateDiffContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_dateDiffContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_DATEDIFF(self): + return self.getToken(GremlinParser.K_DATEDIFF, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def dateLiteral(self): + return self.getTypedRuleContext(GremlinParser.DateLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_dateDiff_Date"): + listener.enterTraversalMethod_dateDiff_Date(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_dateDiff_Date"): + listener.exitTraversalMethod_dateDiff_Date(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_dateDiff_Date"): + return visitor.visitTraversalMethod_dateDiff_Date(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_dateDiff(self): + + localctx = GremlinParser.TraversalMethod_dateDiffContext(self, self._ctx, self.state) + self.enterRule(localctx, 118, self.RULE_traversalMethod_dateDiff) + try: + self.state = 1397 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 37, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_dateDiff_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1387 + self.match(GremlinParser.K_DATEDIFF) + self.state = 1388 + self.match(GremlinParser.LPAREN) + self.state = 1389 + self.nestedTraversal() + self.state = 1390 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_dateDiff_DateContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1392 + self.match(GremlinParser.K_DATEDIFF) + self.state = 1393 + self.match(GremlinParser.LPAREN) + self.state = 1394 + self.dateLiteral() + self.state = 1395 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_dedupContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_dedup + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_dedup_Scope_StringContext(TraversalMethod_dedupContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_dedupContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_DEDUP(self): + return self.getToken(GremlinParser.K_DEDUP, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_dedup_Scope_String"): + listener.enterTraversalMethod_dedup_Scope_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_dedup_Scope_String"): + listener.exitTraversalMethod_dedup_Scope_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_dedup_Scope_String"): + return visitor.visitTraversalMethod_dedup_Scope_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_dedup_StringContext(TraversalMethod_dedupContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_dedupContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_DEDUP(self): + return self.getToken(GremlinParser.K_DEDUP, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_dedup_String"): + listener.enterTraversalMethod_dedup_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_dedup_String"): + listener.exitTraversalMethod_dedup_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_dedup_String"): + return visitor.visitTraversalMethod_dedup_String(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_dedup(self): + + localctx = GremlinParser.TraversalMethod_dedupContext(self, self._ctx, self.state) + self.enterRule(localctx, 120, self.RULE_traversalMethod_dedup) + self._la = 0 # Token type + try: + self.state = 1413 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 39, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_dedup_Scope_StringContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1399 + self.match(GremlinParser.K_DEDUP) + self.state = 1400 + self.match(GremlinParser.LPAREN) + self.state = 1401 + self.traversalScope() + self.state = 1404 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 1402 + self.match(GremlinParser.COMMA) + self.state = 1403 + self.stringNullableLiteralVarargs() + + self.state = 1406 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_dedup_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1408 + self.match(GremlinParser.K_DEDUP) + self.state = 1409 + self.match(GremlinParser.LPAREN) + self.state = 1410 + self.stringNullableLiteralVarargs() + self.state = 1411 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_differenceContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_difference + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_difference_ObjectContext(TraversalMethod_differenceContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a GremlinParser.TraversalMethod_differenceContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_DIFFERENCE(self): + return self.getToken(GremlinParser.K_DIFFERENCE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_difference_Object"): + listener.enterTraversalMethod_difference_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_difference_Object"): + listener.exitTraversalMethod_difference_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_difference_Object"): + return visitor.visitTraversalMethod_difference_Object(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_difference(self): + + localctx = GremlinParser.TraversalMethod_differenceContext(self, self._ctx, self.state) + self.enterRule(localctx, 122, self.RULE_traversalMethod_difference) + try: + localctx = GremlinParser.TraversalMethod_difference_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1415 + self.match(GremlinParser.K_DIFFERENCE) + self.state = 1416 + self.match(GremlinParser.LPAREN) + self.state = 1417 + self.genericArgument() + self.state = 1418 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_discardContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_discard + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_discard"): + listener.enterTraversalMethod_discard(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_discard"): + listener.exitTraversalMethod_discard(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_discard"): + return visitor.visitTraversalMethod_discard(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_discard(self): + + localctx = GremlinParser.TraversalMethod_discardContext(self, self._ctx, self.state) + self.enterRule(localctx, 124, self.RULE_traversalMethod_discard) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1420 + self.match(GremlinParser.T__0) + self.state = 1421 + self.match(GremlinParser.LPAREN) + self.state = 1422 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_disjunctContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_disjunct + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_disjunct_ObjectContext(TraversalMethod_disjunctContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_disjunctContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_DISJUNCT(self): + return self.getToken(GremlinParser.K_DISJUNCT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_disjunct_Object"): + listener.enterTraversalMethod_disjunct_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_disjunct_Object"): + listener.exitTraversalMethod_disjunct_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_disjunct_Object"): + return visitor.visitTraversalMethod_disjunct_Object(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_disjunct(self): + + localctx = GremlinParser.TraversalMethod_disjunctContext(self, self._ctx, self.state) + self.enterRule(localctx, 126, self.RULE_traversalMethod_disjunct) + try: + localctx = GremlinParser.TraversalMethod_disjunct_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1424 + self.match(GremlinParser.K_DISJUNCT) + self.state = 1425 + self.match(GremlinParser.LPAREN) + self.state = 1426 + self.genericArgument() + self.state = 1427 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_dropContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_DROP(self): + return self.getToken(GremlinParser.K_DROP, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_drop + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_drop"): + listener.enterTraversalMethod_drop(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_drop"): + listener.exitTraversalMethod_drop(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_drop"): + return visitor.visitTraversalMethod_drop(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_drop(self): + + localctx = GremlinParser.TraversalMethod_dropContext(self, self._ctx, self.state) + self.enterRule(localctx, 128, self.RULE_traversalMethod_drop) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1429 + self.match(GremlinParser.K_DROP) + self.state = 1430 + self.match(GremlinParser.LPAREN) + self.state = 1431 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_elementContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_ELEMENT(self): + return self.getToken(GremlinParser.K_ELEMENT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_element + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_element"): + listener.enterTraversalMethod_element(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_element"): + listener.exitTraversalMethod_element(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_element"): + return visitor.visitTraversalMethod_element(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_element(self): + + localctx = GremlinParser.TraversalMethod_elementContext(self, self._ctx, self.state) + self.enterRule(localctx, 130, self.RULE_traversalMethod_element) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1433 + self.match(GremlinParser.K_ELEMENT) + self.state = 1434 + self.match(GremlinParser.LPAREN) + self.state = 1435 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_elementMapContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_ELEMENTMAP(self): + return self.getToken(GremlinParser.K_ELEMENTMAP, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_elementMap + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_elementMap"): + listener.enterTraversalMethod_elementMap(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_elementMap"): + listener.exitTraversalMethod_elementMap(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_elementMap"): + return visitor.visitTraversalMethod_elementMap(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_elementMap(self): + + localctx = GremlinParser.TraversalMethod_elementMapContext(self, self._ctx, self.state) + self.enterRule(localctx, 132, self.RULE_traversalMethod_elementMap) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1437 + self.match(GremlinParser.K_ELEMENTMAP) + self.state = 1438 + self.match(GremlinParser.LPAREN) + self.state = 1439 + self.stringNullableLiteralVarargs() + self.state = 1440 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_emitContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_emit + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_emit_EmptyContext(TraversalMethod_emitContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_emitContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_EMIT(self): + return self.getToken(GremlinParser.K_EMIT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_emit_Empty"): + listener.enterTraversalMethod_emit_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_emit_Empty"): + listener.exitTraversalMethod_emit_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_emit_Empty"): + return visitor.visitTraversalMethod_emit_Empty(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_emit_PredicateContext(TraversalMethod_emitContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_emitContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_EMIT(self): + return self.getToken(GremlinParser.K_EMIT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_emit_Predicate"): + listener.enterTraversalMethod_emit_Predicate(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_emit_Predicate"): + listener.exitTraversalMethod_emit_Predicate(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_emit_Predicate"): + return visitor.visitTraversalMethod_emit_Predicate(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_emit_TraversalContext(TraversalMethod_emitContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_emitContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_EMIT(self): + return self.getToken(GremlinParser.K_EMIT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_emit_Traversal"): + listener.enterTraversalMethod_emit_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_emit_Traversal"): + listener.exitTraversalMethod_emit_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_emit_Traversal"): + return visitor.visitTraversalMethod_emit_Traversal(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_emit(self): + + localctx = GremlinParser.TraversalMethod_emitContext(self, self._ctx, self.state) + self.enterRule(localctx, 134, self.RULE_traversalMethod_emit) + try: + self.state = 1455 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 40, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_emit_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1442 + self.match(GremlinParser.K_EMIT) + self.state = 1443 + self.match(GremlinParser.LPAREN) + self.state = 1444 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_emit_PredicateContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1445 + self.match(GremlinParser.K_EMIT) + self.state = 1446 + self.match(GremlinParser.LPAREN) + self.state = 1447 + self.traversalPredicate(0) + self.state = 1448 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_emit_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 1450 + self.match(GremlinParser.K_EMIT) + self.state = 1451 + self.match(GremlinParser.LPAREN) + self.state = 1452 + self.nestedTraversal() + self.state = 1453 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_failContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_fail + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_fail_StringContext(TraversalMethod_failContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_failContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_FAIL(self): + return self.getToken(GremlinParser.K_FAIL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_fail_String"): + listener.enterTraversalMethod_fail_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_fail_String"): + listener.exitTraversalMethod_fail_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_fail_String"): + return visitor.visitTraversalMethod_fail_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_fail_EmptyContext(TraversalMethod_failContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_failContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_FAIL(self): + return self.getToken(GremlinParser.K_FAIL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_fail_Empty"): + listener.enterTraversalMethod_fail_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_fail_Empty"): + listener.exitTraversalMethod_fail_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_fail_Empty"): + return visitor.visitTraversalMethod_fail_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_fail(self): + + localctx = GremlinParser.TraversalMethod_failContext(self, self._ctx, self.state) + self.enterRule(localctx, 136, self.RULE_traversalMethod_fail) + try: + self.state = 1465 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 41, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_fail_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1457 + self.match(GremlinParser.K_FAIL) + self.state = 1458 + self.match(GremlinParser.LPAREN) + self.state = 1459 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_fail_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1460 + self.match(GremlinParser.K_FAIL) + self.state = 1461 + self.match(GremlinParser.LPAREN) + self.state = 1462 + self.stringLiteral() + self.state = 1463 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_filterContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_filter + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_filter_PredicateContext(TraversalMethod_filterContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_filterContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_FILTER(self): + return self.getToken(GremlinParser.K_FILTER, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_filter_Predicate"): + listener.enterTraversalMethod_filter_Predicate(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_filter_Predicate"): + listener.exitTraversalMethod_filter_Predicate(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_filter_Predicate"): + return visitor.visitTraversalMethod_filter_Predicate(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_filter_TraversalContext(TraversalMethod_filterContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_filterContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_FILTER(self): + return self.getToken(GremlinParser.K_FILTER, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_filter_Traversal"): + listener.enterTraversalMethod_filter_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_filter_Traversal"): + listener.exitTraversalMethod_filter_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_filter_Traversal"): + return visitor.visitTraversalMethod_filter_Traversal(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_filter(self): + + localctx = GremlinParser.TraversalMethod_filterContext(self, self._ctx, self.state) + self.enterRule(localctx, 138, self.RULE_traversalMethod_filter) + try: + self.state = 1477 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 42, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_filter_PredicateContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1467 + self.match(GremlinParser.K_FILTER) + self.state = 1468 + self.match(GremlinParser.LPAREN) + self.state = 1469 + self.traversalPredicate(0) + self.state = 1470 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_filter_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1472 + self.match(GremlinParser.K_FILTER) + self.state = 1473 + self.match(GremlinParser.LPAREN) + self.state = 1474 + self.nestedTraversal() + self.state = 1475 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_flatMapContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_FLATMAP(self): + return self.getToken(GremlinParser.K_FLATMAP, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_flatMap + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_flatMap"): + listener.enterTraversalMethod_flatMap(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_flatMap"): + listener.exitTraversalMethod_flatMap(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_flatMap"): + return visitor.visitTraversalMethod_flatMap(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_flatMap(self): + + localctx = GremlinParser.TraversalMethod_flatMapContext(self, self._ctx, self.state) + self.enterRule(localctx, 140, self.RULE_traversalMethod_flatMap) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1479 + self.match(GremlinParser.K_FLATMAP) + self.state = 1480 + self.match(GremlinParser.LPAREN) + self.state = 1481 + self.nestedTraversal() + self.state = 1482 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_foldContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_fold + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_fold_Object_BiFunctionContext(TraversalMethod_foldContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_foldContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_FOLD(self): + return self.getToken(GremlinParser.K_FOLD, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def traversalBiFunction(self): + return self.getTypedRuleContext(GremlinParser.TraversalBiFunctionContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_fold_Object_BiFunction"): + listener.enterTraversalMethod_fold_Object_BiFunction(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_fold_Object_BiFunction"): + listener.exitTraversalMethod_fold_Object_BiFunction(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_fold_Object_BiFunction"): + return visitor.visitTraversalMethod_fold_Object_BiFunction(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_fold_EmptyContext(TraversalMethod_foldContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_foldContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_FOLD(self): + return self.getToken(GremlinParser.K_FOLD, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_fold_Empty"): + listener.enterTraversalMethod_fold_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_fold_Empty"): + listener.exitTraversalMethod_fold_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_fold_Empty"): + return visitor.visitTraversalMethod_fold_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_fold(self): + + localctx = GremlinParser.TraversalMethod_foldContext(self, self._ctx, self.state) + self.enterRule(localctx, 142, self.RULE_traversalMethod_fold) + try: + self.state = 1494 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 43, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_fold_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1484 + self.match(GremlinParser.K_FOLD) + self.state = 1485 + self.match(GremlinParser.LPAREN) + self.state = 1486 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_fold_Object_BiFunctionContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1487 + self.match(GremlinParser.K_FOLD) + self.state = 1488 + self.match(GremlinParser.LPAREN) + self.state = 1489 + self.genericArgument() + self.state = 1490 + self.match(GremlinParser.COMMA) + self.state = 1491 + self.traversalBiFunction() + self.state = 1492 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_formatContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_format + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_format_StringContext(TraversalMethod_formatContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_formatContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_FORMAT(self): + return self.getToken(GremlinParser.K_FORMAT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_format_String"): + listener.enterTraversalMethod_format_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_format_String"): + listener.exitTraversalMethod_format_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_format_String"): + return visitor.visitTraversalMethod_format_String(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_format(self): + + localctx = GremlinParser.TraversalMethod_formatContext(self, self._ctx, self.state) + self.enterRule(localctx, 144, self.RULE_traversalMethod_format) + try: + localctx = GremlinParser.TraversalMethod_format_StringContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1496 + self.match(GremlinParser.K_FORMAT) + self.state = 1497 + self.match(GremlinParser.LPAREN) + self.state = 1498 + self.stringLiteral() + self.state = 1499 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_fromContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_from + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_from_VertexContext(TraversalMethod_fromContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_fromContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_FROM(self): + return self.getToken(GremlinParser.K_FROM, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def structureVertexArgument(self): + return self.getTypedRuleContext(GremlinParser.StructureVertexArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_from_Vertex"): + listener.enterTraversalMethod_from_Vertex(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_from_Vertex"): + listener.exitTraversalMethod_from_Vertex(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_from_Vertex"): + return visitor.visitTraversalMethod_from_Vertex(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_from_StringContext(TraversalMethod_fromContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_fromContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_FROM(self): + return self.getToken(GremlinParser.K_FROM, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_from_String"): + listener.enterTraversalMethod_from_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_from_String"): + listener.exitTraversalMethod_from_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_from_String"): + return visitor.visitTraversalMethod_from_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_from_TraversalContext(TraversalMethod_fromContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_fromContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_FROM(self): + return self.getToken(GremlinParser.K_FROM, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_from_Traversal"): + listener.enterTraversalMethod_from_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_from_Traversal"): + listener.exitTraversalMethod_from_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_from_Traversal"): + return visitor.visitTraversalMethod_from_Traversal(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_from(self): + + localctx = GremlinParser.TraversalMethod_fromContext(self, self._ctx, self.state) + self.enterRule(localctx, 146, self.RULE_traversalMethod_from) + try: + self.state = 1516 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 44, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_from_StringContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1501 + self.match(GremlinParser.K_FROM) + self.state = 1502 + self.match(GremlinParser.LPAREN) + self.state = 1503 + self.stringLiteral() + self.state = 1504 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_from_VertexContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1506 + self.match(GremlinParser.K_FROM) + self.state = 1507 + self.match(GremlinParser.LPAREN) + self.state = 1508 + self.structureVertexArgument() + self.state = 1509 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_from_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 1511 + self.match(GremlinParser.K_FROM) + self.state = 1512 + self.match(GremlinParser.LPAREN) + self.state = 1513 + self.nestedTraversal() + self.state = 1514 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_groupContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_group + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_group_EmptyContext(TraversalMethod_groupContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_groupContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_GROUP(self): + return self.getToken(GremlinParser.K_GROUP, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_group_Empty"): + listener.enterTraversalMethod_group_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_group_Empty"): + listener.exitTraversalMethod_group_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_group_Empty"): + return visitor.visitTraversalMethod_group_Empty(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_group_StringContext(TraversalMethod_groupContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_groupContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_GROUP(self): + return self.getToken(GremlinParser.K_GROUP, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_group_String"): + listener.enterTraversalMethod_group_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_group_String"): + listener.exitTraversalMethod_group_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_group_String"): + return visitor.visitTraversalMethod_group_String(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_group(self): + + localctx = GremlinParser.TraversalMethod_groupContext(self, self._ctx, self.state) + self.enterRule(localctx, 148, self.RULE_traversalMethod_group) + try: + self.state = 1526 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 45, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_group_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1518 + self.match(GremlinParser.K_GROUP) + self.state = 1519 + self.match(GremlinParser.LPAREN) + self.state = 1520 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_group_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1521 + self.match(GremlinParser.K_GROUP) + self.state = 1522 + self.match(GremlinParser.LPAREN) + self.state = 1523 + self.stringLiteral() + self.state = 1524 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_groupCountContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_groupCount + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_groupCount_StringContext(TraversalMethod_groupCountContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a GremlinParser.TraversalMethod_groupCountContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_GROUPCOUNT(self): + return self.getToken(GremlinParser.K_GROUPCOUNT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_groupCount_String"): + listener.enterTraversalMethod_groupCount_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_groupCount_String"): + listener.exitTraversalMethod_groupCount_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_groupCount_String"): + return visitor.visitTraversalMethod_groupCount_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_groupCount_EmptyContext(TraversalMethod_groupCountContext): + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a GremlinParser.TraversalMethod_groupCountContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_GROUPCOUNT(self): + return self.getToken(GremlinParser.K_GROUPCOUNT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_groupCount_Empty"): + listener.enterTraversalMethod_groupCount_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_groupCount_Empty"): + listener.exitTraversalMethod_groupCount_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_groupCount_Empty"): + return visitor.visitTraversalMethod_groupCount_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_groupCount(self): + + localctx = GremlinParser.TraversalMethod_groupCountContext(self, self._ctx, self.state) + self.enterRule(localctx, 150, self.RULE_traversalMethod_groupCount) + try: + self.state = 1536 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 46, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_groupCount_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1528 + self.match(GremlinParser.K_GROUPCOUNT) + self.state = 1529 + self.match(GremlinParser.LPAREN) + self.state = 1530 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_groupCount_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1531 + self.match(GremlinParser.K_GROUPCOUNT) + self.state = 1532 + self.match(GremlinParser.LPAREN) + self.state = 1533 + self.stringLiteral() + self.state = 1534 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_hasContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_has + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_has_T_ObjectContext(TraversalMethod_hasContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HAS(self): + return self.getToken(GremlinParser.K_HAS, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalT(self): + return self.getTypedRuleContext(GremlinParser.TraversalTContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_has_T_Object"): + listener.enterTraversalMethod_has_T_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_has_T_Object"): + listener.exitTraversalMethod_has_T_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_has_T_Object"): + return visitor.visitTraversalMethod_has_T_Object(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_has_T_TraversalContext(TraversalMethod_hasContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HAS(self): + return self.getToken(GremlinParser.K_HAS, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalT(self): + return self.getTypedRuleContext(GremlinParser.TraversalTContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_has_T_Traversal"): + listener.enterTraversalMethod_has_T_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_has_T_Traversal"): + listener.exitTraversalMethod_has_T_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_has_T_Traversal"): + return visitor.visitTraversalMethod_has_T_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_has_String_String_ObjectContext(TraversalMethod_hasContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HAS(self): + return self.getToken(GremlinParser.K_HAS, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableArgument(self): + return self.getTypedRuleContext(GremlinParser.StringNullableArgumentContext, 0) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def stringNullableLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralContext, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_has_String_String_Object"): + listener.enterTraversalMethod_has_String_String_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_has_String_String_Object"): + listener.exitTraversalMethod_has_String_String_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_has_String_String_Object"): + return visitor.visitTraversalMethod_has_String_String_Object(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_has_String_TraversalContext(TraversalMethod_hasContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HAS(self): + return self.getToken(GremlinParser.K_HAS, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_has_String_Traversal"): + listener.enterTraversalMethod_has_String_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_has_String_Traversal"): + listener.exitTraversalMethod_has_String_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_has_String_Traversal"): + return visitor.visitTraversalMethod_has_String_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_has_StringContext(TraversalMethod_hasContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HAS(self): + return self.getToken(GremlinParser.K_HAS, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_has_String"): + listener.enterTraversalMethod_has_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_has_String"): + listener.exitTraversalMethod_has_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_has_String"): + return visitor.visitTraversalMethod_has_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_has_T_PContext(TraversalMethod_hasContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HAS(self): + return self.getToken(GremlinParser.K_HAS, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalT(self): + return self.getTypedRuleContext(GremlinParser.TraversalTContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_has_T_P"): + listener.enterTraversalMethod_has_T_P(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_has_T_P"): + listener.exitTraversalMethod_has_T_P(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_has_T_P"): + return visitor.visitTraversalMethod_has_T_P(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_has_String_PContext(TraversalMethod_hasContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HAS(self): + return self.getToken(GremlinParser.K_HAS, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_has_String_P"): + listener.enterTraversalMethod_has_String_P(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_has_String_P"): + listener.exitTraversalMethod_has_String_P(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_has_String_P"): + return visitor.visitTraversalMethod_has_String_P(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_has_String_ObjectContext(TraversalMethod_hasContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HAS(self): + return self.getToken(GremlinParser.K_HAS, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_has_String_Object"): + listener.enterTraversalMethod_has_String_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_has_String_Object"): + listener.exitTraversalMethod_has_String_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_has_String_Object"): + return visitor.visitTraversalMethod_has_String_Object(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_has_String_String_PContext(TraversalMethod_hasContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HAS(self): + return self.getToken(GremlinParser.K_HAS, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableArgument(self): + return self.getTypedRuleContext(GremlinParser.StringNullableArgumentContext, 0) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def stringNullableLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralContext, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_has_String_String_P"): + listener.enterTraversalMethod_has_String_String_P(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_has_String_String_P"): + listener.exitTraversalMethod_has_String_String_P(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_has_String_String_P"): + return visitor.visitTraversalMethod_has_String_String_P(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_has(self): + + localctx = GremlinParser.TraversalMethod_hasContext(self, self._ctx, self.state) + self.enterRule(localctx, 152, self.RULE_traversalMethod_has) + try: + self.state = 1603 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 47, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_has_StringContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1538 + self.match(GremlinParser.K_HAS) + self.state = 1539 + self.match(GremlinParser.LPAREN) + self.state = 1540 + self.stringNullableLiteral() + self.state = 1541 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_has_String_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1543 + self.match(GremlinParser.K_HAS) + self.state = 1544 + self.match(GremlinParser.LPAREN) + self.state = 1545 + self.stringNullableLiteral() + self.state = 1546 + self.match(GremlinParser.COMMA) + self.state = 1547 + self.genericArgument() + self.state = 1548 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_has_String_PContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 1550 + self.match(GremlinParser.K_HAS) + self.state = 1551 + self.match(GremlinParser.LPAREN) + self.state = 1552 + self.stringNullableLiteral() + self.state = 1553 + self.match(GremlinParser.COMMA) + self.state = 1554 + self.traversalPredicate(0) + self.state = 1555 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 4: + localctx = GremlinParser.TraversalMethod_has_String_String_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 4) + self.state = 1557 + self.match(GremlinParser.K_HAS) + self.state = 1558 + self.match(GremlinParser.LPAREN) + self.state = 1559 + self.stringNullableArgument() + self.state = 1560 + self.match(GremlinParser.COMMA) + self.state = 1561 + self.stringNullableLiteral() + self.state = 1562 + self.match(GremlinParser.COMMA) + self.state = 1563 + self.genericArgument() + self.state = 1564 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 5: + localctx = GremlinParser.TraversalMethod_has_String_String_PContext(self, localctx) + self.enterOuterAlt(localctx, 5) + self.state = 1566 + self.match(GremlinParser.K_HAS) + self.state = 1567 + self.match(GremlinParser.LPAREN) + self.state = 1568 + self.stringNullableArgument() + self.state = 1569 + self.match(GremlinParser.COMMA) + self.state = 1570 + self.stringNullableLiteral() + self.state = 1571 + self.match(GremlinParser.COMMA) + self.state = 1572 + self.traversalPredicate(0) + self.state = 1573 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 6: + localctx = GremlinParser.TraversalMethod_has_String_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 6) + self.state = 1575 + self.match(GremlinParser.K_HAS) + self.state = 1576 + self.match(GremlinParser.LPAREN) + self.state = 1577 + self.stringNullableLiteral() + self.state = 1578 + self.match(GremlinParser.COMMA) + self.state = 1579 + self.nestedTraversal() + self.state = 1580 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 7: + localctx = GremlinParser.TraversalMethod_has_T_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 7) + self.state = 1582 + self.match(GremlinParser.K_HAS) + self.state = 1583 + self.match(GremlinParser.LPAREN) + self.state = 1584 + self.traversalT() + self.state = 1585 + self.match(GremlinParser.COMMA) + self.state = 1586 + self.genericArgument() + self.state = 1587 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 8: + localctx = GremlinParser.TraversalMethod_has_T_PContext(self, localctx) + self.enterOuterAlt(localctx, 8) + self.state = 1589 + self.match(GremlinParser.K_HAS) + self.state = 1590 + self.match(GremlinParser.LPAREN) + self.state = 1591 + self.traversalT() + self.state = 1592 + self.match(GremlinParser.COMMA) + self.state = 1593 + self.traversalPredicate(0) + self.state = 1594 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 9: + localctx = GremlinParser.TraversalMethod_has_T_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 9) + self.state = 1596 + self.match(GremlinParser.K_HAS) + self.state = 1597 + self.match(GremlinParser.LPAREN) + self.state = 1598 + self.traversalT() + self.state = 1599 + self.match(GremlinParser.COMMA) + self.state = 1600 + self.nestedTraversal() + self.state = 1601 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_hasIdContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_hasId + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_hasId_PContext(TraversalMethod_hasIdContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasIdContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HASID(self): + return self.getToken(GremlinParser.K_HASID, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_hasId_P"): + listener.enterTraversalMethod_hasId_P(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_hasId_P"): + listener.exitTraversalMethod_hasId_P(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_hasId_P"): + return visitor.visitTraversalMethod_hasId_P(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_hasId_Object_ObjectContext(TraversalMethod_hasIdContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasIdContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HASID(self): + return self.getToken(GremlinParser.K_HASID, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def genericArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentVarargsContext, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_hasId_Object_Object"): + listener.enterTraversalMethod_hasId_Object_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_hasId_Object_Object"): + listener.exitTraversalMethod_hasId_Object_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_hasId_Object_Object"): + return visitor.visitTraversalMethod_hasId_Object_Object(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_hasId(self): + + localctx = GremlinParser.TraversalMethod_hasIdContext(self, self._ctx, self.state) + self.enterRule(localctx, 154, self.RULE_traversalMethod_hasId) + self._la = 0 # Token type + try: + self.state = 1619 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 49, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_hasId_Object_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1605 + self.match(GremlinParser.K_HASID) + self.state = 1606 + self.match(GremlinParser.LPAREN) + self.state = 1607 + self.genericArgument() + self.state = 1610 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 1608 + self.match(GremlinParser.COMMA) + self.state = 1609 + self.genericArgumentVarargs() + + self.state = 1612 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_hasId_PContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1614 + self.match(GremlinParser.K_HASID) + self.state = 1615 + self.match(GremlinParser.LPAREN) + self.state = 1616 + self.traversalPredicate(0) + self.state = 1617 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_hasKeyContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_hasKey + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_hasKey_PContext(TraversalMethod_hasKeyContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasKeyContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HASKEY(self): + return self.getToken(GremlinParser.K_HASKEY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_hasKey_P"): + listener.enterTraversalMethod_hasKey_P(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_hasKey_P"): + listener.exitTraversalMethod_hasKey_P(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_hasKey_P"): + return visitor.visitTraversalMethod_hasKey_P(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_hasKey_String_StringContext(TraversalMethod_hasKeyContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasKeyContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HASKEY(self): + return self.getToken(GremlinParser.K_HASKEY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_hasKey_String_String"): + listener.enterTraversalMethod_hasKey_String_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_hasKey_String_String"): + listener.exitTraversalMethod_hasKey_String_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_hasKey_String_String"): + return visitor.visitTraversalMethod_hasKey_String_String(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_hasKey(self): + + localctx = GremlinParser.TraversalMethod_hasKeyContext(self, self._ctx, self.state) + self.enterRule(localctx, 156, self.RULE_traversalMethod_hasKey) + self._la = 0 # Token type + try: + self.state = 1635 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 51, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_hasKey_PContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1621 + self.match(GremlinParser.K_HASKEY) + self.state = 1622 + self.match(GremlinParser.LPAREN) + self.state = 1623 + self.traversalPredicate(0) + self.state = 1624 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_hasKey_String_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1626 + self.match(GremlinParser.K_HASKEY) + self.state = 1627 + self.match(GremlinParser.LPAREN) + self.state = 1628 + self.stringNullableLiteral() + self.state = 1631 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 1629 + self.match(GremlinParser.COMMA) + self.state = 1630 + self.stringNullableLiteralVarargs() + + self.state = 1633 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_hasLabelContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_hasLabel + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_hasLabel_String_StringContext(TraversalMethod_hasLabelContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasLabelContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HASLABEL(self): + return self.getToken(GremlinParser.K_HASLABEL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableArgument(self): + return self.getTypedRuleContext(GremlinParser.StringNullableArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def stringNullableArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableArgumentVarargsContext, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_hasLabel_String_String"): + listener.enterTraversalMethod_hasLabel_String_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_hasLabel_String_String"): + listener.exitTraversalMethod_hasLabel_String_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_hasLabel_String_String"): + return visitor.visitTraversalMethod_hasLabel_String_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_hasLabel_PContext(TraversalMethod_hasLabelContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasLabelContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HASLABEL(self): + return self.getToken(GremlinParser.K_HASLABEL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_hasLabel_P"): + listener.enterTraversalMethod_hasLabel_P(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_hasLabel_P"): + listener.exitTraversalMethod_hasLabel_P(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_hasLabel_P"): + return visitor.visitTraversalMethod_hasLabel_P(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_hasLabel(self): + + localctx = GremlinParser.TraversalMethod_hasLabelContext(self, self._ctx, self.state) + self.enterRule(localctx, 158, self.RULE_traversalMethod_hasLabel) + self._la = 0 # Token type + try: + self.state = 1651 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 53, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_hasLabel_PContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1637 + self.match(GremlinParser.K_HASLABEL) + self.state = 1638 + self.match(GremlinParser.LPAREN) + self.state = 1639 + self.traversalPredicate(0) + self.state = 1640 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_hasLabel_String_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1642 + self.match(GremlinParser.K_HASLABEL) + self.state = 1643 + self.match(GremlinParser.LPAREN) + self.state = 1644 + self.stringNullableArgument() + self.state = 1647 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 1645 + self.match(GremlinParser.COMMA) + self.state = 1646 + self.stringNullableArgumentVarargs() + + self.state = 1649 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_hasNotContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_HASNOT(self): + return self.getToken(GremlinParser.K_HASNOT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_hasNot + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_hasNot"): + listener.enterTraversalMethod_hasNot(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_hasNot"): + listener.exitTraversalMethod_hasNot(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_hasNot"): + return visitor.visitTraversalMethod_hasNot(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_hasNot(self): + + localctx = GremlinParser.TraversalMethod_hasNotContext(self, self._ctx, self.state) + self.enterRule(localctx, 160, self.RULE_traversalMethod_hasNot) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1653 + self.match(GremlinParser.K_HASNOT) + self.state = 1654 + self.match(GremlinParser.LPAREN) + self.state = 1655 + self.stringNullableLiteral() + self.state = 1656 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_hasValueContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_hasValue + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_hasValue_PContext(TraversalMethod_hasValueContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasValueContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HASVALUE(self): + return self.getToken(GremlinParser.K_HASVALUE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_hasValue_P"): + listener.enterTraversalMethod_hasValue_P(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_hasValue_P"): + listener.exitTraversalMethod_hasValue_P(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_hasValue_P"): + return visitor.visitTraversalMethod_hasValue_P(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_hasValue_Object_ObjectContext(TraversalMethod_hasValueContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_hasValueContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_HASVALUE(self): + return self.getToken(GremlinParser.K_HASVALUE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def genericArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentVarargsContext, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_hasValue_Object_Object"): + listener.enterTraversalMethod_hasValue_Object_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_hasValue_Object_Object"): + listener.exitTraversalMethod_hasValue_Object_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_hasValue_Object_Object"): + return visitor.visitTraversalMethod_hasValue_Object_Object(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_hasValue(self): + + localctx = GremlinParser.TraversalMethod_hasValueContext(self, self._ctx, self.state) + self.enterRule(localctx, 162, self.RULE_traversalMethod_hasValue) + self._la = 0 # Token type + try: + self.state = 1672 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 55, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_hasValue_Object_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1658 + self.match(GremlinParser.K_HASVALUE) + self.state = 1659 + self.match(GremlinParser.LPAREN) + self.state = 1660 + self.genericArgument() + self.state = 1663 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 1661 + self.match(GremlinParser.COMMA) + self.state = 1662 + self.genericArgumentVarargs() + + self.state = 1665 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_hasValue_PContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1667 + self.match(GremlinParser.K_HASVALUE) + self.state = 1668 + self.match(GremlinParser.LPAREN) + self.state = 1669 + self.traversalPredicate(0) + self.state = 1670 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_idContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_ID(self): + return self.getToken(GremlinParser.K_ID, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_id + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_id"): + listener.enterTraversalMethod_id(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_id"): + listener.exitTraversalMethod_id(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_id"): + return visitor.visitTraversalMethod_id(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_id(self): + + localctx = GremlinParser.TraversalMethod_idContext(self, self._ctx, self.state) + self.enterRule(localctx, 164, self.RULE_traversalMethod_id) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1674 + self.match(GremlinParser.K_ID) + self.state = 1675 + self.match(GremlinParser.LPAREN) + self.state = 1676 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_identityContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_IDENTITY(self): + return self.getToken(GremlinParser.K_IDENTITY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_identity + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_identity"): + listener.enterTraversalMethod_identity(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_identity"): + listener.exitTraversalMethod_identity(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_identity"): + return visitor.visitTraversalMethod_identity(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_identity(self): + + localctx = GremlinParser.TraversalMethod_identityContext(self, self._ctx, self.state) + self.enterRule(localctx, 166, self.RULE_traversalMethod_identity) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1678 + self.match(GremlinParser.K_IDENTITY) + self.state = 1679 + self.match(GremlinParser.LPAREN) + self.state = 1680 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_inContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_IN(self): + return self.getToken(GremlinParser.K_IN, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableArgumentVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_in + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_in"): + listener.enterTraversalMethod_in(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_in"): + listener.exitTraversalMethod_in(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_in"): + return visitor.visitTraversalMethod_in(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_in(self): + + localctx = GremlinParser.TraversalMethod_inContext(self, self._ctx, self.state) + self.enterRule(localctx, 168, self.RULE_traversalMethod_in) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1682 + self.match(GremlinParser.K_IN) + self.state = 1683 + self.match(GremlinParser.LPAREN) + self.state = 1684 + self.stringNullableArgumentVarargs() + self.state = 1685 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_inEContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_INE(self): + return self.getToken(GremlinParser.K_INE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableArgumentVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_inE + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_inE"): + listener.enterTraversalMethod_inE(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_inE"): + listener.exitTraversalMethod_inE(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_inE"): + return visitor.visitTraversalMethod_inE(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_inE(self): + + localctx = GremlinParser.TraversalMethod_inEContext(self, self._ctx, self.state) + self.enterRule(localctx, 170, self.RULE_traversalMethod_inE) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1687 + self.match(GremlinParser.K_INE) + self.state = 1688 + self.match(GremlinParser.LPAREN) + self.state = 1689 + self.stringNullableArgumentVarargs() + self.state = 1690 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_intersectContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_intersect + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_intersect_ObjectContext(TraversalMethod_intersectContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_intersectContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_INTERSECT(self): + return self.getToken(GremlinParser.K_INTERSECT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_intersect_Object"): + listener.enterTraversalMethod_intersect_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_intersect_Object"): + listener.exitTraversalMethod_intersect_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_intersect_Object"): + return visitor.visitTraversalMethod_intersect_Object(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_intersect(self): + + localctx = GremlinParser.TraversalMethod_intersectContext(self, self._ctx, self.state) + self.enterRule(localctx, 172, self.RULE_traversalMethod_intersect) + try: + localctx = GremlinParser.TraversalMethod_intersect_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1692 + self.match(GremlinParser.K_INTERSECT) + self.state = 1693 + self.match(GremlinParser.LPAREN) + self.state = 1694 + self.genericArgument() + self.state = 1695 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_inVContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_INV(self): + return self.getToken(GremlinParser.K_INV, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_inV + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_inV"): + listener.enterTraversalMethod_inV(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_inV"): + listener.exitTraversalMethod_inV(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_inV"): + return visitor.visitTraversalMethod_inV(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_inV(self): + + localctx = GremlinParser.TraversalMethod_inVContext(self, self._ctx, self.state) + self.enterRule(localctx, 174, self.RULE_traversalMethod_inV) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1697 + self.match(GremlinParser.K_INV) + self.state = 1698 + self.match(GremlinParser.LPAREN) + self.state = 1699 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_indexContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_INDEX(self): + return self.getToken(GremlinParser.K_INDEX, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_index + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_index"): + listener.enterTraversalMethod_index(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_index"): + listener.exitTraversalMethod_index(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_index"): + return visitor.visitTraversalMethod_index(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_index(self): + + localctx = GremlinParser.TraversalMethod_indexContext(self, self._ctx, self.state) + self.enterRule(localctx, 176, self.RULE_traversalMethod_index) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1701 + self.match(GremlinParser.K_INDEX) + self.state = 1702 + self.match(GremlinParser.LPAREN) + self.state = 1703 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_injectContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_INJECT(self): + return self.getToken(GremlinParser.K_INJECT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_inject + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_inject"): + listener.enterTraversalMethod_inject(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_inject"): + listener.exitTraversalMethod_inject(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_inject"): + return visitor.visitTraversalMethod_inject(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_inject(self): + + localctx = GremlinParser.TraversalMethod_injectContext(self, self._ctx, self.state) + self.enterRule(localctx, 178, self.RULE_traversalMethod_inject) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1705 + self.match(GremlinParser.K_INJECT) + self.state = 1706 + self.match(GremlinParser.LPAREN) + self.state = 1707 + self.genericArgumentVarargs() + self.state = 1708 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_isContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_is + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_is_ObjectContext(TraversalMethod_isContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_isContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_IS(self): + return self.getToken(GremlinParser.K_IS, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_is_Object"): + listener.enterTraversalMethod_is_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_is_Object"): + listener.exitTraversalMethod_is_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_is_Object"): + return visitor.visitTraversalMethod_is_Object(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_is_PContext(TraversalMethod_isContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_isContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_IS(self): + return self.getToken(GremlinParser.K_IS, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_is_P"): + listener.enterTraversalMethod_is_P(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_is_P"): + listener.exitTraversalMethod_is_P(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_is_P"): + return visitor.visitTraversalMethod_is_P(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_is(self): + + localctx = GremlinParser.TraversalMethod_isContext(self, self._ctx, self.state) + self.enterRule(localctx, 180, self.RULE_traversalMethod_is) + try: + self.state = 1720 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 56, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_is_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1710 + self.match(GremlinParser.K_IS) + self.state = 1711 + self.match(GremlinParser.LPAREN) + self.state = 1712 + self.genericArgument() + self.state = 1713 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_is_PContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1715 + self.match(GremlinParser.K_IS) + self.state = 1716 + self.match(GremlinParser.LPAREN) + self.state = 1717 + self.traversalPredicate(0) + self.state = 1718 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_keyContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_KEY(self): + return self.getToken(GremlinParser.K_KEY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_key + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_key"): + listener.enterTraversalMethod_key(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_key"): + listener.exitTraversalMethod_key(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_key"): + return visitor.visitTraversalMethod_key(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_key(self): + + localctx = GremlinParser.TraversalMethod_keyContext(self, self._ctx, self.state) + self.enterRule(localctx, 182, self.RULE_traversalMethod_key) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1722 + self.match(GremlinParser.K_KEY) + self.state = 1723 + self.match(GremlinParser.LPAREN) + self.state = 1724 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_labelContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_LABEL(self): + return self.getToken(GremlinParser.K_LABEL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_label + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_label"): + listener.enterTraversalMethod_label(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_label"): + listener.exitTraversalMethod_label(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_label"): + return visitor.visitTraversalMethod_label(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_label(self): + + localctx = GremlinParser.TraversalMethod_labelContext(self, self._ctx, self.state) + self.enterRule(localctx, 184, self.RULE_traversalMethod_label) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1726 + self.match(GremlinParser.K_LABEL) + self.state = 1727 + self.match(GremlinParser.LPAREN) + self.state = 1728 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_lengthContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_length + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_length_ScopeContext(TraversalMethod_lengthContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_lengthContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_LENGTH(self): + return self.getToken(GremlinParser.K_LENGTH, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_length_Scope"): + listener.enterTraversalMethod_length_Scope(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_length_Scope"): + listener.exitTraversalMethod_length_Scope(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_length_Scope"): + return visitor.visitTraversalMethod_length_Scope(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_length_EmptyContext(TraversalMethod_lengthContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_lengthContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_LENGTH(self): + return self.getToken(GremlinParser.K_LENGTH, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_length_Empty"): + listener.enterTraversalMethod_length_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_length_Empty"): + listener.exitTraversalMethod_length_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_length_Empty"): + return visitor.visitTraversalMethod_length_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_length(self): + + localctx = GremlinParser.TraversalMethod_lengthContext(self, self._ctx, self.state) + self.enterRule(localctx, 186, self.RULE_traversalMethod_length) + try: + self.state = 1738 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 57, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_length_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1730 + self.match(GremlinParser.K_LENGTH) + self.state = 1731 + self.match(GremlinParser.LPAREN) + self.state = 1732 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_length_ScopeContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1733 + self.match(GremlinParser.K_LENGTH) + self.state = 1734 + self.match(GremlinParser.LPAREN) + self.state = 1735 + self.traversalScope() + self.state = 1736 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_limitContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_limit + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_limit_Scope_longContext(TraversalMethod_limitContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_limitContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_LIMIT(self): + return self.getToken(GremlinParser.K_LIMIT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def integerArgument(self): + return self.getTypedRuleContext(GremlinParser.IntegerArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_limit_Scope_long"): + listener.enterTraversalMethod_limit_Scope_long(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_limit_Scope_long"): + listener.exitTraversalMethod_limit_Scope_long(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_limit_Scope_long"): + return visitor.visitTraversalMethod_limit_Scope_long(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_limit_longContext(TraversalMethod_limitContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_limitContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_LIMIT(self): + return self.getToken(GremlinParser.K_LIMIT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def integerArgument(self): + return self.getTypedRuleContext(GremlinParser.IntegerArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_limit_long"): + listener.enterTraversalMethod_limit_long(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_limit_long"): + listener.exitTraversalMethod_limit_long(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_limit_long"): + return visitor.visitTraversalMethod_limit_long(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_limit(self): + + localctx = GremlinParser.TraversalMethod_limitContext(self, self._ctx, self.state) + self.enterRule(localctx, 188, self.RULE_traversalMethod_limit) + try: + self.state = 1752 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 58, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_limit_Scope_longContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1740 + self.match(GremlinParser.K_LIMIT) + self.state = 1741 + self.match(GremlinParser.LPAREN) + self.state = 1742 + self.traversalScope() + self.state = 1743 + self.match(GremlinParser.COMMA) + self.state = 1744 + self.integerArgument() + self.state = 1745 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_limit_longContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1747 + self.match(GremlinParser.K_LIMIT) + self.state = 1748 + self.match(GremlinParser.LPAREN) + self.state = 1749 + self.integerArgument() + self.state = 1750 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_localContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_LOCAL(self): + return self.getToken(GremlinParser.K_LOCAL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_local + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_local"): + listener.enterTraversalMethod_local(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_local"): + listener.exitTraversalMethod_local(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_local"): + return visitor.visitTraversalMethod_local(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_local(self): + + localctx = GremlinParser.TraversalMethod_localContext(self, self._ctx, self.state) + self.enterRule(localctx, 190, self.RULE_traversalMethod_local) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1754 + self.match(GremlinParser.K_LOCAL) + self.state = 1755 + self.match(GremlinParser.LPAREN) + self.state = 1756 + self.nestedTraversal() + self.state = 1757 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_loopsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_loops + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_loops_StringContext(TraversalMethod_loopsContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_loopsContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_LOOPS(self): + return self.getToken(GremlinParser.K_LOOPS, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_loops_String"): + listener.enterTraversalMethod_loops_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_loops_String"): + listener.exitTraversalMethod_loops_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_loops_String"): + return visitor.visitTraversalMethod_loops_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_loops_EmptyContext(TraversalMethod_loopsContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_loopsContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_LOOPS(self): + return self.getToken(GremlinParser.K_LOOPS, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_loops_Empty"): + listener.enterTraversalMethod_loops_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_loops_Empty"): + listener.exitTraversalMethod_loops_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_loops_Empty"): + return visitor.visitTraversalMethod_loops_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_loops(self): + + localctx = GremlinParser.TraversalMethod_loopsContext(self, self._ctx, self.state) + self.enterRule(localctx, 192, self.RULE_traversalMethod_loops) + try: + self.state = 1767 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 59, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_loops_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1759 + self.match(GremlinParser.K_LOOPS) + self.state = 1760 + self.match(GremlinParser.LPAREN) + self.state = 1761 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_loops_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1762 + self.match(GremlinParser.K_LOOPS) + self.state = 1763 + self.match(GremlinParser.LPAREN) + self.state = 1764 + self.stringLiteral() + self.state = 1765 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_lTrimContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_lTrim + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_lTrim_ScopeContext(TraversalMethod_lTrimContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_lTrimContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_LTRIM(self): + return self.getToken(GremlinParser.K_LTRIM, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_lTrim_Scope"): + listener.enterTraversalMethod_lTrim_Scope(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_lTrim_Scope"): + listener.exitTraversalMethod_lTrim_Scope(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_lTrim_Scope"): + return visitor.visitTraversalMethod_lTrim_Scope(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_lTrim_EmptyContext(TraversalMethod_lTrimContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_lTrimContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_LTRIM(self): + return self.getToken(GremlinParser.K_LTRIM, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_lTrim_Empty"): + listener.enterTraversalMethod_lTrim_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_lTrim_Empty"): + listener.exitTraversalMethod_lTrim_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_lTrim_Empty"): + return visitor.visitTraversalMethod_lTrim_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_lTrim(self): + + localctx = GremlinParser.TraversalMethod_lTrimContext(self, self._ctx, self.state) + self.enterRule(localctx, 194, self.RULE_traversalMethod_lTrim) + try: + self.state = 1777 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 60, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_lTrim_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1769 + self.match(GremlinParser.K_LTRIM) + self.state = 1770 + self.match(GremlinParser.LPAREN) + self.state = 1771 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_lTrim_ScopeContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1772 + self.match(GremlinParser.K_LTRIM) + self.state = 1773 + self.match(GremlinParser.LPAREN) + self.state = 1774 + self.traversalScope() + self.state = 1775 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_mapContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_MAP(self): + return self.getToken(GremlinParser.K_MAP, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_map + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_map"): + listener.enterTraversalMethod_map(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_map"): + listener.exitTraversalMethod_map(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_map"): + return visitor.visitTraversalMethod_map(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_map(self): + + localctx = GremlinParser.TraversalMethod_mapContext(self, self._ctx, self.state) + self.enterRule(localctx, 196, self.RULE_traversalMethod_map) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1779 + self.match(GremlinParser.K_MAP) + self.state = 1780 + self.match(GremlinParser.LPAREN) + self.state = 1781 + self.nestedTraversal() + self.state = 1782 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_matchContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_MATCH(self): + return self.getToken(GremlinParser.K_MATCH, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversalList(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalListContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_match + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_match"): + listener.enterTraversalMethod_match(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_match"): + listener.exitTraversalMethod_match(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_match"): + return visitor.visitTraversalMethod_match(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_match(self): + + localctx = GremlinParser.TraversalMethod_matchContext(self, self._ctx, self.state) + self.enterRule(localctx, 198, self.RULE_traversalMethod_match) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1784 + self.match(GremlinParser.K_MATCH) + self.state = 1785 + self.match(GremlinParser.LPAREN) + self.state = 1786 + self.nestedTraversalList() + self.state = 1787 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_mathContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_MATH(self): + return self.getToken(GremlinParser.K_MATH, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_math + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_math"): + listener.enterTraversalMethod_math(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_math"): + listener.exitTraversalMethod_math(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_math"): + return visitor.visitTraversalMethod_math(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_math(self): + + localctx = GremlinParser.TraversalMethod_mathContext(self, self._ctx, self.state) + self.enterRule(localctx, 200, self.RULE_traversalMethod_math) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1789 + self.match(GremlinParser.K_MATH) + self.state = 1790 + self.match(GremlinParser.LPAREN) + self.state = 1791 + self.stringLiteral() + self.state = 1792 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_maxContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_max + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_max_ScopeContext(TraversalMethod_maxContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_maxContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MAX(self): + return self.getToken(GremlinParser.K_MAX, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_max_Scope"): + listener.enterTraversalMethod_max_Scope(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_max_Scope"): + listener.exitTraversalMethod_max_Scope(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_max_Scope"): + return visitor.visitTraversalMethod_max_Scope(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_max_EmptyContext(TraversalMethod_maxContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_maxContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MAX(self): + return self.getToken(GremlinParser.K_MAX, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_max_Empty"): + listener.enterTraversalMethod_max_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_max_Empty"): + listener.exitTraversalMethod_max_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_max_Empty"): + return visitor.visitTraversalMethod_max_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_max(self): + + localctx = GremlinParser.TraversalMethod_maxContext(self, self._ctx, self.state) + self.enterRule(localctx, 202, self.RULE_traversalMethod_max) + try: + self.state = 1802 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 61, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_max_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1794 + self.match(GremlinParser.K_MAX) + self.state = 1795 + self.match(GremlinParser.LPAREN) + self.state = 1796 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_max_ScopeContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1797 + self.match(GremlinParser.K_MAX) + self.state = 1798 + self.match(GremlinParser.LPAREN) + self.state = 1799 + self.traversalScope() + self.state = 1800 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_meanContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_mean + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_mean_ScopeContext(TraversalMethod_meanContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_meanContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MEAN(self): + return self.getToken(GremlinParser.K_MEAN, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_mean_Scope"): + listener.enterTraversalMethod_mean_Scope(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_mean_Scope"): + listener.exitTraversalMethod_mean_Scope(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_mean_Scope"): + return visitor.visitTraversalMethod_mean_Scope(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_mean_EmptyContext(TraversalMethod_meanContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_meanContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MEAN(self): + return self.getToken(GremlinParser.K_MEAN, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_mean_Empty"): + listener.enterTraversalMethod_mean_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_mean_Empty"): + listener.exitTraversalMethod_mean_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_mean_Empty"): + return visitor.visitTraversalMethod_mean_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_mean(self): + + localctx = GremlinParser.TraversalMethod_meanContext(self, self._ctx, self.state) + self.enterRule(localctx, 204, self.RULE_traversalMethod_mean) + try: + self.state = 1812 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 62, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_mean_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1804 + self.match(GremlinParser.K_MEAN) + self.state = 1805 + self.match(GremlinParser.LPAREN) + self.state = 1806 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_mean_ScopeContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1807 + self.match(GremlinParser.K_MEAN) + self.state = 1808 + self.match(GremlinParser.LPAREN) + self.state = 1809 + self.traversalScope() + self.state = 1810 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_mergeContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_merge + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_merge_ObjectContext(TraversalMethod_mergeContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_mergeContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MERGE(self): + return self.getToken(GremlinParser.K_MERGE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_merge_Object"): + listener.enterTraversalMethod_merge_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_merge_Object"): + listener.exitTraversalMethod_merge_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_merge_Object"): + return visitor.visitTraversalMethod_merge_Object(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_merge(self): + + localctx = GremlinParser.TraversalMethod_mergeContext(self, self._ctx, self.state) + self.enterRule(localctx, 206, self.RULE_traversalMethod_merge) + try: + localctx = GremlinParser.TraversalMethod_merge_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1814 + self.match(GremlinParser.K_MERGE) + self.state = 1815 + self.match(GremlinParser.LPAREN) + self.state = 1816 + self.genericArgument() + self.state = 1817 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_mergeVContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_mergeV + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_mergeV_MapContext(TraversalMethod_mergeVContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_mergeVContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MERGEV(self): + return self.getToken(GremlinParser.K_MERGEV, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericMapNullableArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericMapNullableArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_mergeV_Map"): + listener.enterTraversalMethod_mergeV_Map(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_mergeV_Map"): + listener.exitTraversalMethod_mergeV_Map(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_mergeV_Map"): + return visitor.visitTraversalMethod_mergeV_Map(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_mergeV_TraversalContext(TraversalMethod_mergeVContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_mergeVContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MERGEV(self): + return self.getToken(GremlinParser.K_MERGEV, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_mergeV_Traversal"): + listener.enterTraversalMethod_mergeV_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_mergeV_Traversal"): + listener.exitTraversalMethod_mergeV_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_mergeV_Traversal"): + return visitor.visitTraversalMethod_mergeV_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_mergeV_emptyContext(TraversalMethod_mergeVContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_mergeVContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MERGEV(self): + return self.getToken(GremlinParser.K_MERGEV, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_mergeV_empty"): + listener.enterTraversalMethod_mergeV_empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_mergeV_empty"): + listener.exitTraversalMethod_mergeV_empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_mergeV_empty"): + return visitor.visitTraversalMethod_mergeV_empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_mergeV(self): + + localctx = GremlinParser.TraversalMethod_mergeVContext(self, self._ctx, self.state) + self.enterRule(localctx, 208, self.RULE_traversalMethod_mergeV) + try: + self.state = 1832 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 63, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_mergeV_emptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1819 + self.match(GremlinParser.K_MERGEV) + self.state = 1820 + self.match(GremlinParser.LPAREN) + self.state = 1821 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_mergeV_MapContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1822 + self.match(GremlinParser.K_MERGEV) + self.state = 1823 + self.match(GremlinParser.LPAREN) + self.state = 1824 + self.genericMapNullableArgument() + self.state = 1825 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_mergeV_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 1827 + self.match(GremlinParser.K_MERGEV) + self.state = 1828 + self.match(GremlinParser.LPAREN) + self.state = 1829 + self.nestedTraversal() + self.state = 1830 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_mergeEContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_mergeE + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_mergeE_emptyContext(TraversalMethod_mergeEContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_mergeEContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MERGEE(self): + return self.getToken(GremlinParser.K_MERGEE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_mergeE_empty"): + listener.enterTraversalMethod_mergeE_empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_mergeE_empty"): + listener.exitTraversalMethod_mergeE_empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_mergeE_empty"): + return visitor.visitTraversalMethod_mergeE_empty(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_mergeE_MapContext(TraversalMethod_mergeEContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_mergeEContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MERGEE(self): + return self.getToken(GremlinParser.K_MERGEE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericMapNullableArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericMapNullableArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_mergeE_Map"): + listener.enterTraversalMethod_mergeE_Map(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_mergeE_Map"): + listener.exitTraversalMethod_mergeE_Map(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_mergeE_Map"): + return visitor.visitTraversalMethod_mergeE_Map(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_mergeE_TraversalContext(TraversalMethod_mergeEContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_mergeEContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MERGEE(self): + return self.getToken(GremlinParser.K_MERGEE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_mergeE_Traversal"): + listener.enterTraversalMethod_mergeE_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_mergeE_Traversal"): + listener.exitTraversalMethod_mergeE_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_mergeE_Traversal"): + return visitor.visitTraversalMethod_mergeE_Traversal(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_mergeE(self): + + localctx = GremlinParser.TraversalMethod_mergeEContext(self, self._ctx, self.state) + self.enterRule(localctx, 210, self.RULE_traversalMethod_mergeE) + try: + self.state = 1847 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 64, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_mergeE_emptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1834 + self.match(GremlinParser.K_MERGEE) + self.state = 1835 + self.match(GremlinParser.LPAREN) + self.state = 1836 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_mergeE_MapContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1837 + self.match(GremlinParser.K_MERGEE) + self.state = 1838 + self.match(GremlinParser.LPAREN) + self.state = 1839 + self.genericMapNullableArgument() + self.state = 1840 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_mergeE_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 1842 + self.match(GremlinParser.K_MERGEE) + self.state = 1843 + self.match(GremlinParser.LPAREN) + self.state = 1844 + self.nestedTraversal() + self.state = 1845 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_minContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_min + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_min_EmptyContext(TraversalMethod_minContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_minContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MIN(self): + return self.getToken(GremlinParser.K_MIN, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_min_Empty"): + listener.enterTraversalMethod_min_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_min_Empty"): + listener.exitTraversalMethod_min_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_min_Empty"): + return visitor.visitTraversalMethod_min_Empty(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_min_ScopeContext(TraversalMethod_minContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_minContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_MIN(self): + return self.getToken(GremlinParser.K_MIN, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_min_Scope"): + listener.enterTraversalMethod_min_Scope(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_min_Scope"): + listener.exitTraversalMethod_min_Scope(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_min_Scope"): + return visitor.visitTraversalMethod_min_Scope(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_min(self): + + localctx = GremlinParser.TraversalMethod_minContext(self, self._ctx, self.state) + self.enterRule(localctx, 212, self.RULE_traversalMethod_min) + try: + self.state = 1857 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 65, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_min_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1849 + self.match(GremlinParser.K_MIN) + self.state = 1850 + self.match(GremlinParser.LPAREN) + self.state = 1851 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_min_ScopeContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1852 + self.match(GremlinParser.K_MIN) + self.state = 1853 + self.match(GremlinParser.LPAREN) + self.state = 1854 + self.traversalScope() + self.state = 1855 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_noneContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_none + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_none_PContext(TraversalMethod_noneContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_noneContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_NONE(self): + return self.getToken(GremlinParser.K_NONE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_none_P"): + listener.enterTraversalMethod_none_P(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_none_P"): + listener.exitTraversalMethod_none_P(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_none_P"): + return visitor.visitTraversalMethod_none_P(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_none(self): + + localctx = GremlinParser.TraversalMethod_noneContext(self, self._ctx, self.state) + self.enterRule(localctx, 214, self.RULE_traversalMethod_none) + try: + localctx = GremlinParser.TraversalMethod_none_PContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1859 + self.match(GremlinParser.K_NONE) + self.state = 1860 + self.match(GremlinParser.LPAREN) + self.state = 1861 + self.traversalPredicate(0) + self.state = 1862 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_notContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_NOT(self): + return self.getToken(GremlinParser.K_NOT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_not + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_not"): + listener.enterTraversalMethod_not(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_not"): + listener.exitTraversalMethod_not(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_not"): + return visitor.visitTraversalMethod_not(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_not(self): + + localctx = GremlinParser.TraversalMethod_notContext(self, self._ctx, self.state) + self.enterRule(localctx, 216, self.RULE_traversalMethod_not) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1864 + self.match(GremlinParser.K_NOT) + self.state = 1865 + self.match(GremlinParser.LPAREN) + self.state = 1866 + self.nestedTraversal() + self.state = 1867 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_optionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_option + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_option_Merge_MapContext(TraversalMethod_optionContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_optionContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_OPTION(self): + return self.getToken(GremlinParser.K_OPTION, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalMerge(self): + return self.getTypedRuleContext(GremlinParser.TraversalMergeContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def genericMapNullableArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericMapNullableArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_option_Merge_Map"): + listener.enterTraversalMethod_option_Merge_Map(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_option_Merge_Map"): + listener.exitTraversalMethod_option_Merge_Map(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_option_Merge_Map"): + return visitor.visitTraversalMethod_option_Merge_Map(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_option_Merge_Map_CardinalityContext(TraversalMethod_optionContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_optionContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_OPTION(self): + return self.getToken(GremlinParser.K_OPTION, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalMerge(self): + return self.getTypedRuleContext(GremlinParser.TraversalMergeContext, 0) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def genericMapNullableArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericMapNullableArgumentContext, 0) + + def traversalCardinality(self): + return self.getTypedRuleContext(GremlinParser.TraversalCardinalityContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_option_Merge_Map_Cardinality"): + listener.enterTraversalMethod_option_Merge_Map_Cardinality(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_option_Merge_Map_Cardinality"): + listener.exitTraversalMethod_option_Merge_Map_Cardinality(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_option_Merge_Map_Cardinality"): + return visitor.visitTraversalMethod_option_Merge_Map_Cardinality(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_option_Merge_TraversalContext(TraversalMethod_optionContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_optionContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_OPTION(self): + return self.getToken(GremlinParser.K_OPTION, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalMerge(self): + return self.getTypedRuleContext(GremlinParser.TraversalMergeContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_option_Merge_Traversal"): + listener.enterTraversalMethod_option_Merge_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_option_Merge_Traversal"): + listener.exitTraversalMethod_option_Merge_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_option_Merge_Traversal"): + return visitor.visitTraversalMethod_option_Merge_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_option_Object_TraversalContext(TraversalMethod_optionContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_optionContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_OPTION(self): + return self.getToken(GremlinParser.K_OPTION, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_option_Object_Traversal"): + listener.enterTraversalMethod_option_Object_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_option_Object_Traversal"): + listener.exitTraversalMethod_option_Object_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_option_Object_Traversal"): + return visitor.visitTraversalMethod_option_Object_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_option_Predicate_TraversalContext(TraversalMethod_optionContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_optionContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_OPTION(self): + return self.getToken(GremlinParser.K_OPTION, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_option_Predicate_Traversal"): + listener.enterTraversalMethod_option_Predicate_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_option_Predicate_Traversal"): + listener.exitTraversalMethod_option_Predicate_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_option_Predicate_Traversal"): + return visitor.visitTraversalMethod_option_Predicate_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_option_TraversalContext(TraversalMethod_optionContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_optionContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_OPTION(self): + return self.getToken(GremlinParser.K_OPTION, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_option_Traversal"): + listener.enterTraversalMethod_option_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_option_Traversal"): + listener.exitTraversalMethod_option_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_option_Traversal"): + return visitor.visitTraversalMethod_option_Traversal(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_option(self): + + localctx = GremlinParser.TraversalMethod_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 218, self.RULE_traversalMethod_option) + try: + self.state = 1911 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 66, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_option_Predicate_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1869 + self.match(GremlinParser.K_OPTION) + self.state = 1870 + self.match(GremlinParser.LPAREN) + self.state = 1871 + self.traversalPredicate(0) + self.state = 1872 + self.match(GremlinParser.COMMA) + self.state = 1873 + self.nestedTraversal() + self.state = 1874 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_option_Merge_MapContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1876 + self.match(GremlinParser.K_OPTION) + self.state = 1877 + self.match(GremlinParser.LPAREN) + self.state = 1878 + self.traversalMerge() + self.state = 1879 + self.match(GremlinParser.COMMA) + self.state = 1880 + self.genericMapNullableArgument() + self.state = 1881 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_option_Merge_Map_CardinalityContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 1883 + self.match(GremlinParser.K_OPTION) + self.state = 1884 + self.match(GremlinParser.LPAREN) + self.state = 1885 + self.traversalMerge() + self.state = 1886 + self.match(GremlinParser.COMMA) + self.state = 1887 + self.genericMapNullableArgument() + self.state = 1888 + self.match(GremlinParser.COMMA) + self.state = 1889 + self.traversalCardinality() + self.state = 1890 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 4: + localctx = GremlinParser.TraversalMethod_option_Merge_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 4) + self.state = 1892 + self.match(GremlinParser.K_OPTION) + self.state = 1893 + self.match(GremlinParser.LPAREN) + self.state = 1894 + self.traversalMerge() + self.state = 1895 + self.match(GremlinParser.COMMA) + self.state = 1896 + self.nestedTraversal() + self.state = 1897 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 5: + localctx = GremlinParser.TraversalMethod_option_Object_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 5) + self.state = 1899 + self.match(GremlinParser.K_OPTION) + self.state = 1900 + self.match(GremlinParser.LPAREN) + self.state = 1901 + self.genericArgument() + self.state = 1902 + self.match(GremlinParser.COMMA) + self.state = 1903 + self.nestedTraversal() + self.state = 1904 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 6: + localctx = GremlinParser.TraversalMethod_option_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 6) + self.state = 1906 + self.match(GremlinParser.K_OPTION) + self.state = 1907 + self.match(GremlinParser.LPAREN) + self.state = 1908 + self.nestedTraversal() + self.state = 1909 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_optionalContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_OPTIONAL(self): + return self.getToken(GremlinParser.K_OPTIONAL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_optional + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_optional"): + listener.enterTraversalMethod_optional(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_optional"): + listener.exitTraversalMethod_optional(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_optional"): + return visitor.visitTraversalMethod_optional(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_optional(self): + + localctx = GremlinParser.TraversalMethod_optionalContext(self, self._ctx, self.state) + self.enterRule(localctx, 220, self.RULE_traversalMethod_optional) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1913 + self.match(GremlinParser.K_OPTIONAL) + self.state = 1914 + self.match(GremlinParser.LPAREN) + self.state = 1915 + self.nestedTraversal() + self.state = 1916 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_orContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_OR(self): + return self.getToken(GremlinParser.K_OR, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversalList(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalListContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_or + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_or"): + listener.enterTraversalMethod_or(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_or"): + listener.exitTraversalMethod_or(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_or"): + return visitor.visitTraversalMethod_or(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_or(self): + + localctx = GremlinParser.TraversalMethod_orContext(self, self._ctx, self.state) + self.enterRule(localctx, 222, self.RULE_traversalMethod_or) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1918 + self.match(GremlinParser.K_OR) + self.state = 1919 + self.match(GremlinParser.LPAREN) + self.state = 1920 + self.nestedTraversalList() + self.state = 1921 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_orderContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_order + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_order_EmptyContext(TraversalMethod_orderContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_orderContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_ORDER(self): + return self.getToken(GremlinParser.K_ORDER, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_order_Empty"): + listener.enterTraversalMethod_order_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_order_Empty"): + listener.exitTraversalMethod_order_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_order_Empty"): + return visitor.visitTraversalMethod_order_Empty(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_order_ScopeContext(TraversalMethod_orderContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_orderContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_ORDER(self): + return self.getToken(GremlinParser.K_ORDER, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_order_Scope"): + listener.enterTraversalMethod_order_Scope(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_order_Scope"): + listener.exitTraversalMethod_order_Scope(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_order_Scope"): + return visitor.visitTraversalMethod_order_Scope(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_order(self): + + localctx = GremlinParser.TraversalMethod_orderContext(self, self._ctx, self.state) + self.enterRule(localctx, 224, self.RULE_traversalMethod_order) + try: + self.state = 1931 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 67, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_order_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1923 + self.match(GremlinParser.K_ORDER) + self.state = 1924 + self.match(GremlinParser.LPAREN) + self.state = 1925 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_order_ScopeContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1926 + self.match(GremlinParser.K_ORDER) + self.state = 1927 + self.match(GremlinParser.LPAREN) + self.state = 1928 + self.traversalScope() + self.state = 1929 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_otherVContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_OTHERV(self): + return self.getToken(GremlinParser.K_OTHERV, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_otherV + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_otherV"): + listener.enterTraversalMethod_otherV(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_otherV"): + listener.exitTraversalMethod_otherV(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_otherV"): + return visitor.visitTraversalMethod_otherV(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_otherV(self): + + localctx = GremlinParser.TraversalMethod_otherVContext(self, self._ctx, self.state) + self.enterRule(localctx, 226, self.RULE_traversalMethod_otherV) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1933 + self.match(GremlinParser.K_OTHERV) + self.state = 1934 + self.match(GremlinParser.LPAREN) + self.state = 1935 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_outContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_OUT(self): + return self.getToken(GremlinParser.K_OUT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableArgumentVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_out + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_out"): + listener.enterTraversalMethod_out(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_out"): + listener.exitTraversalMethod_out(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_out"): + return visitor.visitTraversalMethod_out(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_out(self): + + localctx = GremlinParser.TraversalMethod_outContext(self, self._ctx, self.state) + self.enterRule(localctx, 228, self.RULE_traversalMethod_out) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1937 + self.match(GremlinParser.K_OUT) + self.state = 1938 + self.match(GremlinParser.LPAREN) + self.state = 1939 + self.stringNullableArgumentVarargs() + self.state = 1940 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_outEContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_OUTE(self): + return self.getToken(GremlinParser.K_OUTE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableArgumentVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_outE + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_outE"): + listener.enterTraversalMethod_outE(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_outE"): + listener.exitTraversalMethod_outE(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_outE"): + return visitor.visitTraversalMethod_outE(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_outE(self): + + localctx = GremlinParser.TraversalMethod_outEContext(self, self._ctx, self.state) + self.enterRule(localctx, 230, self.RULE_traversalMethod_outE) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1942 + self.match(GremlinParser.K_OUTE) + self.state = 1943 + self.match(GremlinParser.LPAREN) + self.state = 1944 + self.stringNullableArgumentVarargs() + self.state = 1945 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_outVContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_OUTV(self): + return self.getToken(GremlinParser.K_OUTV, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_outV + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_outV"): + listener.enterTraversalMethod_outV(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_outV"): + listener.exitTraversalMethod_outV(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_outV"): + return visitor.visitTraversalMethod_outV(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_outV(self): + + localctx = GremlinParser.TraversalMethod_outVContext(self, self._ctx, self.state) + self.enterRule(localctx, 232, self.RULE_traversalMethod_outV) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1947 + self.match(GremlinParser.K_OUTV) + self.state = 1948 + self.match(GremlinParser.LPAREN) + self.state = 1949 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_pageRankContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_pageRank + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_pageRank_EmptyContext(TraversalMethod_pageRankContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_pageRankContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_PAGERANK(self): + return self.getToken(GremlinParser.K_PAGERANK, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_pageRank_Empty"): + listener.enterTraversalMethod_pageRank_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_pageRank_Empty"): + listener.exitTraversalMethod_pageRank_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_pageRank_Empty"): + return visitor.visitTraversalMethod_pageRank_Empty(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_pageRank_doubleContext(TraversalMethod_pageRankContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_pageRankContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_PAGERANK(self): + return self.getToken(GremlinParser.K_PAGERANK, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def floatArgument(self): + return self.getTypedRuleContext(GremlinParser.FloatArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_pageRank_double"): + listener.enterTraversalMethod_pageRank_double(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_pageRank_double"): + listener.exitTraversalMethod_pageRank_double(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_pageRank_double"): + return visitor.visitTraversalMethod_pageRank_double(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_pageRank(self): + + localctx = GremlinParser.TraversalMethod_pageRankContext(self, self._ctx, self.state) + self.enterRule(localctx, 234, self.RULE_traversalMethod_pageRank) + try: + self.state = 1959 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 68, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_pageRank_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1951 + self.match(GremlinParser.K_PAGERANK) + self.state = 1952 + self.match(GremlinParser.LPAREN) + self.state = 1953 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_pageRank_doubleContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1954 + self.match(GremlinParser.K_PAGERANK) + self.state = 1955 + self.match(GremlinParser.LPAREN) + self.state = 1956 + self.floatArgument() + self.state = 1957 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_pathContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_PATH(self): + return self.getToken(GremlinParser.K_PATH, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_path + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_path"): + listener.enterTraversalMethod_path(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_path"): + listener.exitTraversalMethod_path(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_path"): + return visitor.visitTraversalMethod_path(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_path(self): + + localctx = GremlinParser.TraversalMethod_pathContext(self, self._ctx, self.state) + self.enterRule(localctx, 236, self.RULE_traversalMethod_path) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1961 + self.match(GremlinParser.K_PATH) + self.state = 1962 + self.match(GremlinParser.LPAREN) + self.state = 1963 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_peerPressureContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_PEERPRESSURE(self): + return self.getToken(GremlinParser.K_PEERPRESSURE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_peerPressure + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_peerPressure"): + listener.enterTraversalMethod_peerPressure(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_peerPressure"): + listener.exitTraversalMethod_peerPressure(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_peerPressure"): + return visitor.visitTraversalMethod_peerPressure(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_peerPressure(self): + + localctx = GremlinParser.TraversalMethod_peerPressureContext(self, self._ctx, self.state) + self.enterRule(localctx, 238, self.RULE_traversalMethod_peerPressure) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1965 + self.match(GremlinParser.K_PEERPRESSURE) + self.state = 1966 + self.match(GremlinParser.LPAREN) + self.state = 1967 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_productContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_product + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_product_ObjectContext(TraversalMethod_productContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_productContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_PRODUCT(self): + return self.getToken(GremlinParser.K_PRODUCT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_product_Object"): + listener.enterTraversalMethod_product_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_product_Object"): + listener.exitTraversalMethod_product_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_product_Object"): + return visitor.visitTraversalMethod_product_Object(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_product(self): + + localctx = GremlinParser.TraversalMethod_productContext(self, self._ctx, self.state) + self.enterRule(localctx, 240, self.RULE_traversalMethod_product) + try: + localctx = GremlinParser.TraversalMethod_product_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1969 + self.match(GremlinParser.K_PRODUCT) + self.state = 1970 + self.match(GremlinParser.LPAREN) + self.state = 1971 + self.genericArgument() + self.state = 1972 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_profileContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_profile + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_profile_StringContext(TraversalMethod_profileContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_profileContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_PROFILE(self): + return self.getToken(GremlinParser.K_PROFILE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_profile_String"): + listener.enterTraversalMethod_profile_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_profile_String"): + listener.exitTraversalMethod_profile_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_profile_String"): + return visitor.visitTraversalMethod_profile_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_profile_EmptyContext(TraversalMethod_profileContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_profileContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_PROFILE(self): + return self.getToken(GremlinParser.K_PROFILE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_profile_Empty"): + listener.enterTraversalMethod_profile_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_profile_Empty"): + listener.exitTraversalMethod_profile_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_profile_Empty"): + return visitor.visitTraversalMethod_profile_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_profile(self): + + localctx = GremlinParser.TraversalMethod_profileContext(self, self._ctx, self.state) + self.enterRule(localctx, 242, self.RULE_traversalMethod_profile) + try: + self.state = 1982 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 69, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_profile_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 1974 + self.match(GremlinParser.K_PROFILE) + self.state = 1975 + self.match(GremlinParser.LPAREN) + self.state = 1976 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_profile_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 1977 + self.match(GremlinParser.K_PROFILE) + self.state = 1978 + self.match(GremlinParser.LPAREN) + self.state = 1979 + self.stringLiteral() + self.state = 1980 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_projectContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_PROJECT(self): + return self.getToken(GremlinParser.K_PROJECT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_project + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_project"): + listener.enterTraversalMethod_project(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_project"): + listener.exitTraversalMethod_project(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_project"): + return visitor.visitTraversalMethod_project(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_project(self): + + localctx = GremlinParser.TraversalMethod_projectContext(self, self._ctx, self.state) + self.enterRule(localctx, 244, self.RULE_traversalMethod_project) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1984 + self.match(GremlinParser.K_PROJECT) + self.state = 1985 + self.match(GremlinParser.LPAREN) + self.state = 1986 + self.stringLiteral() + self.state = 1989 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 1987 + self.match(GremlinParser.COMMA) + self.state = 1988 + self.stringNullableLiteralVarargs() + + self.state = 1991 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_propertiesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_PROPERTIES(self): + return self.getToken(GremlinParser.K_PROPERTIES, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_properties + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_properties"): + listener.enterTraversalMethod_properties(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_properties"): + listener.exitTraversalMethod_properties(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_properties"): + return visitor.visitTraversalMethod_properties(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_properties(self): + + localctx = GremlinParser.TraversalMethod_propertiesContext(self, self._ctx, self.state) + self.enterRule(localctx, 246, self.RULE_traversalMethod_properties) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1993 + self.match(GremlinParser.K_PROPERTIES) + self.state = 1994 + self.match(GremlinParser.LPAREN) + self.state = 1995 + self.stringNullableLiteralVarargs() + self.state = 1996 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_propertyContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_property + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_property_Cardinality_Object_Object_ObjectContext(TraversalMethod_propertyContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_propertyContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_PROPERTY(self): + return self.getToken(GremlinParser.K_PROPERTY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalCardinality(self): + return self.getTypedRuleContext(GremlinParser.TraversalCardinalityContext, 0) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def genericArgument(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.GenericArgumentContext) + else: + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, i) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def genericArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentVarargsContext, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_property_Cardinality_Object_Object_Object"): + listener.enterTraversalMethod_property_Cardinality_Object_Object_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_property_Cardinality_Object_Object_Object"): + listener.exitTraversalMethod_property_Cardinality_Object_Object_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_property_Cardinality_Object_Object_Object"): + return visitor.visitTraversalMethod_property_Cardinality_Object_Object_Object(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_property_Object_Object_ObjectContext(TraversalMethod_propertyContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_propertyContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_PROPERTY(self): + return self.getToken(GremlinParser.K_PROPERTY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.GenericArgumentContext) + else: + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, i) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def genericArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentVarargsContext, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_property_Object_Object_Object"): + listener.enterTraversalMethod_property_Object_Object_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_property_Object_Object_Object"): + listener.exitTraversalMethod_property_Object_Object_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_property_Object_Object_Object"): + return visitor.visitTraversalMethod_property_Object_Object_Object(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_property_ObjectContext(TraversalMethod_propertyContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_propertyContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_PROPERTY(self): + return self.getToken(GremlinParser.K_PROPERTY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericMapNullableArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericMapNullableArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_property_Object"): + listener.enterTraversalMethod_property_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_property_Object"): + listener.exitTraversalMethod_property_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_property_Object"): + return visitor.visitTraversalMethod_property_Object(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_property_Cardinality_ObjectContext(TraversalMethod_propertyContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_propertyContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_PROPERTY(self): + return self.getToken(GremlinParser.K_PROPERTY, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalCardinality(self): + return self.getTypedRuleContext(GremlinParser.TraversalCardinalityContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def genericMapNullableArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericMapNullableArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_property_Cardinality_Object"): + listener.enterTraversalMethod_property_Cardinality_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_property_Cardinality_Object"): + listener.exitTraversalMethod_property_Cardinality_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_property_Cardinality_Object"): + return visitor.visitTraversalMethod_property_Cardinality_Object(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_property(self): + + localctx = GremlinParser.TraversalMethod_propertyContext(self, self._ctx, self.state) + self.enterRule(localctx, 248, self.RULE_traversalMethod_property) + self._la = 0 # Token type + try: + self.state = 2034 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 73, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_property_Cardinality_Object_Object_ObjectContext( + self, localctx + ) + self.enterOuterAlt(localctx, 1) + self.state = 1998 + self.match(GremlinParser.K_PROPERTY) + self.state = 1999 + self.match(GremlinParser.LPAREN) + self.state = 2000 + self.traversalCardinality() + self.state = 2001 + self.match(GremlinParser.COMMA) + self.state = 2002 + self.genericArgument() + self.state = 2003 + self.match(GremlinParser.COMMA) + self.state = 2004 + self.genericArgument() + self.state = 2007 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 2005 + self.match(GremlinParser.COMMA) + self.state = 2006 + self.genericArgumentVarargs() + + self.state = 2009 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_property_Cardinality_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2011 + self.match(GremlinParser.K_PROPERTY) + self.state = 2012 + self.match(GremlinParser.LPAREN) + self.state = 2013 + self.traversalCardinality() + self.state = 2014 + self.match(GremlinParser.COMMA) + self.state = 2015 + self.genericMapNullableArgument() + self.state = 2016 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_property_Object_Object_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 2018 + self.match(GremlinParser.K_PROPERTY) + self.state = 2019 + self.match(GremlinParser.LPAREN) + self.state = 2020 + self.genericArgument() + self.state = 2021 + self.match(GremlinParser.COMMA) + self.state = 2022 + self.genericArgument() + self.state = 2025 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 2023 + self.match(GremlinParser.COMMA) + self.state = 2024 + self.genericArgumentVarargs() + + self.state = 2027 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 4: + localctx = GremlinParser.TraversalMethod_property_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 4) + self.state = 2029 + self.match(GremlinParser.K_PROPERTY) + self.state = 2030 + self.match(GremlinParser.LPAREN) + self.state = 2031 + self.genericMapNullableArgument() + self.state = 2032 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_propertyMapContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_PROPERTYMAP(self): + return self.getToken(GremlinParser.K_PROPERTYMAP, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_propertyMap + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_propertyMap"): + listener.enterTraversalMethod_propertyMap(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_propertyMap"): + listener.exitTraversalMethod_propertyMap(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_propertyMap"): + return visitor.visitTraversalMethod_propertyMap(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_propertyMap(self): + + localctx = GremlinParser.TraversalMethod_propertyMapContext(self, self._ctx, self.state) + self.enterRule(localctx, 250, self.RULE_traversalMethod_propertyMap) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2036 + self.match(GremlinParser.K_PROPERTYMAP) + self.state = 2037 + self.match(GremlinParser.LPAREN) + self.state = 2038 + self.stringNullableLiteralVarargs() + self.state = 2039 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_rangeContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_range + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_range_Scope_long_longContext(TraversalMethod_rangeContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_rangeContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_RANGE(self): + return self.getToken(GremlinParser.K_RANGE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def integerArgument(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.IntegerArgumentContext) + else: + return self.getTypedRuleContext(GremlinParser.IntegerArgumentContext, i) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_range_Scope_long_long"): + listener.enterTraversalMethod_range_Scope_long_long(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_range_Scope_long_long"): + listener.exitTraversalMethod_range_Scope_long_long(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_range_Scope_long_long"): + return visitor.visitTraversalMethod_range_Scope_long_long(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_range_long_longContext(TraversalMethod_rangeContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_rangeContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_RANGE(self): + return self.getToken(GremlinParser.K_RANGE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def integerArgument(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.IntegerArgumentContext) + else: + return self.getTypedRuleContext(GremlinParser.IntegerArgumentContext, i) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_range_long_long"): + listener.enterTraversalMethod_range_long_long(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_range_long_long"): + listener.exitTraversalMethod_range_long_long(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_range_long_long"): + return visitor.visitTraversalMethod_range_long_long(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_range(self): + + localctx = GremlinParser.TraversalMethod_rangeContext(self, self._ctx, self.state) + self.enterRule(localctx, 252, self.RULE_traversalMethod_range) + try: + self.state = 2057 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 74, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_range_Scope_long_longContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2041 + self.match(GremlinParser.K_RANGE) + self.state = 2042 + self.match(GremlinParser.LPAREN) + self.state = 2043 + self.traversalScope() + self.state = 2044 + self.match(GremlinParser.COMMA) + self.state = 2045 + self.integerArgument() + self.state = 2046 + self.match(GremlinParser.COMMA) + self.state = 2047 + self.integerArgument() + self.state = 2048 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_range_long_longContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2050 + self.match(GremlinParser.K_RANGE) + self.state = 2051 + self.match(GremlinParser.LPAREN) + self.state = 2052 + self.integerArgument() + self.state = 2053 + self.match(GremlinParser.COMMA) + self.state = 2054 + self.integerArgument() + self.state = 2055 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_readContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_READ(self): + return self.getToken(GremlinParser.K_READ, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_read + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_read"): + listener.enterTraversalMethod_read(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_read"): + listener.exitTraversalMethod_read(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_read"): + return visitor.visitTraversalMethod_read(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_read(self): + + localctx = GremlinParser.TraversalMethod_readContext(self, self._ctx, self.state) + self.enterRule(localctx, 254, self.RULE_traversalMethod_read) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2059 + self.match(GremlinParser.K_READ) + self.state = 2060 + self.match(GremlinParser.LPAREN) + self.state = 2061 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_repeatContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_repeat + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_repeat_String_TraversalContext(TraversalMethod_repeatContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_repeatContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_REPEAT(self): + return self.getToken(GremlinParser.K_REPEAT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_repeat_String_Traversal"): + listener.enterTraversalMethod_repeat_String_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_repeat_String_Traversal"): + listener.exitTraversalMethod_repeat_String_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_repeat_String_Traversal"): + return visitor.visitTraversalMethod_repeat_String_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_repeat_TraversalContext(TraversalMethod_repeatContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_repeatContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_REPEAT(self): + return self.getToken(GremlinParser.K_REPEAT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_repeat_Traversal"): + listener.enterTraversalMethod_repeat_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_repeat_Traversal"): + listener.exitTraversalMethod_repeat_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_repeat_Traversal"): + return visitor.visitTraversalMethod_repeat_Traversal(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_repeat(self): + + localctx = GremlinParser.TraversalMethod_repeatContext(self, self._ctx, self.state) + self.enterRule(localctx, 256, self.RULE_traversalMethod_repeat) + try: + self.state = 2075 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 75, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_repeat_String_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2063 + self.match(GremlinParser.K_REPEAT) + self.state = 2064 + self.match(GremlinParser.LPAREN) + self.state = 2065 + self.stringLiteral() + self.state = 2066 + self.match(GremlinParser.COMMA) + self.state = 2067 + self.nestedTraversal() + self.state = 2068 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_repeat_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2070 + self.match(GremlinParser.K_REPEAT) + self.state = 2071 + self.match(GremlinParser.LPAREN) + self.state = 2072 + self.nestedTraversal() + self.state = 2073 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_replaceContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_replace + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_replace_String_StringContext(TraversalMethod_replaceContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_replaceContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_REPLACE(self): + return self.getToken(GremlinParser.K_REPLACE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableLiteral(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.StringNullableLiteralContext) + else: + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralContext, i) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_replace_String_String"): + listener.enterTraversalMethod_replace_String_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_replace_String_String"): + listener.exitTraversalMethod_replace_String_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_replace_String_String"): + return visitor.visitTraversalMethod_replace_String_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_replace_Scope_String_StringContext(TraversalMethod_replaceContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_replaceContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_REPLACE(self): + return self.getToken(GremlinParser.K_REPLACE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def stringNullableLiteral(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.StringNullableLiteralContext) + else: + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralContext, i) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_replace_Scope_String_String"): + listener.enterTraversalMethod_replace_Scope_String_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_replace_Scope_String_String"): + listener.exitTraversalMethod_replace_Scope_String_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_replace_Scope_String_String"): + return visitor.visitTraversalMethod_replace_Scope_String_String(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_replace(self): + + localctx = GremlinParser.TraversalMethod_replaceContext(self, self._ctx, self.state) + self.enterRule(localctx, 258, self.RULE_traversalMethod_replace) + try: + self.state = 2093 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 76, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_replace_String_StringContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2077 + self.match(GremlinParser.K_REPLACE) + self.state = 2078 + self.match(GremlinParser.LPAREN) + self.state = 2079 + self.stringNullableLiteral() + self.state = 2080 + self.match(GremlinParser.COMMA) + self.state = 2081 + self.stringNullableLiteral() + self.state = 2082 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_replace_Scope_String_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2084 + self.match(GremlinParser.K_REPLACE) + self.state = 2085 + self.match(GremlinParser.LPAREN) + self.state = 2086 + self.traversalScope() + self.state = 2087 + self.match(GremlinParser.COMMA) + self.state = 2088 + self.stringNullableLiteral() + self.state = 2089 + self.match(GremlinParser.COMMA) + self.state = 2090 + self.stringNullableLiteral() + self.state = 2091 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_reverseContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_reverse + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_reverse_EmptyContext(TraversalMethod_reverseContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_reverseContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_REVERSE(self): + return self.getToken(GremlinParser.K_REVERSE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_reverse_Empty"): + listener.enterTraversalMethod_reverse_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_reverse_Empty"): + listener.exitTraversalMethod_reverse_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_reverse_Empty"): + return visitor.visitTraversalMethod_reverse_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_reverse(self): + + localctx = GremlinParser.TraversalMethod_reverseContext(self, self._ctx, self.state) + self.enterRule(localctx, 260, self.RULE_traversalMethod_reverse) + try: + localctx = GremlinParser.TraversalMethod_reverse_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2095 + self.match(GremlinParser.K_REVERSE) + self.state = 2096 + self.match(GremlinParser.LPAREN) + self.state = 2097 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_rTrimContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_rTrim + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_rTrim_ScopeContext(TraversalMethod_rTrimContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_rTrimContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_RTRIM(self): + return self.getToken(GremlinParser.K_RTRIM, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_rTrim_Scope"): + listener.enterTraversalMethod_rTrim_Scope(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_rTrim_Scope"): + listener.exitTraversalMethod_rTrim_Scope(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_rTrim_Scope"): + return visitor.visitTraversalMethod_rTrim_Scope(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_rTrim_EmptyContext(TraversalMethod_rTrimContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_rTrimContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_RTRIM(self): + return self.getToken(GremlinParser.K_RTRIM, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_rTrim_Empty"): + listener.enterTraversalMethod_rTrim_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_rTrim_Empty"): + listener.exitTraversalMethod_rTrim_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_rTrim_Empty"): + return visitor.visitTraversalMethod_rTrim_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_rTrim(self): + + localctx = GremlinParser.TraversalMethod_rTrimContext(self, self._ctx, self.state) + self.enterRule(localctx, 262, self.RULE_traversalMethod_rTrim) + try: + self.state = 2107 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 77, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_rTrim_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2099 + self.match(GremlinParser.K_RTRIM) + self.state = 2100 + self.match(GremlinParser.LPAREN) + self.state = 2101 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_rTrim_ScopeContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2102 + self.match(GremlinParser.K_RTRIM) + self.state = 2103 + self.match(GremlinParser.LPAREN) + self.state = 2104 + self.traversalScope() + self.state = 2105 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_sackContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_sack + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_sack_EmptyContext(TraversalMethod_sackContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_sackContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SACK(self): + return self.getToken(GremlinParser.K_SACK, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_sack_Empty"): + listener.enterTraversalMethod_sack_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_sack_Empty"): + listener.exitTraversalMethod_sack_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_sack_Empty"): + return visitor.visitTraversalMethod_sack_Empty(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_sack_BiFunctionContext(TraversalMethod_sackContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_sackContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SACK(self): + return self.getToken(GremlinParser.K_SACK, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalBiFunction(self): + return self.getTypedRuleContext(GremlinParser.TraversalBiFunctionContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_sack_BiFunction"): + listener.enterTraversalMethod_sack_BiFunction(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_sack_BiFunction"): + listener.exitTraversalMethod_sack_BiFunction(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_sack_BiFunction"): + return visitor.visitTraversalMethod_sack_BiFunction(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_sack(self): + + localctx = GremlinParser.TraversalMethod_sackContext(self, self._ctx, self.state) + self.enterRule(localctx, 264, self.RULE_traversalMethod_sack) + try: + self.state = 2117 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 78, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_sack_BiFunctionContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2109 + self.match(GremlinParser.K_SACK) + self.state = 2110 + self.match(GremlinParser.LPAREN) + self.state = 2111 + self.traversalBiFunction() + self.state = 2112 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_sack_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2114 + self.match(GremlinParser.K_SACK) + self.state = 2115 + self.match(GremlinParser.LPAREN) + self.state = 2116 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_sampleContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_sample + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_sample_Scope_intContext(TraversalMethod_sampleContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_sampleContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SAMPLE(self): + return self.getToken(GremlinParser.K_SAMPLE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(GremlinParser.IntegerLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_sample_Scope_int"): + listener.enterTraversalMethod_sample_Scope_int(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_sample_Scope_int"): + listener.exitTraversalMethod_sample_Scope_int(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_sample_Scope_int"): + return visitor.visitTraversalMethod_sample_Scope_int(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_sample_intContext(TraversalMethod_sampleContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_sampleContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SAMPLE(self): + return self.getToken(GremlinParser.K_SAMPLE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(GremlinParser.IntegerLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_sample_int"): + listener.enterTraversalMethod_sample_int(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_sample_int"): + listener.exitTraversalMethod_sample_int(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_sample_int"): + return visitor.visitTraversalMethod_sample_int(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_sample(self): + + localctx = GremlinParser.TraversalMethod_sampleContext(self, self._ctx, self.state) + self.enterRule(localctx, 266, self.RULE_traversalMethod_sample) + try: + self.state = 2131 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 79, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_sample_Scope_intContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2119 + self.match(GremlinParser.K_SAMPLE) + self.state = 2120 + self.match(GremlinParser.LPAREN) + self.state = 2121 + self.traversalScope() + self.state = 2122 + self.match(GremlinParser.COMMA) + self.state = 2123 + self.integerLiteral() + self.state = 2124 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_sample_intContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2126 + self.match(GremlinParser.K_SAMPLE) + self.state = 2127 + self.match(GremlinParser.LPAREN) + self.state = 2128 + self.integerLiteral() + self.state = 2129 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_selectContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_select + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_select_String_String_StringContext(TraversalMethod_selectContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_selectContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SELECT(self): + return self.getToken(GremlinParser.K_SELECT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.StringLiteralContext) + else: + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, i) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_select_String_String_String"): + listener.enterTraversalMethod_select_String_String_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_select_String_String_String"): + listener.exitTraversalMethod_select_String_String_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_select_String_String_String"): + return visitor.visitTraversalMethod_select_String_String_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_select_Pop_String_String_StringContext(TraversalMethod_selectContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_selectContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SELECT(self): + return self.getToken(GremlinParser.K_SELECT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPop(self): + return self.getTypedRuleContext(GremlinParser.TraversalPopContext, 0) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def stringLiteral(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.StringLiteralContext) + else: + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, i) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_select_Pop_String_String_String"): + listener.enterTraversalMethod_select_Pop_String_String_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_select_Pop_String_String_String"): + listener.exitTraversalMethod_select_Pop_String_String_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_select_Pop_String_String_String"): + return visitor.visitTraversalMethod_select_Pop_String_String_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_select_StringContext(TraversalMethod_selectContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_selectContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SELECT(self): + return self.getToken(GremlinParser.K_SELECT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_select_String"): + listener.enterTraversalMethod_select_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_select_String"): + listener.exitTraversalMethod_select_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_select_String"): + return visitor.visitTraversalMethod_select_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_select_Pop_TraversalContext(TraversalMethod_selectContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_selectContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SELECT(self): + return self.getToken(GremlinParser.K_SELECT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPop(self): + return self.getTypedRuleContext(GremlinParser.TraversalPopContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_select_Pop_Traversal"): + listener.enterTraversalMethod_select_Pop_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_select_Pop_Traversal"): + listener.exitTraversalMethod_select_Pop_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_select_Pop_Traversal"): + return visitor.visitTraversalMethod_select_Pop_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_select_TraversalContext(TraversalMethod_selectContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_selectContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SELECT(self): + return self.getToken(GremlinParser.K_SELECT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_select_Traversal"): + listener.enterTraversalMethod_select_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_select_Traversal"): + listener.exitTraversalMethod_select_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_select_Traversal"): + return visitor.visitTraversalMethod_select_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_select_ColumnContext(TraversalMethod_selectContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_selectContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SELECT(self): + return self.getToken(GremlinParser.K_SELECT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalColumn(self): + return self.getTypedRuleContext(GremlinParser.TraversalColumnContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_select_Column"): + listener.enterTraversalMethod_select_Column(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_select_Column"): + listener.exitTraversalMethod_select_Column(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_select_Column"): + return visitor.visitTraversalMethod_select_Column(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_select_Pop_StringContext(TraversalMethod_selectContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_selectContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SELECT(self): + return self.getToken(GremlinParser.K_SELECT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPop(self): + return self.getTypedRuleContext(GremlinParser.TraversalPopContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_select_Pop_String"): + listener.enterTraversalMethod_select_Pop_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_select_Pop_String"): + listener.exitTraversalMethod_select_Pop_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_select_Pop_String"): + return visitor.visitTraversalMethod_select_Pop_String(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_select(self): + + localctx = GremlinParser.TraversalMethod_selectContext(self, self._ctx, self.state) + self.enterRule(localctx, 268, self.RULE_traversalMethod_select) + self._la = 0 # Token type + try: + self.state = 2186 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 82, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_select_ColumnContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2133 + self.match(GremlinParser.K_SELECT) + self.state = 2134 + self.match(GremlinParser.LPAREN) + self.state = 2135 + self.traversalColumn() + self.state = 2136 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_select_Pop_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2138 + self.match(GremlinParser.K_SELECT) + self.state = 2139 + self.match(GremlinParser.LPAREN) + self.state = 2140 + self.traversalPop() + self.state = 2141 + self.match(GremlinParser.COMMA) + self.state = 2142 + self.stringLiteral() + self.state = 2143 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_select_Pop_String_String_StringContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 2145 + self.match(GremlinParser.K_SELECT) + self.state = 2146 + self.match(GremlinParser.LPAREN) + self.state = 2147 + self.traversalPop() + self.state = 2148 + self.match(GremlinParser.COMMA) + self.state = 2149 + self.stringLiteral() + self.state = 2150 + self.match(GremlinParser.COMMA) + self.state = 2151 + self.stringLiteral() + self.state = 2154 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 2152 + self.match(GremlinParser.COMMA) + self.state = 2153 + self.stringNullableLiteralVarargs() + + self.state = 2156 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 4: + localctx = GremlinParser.TraversalMethod_select_Pop_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 4) + self.state = 2158 + self.match(GremlinParser.K_SELECT) + self.state = 2159 + self.match(GremlinParser.LPAREN) + self.state = 2160 + self.traversalPop() + self.state = 2161 + self.match(GremlinParser.COMMA) + self.state = 2162 + self.nestedTraversal() + self.state = 2163 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 5: + localctx = GremlinParser.TraversalMethod_select_StringContext(self, localctx) + self.enterOuterAlt(localctx, 5) + self.state = 2165 + self.match(GremlinParser.K_SELECT) + self.state = 2166 + self.match(GremlinParser.LPAREN) + self.state = 2167 + self.stringLiteral() + self.state = 2168 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 6: + localctx = GremlinParser.TraversalMethod_select_String_String_StringContext(self, localctx) + self.enterOuterAlt(localctx, 6) + self.state = 2170 + self.match(GremlinParser.K_SELECT) + self.state = 2171 + self.match(GremlinParser.LPAREN) + self.state = 2172 + self.stringLiteral() + self.state = 2173 + self.match(GremlinParser.COMMA) + self.state = 2174 + self.stringLiteral() + self.state = 2177 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 2175 + self.match(GremlinParser.COMMA) + self.state = 2176 + self.stringNullableLiteralVarargs() + + self.state = 2179 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 7: + localctx = GremlinParser.TraversalMethod_select_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 7) + self.state = 2181 + self.match(GremlinParser.K_SELECT) + self.state = 2182 + self.match(GremlinParser.LPAREN) + self.state = 2183 + self.nestedTraversal() + self.state = 2184 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_shortestPathContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_SHORTESTPATH(self): + return self.getToken(GremlinParser.K_SHORTESTPATH, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_shortestPath + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_shortestPath"): + listener.enterTraversalMethod_shortestPath(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_shortestPath"): + listener.exitTraversalMethod_shortestPath(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_shortestPath"): + return visitor.visitTraversalMethod_shortestPath(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_shortestPath(self): + + localctx = GremlinParser.TraversalMethod_shortestPathContext(self, self._ctx, self.state) + self.enterRule(localctx, 270, self.RULE_traversalMethod_shortestPath) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2188 + self.match(GremlinParser.K_SHORTESTPATH) + self.state = 2189 + self.match(GremlinParser.LPAREN) + self.state = 2190 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_sideEffectContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_SIDEEFFECT(self): + return self.getToken(GremlinParser.K_SIDEEFFECT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_sideEffect + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_sideEffect"): + listener.enterTraversalMethod_sideEffect(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_sideEffect"): + listener.exitTraversalMethod_sideEffect(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_sideEffect"): + return visitor.visitTraversalMethod_sideEffect(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_sideEffect(self): + + localctx = GremlinParser.TraversalMethod_sideEffectContext(self, self._ctx, self.state) + self.enterRule(localctx, 272, self.RULE_traversalMethod_sideEffect) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2192 + self.match(GremlinParser.K_SIDEEFFECT) + self.state = 2193 + self.match(GremlinParser.LPAREN) + self.state = 2194 + self.nestedTraversal() + self.state = 2195 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_simplePathContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_SIMPLEPATH(self): + return self.getToken(GremlinParser.K_SIMPLEPATH, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_simplePath + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_simplePath"): + listener.enterTraversalMethod_simplePath(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_simplePath"): + listener.exitTraversalMethod_simplePath(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_simplePath"): + return visitor.visitTraversalMethod_simplePath(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_simplePath(self): + + localctx = GremlinParser.TraversalMethod_simplePathContext(self, self._ctx, self.state) + self.enterRule(localctx, 274, self.RULE_traversalMethod_simplePath) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2197 + self.match(GremlinParser.K_SIMPLEPATH) + self.state = 2198 + self.match(GremlinParser.LPAREN) + self.state = 2199 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_skipContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_skip + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_skip_Scope_longContext(TraversalMethod_skipContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_skipContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SKIP(self): + return self.getToken(GremlinParser.K_SKIP, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def integerArgument(self): + return self.getTypedRuleContext(GremlinParser.IntegerArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_skip_Scope_long"): + listener.enterTraversalMethod_skip_Scope_long(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_skip_Scope_long"): + listener.exitTraversalMethod_skip_Scope_long(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_skip_Scope_long"): + return visitor.visitTraversalMethod_skip_Scope_long(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_skip_longContext(TraversalMethod_skipContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_skipContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SKIP(self): + return self.getToken(GremlinParser.K_SKIP, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def integerArgument(self): + return self.getTypedRuleContext(GremlinParser.IntegerArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_skip_long"): + listener.enterTraversalMethod_skip_long(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_skip_long"): + listener.exitTraversalMethod_skip_long(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_skip_long"): + return visitor.visitTraversalMethod_skip_long(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_skip(self): + + localctx = GremlinParser.TraversalMethod_skipContext(self, self._ctx, self.state) + self.enterRule(localctx, 276, self.RULE_traversalMethod_skip) + try: + self.state = 2213 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 83, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_skip_Scope_longContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2201 + self.match(GremlinParser.K_SKIP) + self.state = 2202 + self.match(GremlinParser.LPAREN) + self.state = 2203 + self.traversalScope() + self.state = 2204 + self.match(GremlinParser.COMMA) + self.state = 2205 + self.integerArgument() + self.state = 2206 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_skip_longContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2208 + self.match(GremlinParser.K_SKIP) + self.state = 2209 + self.match(GremlinParser.LPAREN) + self.state = 2210 + self.integerArgument() + self.state = 2211 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_splitContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_split + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_split_StringContext(TraversalMethod_splitContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_splitContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SPLIT(self): + return self.getToken(GremlinParser.K_SPLIT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_split_String"): + listener.enterTraversalMethod_split_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_split_String"): + listener.exitTraversalMethod_split_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_split_String"): + return visitor.visitTraversalMethod_split_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_split_Scope_StringContext(TraversalMethod_splitContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_splitContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SPLIT(self): + return self.getToken(GremlinParser.K_SPLIT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def stringNullableLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_split_Scope_String"): + listener.enterTraversalMethod_split_Scope_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_split_Scope_String"): + listener.exitTraversalMethod_split_Scope_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_split_Scope_String"): + return visitor.visitTraversalMethod_split_Scope_String(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_split(self): + + localctx = GremlinParser.TraversalMethod_splitContext(self, self._ctx, self.state) + self.enterRule(localctx, 278, self.RULE_traversalMethod_split) + try: + self.state = 2227 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 84, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_split_StringContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2215 + self.match(GremlinParser.K_SPLIT) + self.state = 2216 + self.match(GremlinParser.LPAREN) + self.state = 2217 + self.stringNullableLiteral() + self.state = 2218 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_split_Scope_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2220 + self.match(GremlinParser.K_SPLIT) + self.state = 2221 + self.match(GremlinParser.LPAREN) + self.state = 2222 + self.traversalScope() + self.state = 2223 + self.match(GremlinParser.COMMA) + self.state = 2224 + self.stringNullableLiteral() + self.state = 2225 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_storeContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_STORE(self): + return self.getToken(GremlinParser.K_STORE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_store + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_store"): + listener.enterTraversalMethod_store(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_store"): + listener.exitTraversalMethod_store(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_store"): + return visitor.visitTraversalMethod_store(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_store(self): + + localctx = GremlinParser.TraversalMethod_storeContext(self, self._ctx, self.state) + self.enterRule(localctx, 280, self.RULE_traversalMethod_store) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2229 + self.match(GremlinParser.K_STORE) + self.state = 2230 + self.match(GremlinParser.LPAREN) + self.state = 2231 + self.stringLiteral() + self.state = 2232 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_subgraphContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_SUBGRAPH(self): + return self.getToken(GremlinParser.K_SUBGRAPH, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_subgraph + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_subgraph"): + listener.enterTraversalMethod_subgraph(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_subgraph"): + listener.exitTraversalMethod_subgraph(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_subgraph"): + return visitor.visitTraversalMethod_subgraph(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_subgraph(self): + + localctx = GremlinParser.TraversalMethod_subgraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 282, self.RULE_traversalMethod_subgraph) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2234 + self.match(GremlinParser.K_SUBGRAPH) + self.state = 2235 + self.match(GremlinParser.LPAREN) + self.state = 2236 + self.stringLiteral() + self.state = 2237 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_substringContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_substring + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_substring_int_intContext(TraversalMethod_substringContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_substringContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SUBSTRING(self): + return self.getToken(GremlinParser.K_SUBSTRING, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def integerLiteral(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.IntegerLiteralContext) + else: + return self.getTypedRuleContext(GremlinParser.IntegerLiteralContext, i) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_substring_int_int"): + listener.enterTraversalMethod_substring_int_int(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_substring_int_int"): + listener.exitTraversalMethod_substring_int_int(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_substring_int_int"): + return visitor.visitTraversalMethod_substring_int_int(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_substring_intContext(TraversalMethod_substringContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_substringContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SUBSTRING(self): + return self.getToken(GremlinParser.K_SUBSTRING, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(GremlinParser.IntegerLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_substring_int"): + listener.enterTraversalMethod_substring_int(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_substring_int"): + listener.exitTraversalMethod_substring_int(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_substring_int"): + return visitor.visitTraversalMethod_substring_int(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_substring_Scope_intContext(TraversalMethod_substringContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_substringContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SUBSTRING(self): + return self.getToken(GremlinParser.K_SUBSTRING, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(GremlinParser.IntegerLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_substring_Scope_int"): + listener.enterTraversalMethod_substring_Scope_int(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_substring_Scope_int"): + listener.exitTraversalMethod_substring_Scope_int(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_substring_Scope_int"): + return visitor.visitTraversalMethod_substring_Scope_int(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_substring_Scope_int_intContext(TraversalMethod_substringContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_substringContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SUBSTRING(self): + return self.getToken(GremlinParser.K_SUBSTRING, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def integerLiteral(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.IntegerLiteralContext) + else: + return self.getTypedRuleContext(GremlinParser.IntegerLiteralContext, i) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_substring_Scope_int_int"): + listener.enterTraversalMethod_substring_Scope_int_int(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_substring_Scope_int_int"): + listener.exitTraversalMethod_substring_Scope_int_int(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_substring_Scope_int_int"): + return visitor.visitTraversalMethod_substring_Scope_int_int(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_substring(self): + + localctx = GremlinParser.TraversalMethod_substringContext(self, self._ctx, self.state) + self.enterRule(localctx, 284, self.RULE_traversalMethod_substring) + try: + self.state = 2267 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 85, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_substring_intContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2239 + self.match(GremlinParser.K_SUBSTRING) + self.state = 2240 + self.match(GremlinParser.LPAREN) + self.state = 2241 + self.integerLiteral() + self.state = 2242 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_substring_Scope_intContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2244 + self.match(GremlinParser.K_SUBSTRING) + self.state = 2245 + self.match(GremlinParser.LPAREN) + self.state = 2246 + self.traversalScope() + self.state = 2247 + self.match(GremlinParser.COMMA) + self.state = 2248 + self.integerLiteral() + self.state = 2249 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_substring_int_intContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 2251 + self.match(GremlinParser.K_SUBSTRING) + self.state = 2252 + self.match(GremlinParser.LPAREN) + self.state = 2253 + self.integerLiteral() + self.state = 2254 + self.match(GremlinParser.COMMA) + self.state = 2255 + self.integerLiteral() + self.state = 2256 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 4: + localctx = GremlinParser.TraversalMethod_substring_Scope_int_intContext(self, localctx) + self.enterOuterAlt(localctx, 4) + self.state = 2258 + self.match(GremlinParser.K_SUBSTRING) + self.state = 2259 + self.match(GremlinParser.LPAREN) + self.state = 2260 + self.traversalScope() + self.state = 2261 + self.match(GremlinParser.COMMA) + self.state = 2262 + self.integerLiteral() + self.state = 2263 + self.match(GremlinParser.COMMA) + self.state = 2264 + self.integerLiteral() + self.state = 2265 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_sumContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_sum + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_sum_EmptyContext(TraversalMethod_sumContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_sumContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SUM(self): + return self.getToken(GremlinParser.K_SUM, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_sum_Empty"): + listener.enterTraversalMethod_sum_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_sum_Empty"): + listener.exitTraversalMethod_sum_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_sum_Empty"): + return visitor.visitTraversalMethod_sum_Empty(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_sum_ScopeContext(TraversalMethod_sumContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_sumContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_SUM(self): + return self.getToken(GremlinParser.K_SUM, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_sum_Scope"): + listener.enterTraversalMethod_sum_Scope(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_sum_Scope"): + listener.exitTraversalMethod_sum_Scope(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_sum_Scope"): + return visitor.visitTraversalMethod_sum_Scope(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_sum(self): + + localctx = GremlinParser.TraversalMethod_sumContext(self, self._ctx, self.state) + self.enterRule(localctx, 286, self.RULE_traversalMethod_sum) + try: + self.state = 2277 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 86, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_sum_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2269 + self.match(GremlinParser.K_SUM) + self.state = 2270 + self.match(GremlinParser.LPAREN) + self.state = 2271 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_sum_ScopeContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2272 + self.match(GremlinParser.K_SUM) + self.state = 2273 + self.match(GremlinParser.LPAREN) + self.state = 2274 + self.traversalScope() + self.state = 2275 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_tailContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_tail + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_tail_longContext(TraversalMethod_tailContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_tailContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TAIL(self): + return self.getToken(GremlinParser.K_TAIL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def integerArgument(self): + return self.getTypedRuleContext(GremlinParser.IntegerArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_tail_long"): + listener.enterTraversalMethod_tail_long(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_tail_long"): + listener.exitTraversalMethod_tail_long(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_tail_long"): + return visitor.visitTraversalMethod_tail_long(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_tail_EmptyContext(TraversalMethod_tailContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_tailContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TAIL(self): + return self.getToken(GremlinParser.K_TAIL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_tail_Empty"): + listener.enterTraversalMethod_tail_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_tail_Empty"): + listener.exitTraversalMethod_tail_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_tail_Empty"): + return visitor.visitTraversalMethod_tail_Empty(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_tail_Scope_longContext(TraversalMethod_tailContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_tailContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TAIL(self): + return self.getToken(GremlinParser.K_TAIL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def integerArgument(self): + return self.getTypedRuleContext(GremlinParser.IntegerArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_tail_Scope_long"): + listener.enterTraversalMethod_tail_Scope_long(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_tail_Scope_long"): + listener.exitTraversalMethod_tail_Scope_long(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_tail_Scope_long"): + return visitor.visitTraversalMethod_tail_Scope_long(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_tail_ScopeContext(TraversalMethod_tailContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_tailContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TAIL(self): + return self.getToken(GremlinParser.K_TAIL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_tail_Scope"): + listener.enterTraversalMethod_tail_Scope(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_tail_Scope"): + listener.exitTraversalMethod_tail_Scope(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_tail_Scope"): + return visitor.visitTraversalMethod_tail_Scope(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_tail(self): + + localctx = GremlinParser.TraversalMethod_tailContext(self, self._ctx, self.state) + self.enterRule(localctx, 288, self.RULE_traversalMethod_tail) + try: + self.state = 2299 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 87, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_tail_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2279 + self.match(GremlinParser.K_TAIL) + self.state = 2280 + self.match(GremlinParser.LPAREN) + self.state = 2281 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_tail_ScopeContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2282 + self.match(GremlinParser.K_TAIL) + self.state = 2283 + self.match(GremlinParser.LPAREN) + self.state = 2284 + self.traversalScope() + self.state = 2285 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_tail_Scope_longContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 2287 + self.match(GremlinParser.K_TAIL) + self.state = 2288 + self.match(GremlinParser.LPAREN) + self.state = 2289 + self.traversalScope() + self.state = 2290 + self.match(GremlinParser.COMMA) + self.state = 2291 + self.integerArgument() + self.state = 2292 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 4: + localctx = GremlinParser.TraversalMethod_tail_longContext(self, localctx) + self.enterOuterAlt(localctx, 4) + self.state = 2294 + self.match(GremlinParser.K_TAIL) + self.state = 2295 + self.match(GremlinParser.LPAREN) + self.state = 2296 + self.integerArgument() + self.state = 2297 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_timeLimitContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_TIMELIMIT(self): + return self.getToken(GremlinParser.K_TIMELIMIT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(GremlinParser.IntegerLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_timeLimit + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_timeLimit"): + listener.enterTraversalMethod_timeLimit(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_timeLimit"): + listener.exitTraversalMethod_timeLimit(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_timeLimit"): + return visitor.visitTraversalMethod_timeLimit(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_timeLimit(self): + + localctx = GremlinParser.TraversalMethod_timeLimitContext(self, self._ctx, self.state) + self.enterRule(localctx, 290, self.RULE_traversalMethod_timeLimit) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2301 + self.match(GremlinParser.K_TIMELIMIT) + self.state = 2302 + self.match(GremlinParser.LPAREN) + self.state = 2303 + self.integerLiteral() + self.state = 2304 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_timesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_TIMES(self): + return self.getToken(GremlinParser.K_TIMES, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(GremlinParser.IntegerLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_times + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_times"): + listener.enterTraversalMethod_times(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_times"): + listener.exitTraversalMethod_times(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_times"): + return visitor.visitTraversalMethod_times(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_times(self): + + localctx = GremlinParser.TraversalMethod_timesContext(self, self._ctx, self.state) + self.enterRule(localctx, 292, self.RULE_traversalMethod_times) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2306 + self.match(GremlinParser.K_TIMES) + self.state = 2307 + self.match(GremlinParser.LPAREN) + self.state = 2308 + self.integerLiteral() + self.state = 2309 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_toContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_to + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_to_VertexContext(TraversalMethod_toContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_toContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TO(self): + return self.getToken(GremlinParser.K_TO, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def structureVertexArgument(self): + return self.getTypedRuleContext(GremlinParser.StructureVertexArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_to_Vertex"): + listener.enterTraversalMethod_to_Vertex(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_to_Vertex"): + listener.exitTraversalMethod_to_Vertex(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_to_Vertex"): + return visitor.visitTraversalMethod_to_Vertex(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_to_TraversalContext(TraversalMethod_toContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_toContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TO(self): + return self.getToken(GremlinParser.K_TO, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_to_Traversal"): + listener.enterTraversalMethod_to_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_to_Traversal"): + listener.exitTraversalMethod_to_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_to_Traversal"): + return visitor.visitTraversalMethod_to_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_to_Direction_StringContext(TraversalMethod_toContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_toContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TO(self): + return self.getToken(GremlinParser.K_TO, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalDirection(self): + return self.getTypedRuleContext(GremlinParser.TraversalDirectionContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_to_Direction_String"): + listener.enterTraversalMethod_to_Direction_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_to_Direction_String"): + listener.exitTraversalMethod_to_Direction_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_to_Direction_String"): + return visitor.visitTraversalMethod_to_Direction_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_to_StringContext(TraversalMethod_toContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_toContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TO(self): + return self.getToken(GremlinParser.K_TO, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_to_String"): + listener.enterTraversalMethod_to_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_to_String"): + listener.exitTraversalMethod_to_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_to_String"): + return visitor.visitTraversalMethod_to_String(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_to(self): + + localctx = GremlinParser.TraversalMethod_toContext(self, self._ctx, self.state) + self.enterRule(localctx, 294, self.RULE_traversalMethod_to) + self._la = 0 # Token type + try: + self.state = 2335 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 89, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_to_Direction_StringContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2311 + self.match(GremlinParser.K_TO) + self.state = 2312 + self.match(GremlinParser.LPAREN) + self.state = 2313 + self.traversalDirection() + self.state = 2316 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 2314 + self.match(GremlinParser.COMMA) + self.state = 2315 + self.stringNullableLiteralVarargs() + + self.state = 2318 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_to_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2320 + self.match(GremlinParser.K_TO) + self.state = 2321 + self.match(GremlinParser.LPAREN) + self.state = 2322 + self.stringLiteral() + self.state = 2323 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_to_VertexContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 2325 + self.match(GremlinParser.K_TO) + self.state = 2326 + self.match(GremlinParser.LPAREN) + self.state = 2327 + self.structureVertexArgument() + self.state = 2328 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 4: + localctx = GremlinParser.TraversalMethod_to_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 4) + self.state = 2330 + self.match(GremlinParser.K_TO) + self.state = 2331 + self.match(GremlinParser.LPAREN) + self.state = 2332 + self.nestedTraversal() + self.state = 2333 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_toEContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_TOE(self): + return self.getToken(GremlinParser.K_TOE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalDirection(self): + return self.getTypedRuleContext(GremlinParser.TraversalDirectionContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def stringNullableArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableArgumentVarargsContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_toE + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_toE"): + listener.enterTraversalMethod_toE(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_toE"): + listener.exitTraversalMethod_toE(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_toE"): + return visitor.visitTraversalMethod_toE(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_toE(self): + + localctx = GremlinParser.TraversalMethod_toEContext(self, self._ctx, self.state) + self.enterRule(localctx, 296, self.RULE_traversalMethod_toE) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2337 + self.match(GremlinParser.K_TOE) + self.state = 2338 + self.match(GremlinParser.LPAREN) + self.state = 2339 + self.traversalDirection() + self.state = 2342 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 2340 + self.match(GremlinParser.COMMA) + self.state = 2341 + self.stringNullableArgumentVarargs() + + self.state = 2344 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_toLowerContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_toLower + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_toLower_ScopeContext(TraversalMethod_toLowerContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_toLowerContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TOLOWER(self): + return self.getToken(GremlinParser.K_TOLOWER, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_toLower_Scope"): + listener.enterTraversalMethod_toLower_Scope(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_toLower_Scope"): + listener.exitTraversalMethod_toLower_Scope(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_toLower_Scope"): + return visitor.visitTraversalMethod_toLower_Scope(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_toLower_EmptyContext(TraversalMethod_toLowerContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_toLowerContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TOLOWER(self): + return self.getToken(GremlinParser.K_TOLOWER, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_toLower_Empty"): + listener.enterTraversalMethod_toLower_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_toLower_Empty"): + listener.exitTraversalMethod_toLower_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_toLower_Empty"): + return visitor.visitTraversalMethod_toLower_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_toLower(self): + + localctx = GremlinParser.TraversalMethod_toLowerContext(self, self._ctx, self.state) + self.enterRule(localctx, 298, self.RULE_traversalMethod_toLower) + try: + self.state = 2354 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 91, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_toLower_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2346 + self.match(GremlinParser.K_TOLOWER) + self.state = 2347 + self.match(GremlinParser.LPAREN) + self.state = 2348 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_toLower_ScopeContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2349 + self.match(GremlinParser.K_TOLOWER) + self.state = 2350 + self.match(GremlinParser.LPAREN) + self.state = 2351 + self.traversalScope() + self.state = 2352 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_toUpperContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_toUpper + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_toUpper_ScopeContext(TraversalMethod_toUpperContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_toUpperContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TOUPPER(self): + return self.getToken(GremlinParser.K_TOUPPER, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_toUpper_Scope"): + listener.enterTraversalMethod_toUpper_Scope(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_toUpper_Scope"): + listener.exitTraversalMethod_toUpper_Scope(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_toUpper_Scope"): + return visitor.visitTraversalMethod_toUpper_Scope(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_toUpper_EmptyContext(TraversalMethod_toUpperContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_toUpperContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TOUPPER(self): + return self.getToken(GremlinParser.K_TOUPPER, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_toUpper_Empty"): + listener.enterTraversalMethod_toUpper_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_toUpper_Empty"): + listener.exitTraversalMethod_toUpper_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_toUpper_Empty"): + return visitor.visitTraversalMethod_toUpper_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_toUpper(self): + + localctx = GremlinParser.TraversalMethod_toUpperContext(self, self._ctx, self.state) + self.enterRule(localctx, 300, self.RULE_traversalMethod_toUpper) + try: + self.state = 2364 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 92, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_toUpper_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2356 + self.match(GremlinParser.K_TOUPPER) + self.state = 2357 + self.match(GremlinParser.LPAREN) + self.state = 2358 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_toUpper_ScopeContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2359 + self.match(GremlinParser.K_TOUPPER) + self.state = 2360 + self.match(GremlinParser.LPAREN) + self.state = 2361 + self.traversalScope() + self.state = 2362 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_toVContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_TOV(self): + return self.getToken(GremlinParser.K_TOV, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalDirection(self): + return self.getTypedRuleContext(GremlinParser.TraversalDirectionContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_toV + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_toV"): + listener.enterTraversalMethod_toV(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_toV"): + listener.exitTraversalMethod_toV(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_toV"): + return visitor.visitTraversalMethod_toV(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_toV(self): + + localctx = GremlinParser.TraversalMethod_toVContext(self, self._ctx, self.state) + self.enterRule(localctx, 302, self.RULE_traversalMethod_toV) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2366 + self.match(GremlinParser.K_TOV) + self.state = 2367 + self.match(GremlinParser.LPAREN) + self.state = 2368 + self.traversalDirection() + self.state = 2369 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_treeContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_tree + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_tree_StringContext(TraversalMethod_treeContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_treeContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TREE(self): + return self.getToken(GremlinParser.K_TREE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_tree_String"): + listener.enterTraversalMethod_tree_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_tree_String"): + listener.exitTraversalMethod_tree_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_tree_String"): + return visitor.visitTraversalMethod_tree_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_tree_EmptyContext(TraversalMethod_treeContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_treeContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TREE(self): + return self.getToken(GremlinParser.K_TREE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_tree_Empty"): + listener.enterTraversalMethod_tree_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_tree_Empty"): + listener.exitTraversalMethod_tree_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_tree_Empty"): + return visitor.visitTraversalMethod_tree_Empty(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_tree(self): + + localctx = GremlinParser.TraversalMethod_treeContext(self, self._ctx, self.state) + self.enterRule(localctx, 304, self.RULE_traversalMethod_tree) + try: + self.state = 2379 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 93, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_tree_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2371 + self.match(GremlinParser.K_TREE) + self.state = 2372 + self.match(GremlinParser.LPAREN) + self.state = 2373 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_tree_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2374 + self.match(GremlinParser.K_TREE) + self.state = 2375 + self.match(GremlinParser.LPAREN) + self.state = 2376 + self.stringLiteral() + self.state = 2377 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_trimContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_trim + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_trim_EmptyContext(TraversalMethod_trimContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_trimContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TRIM(self): + return self.getToken(GremlinParser.K_TRIM, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_trim_Empty"): + listener.enterTraversalMethod_trim_Empty(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_trim_Empty"): + listener.exitTraversalMethod_trim_Empty(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_trim_Empty"): + return visitor.visitTraversalMethod_trim_Empty(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_trim_ScopeContext(TraversalMethod_trimContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_trimContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_TRIM(self): + return self.getToken(GremlinParser.K_TRIM, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalScope(self): + return self.getTypedRuleContext(GremlinParser.TraversalScopeContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_trim_Scope"): + listener.enterTraversalMethod_trim_Scope(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_trim_Scope"): + listener.exitTraversalMethod_trim_Scope(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_trim_Scope"): + return visitor.visitTraversalMethod_trim_Scope(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_trim(self): + + localctx = GremlinParser.TraversalMethod_trimContext(self, self._ctx, self.state) + self.enterRule(localctx, 306, self.RULE_traversalMethod_trim) + try: + self.state = 2389 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 94, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_trim_EmptyContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2381 + self.match(GremlinParser.K_TRIM) + self.state = 2382 + self.match(GremlinParser.LPAREN) + self.state = 2383 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_trim_ScopeContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2384 + self.match(GremlinParser.K_TRIM) + self.state = 2385 + self.match(GremlinParser.LPAREN) + self.state = 2386 + self.traversalScope() + self.state = 2387 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_unfoldContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_UNFOLD(self): + return self.getToken(GremlinParser.K_UNFOLD, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_unfold + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_unfold"): + listener.enterTraversalMethod_unfold(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_unfold"): + listener.exitTraversalMethod_unfold(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_unfold"): + return visitor.visitTraversalMethod_unfold(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_unfold(self): + + localctx = GremlinParser.TraversalMethod_unfoldContext(self, self._ctx, self.state) + self.enterRule(localctx, 308, self.RULE_traversalMethod_unfold) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2391 + self.match(GremlinParser.K_UNFOLD) + self.state = 2392 + self.match(GremlinParser.LPAREN) + self.state = 2393 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_unionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_UNION(self): + return self.getToken(GremlinParser.K_UNION, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversalList(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalListContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_union + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_union"): + listener.enterTraversalMethod_union(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_union"): + listener.exitTraversalMethod_union(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_union"): + return visitor.visitTraversalMethod_union(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_union(self): + + localctx = GremlinParser.TraversalMethod_unionContext(self, self._ctx, self.state) + self.enterRule(localctx, 310, self.RULE_traversalMethod_union) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2395 + self.match(GremlinParser.K_UNION) + self.state = 2396 + self.match(GremlinParser.LPAREN) + self.state = 2397 + self.nestedTraversalList() + self.state = 2398 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_untilContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_until + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_until_TraversalContext(TraversalMethod_untilContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_untilContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_UNTIL(self): + return self.getToken(GremlinParser.K_UNTIL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_until_Traversal"): + listener.enterTraversalMethod_until_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_until_Traversal"): + listener.exitTraversalMethod_until_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_until_Traversal"): + return visitor.visitTraversalMethod_until_Traversal(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_until_PredicateContext(TraversalMethod_untilContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_untilContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_UNTIL(self): + return self.getToken(GremlinParser.K_UNTIL, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_until_Predicate"): + listener.enterTraversalMethod_until_Predicate(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_until_Predicate"): + listener.exitTraversalMethod_until_Predicate(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_until_Predicate"): + return visitor.visitTraversalMethod_until_Predicate(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_until(self): + + localctx = GremlinParser.TraversalMethod_untilContext(self, self._ctx, self.state) + self.enterRule(localctx, 312, self.RULE_traversalMethod_until) + try: + self.state = 2410 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 95, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_until_PredicateContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2400 + self.match(GremlinParser.K_UNTIL) + self.state = 2401 + self.match(GremlinParser.LPAREN) + self.state = 2402 + self.traversalPredicate(0) + self.state = 2403 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_until_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2405 + self.match(GremlinParser.K_UNTIL) + self.state = 2406 + self.match(GremlinParser.LPAREN) + self.state = 2407 + self.nestedTraversal() + self.state = 2408 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_valueContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_VALUE(self): + return self.getToken(GremlinParser.K_VALUE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_value + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_value"): + listener.enterTraversalMethod_value(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_value"): + listener.exitTraversalMethod_value(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_value"): + return visitor.visitTraversalMethod_value(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_value(self): + + localctx = GremlinParser.TraversalMethod_valueContext(self, self._ctx, self.state) + self.enterRule(localctx, 314, self.RULE_traversalMethod_value) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2412 + self.match(GremlinParser.K_VALUE) + self.state = 2413 + self.match(GremlinParser.LPAREN) + self.state = 2414 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_valueMapContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_valueMap + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_valueMap_StringContext(TraversalMethod_valueMapContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_valueMapContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_VALUEMAP(self): + return self.getToken(GremlinParser.K_VALUEMAP, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_valueMap_String"): + listener.enterTraversalMethod_valueMap_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_valueMap_String"): + listener.exitTraversalMethod_valueMap_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_valueMap_String"): + return visitor.visitTraversalMethod_valueMap_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_valueMap_boolean_StringContext(TraversalMethod_valueMapContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_valueMapContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_VALUEMAP(self): + return self.getToken(GremlinParser.K_VALUEMAP, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def booleanLiteral(self): + return self.getTypedRuleContext(GremlinParser.BooleanLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_valueMap_boolean_String"): + listener.enterTraversalMethod_valueMap_boolean_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_valueMap_boolean_String"): + listener.exitTraversalMethod_valueMap_boolean_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_valueMap_boolean_String"): + return visitor.visitTraversalMethod_valueMap_boolean_String(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_valueMap(self): + + localctx = GremlinParser.TraversalMethod_valueMapContext(self, self._ctx, self.state) + self.enterRule(localctx, 316, self.RULE_traversalMethod_valueMap) + self._la = 0 # Token type + try: + self.state = 2430 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 97, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_valueMap_StringContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2416 + self.match(GremlinParser.K_VALUEMAP) + self.state = 2417 + self.match(GremlinParser.LPAREN) + self.state = 2418 + self.stringNullableLiteralVarargs() + self.state = 2419 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_valueMap_boolean_StringContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2421 + self.match(GremlinParser.K_VALUEMAP) + self.state = 2422 + self.match(GremlinParser.LPAREN) + self.state = 2423 + self.booleanLiteral() + self.state = 2426 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 263: + self.state = 2424 + self.match(GremlinParser.COMMA) + self.state = 2425 + self.stringNullableLiteralVarargs() + + self.state = 2428 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_valuesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_VALUES(self): + return self.getToken(GremlinParser.K_VALUES, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringNullableLiteralVarargs(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralVarargsContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_values + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_values"): + listener.enterTraversalMethod_values(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_values"): + listener.exitTraversalMethod_values(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_values"): + return visitor.visitTraversalMethod_values(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_values(self): + + localctx = GremlinParser.TraversalMethod_valuesContext(self, self._ctx, self.state) + self.enterRule(localctx, 318, self.RULE_traversalMethod_values) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2432 + self.match(GremlinParser.K_VALUES) + self.state = 2433 + self.match(GremlinParser.LPAREN) + self.state = 2434 + self.stringNullableLiteralVarargs() + self.state = 2435 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_whereContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_where + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_where_PContext(TraversalMethod_whereContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_whereContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_WHERE(self): + return self.getToken(GremlinParser.K_WHERE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_where_P"): + listener.enterTraversalMethod_where_P(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_where_P"): + listener.exitTraversalMethod_where_P(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_where_P"): + return visitor.visitTraversalMethod_where_P(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_where_String_PContext(TraversalMethod_whereContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_whereContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_WHERE(self): + return self.getToken(GremlinParser.K_WHERE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_where_String_P"): + listener.enterTraversalMethod_where_String_P(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_where_String_P"): + listener.exitTraversalMethod_where_String_P(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_where_String_P"): + return visitor.visitTraversalMethod_where_String_P(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_where_TraversalContext(TraversalMethod_whereContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_whereContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_WHERE(self): + return self.getToken(GremlinParser.K_WHERE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_where_Traversal"): + listener.enterTraversalMethod_where_Traversal(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_where_Traversal"): + listener.exitTraversalMethod_where_Traversal(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_where_Traversal"): + return visitor.visitTraversalMethod_where_Traversal(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_where(self): + + localctx = GremlinParser.TraversalMethod_whereContext(self, self._ctx, self.state) + self.enterRule(localctx, 320, self.RULE_traversalMethod_where) + try: + self.state = 2454 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 98, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_where_PContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2437 + self.match(GremlinParser.K_WHERE) + self.state = 2438 + self.match(GremlinParser.LPAREN) + self.state = 2439 + self.traversalPredicate(0) + self.state = 2440 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_where_String_PContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2442 + self.match(GremlinParser.K_WHERE) + self.state = 2443 + self.match(GremlinParser.LPAREN) + self.state = 2444 + self.stringLiteral() + self.state = 2445 + self.match(GremlinParser.COMMA) + self.state = 2446 + self.traversalPredicate(0) + self.state = 2447 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalMethod_where_TraversalContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 2449 + self.match(GremlinParser.K_WHERE) + self.state = 2450 + self.match(GremlinParser.LPAREN) + self.state = 2451 + self.nestedTraversal() + self.state = 2452 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_withContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_with + + def copyFrom(self, ctx: ParserRuleContext): + super().copyFrom(ctx) + + class TraversalMethod_with_StringContext(TraversalMethod_withContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_withContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_WITH(self): + return self.getToken(GremlinParser.K_WITH, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def withOptionKeys(self): + return self.getTypedRuleContext(GremlinParser.WithOptionKeysContext, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_with_String"): + listener.enterTraversalMethod_with_String(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_with_String"): + listener.exitTraversalMethod_with_String(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_with_String"): + return visitor.visitTraversalMethod_with_String(self) + else: + return visitor.visitChildren(self) + + class TraversalMethod_with_String_ObjectContext(TraversalMethod_withContext): + def __init__(self, parser, ctx: ParserRuleContext): # actually a GremlinParser.TraversalMethod_withContext + super().__init__(parser) + self.copyFrom(ctx) + + def K_WITH(self): + return self.getToken(GremlinParser.K_WITH, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def withOptionKeys(self): + return self.getTypedRuleContext(GremlinParser.WithOptionKeysContext, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def withOptionsValues(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsValuesContext, 0) + + def ioOptionsValues(self): + return self.getTypedRuleContext(GremlinParser.IoOptionsValuesContext, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_with_String_Object"): + listener.enterTraversalMethod_with_String_Object(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_with_String_Object"): + listener.exitTraversalMethod_with_String_Object(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_with_String_Object"): + return visitor.visitTraversalMethod_with_String_Object(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_with(self): + + localctx = GremlinParser.TraversalMethod_withContext(self, self._ctx, self.state) + self.enterRule(localctx, 322, self.RULE_traversalMethod_with) + try: + self.state = 2478 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 102, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalMethod_with_StringContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 2456 + self.match(GremlinParser.K_WITH) + self.state = 2457 + self.match(GremlinParser.LPAREN) + self.state = 2460 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [37, 104, 164, 167, 194, 242]: + self.state = 2458 + self.withOptionKeys() + pass + elif token in [254, 255]: + self.state = 2459 + self.stringLiteral() + pass + else: + raise NoViableAltException(self) + + self.state = 2462 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalMethod_with_String_ObjectContext(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 2464 + self.match(GremlinParser.K_WITH) + self.state = 2465 + self.match(GremlinParser.LPAREN) + self.state = 2468 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [37, 104, 164, 167, 194, 242]: + self.state = 2466 + self.withOptionKeys() + pass + elif token in [254, 255]: + self.state = 2467 + self.stringLiteral() + pass + else: + raise NoViableAltException(self) + + self.state = 2470 + self.match(GremlinParser.COMMA) + self.state = 2474 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [242]: + self.state = 2471 + self.withOptionsValues() + pass + elif token in [104]: + self.state = 2472 + self.ioOptionsValues() + pass + elif token in [ + 1, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 11, + 12, + 14, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 31, + 34, + 35, + 36, + 38, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 48, + 50, + 51, + 52, + 55, + 56, + 57, + 59, + 60, + 61, + 65, + 66, + 67, + 69, + 70, + 71, + 72, + 78, + 79, + 81, + 82, + 83, + 84, + 86, + 87, + 88, + 89, + 90, + 92, + 93, + 94, + 98, + 99, + 100, + 102, + 103, + 106, + 108, + 111, + 113, + 114, + 115, + 116, + 117, + 120, + 121, + 122, + 123, + 124, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 136, + 139, + 144, + 146, + 148, + 149, + 150, + 152, + 153, + 155, + 156, + 157, + 158, + 159, + 160, + 162, + 165, + 166, + 168, + 169, + 171, + 172, + 173, + 174, + 176, + 177, + 178, + 179, + 181, + 183, + 184, + 185, + 187, + 188, + 189, + 191, + 192, + 193, + 195, + 197, + 198, + 199, + 200, + 201, + 203, + 204, + 205, + 206, + 208, + 209, + 212, + 213, + 214, + 218, + 221, + 222, + 223, + 224, + 225, + 226, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 249, + 251, + 252, + 253, + 254, + 255, + 258, + 260, + 266, + 267, + 270, + ]: + self.state = 2473 + self.genericArgument() + pass + else: + raise NoViableAltException(self) + + self.state = 2476 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMethod_writeContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_WRITE(self): + return self.getToken(GremlinParser.K_WRITE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMethod_write + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMethod_write"): + listener.enterTraversalMethod_write(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMethod_write"): + listener.exitTraversalMethod_write(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMethod_write"): + return visitor.visitTraversalMethod_write(self) + else: + return visitor.visitChildren(self) + + def traversalMethod_write(self): + + localctx = GremlinParser.TraversalMethod_writeContext(self, self._ctx, self.state) + self.enterRule(localctx, 324, self.RULE_traversalMethod_write) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2480 + self.match(GremlinParser.K_WRITE) + self.state = 2481 + self.match(GremlinParser.LPAREN) + self.state = 2482 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class StructureVertexLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def stringArgument(self): + return self.getTypedRuleContext(GremlinParser.StringArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_VERTEX(self): + return self.getToken(GremlinParser.K_VERTEX, 0) + + def K_REFERENCEVERTEX(self): + return self.getToken(GremlinParser.K_REFERENCEVERTEX, 0) + + def K_NEW(self): + return self.getToken(GremlinParser.K_NEW, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_structureVertexLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStructureVertexLiteral"): + listener.enterStructureVertexLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStructureVertexLiteral"): + listener.exitStructureVertexLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStructureVertexLiteral"): + return visitor.visitStructureVertexLiteral(self) + else: + return visitor.visitChildren(self) + + def structureVertexLiteral(self): + + localctx = GremlinParser.StructureVertexLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 326, self.RULE_structureVertexLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2485 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 146: + self.state = 2484 + self.match(GremlinParser.K_NEW) + + self.state = 2487 + _la = self._input.LA(1) + if not (_la == 181 or _la == 237): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2488 + self.match(GremlinParser.LPAREN) + self.state = 2489 + self.genericArgument() + self.state = 2490 + self.match(GremlinParser.COMMA) + self.state = 2491 + self.stringArgument() + self.state = 2492 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalStrategyContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def classType(self): + return self.getTypedRuleContext(GremlinParser.ClassTypeContext, 0) + + def K_NEW(self): + return self.getToken(GremlinParser.K_NEW, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def configuration(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.ConfigurationContext) + else: + return self.getTypedRuleContext(GremlinParser.ConfigurationContext, i) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalStrategy + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalStrategy"): + listener.enterTraversalStrategy(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalStrategy"): + listener.exitTraversalStrategy(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalStrategy"): + return visitor.visitTraversalStrategy(self) + else: + return visitor.visitChildren(self) + + def traversalStrategy(self): + + localctx = GremlinParser.TraversalStrategyContext(self, self._ctx, self.state) + self.enterRule(localctx, 328, self.RULE_traversalStrategy) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2495 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 146: + self.state = 2494 + self.match(GremlinParser.K_NEW) + + self.state = 2497 + self.classType() + self.state = 2510 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 256: + self.state = 2498 + self.match(GremlinParser.LPAREN) + self.state = 2507 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ( + (((_la) & ~0x3F) == 0 and ((1 << _la) & -4) != 0) + or (((_la - 64) & ~0x3F) == 0 and ((1 << (_la - 64)) & -1) != 0) + or (((_la - 128) & ~0x3F) == 0 and ((1 << (_la - 128)) & -1) != 0) + or (((_la - 192) & ~0x3F) == 0 and ((1 << (_la - 192)) & 576460752303423487) != 0) + or _la == 266 + or _la == 270 + ): + self.state = 2499 + self.configuration() + self.state = 2504 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 263: + self.state = 2500 + self.match(GremlinParser.COMMA) + self.state = 2501 + self.configuration() + self.state = 2506 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2509 + self.match(GremlinParser.RPAREN) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ConfigurationContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def COLON(self): + return self.getToken(GremlinParser.COLON, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def keyword(self): + return self.getTypedRuleContext(GremlinParser.KeywordContext, 0) + + def nakedKey(self): + return self.getTypedRuleContext(GremlinParser.NakedKeyContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_configuration + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterConfiguration"): + listener.enterConfiguration(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitConfiguration"): + listener.exitConfiguration(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConfiguration"): + return visitor.visitConfiguration(self) + else: + return visitor.visitChildren(self) + + def configuration(self): + + localctx = GremlinParser.ConfigurationContext(self, self._ctx, self.state) + self.enterRule(localctx, 330, self.RULE_configuration) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2514 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [ + 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, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 266, + ]: + self.state = 2512 + self.keyword() + pass + elif token in [270]: + self.state = 2513 + self.nakedKey() + pass + else: + raise NoViableAltException(self) + + self.state = 2516 + self.match(GremlinParser.COLON) + self.state = 2517 + self.genericArgument() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalScopeContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_LOCAL(self): + return self.getToken(GremlinParser.K_LOCAL, 0) + + def K_SCOPE(self): + return self.getToken(GremlinParser.K_SCOPE, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_GLOBAL(self): + return self.getToken(GremlinParser.K_GLOBAL, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalScope + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalScope"): + listener.enterTraversalScope(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalScope"): + listener.exitTraversalScope(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalScope"): + return visitor.visitTraversalScope(self) + else: + return visitor.visitChildren(self) + + def traversalScope(self): + + localctx = GremlinParser.TraversalScopeContext(self, self._ctx, self.state) + self.enterRule(localctx, 332, self.RULE_traversalScope) + try: + self.state = 2527 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 109, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2519 + self.match(GremlinParser.K_LOCAL) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2520 + self.match(GremlinParser.K_SCOPE) + self.state = 2521 + self.match(GremlinParser.DOT) + self.state = 2522 + self.match(GremlinParser.K_LOCAL) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2523 + self.match(GremlinParser.K_GLOBAL) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 2524 + self.match(GremlinParser.K_SCOPE) + self.state = 2525 + self.match(GremlinParser.DOT) + self.state = 2526 + self.match(GremlinParser.K_GLOBAL) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalBarrierContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_NORMSACK(self): + return self.getToken(GremlinParser.K_NORMSACK, 0) + + def K_BARRIERU(self): + return self.getToken(GremlinParser.K_BARRIERU, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalBarrier + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalBarrier"): + listener.enterTraversalBarrier(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalBarrier"): + listener.exitTraversalBarrier(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalBarrier"): + return visitor.visitTraversalBarrier(self) + else: + return visitor.visitChildren(self) + + def traversalBarrier(self): + + localctx = GremlinParser.TraversalBarrierContext(self, self._ctx, self.state) + self.enterRule(localctx, 334, self.RULE_traversalBarrier) + try: + self.state = 2533 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [147]: + self.enterOuterAlt(localctx, 1) + self.state = 2529 + self.match(GremlinParser.K_NORMSACK) + pass + elif token in [15]: + self.enterOuterAlt(localctx, 2) + self.state = 2530 + self.match(GremlinParser.K_BARRIERU) + self.state = 2531 + self.match(GremlinParser.DOT) + self.state = 2532 + self.match(GremlinParser.K_NORMSACK) + 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 TraversalTContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalTShort(self): + return self.getTypedRuleContext(GremlinParser.TraversalTShortContext, 0) + + def traversalTLong(self): + return self.getTypedRuleContext(GremlinParser.TraversalTLongContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalT + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalT"): + listener.enterTraversalT(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalT"): + listener.exitTraversalT(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalT"): + return visitor.visitTraversalT(self) + else: + return visitor.visitChildren(self) + + def traversalT(self): + + localctx = GremlinParser.TraversalTContext(self, self._ctx, self.state) + self.enterRule(localctx, 336, self.RULE_traversalT) + try: + self.state = 2537 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [89, 108, 111, 236]: + self.enterOuterAlt(localctx, 1) + self.state = 2535 + self.traversalTShort() + pass + elif token in [208]: + self.enterOuterAlt(localctx, 2) + self.state = 2536 + self.traversalTLong() + 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 TraversalTShortContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_ID(self): + return self.getToken(GremlinParser.K_ID, 0) + + def K_LABEL(self): + return self.getToken(GremlinParser.K_LABEL, 0) + + def K_KEY(self): + return self.getToken(GremlinParser.K_KEY, 0) + + def K_VALUE(self): + return self.getToken(GremlinParser.K_VALUE, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalTShort + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalTShort"): + listener.enterTraversalTShort(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalTShort"): + listener.exitTraversalTShort(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalTShort"): + return visitor.visitTraversalTShort(self) + else: + return visitor.visitChildren(self) + + def traversalTShort(self): + + localctx = GremlinParser.TraversalTShortContext(self, self._ctx, self.state) + self.enterRule(localctx, 338, self.RULE_traversalTShort) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2539 + _la = self._input.LA(1) + if not ((((_la - 89) & ~0x3F) == 0 and ((1 << (_la - 89)) & 4718593) != 0) or _la == 236): + 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 TraversalTLongContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_T(self): + return self.getToken(GremlinParser.K_T, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_ID(self): + return self.getToken(GremlinParser.K_ID, 0) + + def K_LABEL(self): + return self.getToken(GremlinParser.K_LABEL, 0) + + def K_KEY(self): + return self.getToken(GremlinParser.K_KEY, 0) + + def K_VALUE(self): + return self.getToken(GremlinParser.K_VALUE, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalTLong + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalTLong"): + listener.enterTraversalTLong(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalTLong"): + listener.exitTraversalTLong(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalTLong"): + return visitor.visitTraversalTLong(self) + else: + return visitor.visitChildren(self) + + def traversalTLong(self): + + localctx = GremlinParser.TraversalTLongContext(self, self._ctx, self.state) + self.enterRule(localctx, 340, self.RULE_traversalTLong) + try: + self.state = 2553 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 112, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2541 + self.match(GremlinParser.K_T) + self.state = 2542 + self.match(GremlinParser.DOT) + self.state = 2543 + self.match(GremlinParser.K_ID) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2544 + self.match(GremlinParser.K_T) + self.state = 2545 + self.match(GremlinParser.DOT) + self.state = 2546 + self.match(GremlinParser.K_LABEL) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2547 + self.match(GremlinParser.K_T) + self.state = 2548 + self.match(GremlinParser.DOT) + self.state = 2549 + self.match(GremlinParser.K_KEY) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 2550 + self.match(GremlinParser.K_T) + self.state = 2551 + self.match(GremlinParser.DOT) + self.state = 2552 + self.match(GremlinParser.K_VALUE) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalMergeContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_ONCREATE(self): + return self.getToken(GremlinParser.K_ONCREATE, 0) + + def K_MERGEU(self): + return self.getToken(GremlinParser.K_MERGEU, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_ONMATCH(self): + return self.getToken(GremlinParser.K_ONMATCH, 0) + + def K_OUTV(self): + return self.getToken(GremlinParser.K_OUTV, 0) + + def K_INV(self): + return self.getToken(GremlinParser.K_INV, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalMerge + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalMerge"): + listener.enterTraversalMerge(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalMerge"): + listener.exitTraversalMerge(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalMerge"): + return visitor.visitTraversalMerge(self) + else: + return visitor.visitChildren(self) + + def traversalMerge(self): + + localctx = GremlinParser.TraversalMergeContext(self, self._ctx, self.state) + self.enterRule(localctx, 342, self.RULE_traversalMerge) + try: + self.state = 2571 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 113, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2555 + self.match(GremlinParser.K_ONCREATE) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2556 + self.match(GremlinParser.K_MERGEU) + self.state = 2557 + self.match(GremlinParser.DOT) + self.state = 2558 + self.match(GremlinParser.K_ONCREATE) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2559 + self.match(GremlinParser.K_ONMATCH) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 2560 + self.match(GremlinParser.K_MERGEU) + self.state = 2561 + self.match(GremlinParser.DOT) + self.state = 2562 + self.match(GremlinParser.K_ONMATCH) + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 2563 + self.match(GremlinParser.K_OUTV) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 2564 + self.match(GremlinParser.K_MERGEU) + self.state = 2565 + self.match(GremlinParser.DOT) + self.state = 2566 + self.match(GremlinParser.K_OUTV) + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 2567 + self.match(GremlinParser.K_INV) + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 2568 + self.match(GremlinParser.K_MERGEU) + self.state = 2569 + self.match(GremlinParser.DOT) + self.state = 2570 + self.match(GremlinParser.K_INV) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalOrderContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_ASC(self): + return self.getToken(GremlinParser.K_ASC, 0) + + def K_ORDERU(self): + return self.getToken(GremlinParser.K_ORDERU, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_DESC(self): + return self.getToken(GremlinParser.K_DESC, 0) + + def K_SHUFFLE(self): + return self.getToken(GremlinParser.K_SHUFFLE, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalOrder + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalOrder"): + listener.enterTraversalOrder(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalOrder"): + listener.exitTraversalOrder(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalOrder"): + return visitor.visitTraversalOrder(self) + else: + return visitor.visitChildren(self) + + def traversalOrder(self): + + localctx = GremlinParser.TraversalOrderContext(self, self._ctx, self.state) + self.enterRule(localctx, 344, self.RULE_traversalOrder) + try: + self.state = 2585 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 114, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2573 + self.match(GremlinParser.K_ASC) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2574 + self.match(GremlinParser.K_ORDERU) + self.state = 2575 + self.match(GremlinParser.DOT) + self.state = 2576 + self.match(GremlinParser.K_ASC) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2577 + self.match(GremlinParser.K_DESC) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 2578 + self.match(GremlinParser.K_ORDERU) + self.state = 2579 + self.match(GremlinParser.DOT) + self.state = 2580 + self.match(GremlinParser.K_DESC) + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 2581 + self.match(GremlinParser.K_SHUFFLE) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 2582 + self.match(GremlinParser.K_ORDERU) + self.state = 2583 + self.match(GremlinParser.DOT) + self.state = 2584 + self.match(GremlinParser.K_SHUFFLE) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalDirectionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalDirectionShort(self): + return self.getTypedRuleContext(GremlinParser.TraversalDirectionShortContext, 0) + + def traversalDirectionLong(self): + return self.getTypedRuleContext(GremlinParser.TraversalDirectionLongContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalDirection + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalDirection"): + listener.enterTraversalDirection(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalDirection"): + listener.exitTraversalDirection(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalDirection"): + return visitor.visitTraversalDirection(self) + else: + return visitor.visitChildren(self) + + def traversalDirection(self): + + localctx = GremlinParser.TraversalDirectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 346, self.RULE_traversalDirection) + try: + self.state = 2589 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [19, 72, 93, 158, 214]: + self.enterOuterAlt(localctx, 1) + self.state = 2587 + self.traversalDirectionShort() + pass + elif token in [51]: + self.enterOuterAlt(localctx, 2) + self.state = 2588 + self.traversalDirectionLong() + 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 TraversalDirectionShortContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_INU(self): + return self.getToken(GremlinParser.K_INU, 0) + + def K_FROM(self): + return self.getToken(GremlinParser.K_FROM, 0) + + def K_OUTU(self): + return self.getToken(GremlinParser.K_OUTU, 0) + + def K_TO(self): + return self.getToken(GremlinParser.K_TO, 0) + + def K_BOTHU(self): + return self.getToken(GremlinParser.K_BOTHU, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalDirectionShort + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalDirectionShort"): + listener.enterTraversalDirectionShort(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalDirectionShort"): + listener.exitTraversalDirectionShort(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalDirectionShort"): + return visitor.visitTraversalDirectionShort(self) + else: + return visitor.visitChildren(self) + + def traversalDirectionShort(self): + + localctx = GremlinParser.TraversalDirectionShortContext(self, self._ctx, self.state) + self.enterRule(localctx, 348, self.RULE_traversalDirectionShort) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2591 + _la = self._input.LA(1) + if not (_la == 19 or _la == 72 or _la == 93 or _la == 158 or _la == 214): + 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 TraversalDirectionLongContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_DIRECTION(self): + return self.getToken(GremlinParser.K_DIRECTION, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_INU(self): + return self.getToken(GremlinParser.K_INU, 0) + + def K_FROM(self): + return self.getToken(GremlinParser.K_FROM, 0) + + def K_OUTU(self): + return self.getToken(GremlinParser.K_OUTU, 0) + + def K_TO(self): + return self.getToken(GremlinParser.K_TO, 0) + + def K_BOTHU(self): + return self.getToken(GremlinParser.K_BOTHU, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalDirectionLong + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalDirectionLong"): + listener.enterTraversalDirectionLong(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalDirectionLong"): + listener.exitTraversalDirectionLong(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalDirectionLong"): + return visitor.visitTraversalDirectionLong(self) + else: + return visitor.visitChildren(self) + + def traversalDirectionLong(self): + + localctx = GremlinParser.TraversalDirectionLongContext(self, self._ctx, self.state) + self.enterRule(localctx, 350, self.RULE_traversalDirectionLong) + try: + self.state = 2608 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 116, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2593 + self.match(GremlinParser.K_DIRECTION) + self.state = 2594 + self.match(GremlinParser.DOT) + self.state = 2595 + self.match(GremlinParser.K_INU) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2596 + self.match(GremlinParser.K_DIRECTION) + self.state = 2597 + self.match(GremlinParser.DOT) + self.state = 2598 + self.match(GremlinParser.K_FROM) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2599 + self.match(GremlinParser.K_DIRECTION) + self.state = 2600 + self.match(GremlinParser.DOT) + self.state = 2601 + self.match(GremlinParser.K_OUTU) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 2602 + self.match(GremlinParser.K_DIRECTION) + self.state = 2603 + self.match(GremlinParser.DOT) + self.state = 2604 + self.match(GremlinParser.K_TO) + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 2605 + self.match(GremlinParser.K_DIRECTION) + self.state = 2606 + self.match(GremlinParser.DOT) + self.state = 2607 + self.match(GremlinParser.K_BOTHU) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalCardinalityContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericLiteral(self): + return self.getTypedRuleContext(GremlinParser.GenericLiteralContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_CARDINALITY(self): + return self.getToken(GremlinParser.K_CARDINALITY, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_SINGLE(self): + return self.getToken(GremlinParser.K_SINGLE, 0) + + def K_SET(self): + return self.getToken(GremlinParser.K_SET, 0) + + def K_LIST(self): + return self.getToken(GremlinParser.K_LIST, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalCardinality + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalCardinality"): + listener.enterTraversalCardinality(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalCardinality"): + listener.exitTraversalCardinality(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalCardinality"): + return visitor.visitTraversalCardinality(self) + else: + return visitor.visitChildren(self) + + def traversalCardinality(self): + + localctx = GremlinParser.TraversalCardinalityContext(self, self._ctx, self.state) + self.enterRule(localctx, 352, self.RULE_traversalCardinality) + try: + self.state = 2652 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 120, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2614 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [26]: + self.state = 2610 + self.match(GremlinParser.K_CARDINALITY) + self.state = 2611 + self.match(GremlinParser.DOT) + self.state = 2612 + self.match(GremlinParser.K_SINGLE) + pass + elif token in [199]: + self.state = 2613 + self.match(GremlinParser.K_SINGLE) + pass + else: + raise NoViableAltException(self) + + self.state = 2616 + self.match(GremlinParser.LPAREN) + self.state = 2617 + self.genericLiteral() + self.state = 2618 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2624 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [26]: + self.state = 2620 + self.match(GremlinParser.K_CARDINALITY) + self.state = 2621 + self.match(GremlinParser.DOT) + self.state = 2622 + self.match(GremlinParser.K_SET) + pass + elif token in [193]: + self.state = 2623 + self.match(GremlinParser.K_SET) + pass + else: + raise NoViableAltException(self) + + self.state = 2626 + self.match(GremlinParser.LPAREN) + self.state = 2627 + self.genericLiteral() + self.state = 2628 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2634 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [26]: + self.state = 2630 + self.match(GremlinParser.K_CARDINALITY) + self.state = 2631 + self.match(GremlinParser.DOT) + self.state = 2632 + self.match(GremlinParser.K_LIST) + pass + elif token in [115]: + self.state = 2633 + self.match(GremlinParser.K_LIST) + pass + else: + raise NoViableAltException(self) + + self.state = 2636 + self.match(GremlinParser.LPAREN) + self.state = 2637 + self.genericLiteral() + self.state = 2638 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 2640 + self.match(GremlinParser.K_SINGLE) + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 2641 + self.match(GremlinParser.K_CARDINALITY) + self.state = 2642 + self.match(GremlinParser.DOT) + self.state = 2643 + self.match(GremlinParser.K_SINGLE) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 2644 + self.match(GremlinParser.K_SET) + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 2645 + self.match(GremlinParser.K_CARDINALITY) + self.state = 2646 + self.match(GremlinParser.DOT) + self.state = 2647 + self.match(GremlinParser.K_SET) + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 2648 + self.match(GremlinParser.K_LIST) + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 2649 + self.match(GremlinParser.K_CARDINALITY) + self.state = 2650 + self.match(GremlinParser.DOT) + self.state = 2651 + self.match(GremlinParser.K_LIST) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalColumnContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_KEYS(self): + return self.getToken(GremlinParser.K_KEYS, 0) + + def K_COLUMN(self): + return self.getToken(GremlinParser.K_COLUMN, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_VALUES(self): + return self.getToken(GremlinParser.K_VALUES, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalColumn + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalColumn"): + listener.enterTraversalColumn(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalColumn"): + listener.exitTraversalColumn(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalColumn"): + return visitor.visitTraversalColumn(self) + else: + return visitor.visitChildren(self) + + def traversalColumn(self): + + localctx = GremlinParser.TraversalColumnContext(self, self._ctx, self.state) + self.enterRule(localctx, 354, self.RULE_traversalColumn) + try: + self.state = 2662 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 121, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2654 + self.match(GremlinParser.K_KEYS) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2655 + self.match(GremlinParser.K_COLUMN) + self.state = 2656 + self.match(GremlinParser.DOT) + self.state = 2657 + self.match(GremlinParser.K_KEYS) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2658 + self.match(GremlinParser.K_VALUES) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 2659 + self.match(GremlinParser.K_COLUMN) + self.state = 2660 + self.match(GremlinParser.DOT) + self.state = 2661 + self.match(GremlinParser.K_VALUES) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPopContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_FIRST(self): + return self.getToken(GremlinParser.K_FIRST, 0) + + def K_POP(self): + return self.getToken(GremlinParser.K_POP, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_LAST(self): + return self.getToken(GremlinParser.K_LAST, 0) + + def K_ALL(self): + return self.getToken(GremlinParser.K_ALL, 0) + + def K_MIXED(self): + return self.getToken(GremlinParser.K_MIXED, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPop + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPop"): + listener.enterTraversalPop(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPop"): + listener.exitTraversalPop(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPop"): + return visitor.visitTraversalPop(self) + else: + return visitor.visitChildren(self) + + def traversalPop(self): + + localctx = GremlinParser.TraversalPopContext(self, self._ctx, self.state) + self.enterRule(localctx, 356, self.RULE_traversalPop) + try: + self.state = 2680 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 122, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2664 + self.match(GremlinParser.K_FIRST) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2665 + self.match(GremlinParser.K_POP) + self.state = 2666 + self.match(GremlinParser.DOT) + self.state = 2667 + self.match(GremlinParser.K_FIRST) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2668 + self.match(GremlinParser.K_LAST) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 2669 + self.match(GremlinParser.K_POP) + self.state = 2670 + self.match(GremlinParser.DOT) + self.state = 2671 + self.match(GremlinParser.K_LAST) + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 2672 + self.match(GremlinParser.K_ALL) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 2673 + self.match(GremlinParser.K_POP) + self.state = 2674 + self.match(GremlinParser.DOT) + self.state = 2675 + self.match(GremlinParser.K_ALL) + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 2676 + self.match(GremlinParser.K_MIXED) + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 2677 + self.match(GremlinParser.K_POP) + self.state = 2678 + self.match(GremlinParser.DOT) + self.state = 2679 + self.match(GremlinParser.K_MIXED) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalOperatorContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_ADDALL(self): + return self.getToken(GremlinParser.K_ADDALL, 0) + + def K_OPERATOR(self): + return self.getToken(GremlinParser.K_OPERATOR, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_AND(self): + return self.getToken(GremlinParser.K_AND, 0) + + def K_ASSIGN(self): + return self.getToken(GremlinParser.K_ASSIGN, 0) + + def K_DIV(self): + return self.getToken(GremlinParser.K_DIV, 0) + + def K_MAX(self): + return self.getToken(GremlinParser.K_MAX, 0) + + def K_MIN(self): + return self.getToken(GremlinParser.K_MIN, 0) + + def K_MINUS(self): + return self.getToken(GremlinParser.K_MINUS, 0) + + def K_MULT(self): + return self.getToken(GremlinParser.K_MULT, 0) + + def K_OR(self): + return self.getToken(GremlinParser.K_OR, 0) + + def K_SUM(self): + return self.getToken(GremlinParser.K_SUM, 0) + + def K_SUMLONG(self): + return self.getToken(GremlinParser.K_SUMLONG, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalOperator + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalOperator"): + listener.enterTraversalOperator(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalOperator"): + listener.exitTraversalOperator(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalOperator"): + return visitor.visitTraversalOperator(self) + else: + return visitor.visitChildren(self) + + def traversalOperator(self): + + localctx = GremlinParser.TraversalOperatorContext(self, self._ctx, self.state) + self.enterRule(localctx, 358, self.RULE_traversalOperator) + try: + self.state = 2726 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 123, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2682 + self.match(GremlinParser.K_ADDALL) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2683 + self.match(GremlinParser.K_OPERATOR) + self.state = 2684 + self.match(GremlinParser.DOT) + self.state = 2685 + self.match(GremlinParser.K_ADDALL) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2686 + self.match(GremlinParser.K_AND) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 2687 + self.match(GremlinParser.K_OPERATOR) + self.state = 2688 + self.match(GremlinParser.DOT) + self.state = 2689 + self.match(GremlinParser.K_AND) + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 2690 + self.match(GremlinParser.K_ASSIGN) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 2691 + self.match(GremlinParser.K_OPERATOR) + self.state = 2692 + self.match(GremlinParser.DOT) + self.state = 2693 + self.match(GremlinParser.K_ASSIGN) + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 2694 + self.match(GremlinParser.K_DIV) + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 2695 + self.match(GremlinParser.K_OPERATOR) + self.state = 2696 + self.match(GremlinParser.DOT) + self.state = 2697 + self.match(GremlinParser.K_DIV) + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 2698 + self.match(GremlinParser.K_MAX) + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 2699 + self.match(GremlinParser.K_OPERATOR) + self.state = 2700 + self.match(GremlinParser.DOT) + self.state = 2701 + self.match(GremlinParser.K_MAX) + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 2702 + self.match(GremlinParser.K_MIN) + pass + + elif la_ == 12: + self.enterOuterAlt(localctx, 12) + self.state = 2703 + self.match(GremlinParser.K_OPERATOR) + self.state = 2704 + self.match(GremlinParser.DOT) + self.state = 2705 + self.match(GremlinParser.K_MIN) + pass + + elif la_ == 13: + self.enterOuterAlt(localctx, 13) + self.state = 2706 + self.match(GremlinParser.K_MINUS) + pass + + elif la_ == 14: + self.enterOuterAlt(localctx, 14) + self.state = 2707 + self.match(GremlinParser.K_OPERATOR) + self.state = 2708 + self.match(GremlinParser.DOT) + self.state = 2709 + self.match(GremlinParser.K_MINUS) + pass + + elif la_ == 15: + self.enterOuterAlt(localctx, 15) + self.state = 2710 + self.match(GremlinParser.K_MULT) + pass + + elif la_ == 16: + self.enterOuterAlt(localctx, 16) + self.state = 2711 + self.match(GremlinParser.K_OPERATOR) + self.state = 2712 + self.match(GremlinParser.DOT) + self.state = 2713 + self.match(GremlinParser.K_MULT) + pass + + elif la_ == 17: + self.enterOuterAlt(localctx, 17) + self.state = 2714 + self.match(GremlinParser.K_OR) + pass + + elif la_ == 18: + self.enterOuterAlt(localctx, 18) + self.state = 2715 + self.match(GremlinParser.K_OPERATOR) + self.state = 2716 + self.match(GremlinParser.DOT) + self.state = 2717 + self.match(GremlinParser.K_OR) + pass + + elif la_ == 19: + self.enterOuterAlt(localctx, 19) + self.state = 2718 + self.match(GremlinParser.K_SUM) + pass + + elif la_ == 20: + self.enterOuterAlt(localctx, 20) + self.state = 2719 + self.match(GremlinParser.K_OPERATOR) + self.state = 2720 + self.match(GremlinParser.DOT) + self.state = 2721 + self.match(GremlinParser.K_SUM) + pass + + elif la_ == 21: + self.enterOuterAlt(localctx, 21) + self.state = 2722 + self.match(GremlinParser.K_SUMLONG) + pass + + elif la_ == 22: + self.enterOuterAlt(localctx, 22) + self.state = 2723 + self.match(GremlinParser.K_OPERATOR) + self.state = 2724 + self.match(GremlinParser.DOT) + self.state = 2725 + self.match(GremlinParser.K_SUMLONG) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPickContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_ANY(self): + return self.getToken(GremlinParser.K_ANY, 0) + + def K_PICK(self): + return self.getToken(GremlinParser.K_PICK, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_NONE(self): + return self.getToken(GremlinParser.K_NONE, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPick + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPick"): + listener.enterTraversalPick(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPick"): + listener.exitTraversalPick(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPick"): + return visitor.visitTraversalPick(self) + else: + return visitor.visitChildren(self) + + def traversalPick(self): + + localctx = GremlinParser.TraversalPickContext(self, self._ctx, self.state) + self.enterRule(localctx, 360, self.RULE_traversalPick) + try: + self.state = 2736 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 124, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2728 + self.match(GremlinParser.K_ANY) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2729 + self.match(GremlinParser.K_PICK) + self.state = 2730 + self.match(GremlinParser.DOT) + self.state = 2731 + self.match(GremlinParser.K_ANY) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2732 + self.match(GremlinParser.K_NONE) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 2733 + self.match(GremlinParser.K_PICK) + self.state = 2734 + self.match(GremlinParser.DOT) + self.state = 2735 + self.match(GremlinParser.K_NONE) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalDTContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_SECOND(self): + return self.getToken(GremlinParser.K_SECOND, 0) + + def K_DT(self): + return self.getToken(GremlinParser.K_DT, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_MINUTE(self): + return self.getToken(GremlinParser.K_MINUTE, 0) + + def K_HOUR(self): + return self.getToken(GremlinParser.K_HOUR, 0) + + def K_DAY(self): + return self.getToken(GremlinParser.K_DAY, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalDT + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalDT"): + listener.enterTraversalDT(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalDT"): + listener.exitTraversalDT(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalDT"): + return visitor.visitTraversalDT(self) + else: + return visitor.visitChildren(self) + + def traversalDT(self): + + localctx = GremlinParser.TraversalDTContext(self, self._ctx, self.state) + self.enterRule(localctx, 362, self.RULE_traversalDT) + try: + self.state = 2754 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 125, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2738 + self.match(GremlinParser.K_SECOND) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2739 + self.match(GremlinParser.K_DT) + self.state = 2740 + self.match(GremlinParser.DOT) + self.state = 2741 + self.match(GremlinParser.K_SECOND) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2742 + self.match(GremlinParser.K_MINUTE) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 2743 + self.match(GremlinParser.K_DT) + self.state = 2744 + self.match(GremlinParser.DOT) + self.state = 2745 + self.match(GremlinParser.K_MINUTE) + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 2746 + self.match(GremlinParser.K_HOUR) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 2747 + self.match(GremlinParser.K_DT) + self.state = 2748 + self.match(GremlinParser.DOT) + self.state = 2749 + self.match(GremlinParser.K_HOUR) + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 2750 + self.match(GremlinParser.K_DAY) + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 2751 + self.match(GremlinParser.K_DT) + self.state = 2752 + self.match(GremlinParser.DOT) + self.state = 2753 + self.match(GremlinParser.K_DAY) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicateContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalPredicate_eq(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_eqContext, 0) + + def traversalPredicate_neq(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_neqContext, 0) + + def traversalPredicate_lt(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_ltContext, 0) + + def traversalPredicate_lte(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_lteContext, 0) + + def traversalPredicate_gt(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_gtContext, 0) + + def traversalPredicate_gte(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_gteContext, 0) + + def traversalPredicate_inside(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_insideContext, 0) + + def traversalPredicate_outside(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_outsideContext, 0) + + def traversalPredicate_between(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_betweenContext, 0) + + def traversalPredicate_within(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_withinContext, 0) + + def traversalPredicate_without(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_withoutContext, 0) + + def traversalPredicate_not(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_notContext, 0) + + def traversalPredicate_startingWith(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_startingWithContext, 0) + + def traversalPredicate_notStartingWith(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_notStartingWithContext, 0) + + def traversalPredicate_endingWith(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_endingWithContext, 0) + + def traversalPredicate_notEndingWith(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_notEndingWithContext, 0) + + def traversalPredicate_containing(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_containingContext, 0) + + def traversalPredicate_notContaining(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_notContainingContext, 0) + + def traversalPredicate_regex(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_regexContext, 0) + + def traversalPredicate_notRegex(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicate_notRegexContext, 0) + + def traversalPredicate(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.TraversalPredicateContext) + else: + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, i) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_AND(self): + return self.getToken(GremlinParser.K_AND, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_OR(self): + return self.getToken(GremlinParser.K_OR, 0) + + def K_NEGATE(self): + return self.getToken(GremlinParser.K_NEGATE, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate"): + listener.enterTraversalPredicate(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate"): + listener.exitTraversalPredicate(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate"): + return visitor.visitTraversalPredicate(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate(self, _p: int = 0): + _parentctx = self._ctx + _parentState = self.state + localctx = GremlinParser.TraversalPredicateContext(self, self._ctx, _parentState) + _prevctx = localctx + _startState = 364 + self.enterRecursionRule(localctx, 364, self.RULE_traversalPredicate, _p) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2777 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 126, self._ctx) + if la_ == 1: + self.state = 2757 + self.traversalPredicate_eq() + pass + + elif la_ == 2: + self.state = 2758 + self.traversalPredicate_neq() + pass + + elif la_ == 3: + self.state = 2759 + self.traversalPredicate_lt() + pass + + elif la_ == 4: + self.state = 2760 + self.traversalPredicate_lte() + pass + + elif la_ == 5: + self.state = 2761 + self.traversalPredicate_gt() + pass + + elif la_ == 6: + self.state = 2762 + self.traversalPredicate_gte() + pass + + elif la_ == 7: + self.state = 2763 + self.traversalPredicate_inside() + pass + + elif la_ == 8: + self.state = 2764 + self.traversalPredicate_outside() + pass + + elif la_ == 9: + self.state = 2765 + self.traversalPredicate_between() + pass + + elif la_ == 10: + self.state = 2766 + self.traversalPredicate_within() + pass + + elif la_ == 11: + self.state = 2767 + self.traversalPredicate_without() + pass + + elif la_ == 12: + self.state = 2768 + self.traversalPredicate_not() + pass + + elif la_ == 13: + self.state = 2769 + self.traversalPredicate_startingWith() + pass + + elif la_ == 14: + self.state = 2770 + self.traversalPredicate_notStartingWith() + pass + + elif la_ == 15: + self.state = 2771 + self.traversalPredicate_endingWith() + pass + + elif la_ == 16: + self.state = 2772 + self.traversalPredicate_notEndingWith() + pass + + elif la_ == 17: + self.state = 2773 + self.traversalPredicate_containing() + pass + + elif la_ == 18: + self.state = 2774 + self.traversalPredicate_notContaining() + pass + + elif la_ == 19: + self.state = 2775 + self.traversalPredicate_regex() + pass + + elif la_ == 20: + self.state = 2776 + self.traversalPredicate_notRegex() + pass + + self._ctx.stop = self._input.LT(-1) + self.state = 2800 + 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: + if self._parseListeners is not None: + self.triggerExitRuleEvent() + _prevctx = localctx + self.state = 2798 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 127, self._ctx) + if la_ == 1: + localctx = GremlinParser.TraversalPredicateContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_traversalPredicate) + self.state = 2779 + if not self.precpred(self._ctx, 3): + from antlr4.error.Errors import FailedPredicateException + + raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") + self.state = 2780 + self.match(GremlinParser.DOT) + self.state = 2781 + self.match(GremlinParser.K_AND) + self.state = 2782 + self.match(GremlinParser.LPAREN) + self.state = 2783 + self.traversalPredicate(0) + self.state = 2784 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + localctx = GremlinParser.TraversalPredicateContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_traversalPredicate) + self.state = 2786 + if not self.precpred(self._ctx, 2): + from antlr4.error.Errors import FailedPredicateException + + raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") + self.state = 2787 + self.match(GremlinParser.DOT) + self.state = 2788 + self.match(GremlinParser.K_OR) + self.state = 2789 + self.match(GremlinParser.LPAREN) + self.state = 2790 + self.traversalPredicate(0) + self.state = 2791 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + localctx = GremlinParser.TraversalPredicateContext(self, _parentctx, _parentState) + self.pushNewRecursionContext(localctx, _startState, self.RULE_traversalPredicate) + self.state = 2793 + if not self.precpred(self._ctx, 1): + from antlr4.error.Errors import FailedPredicateException + + raise FailedPredicateException(self, "self.precpred(self._ctx, 1)") + self.state = 2794 + self.match(GremlinParser.DOT) + self.state = 2795 + self.match(GremlinParser.K_NEGATE) + self.state = 2796 + self.match(GremlinParser.LPAREN) + self.state = 2797 + self.match(GremlinParser.RPAREN) + pass + + self.state = 2802 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input, 128, self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.unrollRecursionContexts(_parentctx) + return localctx + + class TraversalTerminalMethodContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalTerminalMethod_explain(self): + return self.getTypedRuleContext(GremlinParser.TraversalTerminalMethod_explainContext, 0) + + def traversalTerminalMethod_iterate(self): + return self.getTypedRuleContext(GremlinParser.TraversalTerminalMethod_iterateContext, 0) + + def traversalTerminalMethod_hasNext(self): + return self.getTypedRuleContext(GremlinParser.TraversalTerminalMethod_hasNextContext, 0) + + def traversalTerminalMethod_tryNext(self): + return self.getTypedRuleContext(GremlinParser.TraversalTerminalMethod_tryNextContext, 0) + + def traversalTerminalMethod_next(self): + return self.getTypedRuleContext(GremlinParser.TraversalTerminalMethod_nextContext, 0) + + def traversalTerminalMethod_toList(self): + return self.getTypedRuleContext(GremlinParser.TraversalTerminalMethod_toListContext, 0) + + def traversalTerminalMethod_toSet(self): + return self.getTypedRuleContext(GremlinParser.TraversalTerminalMethod_toSetContext, 0) + + def traversalTerminalMethod_toBulkSet(self): + return self.getTypedRuleContext(GremlinParser.TraversalTerminalMethod_toBulkSetContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalTerminalMethod + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalTerminalMethod"): + listener.enterTraversalTerminalMethod(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalTerminalMethod"): + listener.exitTraversalTerminalMethod(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalTerminalMethod"): + return visitor.visitTraversalTerminalMethod(self) + else: + return visitor.visitChildren(self) + + def traversalTerminalMethod(self): + + localctx = GremlinParser.TraversalTerminalMethodContext(self, self._ctx, self.state) + self.enterRule(localctx, 366, self.RULE_traversalTerminalMethod) + try: + self.state = 2811 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [64]: + self.enterOuterAlt(localctx, 1) + self.state = 2803 + self.traversalTerminalMethod_explain() + pass + elif token in [107]: + self.enterOuterAlt(localctx, 2) + self.state = 2804 + self.traversalTerminalMethod_iterate() + pass + elif token in [85]: + self.enterOuterAlt(localctx, 3) + self.state = 2805 + self.traversalTerminalMethod_hasNext() + pass + elif token in [227]: + self.enterOuterAlt(localctx, 4) + self.state = 2806 + self.traversalTerminalMethod_tryNext() + pass + elif token in [138]: + self.enterOuterAlt(localctx, 5) + self.state = 2807 + self.traversalTerminalMethod_next() + pass + elif token in [217]: + self.enterOuterAlt(localctx, 6) + self.state = 2808 + self.traversalTerminalMethod_toList() + pass + elif token in [219]: + self.enterOuterAlt(localctx, 7) + self.state = 2809 + self.traversalTerminalMethod_toSet() + pass + elif token in [215]: + self.enterOuterAlt(localctx, 8) + self.state = 2810 + self.traversalTerminalMethod_toBulkSet() + 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 TraversalSackMethodContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalBarrier(self): + return self.getTypedRuleContext(GremlinParser.TraversalBarrierContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalSackMethod + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalSackMethod"): + listener.enterTraversalSackMethod(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalSackMethod"): + listener.exitTraversalSackMethod(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalSackMethod"): + return visitor.visitTraversalSackMethod(self) + else: + return visitor.visitChildren(self) + + def traversalSackMethod(self): + + localctx = GremlinParser.TraversalSackMethodContext(self, self._ctx, self.state) + self.enterRule(localctx, 368, self.RULE_traversalSackMethod) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2813 + self.traversalBarrier() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalComparatorContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalOrder(self): + return self.getTypedRuleContext(GremlinParser.TraversalOrderContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalComparator + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalComparator"): + listener.enterTraversalComparator(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalComparator"): + listener.exitTraversalComparator(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalComparator"): + return visitor.visitTraversalComparator(self) + else: + return visitor.visitChildren(self) + + def traversalComparator(self): + + localctx = GremlinParser.TraversalComparatorContext(self, self._ctx, self.state) + self.enterRule(localctx, 370, self.RULE_traversalComparator) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2815 + self.traversalOrder() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalFunctionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalT(self): + return self.getTypedRuleContext(GremlinParser.TraversalTContext, 0) + + def traversalColumn(self): + return self.getTypedRuleContext(GremlinParser.TraversalColumnContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalFunction + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalFunction"): + listener.enterTraversalFunction(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalFunction"): + listener.exitTraversalFunction(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalFunction"): + return visitor.visitTraversalFunction(self) + else: + return visitor.visitChildren(self) + + def traversalFunction(self): + + localctx = GremlinParser.TraversalFunctionContext(self, self._ctx, self.state) + self.enterRule(localctx, 372, self.RULE_traversalFunction) + try: + self.state = 2819 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [89, 108, 111, 208, 236]: + self.enterOuterAlt(localctx, 1) + self.state = 2817 + self.traversalT() + pass + elif token in [30, 109, 235]: + self.enterOuterAlt(localctx, 2) + self.state = 2818 + self.traversalColumn() + 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 TraversalBiFunctionContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalOperator(self): + return self.getTypedRuleContext(GremlinParser.TraversalOperatorContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalBiFunction + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalBiFunction"): + listener.enterTraversalBiFunction(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalBiFunction"): + listener.exitTraversalBiFunction(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalBiFunction"): + return visitor.visitTraversalBiFunction(self) + else: + return visitor.visitChildren(self) + + def traversalBiFunction(self): + + localctx = GremlinParser.TraversalBiFunctionContext(self, self._ctx, self.state) + self.enterRule(localctx, 374, self.RULE_traversalBiFunction) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2821 + self.traversalOperator() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_eqContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_P(self): + return self.getToken(GremlinParser.K_P, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_EQ(self): + return self.getToken(GremlinParser.K_EQ, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_eq + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_eq"): + listener.enterTraversalPredicate_eq(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_eq"): + listener.exitTraversalPredicate_eq(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_eq"): + return visitor.visitTraversalPredicate_eq(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_eq(self): + + localctx = GremlinParser.TraversalPredicate_eqContext(self, self._ctx, self.state) + self.enterRule(localctx, 376, self.RULE_traversalPredicate_eq) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2827 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [163]: + self.state = 2823 + self.match(GremlinParser.K_P) + self.state = 2824 + self.match(GremlinParser.DOT) + self.state = 2825 + self.match(GremlinParser.K_EQ) + pass + elif token in [63]: + self.state = 2826 + self.match(GremlinParser.K_EQ) + pass + else: + raise NoViableAltException(self) + + self.state = 2829 + self.match(GremlinParser.LPAREN) + self.state = 2830 + self.genericArgument() + self.state = 2831 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_neqContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_P(self): + return self.getToken(GremlinParser.K_P, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_NEQ(self): + return self.getToken(GremlinParser.K_NEQ, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_neq + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_neq"): + listener.enterTraversalPredicate_neq(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_neq"): + listener.exitTraversalPredicate_neq(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_neq"): + return visitor.visitTraversalPredicate_neq(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_neq(self): + + localctx = GremlinParser.TraversalPredicate_neqContext(self, self._ctx, self.state) + self.enterRule(localctx, 378, self.RULE_traversalPredicate_neq) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2837 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [163]: + self.state = 2833 + self.match(GremlinParser.K_P) + self.state = 2834 + self.match(GremlinParser.DOT) + self.state = 2835 + self.match(GremlinParser.K_NEQ) + pass + elif token in [145]: + self.state = 2836 + self.match(GremlinParser.K_NEQ) + pass + else: + raise NoViableAltException(self) + + self.state = 2839 + self.match(GremlinParser.LPAREN) + self.state = 2840 + self.genericArgument() + self.state = 2841 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_ltContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_P(self): + return self.getToken(GremlinParser.K_P, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_LT(self): + return self.getToken(GremlinParser.K_LT, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_lt + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_lt"): + listener.enterTraversalPredicate_lt(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_lt"): + listener.exitTraversalPredicate_lt(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_lt"): + return visitor.visitTraversalPredicate_lt(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_lt(self): + + localctx = GremlinParser.TraversalPredicate_ltContext(self, self._ctx, self.state) + self.enterRule(localctx, 380, self.RULE_traversalPredicate_lt) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2847 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [163]: + self.state = 2843 + self.match(GremlinParser.K_P) + self.state = 2844 + self.match(GremlinParser.DOT) + self.state = 2845 + self.match(GremlinParser.K_LT) + pass + elif token in [118]: + self.state = 2846 + self.match(GremlinParser.K_LT) + pass + else: + raise NoViableAltException(self) + + self.state = 2849 + self.match(GremlinParser.LPAREN) + self.state = 2850 + self.genericArgument() + self.state = 2851 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_lteContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_P(self): + return self.getToken(GremlinParser.K_P, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_LTE(self): + return self.getToken(GremlinParser.K_LTE, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_lte + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_lte"): + listener.enterTraversalPredicate_lte(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_lte"): + listener.exitTraversalPredicate_lte(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_lte"): + return visitor.visitTraversalPredicate_lte(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_lte(self): + + localctx = GremlinParser.TraversalPredicate_lteContext(self, self._ctx, self.state) + self.enterRule(localctx, 382, self.RULE_traversalPredicate_lte) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2857 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [163]: + self.state = 2853 + self.match(GremlinParser.K_P) + self.state = 2854 + self.match(GremlinParser.DOT) + self.state = 2855 + self.match(GremlinParser.K_LTE) + pass + elif token in [119]: + self.state = 2856 + self.match(GremlinParser.K_LTE) + pass + else: + raise NoViableAltException(self) + + self.state = 2859 + self.match(GremlinParser.LPAREN) + self.state = 2860 + self.genericArgument() + self.state = 2861 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_gtContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_P(self): + return self.getToken(GremlinParser.K_P, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_GT(self): + return self.getToken(GremlinParser.K_GT, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_gt + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_gt"): + listener.enterTraversalPredicate_gt(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_gt"): + listener.exitTraversalPredicate_gt(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_gt"): + return visitor.visitTraversalPredicate_gt(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_gt(self): + + localctx = GremlinParser.TraversalPredicate_gtContext(self, self._ctx, self.state) + self.enterRule(localctx, 384, self.RULE_traversalPredicate_gt) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2867 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [163]: + self.state = 2863 + self.match(GremlinParser.K_P) + self.state = 2864 + self.match(GremlinParser.DOT) + self.state = 2865 + self.match(GremlinParser.K_GT) + pass + elif token in [74]: + self.state = 2866 + self.match(GremlinParser.K_GT) + pass + else: + raise NoViableAltException(self) + + self.state = 2869 + self.match(GremlinParser.LPAREN) + self.state = 2870 + self.genericArgument() + self.state = 2871 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_gteContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_P(self): + return self.getToken(GremlinParser.K_P, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_GTE(self): + return self.getToken(GremlinParser.K_GTE, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_gte + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_gte"): + listener.enterTraversalPredicate_gte(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_gte"): + listener.exitTraversalPredicate_gte(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_gte"): + return visitor.visitTraversalPredicate_gte(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_gte(self): + + localctx = GremlinParser.TraversalPredicate_gteContext(self, self._ctx, self.state) + self.enterRule(localctx, 386, self.RULE_traversalPredicate_gte) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2877 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [163]: + self.state = 2873 + self.match(GremlinParser.K_P) + self.state = 2874 + self.match(GremlinParser.DOT) + self.state = 2875 + self.match(GremlinParser.K_GTE) + pass + elif token in [75]: + self.state = 2876 + self.match(GremlinParser.K_GTE) + pass + else: + raise NoViableAltException(self) + + self.state = 2879 + self.match(GremlinParser.LPAREN) + self.state = 2880 + self.genericArgument() + self.state = 2881 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_insideContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.GenericArgumentContext) + else: + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, i) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_P(self): + return self.getToken(GremlinParser.K_P, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_INSIDE(self): + return self.getToken(GremlinParser.K_INSIDE, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_inside + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_inside"): + listener.enterTraversalPredicate_inside(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_inside"): + listener.exitTraversalPredicate_inside(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_inside"): + return visitor.visitTraversalPredicate_inside(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_inside(self): + + localctx = GremlinParser.TraversalPredicate_insideContext(self, self._ctx, self.state) + self.enterRule(localctx, 388, self.RULE_traversalPredicate_inside) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2887 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [163]: + self.state = 2883 + self.match(GremlinParser.K_P) + self.state = 2884 + self.match(GremlinParser.DOT) + self.state = 2885 + self.match(GremlinParser.K_INSIDE) + pass + elif token in [101]: + self.state = 2886 + self.match(GremlinParser.K_INSIDE) + pass + else: + raise NoViableAltException(self) + + self.state = 2889 + self.match(GremlinParser.LPAREN) + self.state = 2890 + self.genericArgument() + self.state = 2891 + self.match(GremlinParser.COMMA) + self.state = 2892 + self.genericArgument() + self.state = 2893 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_outsideContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.GenericArgumentContext) + else: + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, i) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_P(self): + return self.getToken(GremlinParser.K_P, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_OUTSIDE(self): + return self.getToken(GremlinParser.K_OUTSIDE, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_outside + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_outside"): + listener.enterTraversalPredicate_outside(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_outside"): + listener.exitTraversalPredicate_outside(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_outside"): + return visitor.visitTraversalPredicate_outside(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_outside(self): + + localctx = GremlinParser.TraversalPredicate_outsideContext(self, self._ctx, self.state) + self.enterRule(localctx, 390, self.RULE_traversalPredicate_outside) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2899 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [163]: + self.state = 2895 + self.match(GremlinParser.K_P) + self.state = 2896 + self.match(GremlinParser.DOT) + self.state = 2897 + self.match(GremlinParser.K_OUTSIDE) + pass + elif token in [161]: + self.state = 2898 + self.match(GremlinParser.K_OUTSIDE) + pass + else: + raise NoViableAltException(self) + + self.state = 2901 + self.match(GremlinParser.LPAREN) + self.state = 2902 + self.genericArgument() + self.state = 2903 + self.match(GremlinParser.COMMA) + self.state = 2904 + self.genericArgument() + self.state = 2905 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_betweenContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def genericArgument(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.GenericArgumentContext) + else: + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, i) + + def COMMA(self): + return self.getToken(GremlinParser.COMMA, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_P(self): + return self.getToken(GremlinParser.K_P, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_BETWEEN(self): + return self.getToken(GremlinParser.K_BETWEEN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_between + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_between"): + listener.enterTraversalPredicate_between(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_between"): + listener.exitTraversalPredicate_between(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_between"): + return visitor.visitTraversalPredicate_between(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_between(self): + + localctx = GremlinParser.TraversalPredicate_betweenContext(self, self._ctx, self.state) + self.enterRule(localctx, 392, self.RULE_traversalPredicate_between) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2911 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [163]: + self.state = 2907 + self.match(GremlinParser.K_P) + self.state = 2908 + self.match(GremlinParser.DOT) + self.state = 2909 + self.match(GremlinParser.K_BETWEEN) + pass + elif token in [17]: + self.state = 2910 + self.match(GremlinParser.K_BETWEEN) + pass + else: + raise NoViableAltException(self) + + self.state = 2913 + self.match(GremlinParser.LPAREN) + self.state = 2914 + self.genericArgument() + self.state = 2915 + self.match(GremlinParser.COMMA) + self.state = 2916 + self.genericArgument() + self.state = 2917 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_withinContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_P(self): + return self.getToken(GremlinParser.K_P, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_WITHIN(self): + return self.getToken(GremlinParser.K_WITHIN, 0) + + def genericArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentVarargsContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_within + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_within"): + listener.enterTraversalPredicate_within(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_within"): + listener.exitTraversalPredicate_within(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_within"): + return visitor.visitTraversalPredicate_within(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_within(self): + + localctx = GremlinParser.TraversalPredicate_withinContext(self, self._ctx, self.state) + self.enterRule(localctx, 394, self.RULE_traversalPredicate_within) + try: + self.state = 2937 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 142, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2923 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [163]: + self.state = 2919 + self.match(GremlinParser.K_P) + self.state = 2920 + self.match(GremlinParser.DOT) + self.state = 2921 + self.match(GremlinParser.K_WITHIN) + pass + elif token in [241]: + self.state = 2922 + self.match(GremlinParser.K_WITHIN) + pass + else: + raise NoViableAltException(self) + + self.state = 2925 + self.match(GremlinParser.LPAREN) + self.state = 2926 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2931 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [163]: + self.state = 2927 + self.match(GremlinParser.K_P) + self.state = 2928 + self.match(GremlinParser.DOT) + self.state = 2929 + self.match(GremlinParser.K_WITHIN) + pass + elif token in [241]: + self.state = 2930 + self.match(GremlinParser.K_WITHIN) + pass + else: + raise NoViableAltException(self) + + self.state = 2933 + self.match(GremlinParser.LPAREN) + self.state = 2934 + self.genericArgumentVarargs() + self.state = 2935 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_withoutContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_P(self): + return self.getToken(GremlinParser.K_P, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_WITHOUT(self): + return self.getToken(GremlinParser.K_WITHOUT, 0) + + def genericArgumentVarargs(self): + return self.getTypedRuleContext(GremlinParser.GenericArgumentVarargsContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_without + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_without"): + listener.enterTraversalPredicate_without(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_without"): + listener.exitTraversalPredicate_without(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_without"): + return visitor.visitTraversalPredicate_without(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_without(self): + + localctx = GremlinParser.TraversalPredicate_withoutContext(self, self._ctx, self.state) + self.enterRule(localctx, 396, self.RULE_traversalPredicate_without) + try: + self.state = 2957 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 145, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2943 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [163]: + self.state = 2939 + self.match(GremlinParser.K_P) + self.state = 2940 + self.match(GremlinParser.DOT) + self.state = 2941 + self.match(GremlinParser.K_WITHOUT) + pass + elif token in [243]: + self.state = 2942 + self.match(GremlinParser.K_WITHOUT) + pass + else: + raise NoViableAltException(self) + + self.state = 2945 + self.match(GremlinParser.LPAREN) + self.state = 2946 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2951 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [163]: + self.state = 2947 + self.match(GremlinParser.K_P) + self.state = 2948 + self.match(GremlinParser.DOT) + self.state = 2949 + self.match(GremlinParser.K_WITHOUT) + pass + elif token in [243]: + self.state = 2950 + self.match(GremlinParser.K_WITHOUT) + pass + else: + raise NoViableAltException(self) + + self.state = 2953 + self.match(GremlinParser.LPAREN) + self.state = 2954 + self.genericArgumentVarargs() + self.state = 2955 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_notContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalPredicate(self): + return self.getTypedRuleContext(GremlinParser.TraversalPredicateContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_P(self): + return self.getToken(GremlinParser.K_P, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_NOT(self): + return self.getToken(GremlinParser.K_NOT, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_not + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_not"): + listener.enterTraversalPredicate_not(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_not"): + listener.exitTraversalPredicate_not(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_not"): + return visitor.visitTraversalPredicate_not(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_not(self): + + localctx = GremlinParser.TraversalPredicate_notContext(self, self._ctx, self.state) + self.enterRule(localctx, 398, self.RULE_traversalPredicate_not) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2963 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [163]: + self.state = 2959 + self.match(GremlinParser.K_P) + self.state = 2960 + self.match(GremlinParser.DOT) + self.state = 2961 + self.match(GremlinParser.K_NOT) + pass + elif token in [144]: + self.state = 2962 + self.match(GremlinParser.K_NOT) + pass + else: + raise NoViableAltException(self) + + self.state = 2965 + self.match(GremlinParser.LPAREN) + self.state = 2966 + self.traversalPredicate(0) + self.state = 2967 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_containingContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringArgument(self): + return self.getTypedRuleContext(GremlinParser.StringArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_TEXTP(self): + return self.getToken(GremlinParser.K_TEXTP, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_CONTAINING(self): + return self.getToken(GremlinParser.K_CONTAINING, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_containing + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_containing"): + listener.enterTraversalPredicate_containing(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_containing"): + listener.exitTraversalPredicate_containing(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_containing"): + return visitor.visitTraversalPredicate_containing(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_containing(self): + + localctx = GremlinParser.TraversalPredicate_containingContext(self, self._ctx, self.state) + self.enterRule(localctx, 400, self.RULE_traversalPredicate_containing) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2973 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [211]: + self.state = 2969 + self.match(GremlinParser.K_TEXTP) + self.state = 2970 + self.match(GremlinParser.DOT) + self.state = 2971 + self.match(GremlinParser.K_CONTAINING) + pass + elif token in [39]: + self.state = 2972 + self.match(GremlinParser.K_CONTAINING) + pass + else: + raise NoViableAltException(self) + + self.state = 2975 + self.match(GremlinParser.LPAREN) + self.state = 2976 + self.stringArgument() + self.state = 2977 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_notContainingContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringArgument(self): + return self.getTypedRuleContext(GremlinParser.StringArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_TEXTP(self): + return self.getToken(GremlinParser.K_TEXTP, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_NOTCONTAINING(self): + return self.getToken(GremlinParser.K_NOTCONTAINING, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_notContaining + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_notContaining"): + listener.enterTraversalPredicate_notContaining(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_notContaining"): + listener.exitTraversalPredicate_notContaining(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_notContaining"): + return visitor.visitTraversalPredicate_notContaining(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_notContaining(self): + + localctx = GremlinParser.TraversalPredicate_notContainingContext(self, self._ctx, self.state) + self.enterRule(localctx, 402, self.RULE_traversalPredicate_notContaining) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2983 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [211]: + self.state = 2979 + self.match(GremlinParser.K_TEXTP) + self.state = 2980 + self.match(GremlinParser.DOT) + self.state = 2981 + self.match(GremlinParser.K_NOTCONTAINING) + pass + elif token in [141]: + self.state = 2982 + self.match(GremlinParser.K_NOTCONTAINING) + pass + else: + raise NoViableAltException(self) + + self.state = 2985 + self.match(GremlinParser.LPAREN) + self.state = 2986 + self.stringArgument() + self.state = 2987 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_startingWithContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringArgument(self): + return self.getTypedRuleContext(GremlinParser.StringArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_TEXTP(self): + return self.getToken(GremlinParser.K_TEXTP, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_STARTINGWITH(self): + return self.getToken(GremlinParser.K_STARTINGWITH, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_startingWith + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_startingWith"): + listener.enterTraversalPredicate_startingWith(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_startingWith"): + listener.exitTraversalPredicate_startingWith(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_startingWith"): + return visitor.visitTraversalPredicate_startingWith(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_startingWith(self): + + localctx = GremlinParser.TraversalPredicate_startingWithContext(self, self._ctx, self.state) + self.enterRule(localctx, 404, self.RULE_traversalPredicate_startingWith) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2993 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [211]: + self.state = 2989 + self.match(GremlinParser.K_TEXTP) + self.state = 2990 + self.match(GremlinParser.DOT) + self.state = 2991 + self.match(GremlinParser.K_STARTINGWITH) + pass + elif token in [202]: + self.state = 2992 + self.match(GremlinParser.K_STARTINGWITH) + pass + else: + raise NoViableAltException(self) + + self.state = 2995 + self.match(GremlinParser.LPAREN) + self.state = 2996 + self.stringArgument() + self.state = 2997 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_notStartingWithContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringArgument(self): + return self.getTypedRuleContext(GremlinParser.StringArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_TEXTP(self): + return self.getToken(GremlinParser.K_TEXTP, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_NOTSTARTINGWITH(self): + return self.getToken(GremlinParser.K_NOTSTARTINGWITH, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_notStartingWith + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_notStartingWith"): + listener.enterTraversalPredicate_notStartingWith(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_notStartingWith"): + listener.exitTraversalPredicate_notStartingWith(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_notStartingWith"): + return visitor.visitTraversalPredicate_notStartingWith(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_notStartingWith(self): + + localctx = GremlinParser.TraversalPredicate_notStartingWithContext(self, self._ctx, self.state) + self.enterRule(localctx, 406, self.RULE_traversalPredicate_notStartingWith) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3003 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [211]: + self.state = 2999 + self.match(GremlinParser.K_TEXTP) + self.state = 3000 + self.match(GremlinParser.DOT) + self.state = 3001 + self.match(GremlinParser.K_NOTSTARTINGWITH) + pass + elif token in [143]: + self.state = 3002 + self.match(GremlinParser.K_NOTSTARTINGWITH) + pass + else: + raise NoViableAltException(self) + + self.state = 3005 + self.match(GremlinParser.LPAREN) + self.state = 3006 + self.stringArgument() + self.state = 3007 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_endingWithContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringArgument(self): + return self.getTypedRuleContext(GremlinParser.StringArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_TEXTP(self): + return self.getToken(GremlinParser.K_TEXTP, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_ENDINGWITH(self): + return self.getToken(GremlinParser.K_ENDINGWITH, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_endingWith + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_endingWith"): + listener.enterTraversalPredicate_endingWith(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_endingWith"): + listener.exitTraversalPredicate_endingWith(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_endingWith"): + return visitor.visitTraversalPredicate_endingWith(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_endingWith(self): + + localctx = GremlinParser.TraversalPredicate_endingWithContext(self, self._ctx, self.state) + self.enterRule(localctx, 408, self.RULE_traversalPredicate_endingWith) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3013 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [211]: + self.state = 3009 + self.match(GremlinParser.K_TEXTP) + self.state = 3010 + self.match(GremlinParser.DOT) + self.state = 3011 + self.match(GremlinParser.K_ENDINGWITH) + pass + elif token in [62]: + self.state = 3012 + self.match(GremlinParser.K_ENDINGWITH) + pass + else: + raise NoViableAltException(self) + + self.state = 3015 + self.match(GremlinParser.LPAREN) + self.state = 3016 + self.stringArgument() + self.state = 3017 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_notEndingWithContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringArgument(self): + return self.getTypedRuleContext(GremlinParser.StringArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_TEXTP(self): + return self.getToken(GremlinParser.K_TEXTP, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_NOTENDINGWITH(self): + return self.getToken(GremlinParser.K_NOTENDINGWITH, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_notEndingWith + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_notEndingWith"): + listener.enterTraversalPredicate_notEndingWith(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_notEndingWith"): + listener.exitTraversalPredicate_notEndingWith(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_notEndingWith"): + return visitor.visitTraversalPredicate_notEndingWith(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_notEndingWith(self): + + localctx = GremlinParser.TraversalPredicate_notEndingWithContext(self, self._ctx, self.state) + self.enterRule(localctx, 410, self.RULE_traversalPredicate_notEndingWith) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3023 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [211]: + self.state = 3019 + self.match(GremlinParser.K_TEXTP) + self.state = 3020 + self.match(GremlinParser.DOT) + self.state = 3021 + self.match(GremlinParser.K_NOTENDINGWITH) + pass + elif token in [142]: + self.state = 3022 + self.match(GremlinParser.K_NOTENDINGWITH) + pass + else: + raise NoViableAltException(self) + + self.state = 3025 + self.match(GremlinParser.LPAREN) + self.state = 3026 + self.stringArgument() + self.state = 3027 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_regexContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringArgument(self): + return self.getTypedRuleContext(GremlinParser.StringArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_TEXTP(self): + return self.getToken(GremlinParser.K_TEXTP, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_REGEX(self): + return self.getToken(GremlinParser.K_REGEX, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_regex + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_regex"): + listener.enterTraversalPredicate_regex(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_regex"): + listener.exitTraversalPredicate_regex(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_regex"): + return visitor.visitTraversalPredicate_regex(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_regex(self): + + localctx = GremlinParser.TraversalPredicate_regexContext(self, self._ctx, self.state) + self.enterRule(localctx, 412, self.RULE_traversalPredicate_regex) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3033 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [211]: + self.state = 3029 + self.match(GremlinParser.K_TEXTP) + self.state = 3030 + self.match(GremlinParser.DOT) + self.state = 3031 + self.match(GremlinParser.K_REGEX) + pass + elif token in [182]: + self.state = 3032 + self.match(GremlinParser.K_REGEX) + pass + else: + raise NoViableAltException(self) + + self.state = 3035 + self.match(GremlinParser.LPAREN) + self.state = 3036 + self.stringArgument() + self.state = 3037 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalPredicate_notRegexContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringArgument(self): + return self.getTypedRuleContext(GremlinParser.StringArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_TEXTP(self): + return self.getToken(GremlinParser.K_TEXTP, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_NOTREGEX(self): + return self.getToken(GremlinParser.K_NOTREGEX, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalPredicate_notRegex + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalPredicate_notRegex"): + listener.enterTraversalPredicate_notRegex(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalPredicate_notRegex"): + listener.exitTraversalPredicate_notRegex(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalPredicate_notRegex"): + return visitor.visitTraversalPredicate_notRegex(self) + else: + return visitor.visitChildren(self) + + def traversalPredicate_notRegex(self): + + localctx = GremlinParser.TraversalPredicate_notRegexContext(self, self._ctx, self.state) + self.enterRule(localctx, 414, self.RULE_traversalPredicate_notRegex) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3043 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [211]: + self.state = 3039 + self.match(GremlinParser.K_TEXTP) + self.state = 3040 + self.match(GremlinParser.DOT) + self.state = 3041 + self.match(GremlinParser.K_NOTREGEX) + pass + elif token in [140]: + self.state = 3042 + self.match(GremlinParser.K_NOTREGEX) + pass + else: + raise NoViableAltException(self) + + self.state = 3045 + self.match(GremlinParser.LPAREN) + self.state = 3046 + self.stringArgument() + self.state = 3047 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalTerminalMethod_explainContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_EXPLAIN(self): + return self.getToken(GremlinParser.K_EXPLAIN, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalTerminalMethod_explain + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalTerminalMethod_explain"): + listener.enterTraversalTerminalMethod_explain(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalTerminalMethod_explain"): + listener.exitTraversalTerminalMethod_explain(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalTerminalMethod_explain"): + return visitor.visitTraversalTerminalMethod_explain(self) + else: + return visitor.visitChildren(self) + + def traversalTerminalMethod_explain(self): + + localctx = GremlinParser.TraversalTerminalMethod_explainContext(self, self._ctx, self.state) + self.enterRule(localctx, 416, self.RULE_traversalTerminalMethod_explain) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3049 + self.match(GremlinParser.K_EXPLAIN) + self.state = 3050 + self.match(GremlinParser.LPAREN) + self.state = 3051 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalTerminalMethod_hasNextContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_HASNEXT(self): + return self.getToken(GremlinParser.K_HASNEXT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalTerminalMethod_hasNext + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalTerminalMethod_hasNext"): + listener.enterTraversalTerminalMethod_hasNext(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalTerminalMethod_hasNext"): + listener.exitTraversalTerminalMethod_hasNext(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalTerminalMethod_hasNext"): + return visitor.visitTraversalTerminalMethod_hasNext(self) + else: + return visitor.visitChildren(self) + + def traversalTerminalMethod_hasNext(self): + + localctx = GremlinParser.TraversalTerminalMethod_hasNextContext(self, self._ctx, self.state) + self.enterRule(localctx, 418, self.RULE_traversalTerminalMethod_hasNext) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3053 + self.match(GremlinParser.K_HASNEXT) + self.state = 3054 + self.match(GremlinParser.LPAREN) + self.state = 3055 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalTerminalMethod_iterateContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_ITERATE(self): + return self.getToken(GremlinParser.K_ITERATE, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalTerminalMethod_iterate + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalTerminalMethod_iterate"): + listener.enterTraversalTerminalMethod_iterate(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalTerminalMethod_iterate"): + listener.exitTraversalTerminalMethod_iterate(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalTerminalMethod_iterate"): + return visitor.visitTraversalTerminalMethod_iterate(self) + else: + return visitor.visitChildren(self) + + def traversalTerminalMethod_iterate(self): + + localctx = GremlinParser.TraversalTerminalMethod_iterateContext(self, self._ctx, self.state) + self.enterRule(localctx, 420, self.RULE_traversalTerminalMethod_iterate) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3057 + self.match(GremlinParser.K_ITERATE) + self.state = 3058 + self.match(GremlinParser.LPAREN) + self.state = 3059 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalTerminalMethod_tryNextContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_TRYNEXT(self): + return self.getToken(GremlinParser.K_TRYNEXT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalTerminalMethod_tryNext + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalTerminalMethod_tryNext"): + listener.enterTraversalTerminalMethod_tryNext(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalTerminalMethod_tryNext"): + listener.exitTraversalTerminalMethod_tryNext(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalTerminalMethod_tryNext"): + return visitor.visitTraversalTerminalMethod_tryNext(self) + else: + return visitor.visitChildren(self) + + def traversalTerminalMethod_tryNext(self): + + localctx = GremlinParser.TraversalTerminalMethod_tryNextContext(self, self._ctx, self.state) + self.enterRule(localctx, 422, self.RULE_traversalTerminalMethod_tryNext) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3061 + self.match(GremlinParser.K_TRYNEXT) + self.state = 3062 + self.match(GremlinParser.LPAREN) + self.state = 3063 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalTerminalMethod_nextContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_NEXT(self): + return self.getToken(GremlinParser.K_NEXT, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(GremlinParser.IntegerLiteralContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalTerminalMethod_next + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalTerminalMethod_next"): + listener.enterTraversalTerminalMethod_next(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalTerminalMethod_next"): + listener.exitTraversalTerminalMethod_next(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalTerminalMethod_next"): + return visitor.visitTraversalTerminalMethod_next(self) + else: + return visitor.visitChildren(self) + + def traversalTerminalMethod_next(self): + + localctx = GremlinParser.TraversalTerminalMethod_nextContext(self, self._ctx, self.state) + self.enterRule(localctx, 424, self.RULE_traversalTerminalMethod_next) + try: + self.state = 3073 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 155, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3065 + self.match(GremlinParser.K_NEXT) + self.state = 3066 + self.match(GremlinParser.LPAREN) + self.state = 3067 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3068 + self.match(GremlinParser.K_NEXT) + self.state = 3069 + self.match(GremlinParser.LPAREN) + self.state = 3070 + self.integerLiteral() + self.state = 3071 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalTerminalMethod_toListContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_TOLIST(self): + return self.getToken(GremlinParser.K_TOLIST, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalTerminalMethod_toList + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalTerminalMethod_toList"): + listener.enterTraversalTerminalMethod_toList(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalTerminalMethod_toList"): + listener.exitTraversalTerminalMethod_toList(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalTerminalMethod_toList"): + return visitor.visitTraversalTerminalMethod_toList(self) + else: + return visitor.visitChildren(self) + + def traversalTerminalMethod_toList(self): + + localctx = GremlinParser.TraversalTerminalMethod_toListContext(self, self._ctx, self.state) + self.enterRule(localctx, 426, self.RULE_traversalTerminalMethod_toList) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3075 + self.match(GremlinParser.K_TOLIST) + self.state = 3076 + self.match(GremlinParser.LPAREN) + self.state = 3077 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalTerminalMethod_toSetContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_TOSET(self): + return self.getToken(GremlinParser.K_TOSET, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalTerminalMethod_toSet + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalTerminalMethod_toSet"): + listener.enterTraversalTerminalMethod_toSet(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalTerminalMethod_toSet"): + listener.exitTraversalTerminalMethod_toSet(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalTerminalMethod_toSet"): + return visitor.visitTraversalTerminalMethod_toSet(self) + else: + return visitor.visitChildren(self) + + def traversalTerminalMethod_toSet(self): + + localctx = GremlinParser.TraversalTerminalMethod_toSetContext(self, self._ctx, self.state) + self.enterRule(localctx, 428, self.RULE_traversalTerminalMethod_toSet) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3079 + self.match(GremlinParser.K_TOSET) + self.state = 3080 + self.match(GremlinParser.LPAREN) + self.state = 3081 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalTerminalMethod_toBulkSetContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_TOBULKSET(self): + return self.getToken(GremlinParser.K_TOBULKSET, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalTerminalMethod_toBulkSet + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalTerminalMethod_toBulkSet"): + listener.enterTraversalTerminalMethod_toBulkSet(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalTerminalMethod_toBulkSet"): + listener.exitTraversalTerminalMethod_toBulkSet(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalTerminalMethod_toBulkSet"): + return visitor.visitTraversalTerminalMethod_toBulkSet(self) + else: + return visitor.visitChildren(self) + + def traversalTerminalMethod_toBulkSet(self): + + localctx = GremlinParser.TraversalTerminalMethod_toBulkSetContext(self, self._ctx, self.state) + self.enterRule(localctx, 430, self.RULE_traversalTerminalMethod_toBulkSet) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3083 + self.match(GremlinParser.K_TOBULKSET) + self.state = 3084 + self.match(GremlinParser.LPAREN) + self.state = 3085 + self.match(GremlinParser.RPAREN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class WithOptionKeysContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def shortestPathConstants(self): + return self.getTypedRuleContext(GremlinParser.ShortestPathConstantsContext, 0) + + def connectedComponentConstants(self): + return self.getTypedRuleContext(GremlinParser.ConnectedComponentConstantsContext, 0) + + def pageRankConstants(self): + return self.getTypedRuleContext(GremlinParser.PageRankConstantsContext, 0) + + def peerPressureConstants(self): + return self.getTypedRuleContext(GremlinParser.PeerPressureConstantsContext, 0) + + def ioOptionsKeys(self): + return self.getTypedRuleContext(GremlinParser.IoOptionsKeysContext, 0) + + def withOptionsConstants_tokens(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsConstants_tokensContext, 0) + + def withOptionsConstants_indexer(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsConstants_indexerContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_withOptionKeys + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterWithOptionKeys"): + listener.enterWithOptionKeys(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitWithOptionKeys"): + listener.exitWithOptionKeys(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitWithOptionKeys"): + return visitor.visitWithOptionKeys(self) + else: + return visitor.visitChildren(self) + + def withOptionKeys(self): + + localctx = GremlinParser.WithOptionKeysContext(self, self._ctx, self.state) + self.enterRule(localctx, 432, self.RULE_withOptionKeys) + try: + self.state = 3094 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 156, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3087 + self.shortestPathConstants() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3088 + self.connectedComponentConstants() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3089 + self.pageRankConstants() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 3090 + self.peerPressureConstants() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 3091 + self.ioOptionsKeys() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 3092 + self.withOptionsConstants_tokens() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 3093 + self.withOptionsConstants_indexer() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ConnectedComponentConstantsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def connectedComponentConstants_component(self): + return self.getTypedRuleContext(GremlinParser.ConnectedComponentConstants_componentContext, 0) + + def connectedComponentConstants_edges(self): + return self.getTypedRuleContext(GremlinParser.ConnectedComponentConstants_edgesContext, 0) + + def connectedComponentConstants_propertyName(self): + return self.getTypedRuleContext(GremlinParser.ConnectedComponentConstants_propertyNameContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_connectedComponentConstants + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterConnectedComponentConstants"): + listener.enterConnectedComponentConstants(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitConnectedComponentConstants"): + listener.exitConnectedComponentConstants(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConnectedComponentConstants"): + return visitor.visitConnectedComponentConstants(self) + else: + return visitor.visitChildren(self) + + def connectedComponentConstants(self): + + localctx = GremlinParser.ConnectedComponentConstantsContext(self, self._ctx, self.state) + self.enterRule(localctx, 434, self.RULE_connectedComponentConstants) + try: + self.state = 3099 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 157, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3096 + self.connectedComponentConstants_component() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3097 + self.connectedComponentConstants_edges() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3098 + self.connectedComponentConstants_propertyName() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class PageRankConstantsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def pageRankConstants_edges(self): + return self.getTypedRuleContext(GremlinParser.PageRankConstants_edgesContext, 0) + + def pageRankConstants_times(self): + return self.getTypedRuleContext(GremlinParser.PageRankConstants_timesContext, 0) + + def pageRankConstants_propertyName(self): + return self.getTypedRuleContext(GremlinParser.PageRankConstants_propertyNameContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_pageRankConstants + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPageRankConstants"): + listener.enterPageRankConstants(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPageRankConstants"): + listener.exitPageRankConstants(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPageRankConstants"): + return visitor.visitPageRankConstants(self) + else: + return visitor.visitChildren(self) + + def pageRankConstants(self): + + localctx = GremlinParser.PageRankConstantsContext(self, self._ctx, self.state) + self.enterRule(localctx, 436, self.RULE_pageRankConstants) + try: + self.state = 3104 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 158, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3101 + self.pageRankConstants_edges() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3102 + self.pageRankConstants_times() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3103 + self.pageRankConstants_propertyName() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class PeerPressureConstantsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def peerPressureConstants_edges(self): + return self.getTypedRuleContext(GremlinParser.PeerPressureConstants_edgesContext, 0) + + def peerPressureConstants_times(self): + return self.getTypedRuleContext(GremlinParser.PeerPressureConstants_timesContext, 0) + + def peerPressureConstants_propertyName(self): + return self.getTypedRuleContext(GremlinParser.PeerPressureConstants_propertyNameContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_peerPressureConstants + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPeerPressureConstants"): + listener.enterPeerPressureConstants(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPeerPressureConstants"): + listener.exitPeerPressureConstants(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPeerPressureConstants"): + return visitor.visitPeerPressureConstants(self) + else: + return visitor.visitChildren(self) + + def peerPressureConstants(self): + + localctx = GremlinParser.PeerPressureConstantsContext(self, self._ctx, self.state) + self.enterRule(localctx, 438, self.RULE_peerPressureConstants) + try: + self.state = 3109 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 159, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3106 + self.peerPressureConstants_edges() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3107 + self.peerPressureConstants_times() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3108 + self.peerPressureConstants_propertyName() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ShortestPathConstantsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def shortestPathConstants_target(self): + return self.getTypedRuleContext(GremlinParser.ShortestPathConstants_targetContext, 0) + + def shortestPathConstants_edges(self): + return self.getTypedRuleContext(GremlinParser.ShortestPathConstants_edgesContext, 0) + + def shortestPathConstants_distance(self): + return self.getTypedRuleContext(GremlinParser.ShortestPathConstants_distanceContext, 0) + + def shortestPathConstants_maxDistance(self): + return self.getTypedRuleContext(GremlinParser.ShortestPathConstants_maxDistanceContext, 0) + + def shortestPathConstants_includeEdges(self): + return self.getTypedRuleContext(GremlinParser.ShortestPathConstants_includeEdgesContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_shortestPathConstants + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterShortestPathConstants"): + listener.enterShortestPathConstants(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitShortestPathConstants"): + listener.exitShortestPathConstants(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitShortestPathConstants"): + return visitor.visitShortestPathConstants(self) + else: + return visitor.visitChildren(self) + + def shortestPathConstants(self): + + localctx = GremlinParser.ShortestPathConstantsContext(self, self._ctx, self.state) + self.enterRule(localctx, 440, self.RULE_shortestPathConstants) + try: + self.state = 3116 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 160, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3111 + self.shortestPathConstants_target() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3112 + self.shortestPathConstants_edges() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3113 + self.shortestPathConstants_distance() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 3114 + self.shortestPathConstants_maxDistance() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 3115 + self.shortestPathConstants_includeEdges() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class WithOptionsValuesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def withOptionsConstants_tokens(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsConstants_tokensContext, 0) + + def withOptionsConstants_none(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsConstants_noneContext, 0) + + def withOptionsConstants_ids(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsConstants_idsContext, 0) + + def withOptionsConstants_labels(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsConstants_labelsContext, 0) + + def withOptionsConstants_keys(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsConstants_keysContext, 0) + + def withOptionsConstants_values(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsConstants_valuesContext, 0) + + def withOptionsConstants_all(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsConstants_allContext, 0) + + def withOptionsConstants_list(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsConstants_listContext, 0) + + def withOptionsConstants_map(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsConstants_mapContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_withOptionsValues + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterWithOptionsValues"): + listener.enterWithOptionsValues(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitWithOptionsValues"): + listener.exitWithOptionsValues(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitWithOptionsValues"): + return visitor.visitWithOptionsValues(self) + else: + return visitor.visitChildren(self) + + def withOptionsValues(self): + + localctx = GremlinParser.WithOptionsValuesContext(self, self._ctx, self.state) + self.enterRule(localctx, 442, self.RULE_withOptionsValues) + try: + self.state = 3127 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 161, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3118 + self.withOptionsConstants_tokens() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3119 + self.withOptionsConstants_none() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3120 + self.withOptionsConstants_ids() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 3121 + self.withOptionsConstants_labels() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 3122 + self.withOptionsConstants_keys() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 3123 + self.withOptionsConstants_values() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 3124 + self.withOptionsConstants_all() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 3125 + self.withOptionsConstants_list() + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 3126 + self.withOptionsConstants_map() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class IoOptionsKeysContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def ioOptionsConstants_reader(self): + return self.getTypedRuleContext(GremlinParser.IoOptionsConstants_readerContext, 0) + + def ioOptionsConstants_writer(self): + return self.getTypedRuleContext(GremlinParser.IoOptionsConstants_writerContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_ioOptionsKeys + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIoOptionsKeys"): + listener.enterIoOptionsKeys(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIoOptionsKeys"): + listener.exitIoOptionsKeys(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIoOptionsKeys"): + return visitor.visitIoOptionsKeys(self) + else: + return visitor.visitChildren(self) + + def ioOptionsKeys(self): + + localctx = GremlinParser.IoOptionsKeysContext(self, self._ctx, self.state) + self.enterRule(localctx, 444, self.RULE_ioOptionsKeys) + try: + self.state = 3131 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 162, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3129 + self.ioOptionsConstants_reader() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3130 + self.ioOptionsConstants_writer() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class IoOptionsValuesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def ioOptionsConstants_gryo(self): + return self.getTypedRuleContext(GremlinParser.IoOptionsConstants_gryoContext, 0) + + def ioOptionsConstants_graphson(self): + return self.getTypedRuleContext(GremlinParser.IoOptionsConstants_graphsonContext, 0) + + def ioOptionsConstants_graphml(self): + return self.getTypedRuleContext(GremlinParser.IoOptionsConstants_graphmlContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_ioOptionsValues + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIoOptionsValues"): + listener.enterIoOptionsValues(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIoOptionsValues"): + listener.exitIoOptionsValues(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIoOptionsValues"): + return visitor.visitIoOptionsValues(self) + else: + return visitor.visitChildren(self) + + def ioOptionsValues(self): + + localctx = GremlinParser.IoOptionsValuesContext(self, self._ctx, self.state) + self.enterRule(localctx, 446, self.RULE_ioOptionsValues) + try: + self.state = 3136 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 163, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3133 + self.ioOptionsConstants_gryo() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3134 + self.ioOptionsConstants_graphson() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3135 + self.ioOptionsConstants_graphml() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ConnectedComponentConstants_componentContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def connectedComponentStringConstant(self): + return self.getTypedRuleContext(GremlinParser.ConnectedComponentStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_COMPONENT(self): + return self.getToken(GremlinParser.K_COMPONENT, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_connectedComponentConstants_component + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterConnectedComponentConstants_component"): + listener.enterConnectedComponentConstants_component(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitConnectedComponentConstants_component"): + listener.exitConnectedComponentConstants_component(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConnectedComponentConstants_component"): + return visitor.visitConnectedComponentConstants_component(self) + else: + return visitor.visitChildren(self) + + def connectedComponentConstants_component(self): + + localctx = GremlinParser.ConnectedComponentConstants_componentContext(self, self._ctx, self.state) + self.enterRule(localctx, 448, self.RULE_connectedComponentConstants_component) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3138 + self.connectedComponentStringConstant() + self.state = 3139 + self.match(GremlinParser.DOT) + self.state = 3140 + self.match(GremlinParser.K_COMPONENT) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ConnectedComponentConstants_edgesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def connectedComponentStringConstant(self): + return self.getTypedRuleContext(GremlinParser.ConnectedComponentStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_EDGES(self): + return self.getToken(GremlinParser.K_EDGES, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_connectedComponentConstants_edges + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterConnectedComponentConstants_edges"): + listener.enterConnectedComponentConstants_edges(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitConnectedComponentConstants_edges"): + listener.exitConnectedComponentConstants_edges(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConnectedComponentConstants_edges"): + return visitor.visitConnectedComponentConstants_edges(self) + else: + return visitor.visitChildren(self) + + def connectedComponentConstants_edges(self): + + localctx = GremlinParser.ConnectedComponentConstants_edgesContext(self, self._ctx, self.state) + self.enterRule(localctx, 450, self.RULE_connectedComponentConstants_edges) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3142 + self.connectedComponentStringConstant() + self.state = 3143 + self.match(GremlinParser.DOT) + self.state = 3144 + self.match(GremlinParser.K_EDGES) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ConnectedComponentConstants_propertyNameContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def connectedComponentStringConstant(self): + return self.getTypedRuleContext(GremlinParser.ConnectedComponentStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_PROPERTYNAME(self): + return self.getToken(GremlinParser.K_PROPERTYNAME, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_connectedComponentConstants_propertyName + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterConnectedComponentConstants_propertyName"): + listener.enterConnectedComponentConstants_propertyName(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitConnectedComponentConstants_propertyName"): + listener.exitConnectedComponentConstants_propertyName(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConnectedComponentConstants_propertyName"): + return visitor.visitConnectedComponentConstants_propertyName(self) + else: + return visitor.visitChildren(self) + + def connectedComponentConstants_propertyName(self): + + localctx = GremlinParser.ConnectedComponentConstants_propertyNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 452, self.RULE_connectedComponentConstants_propertyName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3146 + self.connectedComponentStringConstant() + self.state = 3147 + self.match(GremlinParser.DOT) + self.state = 3148 + self.match(GremlinParser.K_PROPERTYNAME) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class PageRankConstants_edgesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def pageRankStringConstant(self): + return self.getTypedRuleContext(GremlinParser.PageRankStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_EDGES(self): + return self.getToken(GremlinParser.K_EDGES, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_pageRankConstants_edges + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPageRankConstants_edges"): + listener.enterPageRankConstants_edges(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPageRankConstants_edges"): + listener.exitPageRankConstants_edges(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPageRankConstants_edges"): + return visitor.visitPageRankConstants_edges(self) + else: + return visitor.visitChildren(self) + + def pageRankConstants_edges(self): + + localctx = GremlinParser.PageRankConstants_edgesContext(self, self._ctx, self.state) + self.enterRule(localctx, 454, self.RULE_pageRankConstants_edges) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3150 + self.pageRankStringConstant() + self.state = 3151 + self.match(GremlinParser.DOT) + self.state = 3152 + self.match(GremlinParser.K_EDGES) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class PageRankConstants_timesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def pageRankStringConstant(self): + return self.getTypedRuleContext(GremlinParser.PageRankStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_TIMES(self): + return self.getToken(GremlinParser.K_TIMES, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_pageRankConstants_times + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPageRankConstants_times"): + listener.enterPageRankConstants_times(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPageRankConstants_times"): + listener.exitPageRankConstants_times(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPageRankConstants_times"): + return visitor.visitPageRankConstants_times(self) + else: + return visitor.visitChildren(self) + + def pageRankConstants_times(self): + + localctx = GremlinParser.PageRankConstants_timesContext(self, self._ctx, self.state) + self.enterRule(localctx, 456, self.RULE_pageRankConstants_times) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3154 + self.pageRankStringConstant() + self.state = 3155 + self.match(GremlinParser.DOT) + self.state = 3156 + self.match(GremlinParser.K_TIMES) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class PageRankConstants_propertyNameContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def pageRankStringConstant(self): + return self.getTypedRuleContext(GremlinParser.PageRankStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_PROPERTYNAME(self): + return self.getToken(GremlinParser.K_PROPERTYNAME, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_pageRankConstants_propertyName + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPageRankConstants_propertyName"): + listener.enterPageRankConstants_propertyName(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPageRankConstants_propertyName"): + listener.exitPageRankConstants_propertyName(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPageRankConstants_propertyName"): + return visitor.visitPageRankConstants_propertyName(self) + else: + return visitor.visitChildren(self) + + def pageRankConstants_propertyName(self): + + localctx = GremlinParser.PageRankConstants_propertyNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 458, self.RULE_pageRankConstants_propertyName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3158 + self.pageRankStringConstant() + self.state = 3159 + self.match(GremlinParser.DOT) + self.state = 3160 + self.match(GremlinParser.K_PROPERTYNAME) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class PeerPressureConstants_edgesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def peerPressureStringConstant(self): + return self.getTypedRuleContext(GremlinParser.PeerPressureStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_EDGES(self): + return self.getToken(GremlinParser.K_EDGES, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_peerPressureConstants_edges + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPeerPressureConstants_edges"): + listener.enterPeerPressureConstants_edges(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPeerPressureConstants_edges"): + listener.exitPeerPressureConstants_edges(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPeerPressureConstants_edges"): + return visitor.visitPeerPressureConstants_edges(self) + else: + return visitor.visitChildren(self) + + def peerPressureConstants_edges(self): + + localctx = GremlinParser.PeerPressureConstants_edgesContext(self, self._ctx, self.state) + self.enterRule(localctx, 460, self.RULE_peerPressureConstants_edges) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3162 + self.peerPressureStringConstant() + self.state = 3163 + self.match(GremlinParser.DOT) + self.state = 3164 + self.match(GremlinParser.K_EDGES) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class PeerPressureConstants_timesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def peerPressureStringConstant(self): + return self.getTypedRuleContext(GremlinParser.PeerPressureStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_TIMES(self): + return self.getToken(GremlinParser.K_TIMES, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_peerPressureConstants_times + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPeerPressureConstants_times"): + listener.enterPeerPressureConstants_times(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPeerPressureConstants_times"): + listener.exitPeerPressureConstants_times(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPeerPressureConstants_times"): + return visitor.visitPeerPressureConstants_times(self) + else: + return visitor.visitChildren(self) + + def peerPressureConstants_times(self): + + localctx = GremlinParser.PeerPressureConstants_timesContext(self, self._ctx, self.state) + self.enterRule(localctx, 462, self.RULE_peerPressureConstants_times) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3166 + self.peerPressureStringConstant() + self.state = 3167 + self.match(GremlinParser.DOT) + self.state = 3168 + self.match(GremlinParser.K_TIMES) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class PeerPressureConstants_propertyNameContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def peerPressureStringConstant(self): + return self.getTypedRuleContext(GremlinParser.PeerPressureStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_PROPERTYNAME(self): + return self.getToken(GremlinParser.K_PROPERTYNAME, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_peerPressureConstants_propertyName + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPeerPressureConstants_propertyName"): + listener.enterPeerPressureConstants_propertyName(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPeerPressureConstants_propertyName"): + listener.exitPeerPressureConstants_propertyName(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPeerPressureConstants_propertyName"): + return visitor.visitPeerPressureConstants_propertyName(self) + else: + return visitor.visitChildren(self) + + def peerPressureConstants_propertyName(self): + + localctx = GremlinParser.PeerPressureConstants_propertyNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 464, self.RULE_peerPressureConstants_propertyName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3170 + self.peerPressureStringConstant() + self.state = 3171 + self.match(GremlinParser.DOT) + self.state = 3172 + self.match(GremlinParser.K_PROPERTYNAME) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ShortestPathConstants_targetContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def shortestPathStringConstant(self): + return self.getTypedRuleContext(GremlinParser.ShortestPathStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_TARGET(self): + return self.getToken(GremlinParser.K_TARGET, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_shortestPathConstants_target + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterShortestPathConstants_target"): + listener.enterShortestPathConstants_target(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitShortestPathConstants_target"): + listener.exitShortestPathConstants_target(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitShortestPathConstants_target"): + return visitor.visitShortestPathConstants_target(self) + else: + return visitor.visitChildren(self) + + def shortestPathConstants_target(self): + + localctx = GremlinParser.ShortestPathConstants_targetContext(self, self._ctx, self.state) + self.enterRule(localctx, 466, self.RULE_shortestPathConstants_target) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3174 + self.shortestPathStringConstant() + self.state = 3175 + self.match(GremlinParser.DOT) + self.state = 3176 + self.match(GremlinParser.K_TARGET) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ShortestPathConstants_edgesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def shortestPathStringConstant(self): + return self.getTypedRuleContext(GremlinParser.ShortestPathStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_EDGES(self): + return self.getToken(GremlinParser.K_EDGES, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_shortestPathConstants_edges + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterShortestPathConstants_edges"): + listener.enterShortestPathConstants_edges(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitShortestPathConstants_edges"): + listener.exitShortestPathConstants_edges(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitShortestPathConstants_edges"): + return visitor.visitShortestPathConstants_edges(self) + else: + return visitor.visitChildren(self) + + def shortestPathConstants_edges(self): + + localctx = GremlinParser.ShortestPathConstants_edgesContext(self, self._ctx, self.state) + self.enterRule(localctx, 468, self.RULE_shortestPathConstants_edges) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3178 + self.shortestPathStringConstant() + self.state = 3179 + self.match(GremlinParser.DOT) + self.state = 3180 + self.match(GremlinParser.K_EDGES) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ShortestPathConstants_distanceContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def shortestPathStringConstant(self): + return self.getTypedRuleContext(GremlinParser.ShortestPathStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_DISTANCE(self): + return self.getToken(GremlinParser.K_DISTANCE, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_shortestPathConstants_distance + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterShortestPathConstants_distance"): + listener.enterShortestPathConstants_distance(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitShortestPathConstants_distance"): + listener.exitShortestPathConstants_distance(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitShortestPathConstants_distance"): + return visitor.visitShortestPathConstants_distance(self) + else: + return visitor.visitChildren(self) + + def shortestPathConstants_distance(self): + + localctx = GremlinParser.ShortestPathConstants_distanceContext(self, self._ctx, self.state) + self.enterRule(localctx, 470, self.RULE_shortestPathConstants_distance) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3182 + self.shortestPathStringConstant() + self.state = 3183 + self.match(GremlinParser.DOT) + self.state = 3184 + self.match(GremlinParser.K_DISTANCE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ShortestPathConstants_maxDistanceContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def shortestPathStringConstant(self): + return self.getTypedRuleContext(GremlinParser.ShortestPathStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_MAXDISTANCE(self): + return self.getToken(GremlinParser.K_MAXDISTANCE, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_shortestPathConstants_maxDistance + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterShortestPathConstants_maxDistance"): + listener.enterShortestPathConstants_maxDistance(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitShortestPathConstants_maxDistance"): + listener.exitShortestPathConstants_maxDistance(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitShortestPathConstants_maxDistance"): + return visitor.visitShortestPathConstants_maxDistance(self) + else: + return visitor.visitChildren(self) + + def shortestPathConstants_maxDistance(self): + + localctx = GremlinParser.ShortestPathConstants_maxDistanceContext(self, self._ctx, self.state) + self.enterRule(localctx, 472, self.RULE_shortestPathConstants_maxDistance) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3186 + self.shortestPathStringConstant() + self.state = 3187 + self.match(GremlinParser.DOT) + self.state = 3188 + self.match(GremlinParser.K_MAXDISTANCE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ShortestPathConstants_includeEdgesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def shortestPathStringConstant(self): + return self.getTypedRuleContext(GremlinParser.ShortestPathStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_INCLUDEEDGES(self): + return self.getToken(GremlinParser.K_INCLUDEEDGES, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_shortestPathConstants_includeEdges + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterShortestPathConstants_includeEdges"): + listener.enterShortestPathConstants_includeEdges(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitShortestPathConstants_includeEdges"): + listener.exitShortestPathConstants_includeEdges(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitShortestPathConstants_includeEdges"): + return visitor.visitShortestPathConstants_includeEdges(self) + else: + return visitor.visitChildren(self) + + def shortestPathConstants_includeEdges(self): + + localctx = GremlinParser.ShortestPathConstants_includeEdgesContext(self, self._ctx, self.state) + self.enterRule(localctx, 474, self.RULE_shortestPathConstants_includeEdges) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3190 + self.shortestPathStringConstant() + self.state = 3191 + self.match(GremlinParser.DOT) + self.state = 3192 + self.match(GremlinParser.K_INCLUDEEDGES) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class WithOptionsConstants_tokensContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def withOptionsStringConstant(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_TOKENS(self): + return self.getToken(GremlinParser.K_TOKENS, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_withOptionsConstants_tokens + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterWithOptionsConstants_tokens"): + listener.enterWithOptionsConstants_tokens(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitWithOptionsConstants_tokens"): + listener.exitWithOptionsConstants_tokens(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitWithOptionsConstants_tokens"): + return visitor.visitWithOptionsConstants_tokens(self) + else: + return visitor.visitChildren(self) + + def withOptionsConstants_tokens(self): + + localctx = GremlinParser.WithOptionsConstants_tokensContext(self, self._ctx, self.state) + self.enterRule(localctx, 476, self.RULE_withOptionsConstants_tokens) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3194 + self.withOptionsStringConstant() + self.state = 3195 + self.match(GremlinParser.DOT) + self.state = 3196 + self.match(GremlinParser.K_TOKENS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class WithOptionsConstants_noneContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def withOptionsStringConstant(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_NONE(self): + return self.getToken(GremlinParser.K_NONE, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_withOptionsConstants_none + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterWithOptionsConstants_none"): + listener.enterWithOptionsConstants_none(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitWithOptionsConstants_none"): + listener.exitWithOptionsConstants_none(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitWithOptionsConstants_none"): + return visitor.visitWithOptionsConstants_none(self) + else: + return visitor.visitChildren(self) + + def withOptionsConstants_none(self): + + localctx = GremlinParser.WithOptionsConstants_noneContext(self, self._ctx, self.state) + self.enterRule(localctx, 478, self.RULE_withOptionsConstants_none) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3198 + self.withOptionsStringConstant() + self.state = 3199 + self.match(GremlinParser.DOT) + self.state = 3200 + self.match(GremlinParser.K_NONE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class WithOptionsConstants_idsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def withOptionsStringConstant(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_IDS(self): + return self.getToken(GremlinParser.K_IDS, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_withOptionsConstants_ids + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterWithOptionsConstants_ids"): + listener.enterWithOptionsConstants_ids(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitWithOptionsConstants_ids"): + listener.exitWithOptionsConstants_ids(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitWithOptionsConstants_ids"): + return visitor.visitWithOptionsConstants_ids(self) + else: + return visitor.visitChildren(self) + + def withOptionsConstants_ids(self): + + localctx = GremlinParser.WithOptionsConstants_idsContext(self, self._ctx, self.state) + self.enterRule(localctx, 480, self.RULE_withOptionsConstants_ids) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3202 + self.withOptionsStringConstant() + self.state = 3203 + self.match(GremlinParser.DOT) + self.state = 3204 + self.match(GremlinParser.K_IDS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class WithOptionsConstants_labelsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def withOptionsStringConstant(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_LABELS(self): + return self.getToken(GremlinParser.K_LABELS, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_withOptionsConstants_labels + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterWithOptionsConstants_labels"): + listener.enterWithOptionsConstants_labels(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitWithOptionsConstants_labels"): + listener.exitWithOptionsConstants_labels(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitWithOptionsConstants_labels"): + return visitor.visitWithOptionsConstants_labels(self) + else: + return visitor.visitChildren(self) + + def withOptionsConstants_labels(self): + + localctx = GremlinParser.WithOptionsConstants_labelsContext(self, self._ctx, self.state) + self.enterRule(localctx, 482, self.RULE_withOptionsConstants_labels) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3206 + self.withOptionsStringConstant() + self.state = 3207 + self.match(GremlinParser.DOT) + self.state = 3208 + self.match(GremlinParser.K_LABELS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class WithOptionsConstants_keysContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def withOptionsStringConstant(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_KEYS(self): + return self.getToken(GremlinParser.K_KEYS, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_withOptionsConstants_keys + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterWithOptionsConstants_keys"): + listener.enterWithOptionsConstants_keys(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitWithOptionsConstants_keys"): + listener.exitWithOptionsConstants_keys(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitWithOptionsConstants_keys"): + return visitor.visitWithOptionsConstants_keys(self) + else: + return visitor.visitChildren(self) + + def withOptionsConstants_keys(self): + + localctx = GremlinParser.WithOptionsConstants_keysContext(self, self._ctx, self.state) + self.enterRule(localctx, 484, self.RULE_withOptionsConstants_keys) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3210 + self.withOptionsStringConstant() + self.state = 3211 + self.match(GremlinParser.DOT) + self.state = 3212 + self.match(GremlinParser.K_KEYS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class WithOptionsConstants_valuesContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def withOptionsStringConstant(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_VALUES(self): + return self.getToken(GremlinParser.K_VALUES, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_withOptionsConstants_values + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterWithOptionsConstants_values"): + listener.enterWithOptionsConstants_values(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitWithOptionsConstants_values"): + listener.exitWithOptionsConstants_values(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitWithOptionsConstants_values"): + return visitor.visitWithOptionsConstants_values(self) + else: + return visitor.visitChildren(self) + + def withOptionsConstants_values(self): + + localctx = GremlinParser.WithOptionsConstants_valuesContext(self, self._ctx, self.state) + self.enterRule(localctx, 486, self.RULE_withOptionsConstants_values) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3214 + self.withOptionsStringConstant() + self.state = 3215 + self.match(GremlinParser.DOT) + self.state = 3216 + self.match(GremlinParser.K_VALUES) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class WithOptionsConstants_allContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def withOptionsStringConstant(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_ALL(self): + return self.getToken(GremlinParser.K_ALL, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_withOptionsConstants_all + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterWithOptionsConstants_all"): + listener.enterWithOptionsConstants_all(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitWithOptionsConstants_all"): + listener.exitWithOptionsConstants_all(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitWithOptionsConstants_all"): + return visitor.visitWithOptionsConstants_all(self) + else: + return visitor.visitChildren(self) + + def withOptionsConstants_all(self): + + localctx = GremlinParser.WithOptionsConstants_allContext(self, self._ctx, self.state) + self.enterRule(localctx, 488, self.RULE_withOptionsConstants_all) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3218 + self.withOptionsStringConstant() + self.state = 3219 + self.match(GremlinParser.DOT) + self.state = 3220 + self.match(GremlinParser.K_ALL) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class WithOptionsConstants_indexerContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def withOptionsStringConstant(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_INDEXER(self): + return self.getToken(GremlinParser.K_INDEXER, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_withOptionsConstants_indexer + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterWithOptionsConstants_indexer"): + listener.enterWithOptionsConstants_indexer(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitWithOptionsConstants_indexer"): + listener.exitWithOptionsConstants_indexer(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitWithOptionsConstants_indexer"): + return visitor.visitWithOptionsConstants_indexer(self) + else: + return visitor.visitChildren(self) + + def withOptionsConstants_indexer(self): + + localctx = GremlinParser.WithOptionsConstants_indexerContext(self, self._ctx, self.state) + self.enterRule(localctx, 490, self.RULE_withOptionsConstants_indexer) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3222 + self.withOptionsStringConstant() + self.state = 3223 + self.match(GremlinParser.DOT) + self.state = 3224 + self.match(GremlinParser.K_INDEXER) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class WithOptionsConstants_listContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def withOptionsStringConstant(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_LIST(self): + return self.getToken(GremlinParser.K_LIST, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_withOptionsConstants_list + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterWithOptionsConstants_list"): + listener.enterWithOptionsConstants_list(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitWithOptionsConstants_list"): + listener.exitWithOptionsConstants_list(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitWithOptionsConstants_list"): + return visitor.visitWithOptionsConstants_list(self) + else: + return visitor.visitChildren(self) + + def withOptionsConstants_list(self): + + localctx = GremlinParser.WithOptionsConstants_listContext(self, self._ctx, self.state) + self.enterRule(localctx, 492, self.RULE_withOptionsConstants_list) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3226 + self.withOptionsStringConstant() + self.state = 3227 + self.match(GremlinParser.DOT) + self.state = 3228 + self.match(GremlinParser.K_LIST) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class WithOptionsConstants_mapContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def withOptionsStringConstant(self): + return self.getTypedRuleContext(GremlinParser.WithOptionsStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_MAP(self): + return self.getToken(GremlinParser.K_MAP, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_withOptionsConstants_map + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterWithOptionsConstants_map"): + listener.enterWithOptionsConstants_map(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitWithOptionsConstants_map"): + listener.exitWithOptionsConstants_map(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitWithOptionsConstants_map"): + return visitor.visitWithOptionsConstants_map(self) + else: + return visitor.visitChildren(self) + + def withOptionsConstants_map(self): + + localctx = GremlinParser.WithOptionsConstants_mapContext(self, self._ctx, self.state) + self.enterRule(localctx, 494, self.RULE_withOptionsConstants_map) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3230 + self.withOptionsStringConstant() + self.state = 3231 + self.match(GremlinParser.DOT) + self.state = 3232 + self.match(GremlinParser.K_MAP) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class IoOptionsConstants_readerContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def ioOptionsStringConstant(self): + return self.getTypedRuleContext(GremlinParser.IoOptionsStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_READER(self): + return self.getToken(GremlinParser.K_READER, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_ioOptionsConstants_reader + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIoOptionsConstants_reader"): + listener.enterIoOptionsConstants_reader(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIoOptionsConstants_reader"): + listener.exitIoOptionsConstants_reader(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIoOptionsConstants_reader"): + return visitor.visitIoOptionsConstants_reader(self) + else: + return visitor.visitChildren(self) + + def ioOptionsConstants_reader(self): + + localctx = GremlinParser.IoOptionsConstants_readerContext(self, self._ctx, self.state) + self.enterRule(localctx, 496, self.RULE_ioOptionsConstants_reader) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3234 + self.ioOptionsStringConstant() + self.state = 3235 + self.match(GremlinParser.DOT) + self.state = 3236 + self.match(GremlinParser.K_READER) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class IoOptionsConstants_writerContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def ioOptionsStringConstant(self): + return self.getTypedRuleContext(GremlinParser.IoOptionsStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_WRITER(self): + return self.getToken(GremlinParser.K_WRITER, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_ioOptionsConstants_writer + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIoOptionsConstants_writer"): + listener.enterIoOptionsConstants_writer(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIoOptionsConstants_writer"): + listener.exitIoOptionsConstants_writer(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIoOptionsConstants_writer"): + return visitor.visitIoOptionsConstants_writer(self) + else: + return visitor.visitChildren(self) + + def ioOptionsConstants_writer(self): + + localctx = GremlinParser.IoOptionsConstants_writerContext(self, self._ctx, self.state) + self.enterRule(localctx, 498, self.RULE_ioOptionsConstants_writer) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3238 + self.ioOptionsStringConstant() + self.state = 3239 + self.match(GremlinParser.DOT) + self.state = 3240 + self.match(GremlinParser.K_WRITER) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class IoOptionsConstants_gryoContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def ioOptionsStringConstant(self): + return self.getTypedRuleContext(GremlinParser.IoOptionsStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_GRYO(self): + return self.getToken(GremlinParser.K_GRYO, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_ioOptionsConstants_gryo + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIoOptionsConstants_gryo"): + listener.enterIoOptionsConstants_gryo(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIoOptionsConstants_gryo"): + listener.exitIoOptionsConstants_gryo(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIoOptionsConstants_gryo"): + return visitor.visitIoOptionsConstants_gryo(self) + else: + return visitor.visitChildren(self) + + def ioOptionsConstants_gryo(self): + + localctx = GremlinParser.IoOptionsConstants_gryoContext(self, self._ctx, self.state) + self.enterRule(localctx, 500, self.RULE_ioOptionsConstants_gryo) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3242 + self.ioOptionsStringConstant() + self.state = 3243 + self.match(GremlinParser.DOT) + self.state = 3244 + self.match(GremlinParser.K_GRYO) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class IoOptionsConstants_graphsonContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def ioOptionsStringConstant(self): + return self.getTypedRuleContext(GremlinParser.IoOptionsStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_GRAPHSON(self): + return self.getToken(GremlinParser.K_GRAPHSON, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_ioOptionsConstants_graphson + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIoOptionsConstants_graphson"): + listener.enterIoOptionsConstants_graphson(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIoOptionsConstants_graphson"): + listener.exitIoOptionsConstants_graphson(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIoOptionsConstants_graphson"): + return visitor.visitIoOptionsConstants_graphson(self) + else: + return visitor.visitChildren(self) + + def ioOptionsConstants_graphson(self): + + localctx = GremlinParser.IoOptionsConstants_graphsonContext(self, self._ctx, self.state) + self.enterRule(localctx, 502, self.RULE_ioOptionsConstants_graphson) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3246 + self.ioOptionsStringConstant() + self.state = 3247 + self.match(GremlinParser.DOT) + self.state = 3248 + self.match(GremlinParser.K_GRAPHSON) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class IoOptionsConstants_graphmlContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def ioOptionsStringConstant(self): + return self.getTypedRuleContext(GremlinParser.IoOptionsStringConstantContext, 0) + + def DOT(self): + return self.getToken(GremlinParser.DOT, 0) + + def K_GRAPHML(self): + return self.getToken(GremlinParser.K_GRAPHML, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_ioOptionsConstants_graphml + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIoOptionsConstants_graphml"): + listener.enterIoOptionsConstants_graphml(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIoOptionsConstants_graphml"): + listener.exitIoOptionsConstants_graphml(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIoOptionsConstants_graphml"): + return visitor.visitIoOptionsConstants_graphml(self) + else: + return visitor.visitChildren(self) + + def ioOptionsConstants_graphml(self): + + localctx = GremlinParser.IoOptionsConstants_graphmlContext(self, self._ctx, self.state) + self.enterRule(localctx, 504, self.RULE_ioOptionsConstants_graphml) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3250 + self.ioOptionsStringConstant() + self.state = 3251 + self.match(GremlinParser.DOT) + self.state = 3252 + self.match(GremlinParser.K_GRAPHML) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ConnectedComponentStringConstantContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_CONNECTEDCOMPONENTU(self): + return self.getToken(GremlinParser.K_CONNECTEDCOMPONENTU, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_connectedComponentStringConstant + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterConnectedComponentStringConstant"): + listener.enterConnectedComponentStringConstant(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitConnectedComponentStringConstant"): + listener.exitConnectedComponentStringConstant(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConnectedComponentStringConstant"): + return visitor.visitConnectedComponentStringConstant(self) + else: + return visitor.visitChildren(self) + + def connectedComponentStringConstant(self): + + localctx = GremlinParser.ConnectedComponentStringConstantContext(self, self._ctx, self.state) + self.enterRule(localctx, 506, self.RULE_connectedComponentStringConstant) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3254 + self.match(GremlinParser.K_CONNECTEDCOMPONENTU) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class PageRankStringConstantContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_PAGERANKU(self): + return self.getToken(GremlinParser.K_PAGERANKU, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_pageRankStringConstant + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPageRankStringConstant"): + listener.enterPageRankStringConstant(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPageRankStringConstant"): + listener.exitPageRankStringConstant(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPageRankStringConstant"): + return visitor.visitPageRankStringConstant(self) + else: + return visitor.visitChildren(self) + + def pageRankStringConstant(self): + + localctx = GremlinParser.PageRankStringConstantContext(self, self._ctx, self.state) + self.enterRule(localctx, 508, self.RULE_pageRankStringConstant) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3256 + self.match(GremlinParser.K_PAGERANKU) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class PeerPressureStringConstantContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_PEERPRESSUREU(self): + return self.getToken(GremlinParser.K_PEERPRESSUREU, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_peerPressureStringConstant + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPeerPressureStringConstant"): + listener.enterPeerPressureStringConstant(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPeerPressureStringConstant"): + listener.exitPeerPressureStringConstant(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPeerPressureStringConstant"): + return visitor.visitPeerPressureStringConstant(self) + else: + return visitor.visitChildren(self) + + def peerPressureStringConstant(self): + + localctx = GremlinParser.PeerPressureStringConstantContext(self, self._ctx, self.state) + self.enterRule(localctx, 510, self.RULE_peerPressureStringConstant) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3258 + self.match(GremlinParser.K_PEERPRESSUREU) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ShortestPathStringConstantContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_SHORTESTPATHU(self): + return self.getToken(GremlinParser.K_SHORTESTPATHU, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_shortestPathStringConstant + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterShortestPathStringConstant"): + listener.enterShortestPathStringConstant(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitShortestPathStringConstant"): + listener.exitShortestPathStringConstant(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitShortestPathStringConstant"): + return visitor.visitShortestPathStringConstant(self) + else: + return visitor.visitChildren(self) + + def shortestPathStringConstant(self): + + localctx = GremlinParser.ShortestPathStringConstantContext(self, self._ctx, self.state) + self.enterRule(localctx, 512, self.RULE_shortestPathStringConstant) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3260 + self.match(GremlinParser.K_SHORTESTPATHU) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class WithOptionsStringConstantContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_WITHOPTOPTIONS(self): + return self.getToken(GremlinParser.K_WITHOPTOPTIONS, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_withOptionsStringConstant + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterWithOptionsStringConstant"): + listener.enterWithOptionsStringConstant(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitWithOptionsStringConstant"): + listener.exitWithOptionsStringConstant(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitWithOptionsStringConstant"): + return visitor.visitWithOptionsStringConstant(self) + else: + return visitor.visitChildren(self) + + def withOptionsStringConstant(self): + + localctx = GremlinParser.WithOptionsStringConstantContext(self, self._ctx, self.state) + self.enterRule(localctx, 514, self.RULE_withOptionsStringConstant) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3262 + self.match(GremlinParser.K_WITHOPTOPTIONS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class IoOptionsStringConstantContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_IOU(self): + return self.getToken(GremlinParser.K_IOU, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_ioOptionsStringConstant + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIoOptionsStringConstant"): + listener.enterIoOptionsStringConstant(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIoOptionsStringConstant"): + listener.exitIoOptionsStringConstant(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIoOptionsStringConstant"): + return visitor.visitIoOptionsStringConstant(self) + else: + return visitor.visitChildren(self) + + def ioOptionsStringConstant(self): + + localctx = GremlinParser.IoOptionsStringConstantContext(self, self._ctx, self.state) + self.enterRule(localctx, 516, self.RULE_ioOptionsStringConstant) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3264 + self.match(GremlinParser.K_IOU) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class BooleanArgumentContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def booleanLiteral(self): + return self.getTypedRuleContext(GremlinParser.BooleanLiteralContext, 0) + + def variable(self): + return self.getTypedRuleContext(GremlinParser.VariableContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_booleanArgument + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBooleanArgument"): + listener.enterBooleanArgument(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBooleanArgument"): + listener.exitBooleanArgument(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBooleanArgument"): + return visitor.visitBooleanArgument(self) + else: + return visitor.visitChildren(self) + + def booleanArgument(self): + + localctx = GremlinParser.BooleanArgumentContext(self, self._ctx, self.state) + self.enterRule(localctx, 518, self.RULE_booleanArgument) + try: + self.state = 3268 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [66, 226]: + self.enterOuterAlt(localctx, 1) + self.state = 3266 + self.booleanLiteral() + pass + elif token in [270]: + self.enterOuterAlt(localctx, 2) + self.state = 3267 + self.variable() + 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 IntegerArgumentContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def integerLiteral(self): + return self.getTypedRuleContext(GremlinParser.IntegerLiteralContext, 0) + + def variable(self): + return self.getTypedRuleContext(GremlinParser.VariableContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_integerArgument + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntegerArgument"): + listener.enterIntegerArgument(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntegerArgument"): + listener.exitIntegerArgument(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntegerArgument"): + return visitor.visitIntegerArgument(self) + else: + return visitor.visitChildren(self) + + def integerArgument(self): + + localctx = GremlinParser.IntegerArgumentContext(self, self._ctx, self.state) + self.enterRule(localctx, 520, self.RULE_integerArgument) + try: + self.state = 3272 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [251]: + self.enterOuterAlt(localctx, 1) + self.state = 3270 + self.integerLiteral() + pass + elif token in [270]: + self.enterOuterAlt(localctx, 2) + self.state = 3271 + self.variable() + 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 FloatArgumentContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def floatLiteral(self): + return self.getTypedRuleContext(GremlinParser.FloatLiteralContext, 0) + + def variable(self): + return self.getTypedRuleContext(GremlinParser.VariableContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_floatArgument + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFloatArgument"): + listener.enterFloatArgument(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFloatArgument"): + listener.exitFloatArgument(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFloatArgument"): + return visitor.visitFloatArgument(self) + else: + return visitor.visitChildren(self) + + def floatArgument(self): + + localctx = GremlinParser.FloatArgumentContext(self, self._ctx, self.state) + self.enterRule(localctx, 522, self.RULE_floatArgument) + try: + self.state = 3276 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [99, 136, 252, 253]: + self.enterOuterAlt(localctx, 1) + self.state = 3274 + self.floatLiteral() + pass + elif token in [270]: + self.enterOuterAlt(localctx, 2) + self.state = 3275 + self.variable() + 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 StringArgumentContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def variable(self): + return self.getTypedRuleContext(GremlinParser.VariableContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_stringArgument + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStringArgument"): + listener.enterStringArgument(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStringArgument"): + listener.exitStringArgument(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStringArgument"): + return visitor.visitStringArgument(self) + else: + return visitor.visitChildren(self) + + def stringArgument(self): + + localctx = GremlinParser.StringArgumentContext(self, self._ctx, self.state) + self.enterRule(localctx, 524, self.RULE_stringArgument) + try: + self.state = 3280 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [254, 255]: + self.enterOuterAlt(localctx, 1) + self.state = 3278 + self.stringLiteral() + pass + elif token in [270]: + self.enterOuterAlt(localctx, 2) + self.state = 3279 + self.variable() + 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 StringNullableArgumentContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def stringNullableLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralContext, 0) + + def variable(self): + return self.getTypedRuleContext(GremlinParser.VariableContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_stringNullableArgument + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStringNullableArgument"): + listener.enterStringNullableArgument(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStringNullableArgument"): + listener.exitStringNullableArgument(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStringNullableArgument"): + return visitor.visitStringNullableArgument(self) + else: + return visitor.visitChildren(self) + + def stringNullableArgument(self): + + localctx = GremlinParser.StringNullableArgumentContext(self, self._ctx, self.state) + self.enterRule(localctx, 526, self.RULE_stringNullableArgument) + try: + self.state = 3284 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [148, 254, 255]: + self.enterOuterAlt(localctx, 1) + self.state = 3282 + self.stringNullableLiteral() + pass + elif token in [270]: + self.enterOuterAlt(localctx, 2) + self.state = 3283 + self.variable() + 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 StringNullableArgumentVarargsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def stringNullableArgument(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.StringNullableArgumentContext) + else: + return self.getTypedRuleContext(GremlinParser.StringNullableArgumentContext, i) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def getRuleIndex(self): + return GremlinParser.RULE_stringNullableArgumentVarargs + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStringNullableArgumentVarargs"): + listener.enterStringNullableArgumentVarargs(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStringNullableArgumentVarargs"): + listener.exitStringNullableArgumentVarargs(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStringNullableArgumentVarargs"): + return visitor.visitStringNullableArgumentVarargs(self) + else: + return visitor.visitChildren(self) + + def stringNullableArgumentVarargs(self): + + localctx = GremlinParser.StringNullableArgumentVarargsContext(self, self._ctx, self.state) + self.enterRule(localctx, 528, self.RULE_stringNullableArgumentVarargs) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3294 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 148 or (((_la - 254) & ~0x3F) == 0 and ((1 << (_la - 254)) & 65539) != 0): + self.state = 3286 + self.stringNullableArgument() + self.state = 3291 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 263: + self.state = 3287 + self.match(GremlinParser.COMMA) + self.state = 3288 + self.stringNullableArgument() + self.state = 3293 + 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 DateArgumentContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def dateLiteral(self): + return self.getTypedRuleContext(GremlinParser.DateLiteralContext, 0) + + def variable(self): + return self.getTypedRuleContext(GremlinParser.VariableContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_dateArgument + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDateArgument"): + listener.enterDateArgument(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDateArgument"): + listener.exitDateArgument(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDateArgument"): + return visitor.visitDateArgument(self) + else: + return visitor.visitChildren(self) + + def dateArgument(self): + + localctx = GremlinParser.DateArgumentContext(self, self._ctx, self.state) + self.enterRule(localctx, 530, self.RULE_dateArgument) + try: + self.state = 3298 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [45, 46]: + self.enterOuterAlt(localctx, 1) + self.state = 3296 + self.dateLiteral() + pass + elif token in [270]: + self.enterOuterAlt(localctx, 2) + self.state = 3297 + self.variable() + 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 GenericArgumentContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def genericLiteral(self): + return self.getTypedRuleContext(GremlinParser.GenericLiteralContext, 0) + + def variable(self): + return self.getTypedRuleContext(GremlinParser.VariableContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_genericArgument + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGenericArgument"): + listener.enterGenericArgument(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGenericArgument"): + listener.exitGenericArgument(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericArgument"): + return visitor.visitGenericArgument(self) + else: + return visitor.visitChildren(self) + + def genericArgument(self): + + localctx = GremlinParser.GenericArgumentContext(self, self._ctx, self.state) + self.enterRule(localctx, 532, self.RULE_genericArgument) + try: + self.state = 3302 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [ + 1, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 11, + 12, + 14, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 31, + 34, + 35, + 36, + 38, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 48, + 50, + 51, + 52, + 55, + 56, + 57, + 59, + 60, + 61, + 65, + 66, + 67, + 69, + 70, + 71, + 72, + 78, + 79, + 81, + 82, + 83, + 84, + 86, + 87, + 88, + 89, + 90, + 92, + 93, + 94, + 98, + 99, + 100, + 102, + 103, + 106, + 108, + 111, + 113, + 114, + 115, + 116, + 117, + 120, + 121, + 122, + 123, + 124, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 136, + 139, + 144, + 146, + 148, + 149, + 150, + 152, + 153, + 155, + 156, + 157, + 158, + 159, + 160, + 162, + 165, + 166, + 168, + 169, + 171, + 172, + 173, + 174, + 176, + 177, + 178, + 179, + 181, + 183, + 184, + 185, + 187, + 188, + 189, + 191, + 192, + 193, + 195, + 197, + 198, + 199, + 200, + 201, + 203, + 204, + 205, + 206, + 208, + 209, + 212, + 213, + 214, + 218, + 221, + 222, + 223, + 224, + 225, + 226, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 249, + 251, + 252, + 253, + 254, + 255, + 258, + 260, + 266, + 267, + ]: + self.enterOuterAlt(localctx, 1) + self.state = 3300 + self.genericLiteral() + pass + elif token in [270]: + self.enterOuterAlt(localctx, 2) + self.state = 3301 + self.variable() + 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 GenericArgumentVarargsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def genericArgument(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.GenericArgumentContext) + else: + return self.getTypedRuleContext(GremlinParser.GenericArgumentContext, i) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def getRuleIndex(self): + return GremlinParser.RULE_genericArgumentVarargs + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGenericArgumentVarargs"): + listener.enterGenericArgumentVarargs(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGenericArgumentVarargs"): + listener.exitGenericArgumentVarargs(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericArgumentVarargs"): + return visitor.visitGenericArgumentVarargs(self) + else: + return visitor.visitChildren(self) + + def genericArgumentVarargs(self): + + localctx = GremlinParser.GenericArgumentVarargsContext(self, self._ctx, self.state) + self.enterRule(localctx, 534, self.RULE_genericArgumentVarargs) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3312 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ( + (((_la) & ~0x3F) == 0 and ((1 << _la) & 4295729655916026874) != 0) + or (((_la - 65) & ~0x3F) == 0 and ((1 << (_la - 65)) & -1180142740035378953) != 0) + or (((_la - 129) & ~0x3F) == 0 and ((1 << (_la - 129)) & -2461290094875999089) != 0) + or (((_la - 193) & ~0x3F) == 0 and ((1 << (_la - 193)) & 9007339940458642933) != 0) + or (((_la - 258) & ~0x3F) == 0 and ((1 << (_la - 258)) & 4869) != 0) + ): + self.state = 3304 + self.genericArgument() + self.state = 3309 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 263: + self.state = 3305 + self.match(GremlinParser.COMMA) + self.state = 3306 + self.genericArgument() + self.state = 3311 + 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 GenericMapArgumentContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def genericMapLiteral(self): + return self.getTypedRuleContext(GremlinParser.GenericMapLiteralContext, 0) + + def variable(self): + return self.getTypedRuleContext(GremlinParser.VariableContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_genericMapArgument + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGenericMapArgument"): + listener.enterGenericMapArgument(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGenericMapArgument"): + listener.exitGenericMapArgument(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericMapArgument"): + return visitor.visitGenericMapArgument(self) + else: + return visitor.visitChildren(self) + + def genericMapArgument(self): + + localctx = GremlinParser.GenericMapArgumentContext(self, self._ctx, self.state) + self.enterRule(localctx, 536, self.RULE_genericMapArgument) + try: + self.state = 3316 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [260]: + self.enterOuterAlt(localctx, 1) + self.state = 3314 + self.genericMapLiteral() + pass + elif token in [270]: + self.enterOuterAlt(localctx, 2) + self.state = 3315 + self.variable() + 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 GenericMapNullableArgumentContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def genericMapNullableLiteral(self): + return self.getTypedRuleContext(GremlinParser.GenericMapNullableLiteralContext, 0) + + def variable(self): + return self.getTypedRuleContext(GremlinParser.VariableContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_genericMapNullableArgument + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGenericMapNullableArgument"): + listener.enterGenericMapNullableArgument(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGenericMapNullableArgument"): + listener.exitGenericMapNullableArgument(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericMapNullableArgument"): + return visitor.visitGenericMapNullableArgument(self) + else: + return visitor.visitChildren(self) + + def genericMapNullableArgument(self): + + localctx = GremlinParser.GenericMapNullableArgumentContext(self, self._ctx, self.state) + self.enterRule(localctx, 538, self.RULE_genericMapNullableArgument) + try: + self.state = 3320 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [148, 260]: + self.enterOuterAlt(localctx, 1) + self.state = 3318 + self.genericMapNullableLiteral() + pass + elif token in [270]: + self.enterOuterAlt(localctx, 2) + self.state = 3319 + self.variable() + 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 NullableGenericLiteralMapContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def genericMapLiteral(self): + return self.getTypedRuleContext(GremlinParser.GenericMapLiteralContext, 0) + + def nullLiteral(self): + return self.getTypedRuleContext(GremlinParser.NullLiteralContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_nullableGenericLiteralMap + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNullableGenericLiteralMap"): + listener.enterNullableGenericLiteralMap(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNullableGenericLiteralMap"): + listener.exitNullableGenericLiteralMap(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNullableGenericLiteralMap"): + return visitor.visitNullableGenericLiteralMap(self) + else: + return visitor.visitChildren(self) + + def nullableGenericLiteralMap(self): + + localctx = GremlinParser.NullableGenericLiteralMapContext(self, self._ctx, self.state) + self.enterRule(localctx, 540, self.RULE_nullableGenericLiteralMap) + try: + self.state = 3324 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [260]: + self.enterOuterAlt(localctx, 1) + self.state = 3322 + self.genericMapLiteral() + pass + elif token in [148]: + self.enterOuterAlt(localctx, 2) + self.state = 3323 + self.nullLiteral() + 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 StructureVertexArgumentContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def structureVertexLiteral(self): + return self.getTypedRuleContext(GremlinParser.StructureVertexLiteralContext, 0) + + def variable(self): + return self.getTypedRuleContext(GremlinParser.VariableContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_structureVertexArgument + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStructureVertexArgument"): + listener.enterStructureVertexArgument(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStructureVertexArgument"): + listener.exitStructureVertexArgument(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStructureVertexArgument"): + return visitor.visitStructureVertexArgument(self) + else: + return visitor.visitChildren(self) + + def structureVertexArgument(self): + + localctx = GremlinParser.StructureVertexArgumentContext(self, self._ctx, self.state) + self.enterRule(localctx, 542, self.RULE_structureVertexArgument) + try: + self.state = 3328 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [146, 181, 237]: + self.enterOuterAlt(localctx, 1) + self.state = 3326 + self.structureVertexLiteral() + pass + elif token in [270]: + self.enterOuterAlt(localctx, 2) + self.state = 3327 + self.variable() + 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 TraversalStrategyVarargsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalStrategyExpr(self): + return self.getTypedRuleContext(GremlinParser.TraversalStrategyExprContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalStrategyVarargs + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalStrategyVarargs"): + listener.enterTraversalStrategyVarargs(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalStrategyVarargs"): + listener.exitTraversalStrategyVarargs(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalStrategyVarargs"): + return visitor.visitTraversalStrategyVarargs(self) + else: + return visitor.visitChildren(self) + + def traversalStrategyVarargs(self): + + localctx = GremlinParser.TraversalStrategyVarargsContext(self, self._ctx, self.state) + self.enterRule(localctx, 544, self.RULE_traversalStrategyVarargs) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3331 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 146 or _la == 270: + self.state = 3330 + self.traversalStrategyExpr() + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class TraversalStrategyExprContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def traversalStrategy(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.TraversalStrategyContext) + else: + return self.getTypedRuleContext(GremlinParser.TraversalStrategyContext, i) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def getRuleIndex(self): + return GremlinParser.RULE_traversalStrategyExpr + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTraversalStrategyExpr"): + listener.enterTraversalStrategyExpr(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTraversalStrategyExpr"): + listener.exitTraversalStrategyExpr(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTraversalStrategyExpr"): + return visitor.visitTraversalStrategyExpr(self) + else: + return visitor.visitChildren(self) + + def traversalStrategyExpr(self): + + localctx = GremlinParser.TraversalStrategyExprContext(self, self._ctx, self.state) + self.enterRule(localctx, 546, self.RULE_traversalStrategyExpr) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3333 + self.traversalStrategy() + self.state = 3338 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 263: + self.state = 3334 + self.match(GremlinParser.COMMA) + self.state = 3335 + self.traversalStrategy() + self.state = 3340 + 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 ClassTypeListContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def classTypeExpr(self): + return self.getTypedRuleContext(GremlinParser.ClassTypeExprContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_classTypeList + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterClassTypeList"): + listener.enterClassTypeList(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitClassTypeList"): + listener.exitClassTypeList(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitClassTypeList"): + return visitor.visitClassTypeList(self) + else: + return visitor.visitChildren(self) + + def classTypeList(self): + + localctx = GremlinParser.ClassTypeListContext(self, self._ctx, self.state) + self.enterRule(localctx, 548, self.RULE_classTypeList) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3342 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 270: + self.state = 3341 + self.classTypeExpr() + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ClassTypeExprContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def classType(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.ClassTypeContext) + else: + return self.getTypedRuleContext(GremlinParser.ClassTypeContext, i) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def getRuleIndex(self): + return GremlinParser.RULE_classTypeExpr + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterClassTypeExpr"): + listener.enterClassTypeExpr(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitClassTypeExpr"): + listener.exitClassTypeExpr(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitClassTypeExpr"): + return visitor.visitClassTypeExpr(self) + else: + return visitor.visitChildren(self) + + def classTypeExpr(self): + + localctx = GremlinParser.ClassTypeExprContext(self, self._ctx, self.state) + self.enterRule(localctx, 550, self.RULE_classTypeExpr) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3344 + self.classType() + self.state = 3349 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 263: + self.state = 3345 + self.match(GremlinParser.COMMA) + self.state = 3346 + self.classType() + self.state = 3351 + 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 NestedTraversalListContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def nestedTraversalExpr(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalExprContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_nestedTraversalList + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNestedTraversalList"): + listener.enterNestedTraversalList(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNestedTraversalList"): + listener.exitNestedTraversalList(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNestedTraversalList"): + return visitor.visitNestedTraversalList(self) + else: + return visitor.visitChildren(self) + + def nestedTraversalList(self): + + localctx = GremlinParser.NestedTraversalListContext(self, self._ctx, self.state) + self.enterRule(localctx, 552, self.RULE_nestedTraversalList) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3353 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ( + (((_la) & ~0x3F) == 0 and ((1 << _la) & 4221310310834002938) != 0) + or (((_la - 65) & ~0x3F) == 0 and ((1 << (_la - 65)) & -5792954675826302731) != 0) + or (((_la - 129) & ~0x3F) == 0 and ((1 << (_la - 129)) & -7077480812983057401) != 0) + or (((_la - 195) & ~0x3F) == 0 and ((1 << (_la - 195)) & 18045032305938285) != 0) + or _la == 267 + ): + self.state = 3352 + self.nestedTraversalExpr() + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class NestedTraversalExprContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def nestedTraversal(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.NestedTraversalContext) + else: + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, i) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def getRuleIndex(self): + return GremlinParser.RULE_nestedTraversalExpr + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNestedTraversalExpr"): + listener.enterNestedTraversalExpr(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNestedTraversalExpr"): + listener.exitNestedTraversalExpr(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNestedTraversalExpr"): + return visitor.visitNestedTraversalExpr(self) + else: + return visitor.visitChildren(self) + + def nestedTraversalExpr(self): + + localctx = GremlinParser.NestedTraversalExprContext(self, self._ctx, self.state) + self.enterRule(localctx, 554, self.RULE_nestedTraversalExpr) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3355 + self.nestedTraversal() + self.state = 3360 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 263: + self.state = 3356 + self.match(GremlinParser.COMMA) + self.state = 3357 + self.nestedTraversal() + self.state = 3362 + 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 GenericCollectionLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LBRACK(self): + return self.getToken(GremlinParser.LBRACK, 0) + + def RBRACK(self): + return self.getToken(GremlinParser.RBRACK, 0) + + def genericLiteral(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.GenericLiteralContext) + else: + return self.getTypedRuleContext(GremlinParser.GenericLiteralContext, i) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def getRuleIndex(self): + return GremlinParser.RULE_genericCollectionLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGenericCollectionLiteral"): + listener.enterGenericCollectionLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGenericCollectionLiteral"): + listener.exitGenericCollectionLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericCollectionLiteral"): + return visitor.visitGenericCollectionLiteral(self) + else: + return visitor.visitChildren(self) + + def genericCollectionLiteral(self): + + localctx = GremlinParser.GenericCollectionLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 556, self.RULE_genericCollectionLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3363 + self.match(GremlinParser.LBRACK) + self.state = 3372 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ( + (((_la) & ~0x3F) == 0 and ((1 << _la) & 4295729655916026874) != 0) + or (((_la - 65) & ~0x3F) == 0 and ((1 << (_la - 65)) & -1180142740035378953) != 0) + or (((_la - 129) & ~0x3F) == 0 and ((1 << (_la - 129)) & -2461290094875999089) != 0) + or (((_la - 193) & ~0x3F) == 0 and ((1 << (_la - 193)) & 9007339940458642933) != 0) + or (((_la - 258) & ~0x3F) == 0 and ((1 << (_la - 258)) & 773) != 0) + ): + self.state = 3364 + self.genericLiteral() + self.state = 3369 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 263: + self.state = 3365 + self.match(GremlinParser.COMMA) + self.state = 3366 + self.genericLiteral() + self.state = 3371 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 3374 + self.match(GremlinParser.RBRACK) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class GenericLiteralVarargsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def genericLiteralExpr(self): + return self.getTypedRuleContext(GremlinParser.GenericLiteralExprContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_genericLiteralVarargs + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGenericLiteralVarargs"): + listener.enterGenericLiteralVarargs(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGenericLiteralVarargs"): + listener.exitGenericLiteralVarargs(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericLiteralVarargs"): + return visitor.visitGenericLiteralVarargs(self) + else: + return visitor.visitChildren(self) + + def genericLiteralVarargs(self): + + localctx = GremlinParser.GenericLiteralVarargsContext(self, self._ctx, self.state) + self.enterRule(localctx, 558, self.RULE_genericLiteralVarargs) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3377 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ( + (((_la) & ~0x3F) == 0 and ((1 << _la) & 4295729655916026874) != 0) + or (((_la - 65) & ~0x3F) == 0 and ((1 << (_la - 65)) & -1180142740035378953) != 0) + or (((_la - 129) & ~0x3F) == 0 and ((1 << (_la - 129)) & -2461290094875999089) != 0) + or (((_la - 193) & ~0x3F) == 0 and ((1 << (_la - 193)) & 9007339940458642933) != 0) + or (((_la - 258) & ~0x3F) == 0 and ((1 << (_la - 258)) & 773) != 0) + ): + self.state = 3376 + self.genericLiteralExpr() + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class GenericLiteralExprContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def genericLiteral(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.GenericLiteralContext) + else: + return self.getTypedRuleContext(GremlinParser.GenericLiteralContext, i) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def getRuleIndex(self): + return GremlinParser.RULE_genericLiteralExpr + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGenericLiteralExpr"): + listener.enterGenericLiteralExpr(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGenericLiteralExpr"): + listener.exitGenericLiteralExpr(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericLiteralExpr"): + return visitor.visitGenericLiteralExpr(self) + else: + return visitor.visitChildren(self) + + def genericLiteralExpr(self): + + localctx = GremlinParser.GenericLiteralExprContext(self, self._ctx, self.state) + self.enterRule(localctx, 560, self.RULE_genericLiteralExpr) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3379 + self.genericLiteral() + self.state = 3384 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 263: + self.state = 3380 + self.match(GremlinParser.COMMA) + self.state = 3381 + self.genericLiteral() + self.state = 3386 + 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 GenericMapNullableLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def genericMapLiteral(self): + return self.getTypedRuleContext(GremlinParser.GenericMapLiteralContext, 0) + + def nullLiteral(self): + return self.getTypedRuleContext(GremlinParser.NullLiteralContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_genericMapNullableLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGenericMapNullableLiteral"): + listener.enterGenericMapNullableLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGenericMapNullableLiteral"): + listener.exitGenericMapNullableLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericMapNullableLiteral"): + return visitor.visitGenericMapNullableLiteral(self) + else: + return visitor.visitChildren(self) + + def genericMapNullableLiteral(self): + + localctx = GremlinParser.GenericMapNullableLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 562, self.RULE_genericMapNullableLiteral) + try: + self.state = 3389 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [260]: + self.enterOuterAlt(localctx, 1) + self.state = 3387 + self.genericMapLiteral() + pass + elif token in [148]: + self.enterOuterAlt(localctx, 2) + self.state = 3388 + self.nullLiteral() + 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 GenericRangeLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def integerLiteral(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.IntegerLiteralContext) + else: + return self.getTypedRuleContext(GremlinParser.IntegerLiteralContext, i) + + def DOT(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.DOT) + else: + return self.getToken(GremlinParser.DOT, i) + + def stringLiteral(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.StringLiteralContext) + else: + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, i) + + def getRuleIndex(self): + return GremlinParser.RULE_genericRangeLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGenericRangeLiteral"): + listener.enterGenericRangeLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGenericRangeLiteral"): + listener.exitGenericRangeLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericRangeLiteral"): + return visitor.visitGenericRangeLiteral(self) + else: + return visitor.visitChildren(self) + + def genericRangeLiteral(self): + + localctx = GremlinParser.GenericRangeLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 564, self.RULE_genericRangeLiteral) + try: + self.state = 3401 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [251]: + self.enterOuterAlt(localctx, 1) + self.state = 3391 + self.integerLiteral() + self.state = 3392 + self.match(GremlinParser.DOT) + self.state = 3393 + self.match(GremlinParser.DOT) + self.state = 3394 + self.integerLiteral() + pass + elif token in [254, 255]: + self.enterOuterAlt(localctx, 2) + self.state = 3396 + self.stringLiteral() + self.state = 3397 + self.match(GremlinParser.DOT) + self.state = 3398 + self.match(GremlinParser.DOT) + self.state = 3399 + self.stringLiteral() + 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 GenericSetLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LBRACE(self): + return self.getToken(GremlinParser.LBRACE, 0) + + def RBRACE(self): + return self.getToken(GremlinParser.RBRACE, 0) + + def genericLiteral(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.GenericLiteralContext) + else: + return self.getTypedRuleContext(GremlinParser.GenericLiteralContext, i) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def getRuleIndex(self): + return GremlinParser.RULE_genericSetLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGenericSetLiteral"): + listener.enterGenericSetLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGenericSetLiteral"): + listener.exitGenericSetLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericSetLiteral"): + return visitor.visitGenericSetLiteral(self) + else: + return visitor.visitChildren(self) + + def genericSetLiteral(self): + + localctx = GremlinParser.GenericSetLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 566, self.RULE_genericSetLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3403 + self.match(GremlinParser.LBRACE) + self.state = 3412 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ( + (((_la) & ~0x3F) == 0 and ((1 << _la) & 4295729655916026874) != 0) + or (((_la - 65) & ~0x3F) == 0 and ((1 << (_la - 65)) & -1180142740035378953) != 0) + or (((_la - 129) & ~0x3F) == 0 and ((1 << (_la - 129)) & -2461290094875999089) != 0) + or (((_la - 193) & ~0x3F) == 0 and ((1 << (_la - 193)) & 9007339940458642933) != 0) + or (((_la - 258) & ~0x3F) == 0 and ((1 << (_la - 258)) & 773) != 0) + ): + self.state = 3404 + self.genericLiteral() + self.state = 3409 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 263: + self.state = 3405 + self.match(GremlinParser.COMMA) + self.state = 3406 + self.genericLiteral() + self.state = 3411 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 3414 + self.match(GremlinParser.RBRACE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class StringNullableLiteralVarargsContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def stringNullableLiteral(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.StringNullableLiteralContext) + else: + return self.getTypedRuleContext(GremlinParser.StringNullableLiteralContext, i) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def getRuleIndex(self): + return GremlinParser.RULE_stringNullableLiteralVarargs + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStringNullableLiteralVarargs"): + listener.enterStringNullableLiteralVarargs(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStringNullableLiteralVarargs"): + listener.exitStringNullableLiteralVarargs(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStringNullableLiteralVarargs"): + return visitor.visitStringNullableLiteralVarargs(self) + else: + return visitor.visitChildren(self) + + def stringNullableLiteralVarargs(self): + + localctx = GremlinParser.StringNullableLiteralVarargsContext(self, self._ctx, self.state) + self.enterRule(localctx, 568, self.RULE_stringNullableLiteralVarargs) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3424 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == 148 or _la == 254 or _la == 255: + self.state = 3416 + self.stringNullableLiteral() + self.state = 3421 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 263: + self.state = 3417 + self.match(GremlinParser.COMMA) + self.state = 3418 + self.stringNullableLiteral() + self.state = 3423 + 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 GenericLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def numericLiteral(self): + return self.getTypedRuleContext(GremlinParser.NumericLiteralContext, 0) + + def booleanLiteral(self): + return self.getTypedRuleContext(GremlinParser.BooleanLiteralContext, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def dateLiteral(self): + return self.getTypedRuleContext(GremlinParser.DateLiteralContext, 0) + + def nullLiteral(self): + return self.getTypedRuleContext(GremlinParser.NullLiteralContext, 0) + + def traversalT(self): + return self.getTypedRuleContext(GremlinParser.TraversalTContext, 0) + + def traversalCardinality(self): + return self.getTypedRuleContext(GremlinParser.TraversalCardinalityContext, 0) + + def traversalDirection(self): + return self.getTypedRuleContext(GremlinParser.TraversalDirectionContext, 0) + + def traversalMerge(self): + return self.getTypedRuleContext(GremlinParser.TraversalMergeContext, 0) + + def traversalPick(self): + return self.getTypedRuleContext(GremlinParser.TraversalPickContext, 0) + + def traversalDT(self): + return self.getTypedRuleContext(GremlinParser.TraversalDTContext, 0) + + def structureVertexLiteral(self): + return self.getTypedRuleContext(GremlinParser.StructureVertexLiteralContext, 0) + + def genericSetLiteral(self): + return self.getTypedRuleContext(GremlinParser.GenericSetLiteralContext, 0) + + def genericCollectionLiteral(self): + return self.getTypedRuleContext(GremlinParser.GenericCollectionLiteralContext, 0) + + def genericRangeLiteral(self): + return self.getTypedRuleContext(GremlinParser.GenericRangeLiteralContext, 0) + + def nestedTraversal(self): + return self.getTypedRuleContext(GremlinParser.NestedTraversalContext, 0) + + def terminatedTraversal(self): + return self.getTypedRuleContext(GremlinParser.TerminatedTraversalContext, 0) + + def uuidLiteral(self): + return self.getTypedRuleContext(GremlinParser.UuidLiteralContext, 0) + + def genericMapLiteral(self): + return self.getTypedRuleContext(GremlinParser.GenericMapLiteralContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_genericLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGenericLiteral"): + listener.enterGenericLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGenericLiteral"): + listener.exitGenericLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericLiteral"): + return visitor.visitGenericLiteral(self) + else: + return visitor.visitChildren(self) + + def genericLiteral(self): + + localctx = GremlinParser.GenericLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 570, self.RULE_genericLiteral) + try: + self.state = 3445 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 195, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3426 + self.numericLiteral() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3427 + self.booleanLiteral() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3428 + self.stringLiteral() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 3429 + self.dateLiteral() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 3430 + self.nullLiteral() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 3431 + self.traversalT() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 3432 + self.traversalCardinality() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 3433 + self.traversalDirection() + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 3434 + self.traversalMerge() + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 3435 + self.traversalPick() + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 3436 + self.traversalDT() + pass + + elif la_ == 12: + self.enterOuterAlt(localctx, 12) + self.state = 3437 + self.structureVertexLiteral() + pass + + elif la_ == 13: + self.enterOuterAlt(localctx, 13) + self.state = 3438 + self.genericSetLiteral() + pass + + elif la_ == 14: + self.enterOuterAlt(localctx, 14) + self.state = 3439 + self.genericCollectionLiteral() + pass + + elif la_ == 15: + self.enterOuterAlt(localctx, 15) + self.state = 3440 + self.genericRangeLiteral() + pass + + elif la_ == 16: + self.enterOuterAlt(localctx, 16) + self.state = 3441 + self.nestedTraversal() + pass + + elif la_ == 17: + self.enterOuterAlt(localctx, 17) + self.state = 3442 + self.terminatedTraversal() + pass + + elif la_ == 18: + self.enterOuterAlt(localctx, 18) + self.state = 3443 + self.uuidLiteral() + pass + + elif la_ == 19: + self.enterOuterAlt(localctx, 19) + self.state = 3444 + self.genericMapLiteral() + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class GenericMapLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LBRACK(self): + return self.getToken(GremlinParser.LBRACK, 0) + + def COLON(self): + return self.getToken(GremlinParser.COLON, 0) + + def RBRACK(self): + return self.getToken(GremlinParser.RBRACK, 0) + + def mapEntry(self, i: int = None): + if i is None: + return self.getTypedRuleContexts(GremlinParser.MapEntryContext) + else: + return self.getTypedRuleContext(GremlinParser.MapEntryContext, i) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(GremlinParser.COMMA) + else: + return self.getToken(GremlinParser.COMMA, i) + + def getRuleIndex(self): + return GremlinParser.RULE_genericMapLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterGenericMapLiteral"): + listener.enterGenericMapLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitGenericMapLiteral"): + listener.exitGenericMapLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericMapLiteral"): + return visitor.visitGenericMapLiteral(self) + else: + return visitor.visitChildren(self) + + def genericMapLiteral(self): + + localctx = GremlinParser.GenericMapLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 572, self.RULE_genericMapLiteral) + self._la = 0 # Token type + try: + self.state = 3461 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 197, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3447 + self.match(GremlinParser.LBRACK) + self.state = 3448 + self.match(GremlinParser.COLON) + self.state = 3449 + self.match(GremlinParser.RBRACK) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3450 + self.match(GremlinParser.LBRACK) + self.state = 3451 + self.mapEntry() + self.state = 3456 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la == 263: + self.state = 3452 + self.match(GremlinParser.COMMA) + self.state = 3453 + self.mapEntry() + self.state = 3458 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 3459 + self.match(GremlinParser.RBRACK) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class MapKeyContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def traversalT(self): + return self.getTypedRuleContext(GremlinParser.TraversalTContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def traversalTLong(self): + return self.getTypedRuleContext(GremlinParser.TraversalTLongContext, 0) + + def traversalDirection(self): + return self.getTypedRuleContext(GremlinParser.TraversalDirectionContext, 0) + + def traversalDirectionLong(self): + return self.getTypedRuleContext(GremlinParser.TraversalDirectionLongContext, 0) + + def genericSetLiteral(self): + return self.getTypedRuleContext(GremlinParser.GenericSetLiteralContext, 0) + + def genericCollectionLiteral(self): + return self.getTypedRuleContext(GremlinParser.GenericCollectionLiteralContext, 0) + + def genericMapLiteral(self): + return self.getTypedRuleContext(GremlinParser.GenericMapLiteralContext, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def numericLiteral(self): + return self.getTypedRuleContext(GremlinParser.NumericLiteralContext, 0) + + def keyword(self): + return self.getTypedRuleContext(GremlinParser.KeywordContext, 0) + + def nakedKey(self): + return self.getTypedRuleContext(GremlinParser.NakedKeyContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_mapKey + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterMapKey"): + listener.enterMapKey(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitMapKey"): + listener.exitMapKey(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMapKey"): + return visitor.visitMapKey(self) + else: + return visitor.visitChildren(self) + + def mapKey(self): + + localctx = GremlinParser.MapKeyContext(self, self._ctx, self.state) + self.enterRule(localctx, 574, self.RULE_mapKey) + try: + self.state = 3516 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 206, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3468 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [256]: + self.state = 3463 + self.match(GremlinParser.LPAREN) + self.state = 3464 + self.traversalT() + self.state = 3465 + self.match(GremlinParser.RPAREN) + pass + elif token in [208]: + self.state = 3467 + self.traversalTLong() + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3475 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [256]: + self.state = 3470 + self.match(GremlinParser.LPAREN) + self.state = 3471 + self.traversalDirection() + self.state = 3472 + self.match(GremlinParser.RPAREN) + pass + elif token in [51]: + self.state = 3474 + self.traversalDirectionLong() + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3482 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [256]: + self.state = 3477 + self.match(GremlinParser.LPAREN) + self.state = 3478 + self.genericSetLiteral() + self.state = 3479 + self.match(GremlinParser.RPAREN) + pass + elif token in [258]: + self.state = 3481 + self.genericSetLiteral() + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 3489 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [256]: + self.state = 3484 + self.match(GremlinParser.LPAREN) + self.state = 3485 + self.genericCollectionLiteral() + self.state = 3486 + self.match(GremlinParser.RPAREN) + pass + elif token in [260]: + self.state = 3488 + self.genericCollectionLiteral() + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 3496 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [256]: + self.state = 3491 + self.match(GremlinParser.LPAREN) + self.state = 3492 + self.genericMapLiteral() + self.state = 3493 + self.match(GremlinParser.RPAREN) + pass + elif token in [260]: + self.state = 3495 + self.genericMapLiteral() + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 3503 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [256]: + self.state = 3498 + self.match(GremlinParser.LPAREN) + self.state = 3499 + self.stringLiteral() + self.state = 3500 + self.match(GremlinParser.RPAREN) + pass + elif token in [254, 255]: + self.state = 3502 + self.stringLiteral() + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 3510 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [256]: + self.state = 3505 + self.match(GremlinParser.LPAREN) + self.state = 3506 + self.numericLiteral() + self.state = 3507 + self.match(GremlinParser.RPAREN) + pass + elif token in [99, 136, 251, 252, 253]: + self.state = 3509 + self.numericLiteral() + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 3514 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [ + 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, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96, + 97, + 98, + 99, + 100, + 101, + 102, + 103, + 104, + 105, + 106, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118, + 119, + 120, + 121, + 122, + 123, + 124, + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134, + 135, + 136, + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144, + 145, + 146, + 147, + 148, + 149, + 150, + 151, + 152, + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162, + 163, + 164, + 165, + 166, + 167, + 168, + 169, + 170, + 171, + 172, + 173, + 174, + 175, + 176, + 177, + 178, + 179, + 180, + 181, + 182, + 183, + 184, + 185, + 186, + 187, + 188, + 189, + 190, + 191, + 192, + 193, + 194, + 195, + 196, + 197, + 198, + 199, + 200, + 201, + 202, + 203, + 204, + 205, + 206, + 207, + 208, + 209, + 210, + 211, + 212, + 213, + 214, + 215, + 216, + 217, + 218, + 219, + 220, + 221, + 222, + 223, + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 266, + ]: + self.state = 3512 + self.keyword() + pass + elif token in [270]: + self.state = 3513 + self.nakedKey() + pass + else: + raise NoViableAltException(self) + + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class MapEntryContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def mapKey(self): + return self.getTypedRuleContext(GremlinParser.MapKeyContext, 0) + + def COLON(self): + return self.getToken(GremlinParser.COLON, 0) + + def genericLiteral(self): + return self.getTypedRuleContext(GremlinParser.GenericLiteralContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_mapEntry + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterMapEntry"): + listener.enterMapEntry(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitMapEntry"): + listener.exitMapEntry(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMapEntry"): + return visitor.visitMapEntry(self) + else: + return visitor.visitChildren(self) + + def mapEntry(self): + + localctx = GremlinParser.MapEntryContext(self, self._ctx, self.state) + self.enterRule(localctx, 576, self.RULE_mapEntry) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3518 + self.mapKey() + self.state = 3519 + self.match(GremlinParser.COLON) + self.state = 3520 + self.genericLiteral() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class StringLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def EmptyStringLiteral(self): + return self.getToken(GremlinParser.EmptyStringLiteral, 0) + + def NonEmptyStringLiteral(self): + return self.getToken(GremlinParser.NonEmptyStringLiteral, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_stringLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStringLiteral"): + listener.enterStringLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStringLiteral"): + listener.exitStringLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStringLiteral"): + return visitor.visitStringLiteral(self) + else: + return visitor.visitChildren(self) + + def stringLiteral(self): + + localctx = GremlinParser.StringLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 578, self.RULE_stringLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3522 + _la = self._input.LA(1) + if not (_la == 254 or _la == 255): + 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 StringNullableLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def EmptyStringLiteral(self): + return self.getToken(GremlinParser.EmptyStringLiteral, 0) + + def NonEmptyStringLiteral(self): + return self.getToken(GremlinParser.NonEmptyStringLiteral, 0) + + def K_NULL(self): + return self.getToken(GremlinParser.K_NULL, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_stringNullableLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStringNullableLiteral"): + listener.enterStringNullableLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStringNullableLiteral"): + listener.exitStringNullableLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStringNullableLiteral"): + return visitor.visitStringNullableLiteral(self) + else: + return visitor.visitChildren(self) + + def stringNullableLiteral(self): + + localctx = GremlinParser.StringNullableLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 580, self.RULE_stringNullableLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3524 + _la = self._input.LA(1) + if not (_la == 148 or _la == 254 or _la == 255): + 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 IntegerLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def IntegerLiteral(self): + return self.getToken(GremlinParser.IntegerLiteral, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_integerLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntegerLiteral"): + listener.enterIntegerLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntegerLiteral"): + listener.exitIntegerLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntegerLiteral"): + return visitor.visitIntegerLiteral(self) + else: + return visitor.visitChildren(self) + + def integerLiteral(self): + + localctx = GremlinParser.IntegerLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 582, self.RULE_integerLiteral) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3526 + self.match(GremlinParser.IntegerLiteral) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class FloatLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def FloatingPointLiteral(self): + return self.getToken(GremlinParser.FloatingPointLiteral, 0) + + def infLiteral(self): + return self.getTypedRuleContext(GremlinParser.InfLiteralContext, 0) + + def nanLiteral(self): + return self.getTypedRuleContext(GremlinParser.NanLiteralContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_floatLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFloatLiteral"): + listener.enterFloatLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFloatLiteral"): + listener.exitFloatLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFloatLiteral"): + return visitor.visitFloatLiteral(self) + else: + return visitor.visitChildren(self) + + def floatLiteral(self): + + localctx = GremlinParser.FloatLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 584, self.RULE_floatLiteral) + try: + self.state = 3531 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [252]: + self.enterOuterAlt(localctx, 1) + self.state = 3528 + self.match(GremlinParser.FloatingPointLiteral) + pass + elif token in [99, 253]: + self.enterOuterAlt(localctx, 2) + self.state = 3529 + self.infLiteral() + pass + elif token in [136]: + self.enterOuterAlt(localctx, 3) + self.state = 3530 + self.nanLiteral() + 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 NumericLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def integerLiteral(self): + return self.getTypedRuleContext(GremlinParser.IntegerLiteralContext, 0) + + def floatLiteral(self): + return self.getTypedRuleContext(GremlinParser.FloatLiteralContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_numericLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNumericLiteral"): + listener.enterNumericLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNumericLiteral"): + listener.exitNumericLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNumericLiteral"): + return visitor.visitNumericLiteral(self) + else: + return visitor.visitChildren(self) + + def numericLiteral(self): + + localctx = GremlinParser.NumericLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 586, self.RULE_numericLiteral) + try: + self.state = 3535 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [251]: + self.enterOuterAlt(localctx, 1) + self.state = 3533 + self.integerLiteral() + pass + elif token in [99, 136, 252, 253]: + self.enterOuterAlt(localctx, 2) + self.state = 3534 + self.floatLiteral() + 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 BooleanLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_TRUE(self): + return self.getToken(GremlinParser.K_TRUE, 0) + + def K_FALSE(self): + return self.getToken(GremlinParser.K_FALSE, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_booleanLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBooleanLiteral"): + listener.enterBooleanLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBooleanLiteral"): + listener.exitBooleanLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBooleanLiteral"): + return visitor.visitBooleanLiteral(self) + else: + return visitor.visitChildren(self) + + def booleanLiteral(self): + + localctx = GremlinParser.BooleanLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 588, self.RULE_booleanLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3537 + _la = self._input.LA(1) + if not (_la == 66 or _la == 226): + 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 DateLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_DATETIME(self): + return self.getToken(GremlinParser.K_DATETIME, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def stringArgument(self): + return self.getTypedRuleContext(GremlinParser.StringArgumentContext, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def K_DATETIMEU(self): + return self.getToken(GremlinParser.K_DATETIMEU, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_dateLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDateLiteral"): + listener.enterDateLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDateLiteral"): + listener.exitDateLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDateLiteral"): + return visitor.visitDateLiteral(self) + else: + return visitor.visitChildren(self) + + def dateLiteral(self): + + localctx = GremlinParser.DateLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 590, self.RULE_dateLiteral) + try: + self.state = 3555 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 209, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3539 + self.match(GremlinParser.K_DATETIME) + self.state = 3540 + self.match(GremlinParser.LPAREN) + self.state = 3541 + self.stringArgument() + self.state = 3542 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3544 + self.match(GremlinParser.K_DATETIME) + self.state = 3545 + self.match(GremlinParser.LPAREN) + self.state = 3546 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3547 + self.match(GremlinParser.K_DATETIMEU) + self.state = 3548 + self.match(GremlinParser.LPAREN) + self.state = 3549 + self.stringArgument() + self.state = 3550 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 3552 + self.match(GremlinParser.K_DATETIMEU) + self.state = 3553 + self.match(GremlinParser.LPAREN) + self.state = 3554 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class NullLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_NULL(self): + return self.getToken(GremlinParser.K_NULL, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_nullLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNullLiteral"): + listener.enterNullLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNullLiteral"): + listener.exitNullLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNullLiteral"): + return visitor.visitNullLiteral(self) + else: + return visitor.visitChildren(self) + + def nullLiteral(self): + + localctx = GremlinParser.NullLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 592, self.RULE_nullLiteral) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3557 + self.match(GremlinParser.K_NULL) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class NanLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_NAN(self): + return self.getToken(GremlinParser.K_NAN, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_nanLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNanLiteral"): + listener.enterNanLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNanLiteral"): + listener.exitNanLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNanLiteral"): + return visitor.visitNanLiteral(self) + else: + return visitor.visitChildren(self) + + def nanLiteral(self): + + localctx = GremlinParser.NanLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 594, self.RULE_nanLiteral) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3559 + self.match(GremlinParser.K_NAN) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class InfLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_INFINITY(self): + return self.getToken(GremlinParser.K_INFINITY, 0) + + def SignedInfLiteral(self): + return self.getToken(GremlinParser.SignedInfLiteral, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_infLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterInfLiteral"): + listener.enterInfLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitInfLiteral"): + listener.exitInfLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInfLiteral"): + return visitor.visitInfLiteral(self) + else: + return visitor.visitChildren(self) + + def infLiteral(self): + + localctx = GremlinParser.InfLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 596, self.RULE_infLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3561 + _la = self._input.LA(1) + if not (_la == 99 or _la == 253): + 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 UuidLiteralContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def K_UUID(self): + return self.getToken(GremlinParser.K_UUID, 0) + + def LPAREN(self): + return self.getToken(GremlinParser.LPAREN, 0) + + def RPAREN(self): + return self.getToken(GremlinParser.RPAREN, 0) + + def stringLiteral(self): + return self.getTypedRuleContext(GremlinParser.StringLiteralContext, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_uuidLiteral + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUuidLiteral"): + listener.enterUuidLiteral(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUuidLiteral"): + listener.exitUuidLiteral(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUuidLiteral"): + return visitor.visitUuidLiteral(self) + else: + return visitor.visitChildren(self) + + def uuidLiteral(self): + + localctx = GremlinParser.UuidLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 598, self.RULE_uuidLiteral) + try: + self.state = 3571 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input, 210, self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3563 + self.match(GremlinParser.K_UUID) + self.state = 3564 + self.match(GremlinParser.LPAREN) + self.state = 3565 + self.match(GremlinParser.RPAREN) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3566 + self.match(GremlinParser.K_UUID) + self.state = 3567 + self.match(GremlinParser.LPAREN) + self.state = 3568 + self.stringLiteral() + self.state = 3569 + self.match(GremlinParser.RPAREN) + pass + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class NakedKeyContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def Identifier(self): + return self.getToken(GremlinParser.Identifier, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_nakedKey + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNakedKey"): + listener.enterNakedKey(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNakedKey"): + listener.exitNakedKey(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNakedKey"): + return visitor.visitNakedKey(self) + else: + return visitor.visitChildren(self) + + def nakedKey(self): + + localctx = GremlinParser.NakedKeyContext(self, self._ctx, self.state) + self.enterRule(localctx, 600, self.RULE_nakedKey) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3573 + self.match(GremlinParser.Identifier) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class ClassTypeContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def Identifier(self): + return self.getToken(GremlinParser.Identifier, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_classType + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterClassType"): + listener.enterClassType(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitClassType"): + listener.exitClassType(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitClassType"): + return visitor.visitClassType(self) + else: + return visitor.visitChildren(self) + + def classType(self): + + localctx = GremlinParser.ClassTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 602, self.RULE_classType) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3575 + self.match(GremlinParser.Identifier) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class VariableContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def Identifier(self): + return self.getToken(GremlinParser.Identifier, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_variable + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterVariable"): + listener.enterVariable(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitVariable"): + listener.exitVariable(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitVariable"): + return visitor.visitVariable(self) + else: + return visitor.visitChildren(self) + + def variable(self): + + localctx = GremlinParser.VariableContext(self, self._ctx, self.state) + self.enterRule(localctx, 604, self.RULE_variable) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3577 + self.match(GremlinParser.Identifier) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class KeywordContext(ParserRuleContext): + __slots__ = "parser" + + def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1): + super().__init__(parent, invokingState) + self.parser = parser + + def TRAVERSAL_ROOT(self): + return self.getToken(GremlinParser.TRAVERSAL_ROOT, 0) + + def K_ADDALL(self): + return self.getToken(GremlinParser.K_ADDALL, 0) + + def K_ADDE(self): + return self.getToken(GremlinParser.K_ADDE, 0) + + def K_ADDV(self): + return self.getToken(GremlinParser.K_ADDV, 0) + + def K_AGGREGATE(self): + return self.getToken(GremlinParser.K_AGGREGATE, 0) + + def K_ALL(self): + return self.getToken(GremlinParser.K_ALL, 0) + + def K_AND(self): + return self.getToken(GremlinParser.K_AND, 0) + + def K_ANY(self): + return self.getToken(GremlinParser.K_ANY, 0) + + def K_AS(self): + return self.getToken(GremlinParser.K_AS, 0) + + def K_ASC(self): + return self.getToken(GremlinParser.K_ASC, 0) + + def K_ASDATE(self): + return self.getToken(GremlinParser.K_ASDATE, 0) + + def K_ASSTRING(self): + return self.getToken(GremlinParser.K_ASSTRING, 0) + + def K_ASSIGN(self): + return self.getToken(GremlinParser.K_ASSIGN, 0) + + def K_BARRIER(self): + return self.getToken(GremlinParser.K_BARRIER, 0) + + def K_BARRIERU(self): + return self.getToken(GremlinParser.K_BARRIERU, 0) + + def K_BEGIN(self): + return self.getToken(GremlinParser.K_BEGIN, 0) + + def K_BETWEEN(self): + return self.getToken(GremlinParser.K_BETWEEN, 0) + + def K_BOTH(self): + return self.getToken(GremlinParser.K_BOTH, 0) + + def K_BOTHU(self): + return self.getToken(GremlinParser.K_BOTHU, 0) + + def K_BOTHE(self): + return self.getToken(GremlinParser.K_BOTHE, 0) + + def K_BOTHV(self): + return self.getToken(GremlinParser.K_BOTHV, 0) + + def K_BRANCH(self): + return self.getToken(GremlinParser.K_BRANCH, 0) + + def K_BY(self): + return self.getToken(GremlinParser.K_BY, 0) + + def K_CALL(self): + return self.getToken(GremlinParser.K_CALL, 0) + + def K_CAP(self): + return self.getToken(GremlinParser.K_CAP, 0) + + def K_CARDINALITY(self): + return self.getToken(GremlinParser.K_CARDINALITY, 0) + + def K_CHOOSE(self): + return self.getToken(GremlinParser.K_CHOOSE, 0) + + def K_COALESCE(self): + return self.getToken(GremlinParser.K_COALESCE, 0) + + def K_COIN(self): + return self.getToken(GremlinParser.K_COIN, 0) + + def K_COLUMN(self): + return self.getToken(GremlinParser.K_COLUMN, 0) + + def K_COMBINE(self): + return self.getToken(GremlinParser.K_COMBINE, 0) + + def K_CONCAT(self): + return self.getToken(GremlinParser.K_CONCAT, 0) + + def K_COMMIT(self): + return self.getToken(GremlinParser.K_COMMIT, 0) + + def K_COMPONENT(self): + return self.getToken(GremlinParser.K_COMPONENT, 0) + + def K_CONJOIN(self): + return self.getToken(GremlinParser.K_CONJOIN, 0) + + def K_CONNECTEDCOMPONENT(self): + return self.getToken(GremlinParser.K_CONNECTEDCOMPONENT, 0) + + def K_CONNECTEDCOMPONENTU(self): + return self.getToken(GremlinParser.K_CONNECTEDCOMPONENTU, 0) + + def K_CONSTANT(self): + return self.getToken(GremlinParser.K_CONSTANT, 0) + + def K_CONTAINING(self): + return self.getToken(GremlinParser.K_CONTAINING, 0) + + def K_COUNT(self): + return self.getToken(GremlinParser.K_COUNT, 0) + + def K_CYCLICPATH(self): + return self.getToken(GremlinParser.K_CYCLICPATH, 0) + + def K_DAY(self): + return self.getToken(GremlinParser.K_DAY, 0) + + def K_DATEADD(self): + return self.getToken(GremlinParser.K_DATEADD, 0) + + def K_DATEDIFF(self): + return self.getToken(GremlinParser.K_DATEDIFF, 0) + + def K_DATETIME(self): + return self.getToken(GremlinParser.K_DATETIME, 0) + + def K_DATETIMEU(self): + return self.getToken(GremlinParser.K_DATETIMEU, 0) + + def K_DECR(self): + return self.getToken(GremlinParser.K_DECR, 0) + + def K_DEDUP(self): + return self.getToken(GremlinParser.K_DEDUP, 0) + + def K_DESC(self): + return self.getToken(GremlinParser.K_DESC, 0) + + def K_DIFFERENCE(self): + return self.getToken(GremlinParser.K_DIFFERENCE, 0) + + def K_DIRECTION(self): + return self.getToken(GremlinParser.K_DIRECTION, 0) + + def K_DISJUNCT(self): + return self.getToken(GremlinParser.K_DISJUNCT, 0) + + def K_DISTANCE(self): + return self.getToken(GremlinParser.K_DISTANCE, 0) + + def K_DIV(self): + return self.getToken(GremlinParser.K_DIV, 0) + + def K_DROP(self): + return self.getToken(GremlinParser.K_DROP, 0) + + def K_DT(self): + return self.getToken(GremlinParser.K_DT, 0) + + def K_E(self): + return self.getToken(GremlinParser.K_E, 0) + + def K_EDGES(self): + return self.getToken(GremlinParser.K_EDGES, 0) + + def K_ELEMENTMAP(self): + return self.getToken(GremlinParser.K_ELEMENTMAP, 0) + + def K_ELEMENT(self): + return self.getToken(GremlinParser.K_ELEMENT, 0) + + def K_EMIT(self): + return self.getToken(GremlinParser.K_EMIT, 0) + + def K_ENDINGWITH(self): + return self.getToken(GremlinParser.K_ENDINGWITH, 0) + + def K_EQ(self): + return self.getToken(GremlinParser.K_EQ, 0) + + def K_EXPLAIN(self): + return self.getToken(GremlinParser.K_EXPLAIN, 0) + + def K_FAIL(self): + return self.getToken(GremlinParser.K_FAIL, 0) + + def K_FALSE(self): + return self.getToken(GremlinParser.K_FALSE, 0) + + def K_FILTER(self): + return self.getToken(GremlinParser.K_FILTER, 0) + + def K_FIRST(self): + return self.getToken(GremlinParser.K_FIRST, 0) + + def K_FLATMAP(self): + return self.getToken(GremlinParser.K_FLATMAP, 0) + + def K_FOLD(self): + return self.getToken(GremlinParser.K_FOLD, 0) + + def K_FORMAT(self): + return self.getToken(GremlinParser.K_FORMAT, 0) + + def K_FROM(self): + return self.getToken(GremlinParser.K_FROM, 0) + + def K_GLOBAL(self): + return self.getToken(GremlinParser.K_GLOBAL, 0) + + def K_GT(self): + return self.getToken(GremlinParser.K_GT, 0) + + def K_GTE(self): + return self.getToken(GremlinParser.K_GTE, 0) + + def K_GRAPHML(self): + return self.getToken(GremlinParser.K_GRAPHML, 0) + + def K_GRAPHSON(self): + return self.getToken(GremlinParser.K_GRAPHSON, 0) + + def K_GROUP(self): + return self.getToken(GremlinParser.K_GROUP, 0) + + def K_GROUPCOUNT(self): + return self.getToken(GremlinParser.K_GROUPCOUNT, 0) + + def K_GRYO(self): + return self.getToken(GremlinParser.K_GRYO, 0) + + def K_HAS(self): + return self.getToken(GremlinParser.K_HAS, 0) + + def K_HASID(self): + return self.getToken(GremlinParser.K_HASID, 0) + + def K_HASKEY(self): + return self.getToken(GremlinParser.K_HASKEY, 0) + + def K_HASLABEL(self): + return self.getToken(GremlinParser.K_HASLABEL, 0) + + def K_HASNEXT(self): + return self.getToken(GremlinParser.K_HASNEXT, 0) + + def K_HASNOT(self): + return self.getToken(GremlinParser.K_HASNOT, 0) + + def K_HASVALUE(self): + return self.getToken(GremlinParser.K_HASVALUE, 0) + + def K_HOUR(self): + return self.getToken(GremlinParser.K_HOUR, 0) + + def K_ID(self): + return self.getToken(GremlinParser.K_ID, 0) + + def K_IDENTITY(self): + return self.getToken(GremlinParser.K_IDENTITY, 0) + + def K_IDS(self): + return self.getToken(GremlinParser.K_IDS, 0) + + def K_IN(self): + return self.getToken(GremlinParser.K_IN, 0) + + def K_INU(self): + return self.getToken(GremlinParser.K_INU, 0) + + def K_INCLUDEEDGES(self): + return self.getToken(GremlinParser.K_INCLUDEEDGES, 0) + + def K_INCR(self): + return self.getToken(GremlinParser.K_INCR, 0) + + def K_INDEXER(self): + return self.getToken(GremlinParser.K_INDEXER, 0) + + def K_INE(self): + return self.getToken(GremlinParser.K_INE, 0) + + def K_INDEX(self): + return self.getToken(GremlinParser.K_INDEX, 0) + + def K_INFINITY(self): + return self.getToken(GremlinParser.K_INFINITY, 0) + + def K_INJECT(self): + return self.getToken(GremlinParser.K_INJECT, 0) + + def K_INSIDE(self): + return self.getToken(GremlinParser.K_INSIDE, 0) + + def K_INTERSECT(self): + return self.getToken(GremlinParser.K_INTERSECT, 0) + + def K_INV(self): + return self.getToken(GremlinParser.K_INV, 0) + + def K_IO(self): + return self.getToken(GremlinParser.K_IO, 0) + + def K_IOU(self): + return self.getToken(GremlinParser.K_IOU, 0) + + def K_IS(self): + return self.getToken(GremlinParser.K_IS, 0) + + def K_ITERATE(self): + return self.getToken(GremlinParser.K_ITERATE, 0) + + def K_KEY(self): + return self.getToken(GremlinParser.K_KEY, 0) + + def K_KEYS(self): + return self.getToken(GremlinParser.K_KEYS, 0) + + def K_LABELS(self): + return self.getToken(GremlinParser.K_LABELS, 0) + + def K_LABEL(self): + return self.getToken(GremlinParser.K_LABEL, 0) + + def K_LAST(self): + return self.getToken(GremlinParser.K_LAST, 0) + + def K_LENGTH(self): + return self.getToken(GremlinParser.K_LENGTH, 0) + + def K_LIMIT(self): + return self.getToken(GremlinParser.K_LIMIT, 0) + + def K_LIST(self): + return self.getToken(GremlinParser.K_LIST, 0) + + def K_LOCAL(self): + return self.getToken(GremlinParser.K_LOCAL, 0) + + def K_LOOPS(self): + return self.getToken(GremlinParser.K_LOOPS, 0) + + def K_LT(self): + return self.getToken(GremlinParser.K_LT, 0) + + def K_LTE(self): + return self.getToken(GremlinParser.K_LTE, 0) + + def K_LTRIM(self): + return self.getToken(GremlinParser.K_LTRIM, 0) + + def K_MAP(self): + return self.getToken(GremlinParser.K_MAP, 0) + + def K_MATCH(self): + return self.getToken(GremlinParser.K_MATCH, 0) + + def K_MATH(self): + return self.getToken(GremlinParser.K_MATH, 0) + + def K_MAX(self): + return self.getToken(GremlinParser.K_MAX, 0) + + def K_MAXDISTANCE(self): + return self.getToken(GremlinParser.K_MAXDISTANCE, 0) + + def K_MEAN(self): + return self.getToken(GremlinParser.K_MEAN, 0) + + def K_MERGE(self): + return self.getToken(GremlinParser.K_MERGE, 0) + + def K_MERGEU(self): + return self.getToken(GremlinParser.K_MERGEU, 0) + + def K_MERGEE(self): + return self.getToken(GremlinParser.K_MERGEE, 0) + + def K_MERGEV(self): + return self.getToken(GremlinParser.K_MERGEV, 0) + + def K_MIN(self): + return self.getToken(GremlinParser.K_MIN, 0) + + def K_MINUTE(self): + return self.getToken(GremlinParser.K_MINUTE, 0) + + def K_MINUS(self): + return self.getToken(GremlinParser.K_MINUS, 0) + + def K_MIXED(self): + return self.getToken(GremlinParser.K_MIXED, 0) + + def K_MULT(self): + return self.getToken(GremlinParser.K_MULT, 0) + + def K_NAN(self): + return self.getToken(GremlinParser.K_NAN, 0) + + def K_NEGATE(self): + return self.getToken(GremlinParser.K_NEGATE, 0) + + def K_NEW(self): + return self.getToken(GremlinParser.K_NEW, 0) + + def K_NONE(self): + return self.getToken(GremlinParser.K_NONE, 0) + + def K_NOTCONTAINING(self): + return self.getToken(GremlinParser.K_NOTCONTAINING, 0) + + def K_NOTENDINGWITH(self): + return self.getToken(GremlinParser.K_NOTENDINGWITH, 0) + + def K_NOTREGEX(self): + return self.getToken(GremlinParser.K_NOTREGEX, 0) + + def K_NOTSTARTINGWITH(self): + return self.getToken(GremlinParser.K_NOTSTARTINGWITH, 0) + + def K_NOT(self): + return self.getToken(GremlinParser.K_NOT, 0) + + def K_NEQ(self): + return self.getToken(GremlinParser.K_NEQ, 0) + + def K_NEXT(self): + return self.getToken(GremlinParser.K_NEXT, 0) + + def K_NULL(self): + return self.getToken(GremlinParser.K_NULL, 0) + + def K_NORMSACK(self): + return self.getToken(GremlinParser.K_NORMSACK, 0) + + def K_ONCREATE(self): + return self.getToken(GremlinParser.K_ONCREATE, 0) + + def K_ONMATCH(self): + return self.getToken(GremlinParser.K_ONMATCH, 0) + + def K_OPERATOR(self): + return self.getToken(GremlinParser.K_OPERATOR, 0) + + def K_OPTION(self): + return self.getToken(GremlinParser.K_OPTION, 0) + + def K_OPTIONAL(self): + return self.getToken(GremlinParser.K_OPTIONAL, 0) + + def K_ORDER(self): + return self.getToken(GremlinParser.K_ORDER, 0) + + def K_ORDERU(self): + return self.getToken(GremlinParser.K_ORDERU, 0) + + def K_OR(self): + return self.getToken(GremlinParser.K_OR, 0) + + def K_OTHERV(self): + return self.getToken(GremlinParser.K_OTHERV, 0) + + def K_OUT(self): + return self.getToken(GremlinParser.K_OUT, 0) + + def K_OUTU(self): + return self.getToken(GremlinParser.K_OUTU, 0) + + def K_OUTE(self): + return self.getToken(GremlinParser.K_OUTE, 0) + + def K_OUTSIDE(self): + return self.getToken(GremlinParser.K_OUTSIDE, 0) + + def K_OUTV(self): + return self.getToken(GremlinParser.K_OUTV, 0) + + def K_P(self): + return self.getToken(GremlinParser.K_P, 0) + + def K_PAGERANK(self): + return self.getToken(GremlinParser.K_PAGERANK, 0) + + def K_PAGERANKU(self): + return self.getToken(GremlinParser.K_PAGERANKU, 0) + + def K_PATH(self): + return self.getToken(GremlinParser.K_PATH, 0) + + def K_PEERPRESSURE(self): + return self.getToken(GremlinParser.K_PEERPRESSURE, 0) + + def K_PEERPRESSUREU(self): + return self.getToken(GremlinParser.K_PEERPRESSUREU, 0) + + def K_PICK(self): + return self.getToken(GremlinParser.K_PICK, 0) + + def K_POP(self): + return self.getToken(GremlinParser.K_POP, 0) + + def K_PROFILE(self): + return self.getToken(GremlinParser.K_PROFILE, 0) + + def K_PROJECT(self): + return self.getToken(GremlinParser.K_PROJECT, 0) + + def K_PROPERTIES(self): + return self.getToken(GremlinParser.K_PROPERTIES, 0) + + def K_PROPERTYMAP(self): + return self.getToken(GremlinParser.K_PROPERTYMAP, 0) + + def K_PROPERTYNAME(self): + return self.getToken(GremlinParser.K_PROPERTYNAME, 0) + + def K_PROPERTY(self): + return self.getToken(GremlinParser.K_PROPERTY, 0) + + def K_PRODUCT(self): + return self.getToken(GremlinParser.K_PRODUCT, 0) + + def K_RANGE(self): + return self.getToken(GremlinParser.K_RANGE, 0) + + def K_READ(self): + return self.getToken(GremlinParser.K_READ, 0) + + def K_READER(self): + return self.getToken(GremlinParser.K_READER, 0) + + def K_REFERENCEVERTEX(self): + return self.getToken(GremlinParser.K_REFERENCEVERTEX, 0) + + def K_REGEX(self): + return self.getToken(GremlinParser.K_REGEX, 0) + + def K_REPLACE(self): + return self.getToken(GremlinParser.K_REPLACE, 0) + + def K_REPEAT(self): + return self.getToken(GremlinParser.K_REPEAT, 0) + + def K_REVERSE(self): + return self.getToken(GremlinParser.K_REVERSE, 0) + + def K_ROLLBACK(self): + return self.getToken(GremlinParser.K_ROLLBACK, 0) + + def K_RTRIM(self): + return self.getToken(GremlinParser.K_RTRIM, 0) + + def K_SACK(self): + return self.getToken(GremlinParser.K_SACK, 0) + + def K_SAMPLE(self): + return self.getToken(GremlinParser.K_SAMPLE, 0) + + def K_SCOPE(self): + return self.getToken(GremlinParser.K_SCOPE, 0) + + def K_SECOND(self): + return self.getToken(GremlinParser.K_SECOND, 0) + + def K_SELECT(self): + return self.getToken(GremlinParser.K_SELECT, 0) + + def K_SET(self): + return self.getToken(GremlinParser.K_SET, 0) + + def K_SHORTESTPATH(self): + return self.getToken(GremlinParser.K_SHORTESTPATH, 0) + + def K_SHORTESTPATHU(self): + return self.getToken(GremlinParser.K_SHORTESTPATHU, 0) + + def K_SHUFFLE(self): + return self.getToken(GremlinParser.K_SHUFFLE, 0) + + def K_SIDEEFFECT(self): + return self.getToken(GremlinParser.K_SIDEEFFECT, 0) + + def K_SIMPLEPATH(self): + return self.getToken(GremlinParser.K_SIMPLEPATH, 0) + + def K_SINGLE(self): + return self.getToken(GremlinParser.K_SINGLE, 0) + + def K_SKIP(self): + return self.getToken(GremlinParser.K_SKIP, 0) + + def K_SPLIT(self): + return self.getToken(GremlinParser.K_SPLIT, 0) + + def K_STARTINGWITH(self): + return self.getToken(GremlinParser.K_STARTINGWITH, 0) + + def K_STORE(self): + return self.getToken(GremlinParser.K_STORE, 0) + + def K_SUBGRAPH(self): + return self.getToken(GremlinParser.K_SUBGRAPH, 0) + + def K_SUBSTRING(self): + return self.getToken(GremlinParser.K_SUBSTRING, 0) + + def K_SUM(self): + return self.getToken(GremlinParser.K_SUM, 0) + + def K_SUMLONG(self): + return self.getToken(GremlinParser.K_SUMLONG, 0) + + def K_T(self): + return self.getToken(GremlinParser.K_T, 0) + + def K_TAIL(self): + return self.getToken(GremlinParser.K_TAIL, 0) + + def K_TARGET(self): + return self.getToken(GremlinParser.K_TARGET, 0) + + def K_TEXTP(self): + return self.getToken(GremlinParser.K_TEXTP, 0) + + def K_TIMELIMIT(self): + return self.getToken(GremlinParser.K_TIMELIMIT, 0) + + def K_TIMES(self): + return self.getToken(GremlinParser.K_TIMES, 0) + + def K_TO(self): + return self.getToken(GremlinParser.K_TO, 0) + + def K_TOBULKSET(self): + return self.getToken(GremlinParser.K_TOBULKSET, 0) + + def K_TOKENS(self): + return self.getToken(GremlinParser.K_TOKENS, 0) + + def K_TOLIST(self): + return self.getToken(GremlinParser.K_TOLIST, 0) + + def K_TOLOWER(self): + return self.getToken(GremlinParser.K_TOLOWER, 0) + + def K_TOSET(self): + return self.getToken(GremlinParser.K_TOSET, 0) + + def K_TOSTRING(self): + return self.getToken(GremlinParser.K_TOSTRING, 0) + + def K_TOUPPER(self): + return self.getToken(GremlinParser.K_TOUPPER, 0) + + def K_TOE(self): + return self.getToken(GremlinParser.K_TOE, 0) + + def K_TOV(self): + return self.getToken(GremlinParser.K_TOV, 0) + + def K_TREE(self): + return self.getToken(GremlinParser.K_TREE, 0) + + def K_TRIM(self): + return self.getToken(GremlinParser.K_TRIM, 0) + + def K_TRUE(self): + return self.getToken(GremlinParser.K_TRUE, 0) + + def K_TRYNEXT(self): + return self.getToken(GremlinParser.K_TRYNEXT, 0) + + def K_TX(self): + return self.getToken(GremlinParser.K_TX, 0) + + def K_UNFOLD(self): + return self.getToken(GremlinParser.K_UNFOLD, 0) + + def K_UNION(self): + return self.getToken(GremlinParser.K_UNION, 0) + + def K_UNTIL(self): + return self.getToken(GremlinParser.K_UNTIL, 0) + + def K_UUID(self): + return self.getToken(GremlinParser.K_UUID, 0) + + def K_V(self): + return self.getToken(GremlinParser.K_V, 0) + + def K_VALUEMAP(self): + return self.getToken(GremlinParser.K_VALUEMAP, 0) + + def K_VALUES(self): + return self.getToken(GremlinParser.K_VALUES, 0) + + def K_VALUE(self): + return self.getToken(GremlinParser.K_VALUE, 0) + + def K_VERTEX(self): + return self.getToken(GremlinParser.K_VERTEX, 0) + + def K_WHERE(self): + return self.getToken(GremlinParser.K_WHERE, 0) + + def K_WITH(self): + return self.getToken(GremlinParser.K_WITH, 0) + + def K_WITHBULK(self): + return self.getToken(GremlinParser.K_WITHBULK, 0) + + def K_WITHIN(self): + return self.getToken(GremlinParser.K_WITHIN, 0) + + def K_WITHOPTOPTIONS(self): + return self.getToken(GremlinParser.K_WITHOPTOPTIONS, 0) + + def K_WITHOUT(self): + return self.getToken(GremlinParser.K_WITHOUT, 0) + + def K_WITHOUTSTRATEGIES(self): + return self.getToken(GremlinParser.K_WITHOUTSTRATEGIES, 0) + + def K_WITHPATH(self): + return self.getToken(GremlinParser.K_WITHPATH, 0) + + def K_WITHSACK(self): + return self.getToken(GremlinParser.K_WITHSACK, 0) + + def K_WITHSIDEEFFECT(self): + return self.getToken(GremlinParser.K_WITHSIDEEFFECT, 0) + + def K_WITHSTRATEGIES(self): + return self.getToken(GremlinParser.K_WITHSTRATEGIES, 0) + + def K_WRITE(self): + return self.getToken(GremlinParser.K_WRITE, 0) + + def K_WRITER(self): + return self.getToken(GremlinParser.K_WRITER, 0) + + def getRuleIndex(self): + return GremlinParser.RULE_keyword + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterKeyword"): + listener.enterKeyword(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitKeyword"): + listener.exitKeyword(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitKeyword"): + return visitor.visitKeyword(self) + else: + return visitor.visitChildren(self) + + def keyword(self): + + localctx = GremlinParser.KeywordContext(self, self._ctx, self.state) + self.enterRule(localctx, 606, self.RULE_keyword) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3579 + _la = self._input.LA(1) + if not ( + (((_la) & ~0x3F) == 0 and ((1 << _la) & -4) != 0) + or (((_la - 64) & ~0x3F) == 0 and ((1 << (_la - 64)) & -1) != 0) + or (((_la - 128) & ~0x3F) == 0 and ((1 << (_la - 128)) & -1) != 0) + or (((_la - 192) & ~0x3F) == 0 and ((1 << (_la - 192)) & 576460752303423487) != 0) + or _la == 266 + ): + 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 + + def sempred(self, localctx: RuleContext, ruleIndex: int, predIndex: int): + if self._predicates == None: + self._predicates = dict() + self._predicates[1] = self.query_sempred + self._predicates[3] = self.traversalSource_sempred + self._predicates[25] = self.chainedTraversal_sempred + self._predicates[182] = self.traversalPredicate_sempred + pred = self._predicates.get(ruleIndex, None) + if pred is None: + raise Exception("No predicate with index:" + str(ruleIndex)) + else: + return pred(localctx, predIndex) + + def query_sempred(self, localctx: QueryContext, predIndex: int): + if predIndex == 0: + return self.precpred(self._ctx, 2) + + def traversalSource_sempred(self, localctx: TraversalSourceContext, predIndex: int): + if predIndex == 1: + return self.precpred(self._ctx, 1) + + def chainedTraversal_sempred(self, localctx: ChainedTraversalContext, predIndex: int): + if predIndex == 2: + return self.precpred(self._ctx, 1) + + def traversalPredicate_sempred(self, localctx: TraversalPredicateContext, predIndex: int): + if predIndex == 3: + return self.precpred(self._ctx, 3) + + if predIndex == 4: + return self.precpred(self._ctx, 2) + + if predIndex == 5: + return self.precpred(self._ctx, 1) diff --git a/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinVisitor.py b/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinVisitor.py new file mode 100644 index 000000000..5b32da305 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/gremlin/GremlinVisitor.py @@ -0,0 +1,1778 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +# Generated from ./Gremlin.g4 by ANTLR 4.13.1 +from antlr4 import * + +if "." in __name__: + from .GremlinParser import GremlinParser +else: + from GremlinParser import GremlinParser + +# This class defines a complete generic visitor for a parse tree produced by GremlinParser. + + +class GremlinVisitor(ParseTreeVisitor): + # Visit a parse tree produced by GremlinParser#queryList. + def visitQueryList(self, ctx: GremlinParser.QueryListContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#query. + def visitQuery(self, ctx: GremlinParser.QueryContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#emptyQuery. + def visitEmptyQuery(self, ctx: GremlinParser.EmptyQueryContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSource. + def visitTraversalSource(self, ctx: GremlinParser.TraversalSourceContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#transactionPart. + def visitTransactionPart(self, ctx: GremlinParser.TransactionPartContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#rootTraversal. + def visitRootTraversal(self, ctx: GremlinParser.RootTraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSelfMethod. + def visitTraversalSourceSelfMethod(self, ctx: GremlinParser.TraversalSourceSelfMethodContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSelfMethod_withBulk. + def visitTraversalSourceSelfMethod_withBulk(self, ctx: GremlinParser.TraversalSourceSelfMethod_withBulkContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSelfMethod_withPath. + def visitTraversalSourceSelfMethod_withPath(self, ctx: GremlinParser.TraversalSourceSelfMethod_withPathContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSelfMethod_withSack. + def visitTraversalSourceSelfMethod_withSack(self, ctx: GremlinParser.TraversalSourceSelfMethod_withSackContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSelfMethod_withSideEffect. + def visitTraversalSourceSelfMethod_withSideEffect( + self, ctx: GremlinParser.TraversalSourceSelfMethod_withSideEffectContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSelfMethod_withStrategies. + def visitTraversalSourceSelfMethod_withStrategies( + self, ctx: GremlinParser.TraversalSourceSelfMethod_withStrategiesContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSelfMethod_withoutStrategies. + def visitTraversalSourceSelfMethod_withoutStrategies( + self, ctx: GremlinParser.TraversalSourceSelfMethod_withoutStrategiesContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSelfMethod_with. + def visitTraversalSourceSelfMethod_with(self, ctx: GremlinParser.TraversalSourceSelfMethod_withContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod. + def visitTraversalSourceSpawnMethod(self, ctx: GremlinParser.TraversalSourceSpawnMethodContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_addE. + def visitTraversalSourceSpawnMethod_addE(self, ctx: GremlinParser.TraversalSourceSpawnMethod_addEContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_addV. + def visitTraversalSourceSpawnMethod_addV(self, ctx: GremlinParser.TraversalSourceSpawnMethod_addVContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_E. + def visitTraversalSourceSpawnMethod_E(self, ctx: GremlinParser.TraversalSourceSpawnMethod_EContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_V. + def visitTraversalSourceSpawnMethod_V(self, ctx: GremlinParser.TraversalSourceSpawnMethod_VContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_inject. + def visitTraversalSourceSpawnMethod_inject(self, ctx: GremlinParser.TraversalSourceSpawnMethod_injectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_io. + def visitTraversalSourceSpawnMethod_io(self, ctx: GremlinParser.TraversalSourceSpawnMethod_ioContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_mergeV_Map. + def visitTraversalSourceSpawnMethod_mergeV_Map( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_mergeV_MapContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_mergeV_Traversal. + def visitTraversalSourceSpawnMethod_mergeV_Traversal( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_mergeV_TraversalContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_mergeE_Map. + def visitTraversalSourceSpawnMethod_mergeE_Map( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_mergeE_MapContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_mergeE_Traversal. + def visitTraversalSourceSpawnMethod_mergeE_Traversal( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_mergeE_TraversalContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_call_empty. + def visitTraversalSourceSpawnMethod_call_empty( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_emptyContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_call_string. + def visitTraversalSourceSpawnMethod_call_string( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_stringContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_call_string_map. + def visitTraversalSourceSpawnMethod_call_string_map( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_string_mapContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_call_string_traversal. + def visitTraversalSourceSpawnMethod_call_string_traversal( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_string_traversalContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_call_string_map_traversal. + def visitTraversalSourceSpawnMethod_call_string_map_traversal( + self, ctx: GremlinParser.TraversalSourceSpawnMethod_call_string_map_traversalContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSourceSpawnMethod_union. + def visitTraversalSourceSpawnMethod_union(self, ctx: GremlinParser.TraversalSourceSpawnMethod_unionContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#chainedTraversal. + def visitChainedTraversal(self, ctx: GremlinParser.ChainedTraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#nestedTraversal. + def visitNestedTraversal(self, ctx: GremlinParser.NestedTraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#terminatedTraversal. + def visitTerminatedTraversal(self, ctx: GremlinParser.TerminatedTraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod. + def visitTraversalMethod(self, ctx: GremlinParser.TraversalMethodContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_V. + def visitTraversalMethod_V(self, ctx: GremlinParser.TraversalMethod_VContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_E. + def visitTraversalMethod_E(self, ctx: GremlinParser.TraversalMethod_EContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_addE_String. + def visitTraversalMethod_addE_String(self, ctx: GremlinParser.TraversalMethod_addE_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_addE_Traversal. + def visitTraversalMethod_addE_Traversal(self, ctx: GremlinParser.TraversalMethod_addE_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_addV_Empty. + def visitTraversalMethod_addV_Empty(self, ctx: GremlinParser.TraversalMethod_addV_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_addV_String. + def visitTraversalMethod_addV_String(self, ctx: GremlinParser.TraversalMethod_addV_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_addV_Traversal. + def visitTraversalMethod_addV_Traversal(self, ctx: GremlinParser.TraversalMethod_addV_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_aggregate_Scope_String. + def visitTraversalMethod_aggregate_Scope_String( + self, ctx: GremlinParser.TraversalMethod_aggregate_Scope_StringContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_aggregate_String. + def visitTraversalMethod_aggregate_String(self, ctx: GremlinParser.TraversalMethod_aggregate_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_all_P. + def visitTraversalMethod_all_P(self, ctx: GremlinParser.TraversalMethod_all_PContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_and. + def visitTraversalMethod_and(self, ctx: GremlinParser.TraversalMethod_andContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_any_P. + def visitTraversalMethod_any_P(self, ctx: GremlinParser.TraversalMethod_any_PContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_as. + def visitTraversalMethod_as(self, ctx: GremlinParser.TraversalMethod_asContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_asDate. + def visitTraversalMethod_asDate(self, ctx: GremlinParser.TraversalMethod_asDateContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_asString_Empty. + def visitTraversalMethod_asString_Empty(self, ctx: GremlinParser.TraversalMethod_asString_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_asString_Scope. + def visitTraversalMethod_asString_Scope(self, ctx: GremlinParser.TraversalMethod_asString_ScopeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_barrier_Consumer. + def visitTraversalMethod_barrier_Consumer(self, ctx: GremlinParser.TraversalMethod_barrier_ConsumerContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_barrier_Empty. + def visitTraversalMethod_barrier_Empty(self, ctx: GremlinParser.TraversalMethod_barrier_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_barrier_int. + def visitTraversalMethod_barrier_int(self, ctx: GremlinParser.TraversalMethod_barrier_intContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_both. + def visitTraversalMethod_both(self, ctx: GremlinParser.TraversalMethod_bothContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_bothE. + def visitTraversalMethod_bothE(self, ctx: GremlinParser.TraversalMethod_bothEContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_bothV. + def visitTraversalMethod_bothV(self, ctx: GremlinParser.TraversalMethod_bothVContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_branch. + def visitTraversalMethod_branch(self, ctx: GremlinParser.TraversalMethod_branchContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_by_Comparator. + def visitTraversalMethod_by_Comparator(self, ctx: GremlinParser.TraversalMethod_by_ComparatorContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_by_Empty. + def visitTraversalMethod_by_Empty(self, ctx: GremlinParser.TraversalMethod_by_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_by_Function. + def visitTraversalMethod_by_Function(self, ctx: GremlinParser.TraversalMethod_by_FunctionContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_by_Function_Comparator. + def visitTraversalMethod_by_Function_Comparator( + self, ctx: GremlinParser.TraversalMethod_by_Function_ComparatorContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_by_Order. + def visitTraversalMethod_by_Order(self, ctx: GremlinParser.TraversalMethod_by_OrderContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_by_String. + def visitTraversalMethod_by_String(self, ctx: GremlinParser.TraversalMethod_by_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_by_String_Comparator. + def visitTraversalMethod_by_String_Comparator(self, ctx: GremlinParser.TraversalMethod_by_String_ComparatorContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_by_T. + def visitTraversalMethod_by_T(self, ctx: GremlinParser.TraversalMethod_by_TContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_by_Traversal. + def visitTraversalMethod_by_Traversal(self, ctx: GremlinParser.TraversalMethod_by_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_by_Traversal_Comparator. + def visitTraversalMethod_by_Traversal_Comparator( + self, ctx: GremlinParser.TraversalMethod_by_Traversal_ComparatorContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_call_string. + def visitTraversalMethod_call_string(self, ctx: GremlinParser.TraversalMethod_call_stringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_call_string_map. + def visitTraversalMethod_call_string_map(self, ctx: GremlinParser.TraversalMethod_call_string_mapContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_call_string_traversal. + def visitTraversalMethod_call_string_traversal( + self, ctx: GremlinParser.TraversalMethod_call_string_traversalContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_call_string_map_traversal. + def visitTraversalMethod_call_string_map_traversal( + self, ctx: GremlinParser.TraversalMethod_call_string_map_traversalContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_cap. + def visitTraversalMethod_cap(self, ctx: GremlinParser.TraversalMethod_capContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_choose_Function. + def visitTraversalMethod_choose_Function(self, ctx: GremlinParser.TraversalMethod_choose_FunctionContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_choose_Predicate_Traversal. + def visitTraversalMethod_choose_Predicate_Traversal( + self, ctx: GremlinParser.TraversalMethod_choose_Predicate_TraversalContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_choose_Predicate_Traversal_Traversal. + def visitTraversalMethod_choose_Predicate_Traversal_Traversal( + self, ctx: GremlinParser.TraversalMethod_choose_Predicate_Traversal_TraversalContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_choose_Traversal. + def visitTraversalMethod_choose_Traversal(self, ctx: GremlinParser.TraversalMethod_choose_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_choose_Traversal_Traversal. + def visitTraversalMethod_choose_Traversal_Traversal( + self, ctx: GremlinParser.TraversalMethod_choose_Traversal_TraversalContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_choose_Traversal_Traversal_Traversal. + def visitTraversalMethod_choose_Traversal_Traversal_Traversal( + self, ctx: GremlinParser.TraversalMethod_choose_Traversal_Traversal_TraversalContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_coalesce. + def visitTraversalMethod_coalesce(self, ctx: GremlinParser.TraversalMethod_coalesceContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_coin. + def visitTraversalMethod_coin(self, ctx: GremlinParser.TraversalMethod_coinContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_combine_Object. + def visitTraversalMethod_combine_Object(self, ctx: GremlinParser.TraversalMethod_combine_ObjectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_concat_Traversal_Traversal. + def visitTraversalMethod_concat_Traversal_Traversal( + self, ctx: GremlinParser.TraversalMethod_concat_Traversal_TraversalContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_concat_String. + def visitTraversalMethod_concat_String(self, ctx: GremlinParser.TraversalMethod_concat_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_conjoin_String. + def visitTraversalMethod_conjoin_String(self, ctx: GremlinParser.TraversalMethod_conjoin_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_connectedComponent. + def visitTraversalMethod_connectedComponent(self, ctx: GremlinParser.TraversalMethod_connectedComponentContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_constant. + def visitTraversalMethod_constant(self, ctx: GremlinParser.TraversalMethod_constantContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_count_Empty. + def visitTraversalMethod_count_Empty(self, ctx: GremlinParser.TraversalMethod_count_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_count_Scope. + def visitTraversalMethod_count_Scope(self, ctx: GremlinParser.TraversalMethod_count_ScopeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_cyclicPath. + def visitTraversalMethod_cyclicPath(self, ctx: GremlinParser.TraversalMethod_cyclicPathContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_dateAdd. + def visitTraversalMethod_dateAdd(self, ctx: GremlinParser.TraversalMethod_dateAddContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_dateDiff_Traversal. + def visitTraversalMethod_dateDiff_Traversal(self, ctx: GremlinParser.TraversalMethod_dateDiff_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_dateDiff_Date. + def visitTraversalMethod_dateDiff_Date(self, ctx: GremlinParser.TraversalMethod_dateDiff_DateContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_dedup_Scope_String. + def visitTraversalMethod_dedup_Scope_String(self, ctx: GremlinParser.TraversalMethod_dedup_Scope_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_dedup_String. + def visitTraversalMethod_dedup_String(self, ctx: GremlinParser.TraversalMethod_dedup_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_difference_Object. + def visitTraversalMethod_difference_Object(self, ctx: GremlinParser.TraversalMethod_difference_ObjectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_discard. + def visitTraversalMethod_discard(self, ctx: GremlinParser.TraversalMethod_discardContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_disjunct_Object. + def visitTraversalMethod_disjunct_Object(self, ctx: GremlinParser.TraversalMethod_disjunct_ObjectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_drop. + def visitTraversalMethod_drop(self, ctx: GremlinParser.TraversalMethod_dropContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_element. + def visitTraversalMethod_element(self, ctx: GremlinParser.TraversalMethod_elementContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_elementMap. + def visitTraversalMethod_elementMap(self, ctx: GremlinParser.TraversalMethod_elementMapContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_emit_Empty. + def visitTraversalMethod_emit_Empty(self, ctx: GremlinParser.TraversalMethod_emit_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_emit_Predicate. + def visitTraversalMethod_emit_Predicate(self, ctx: GremlinParser.TraversalMethod_emit_PredicateContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_emit_Traversal. + def visitTraversalMethod_emit_Traversal(self, ctx: GremlinParser.TraversalMethod_emit_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_fail_Empty. + def visitTraversalMethod_fail_Empty(self, ctx: GremlinParser.TraversalMethod_fail_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_fail_String. + def visitTraversalMethod_fail_String(self, ctx: GremlinParser.TraversalMethod_fail_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_filter_Predicate. + def visitTraversalMethod_filter_Predicate(self, ctx: GremlinParser.TraversalMethod_filter_PredicateContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_filter_Traversal. + def visitTraversalMethod_filter_Traversal(self, ctx: GremlinParser.TraversalMethod_filter_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_flatMap. + def visitTraversalMethod_flatMap(self, ctx: GremlinParser.TraversalMethod_flatMapContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_fold_Empty. + def visitTraversalMethod_fold_Empty(self, ctx: GremlinParser.TraversalMethod_fold_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_fold_Object_BiFunction. + def visitTraversalMethod_fold_Object_BiFunction( + self, ctx: GremlinParser.TraversalMethod_fold_Object_BiFunctionContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_format_String. + def visitTraversalMethod_format_String(self, ctx: GremlinParser.TraversalMethod_format_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_from_String. + def visitTraversalMethod_from_String(self, ctx: GremlinParser.TraversalMethod_from_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_from_Vertex. + def visitTraversalMethod_from_Vertex(self, ctx: GremlinParser.TraversalMethod_from_VertexContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_from_Traversal. + def visitTraversalMethod_from_Traversal(self, ctx: GremlinParser.TraversalMethod_from_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_group_Empty. + def visitTraversalMethod_group_Empty(self, ctx: GremlinParser.TraversalMethod_group_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_group_String. + def visitTraversalMethod_group_String(self, ctx: GremlinParser.TraversalMethod_group_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_groupCount_Empty. + def visitTraversalMethod_groupCount_Empty(self, ctx: GremlinParser.TraversalMethod_groupCount_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_groupCount_String. + def visitTraversalMethod_groupCount_String(self, ctx: GremlinParser.TraversalMethod_groupCount_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_has_String. + def visitTraversalMethod_has_String(self, ctx: GremlinParser.TraversalMethod_has_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_has_String_Object. + def visitTraversalMethod_has_String_Object(self, ctx: GremlinParser.TraversalMethod_has_String_ObjectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_has_String_P. + def visitTraversalMethod_has_String_P(self, ctx: GremlinParser.TraversalMethod_has_String_PContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_has_String_String_Object. + def visitTraversalMethod_has_String_String_Object( + self, ctx: GremlinParser.TraversalMethod_has_String_String_ObjectContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_has_String_String_P. + def visitTraversalMethod_has_String_String_P(self, ctx: GremlinParser.TraversalMethod_has_String_String_PContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_has_String_Traversal. + def visitTraversalMethod_has_String_Traversal(self, ctx: GremlinParser.TraversalMethod_has_String_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_has_T_Object. + def visitTraversalMethod_has_T_Object(self, ctx: GremlinParser.TraversalMethod_has_T_ObjectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_has_T_P. + def visitTraversalMethod_has_T_P(self, ctx: GremlinParser.TraversalMethod_has_T_PContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_has_T_Traversal. + def visitTraversalMethod_has_T_Traversal(self, ctx: GremlinParser.TraversalMethod_has_T_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_hasId_Object_Object. + def visitTraversalMethod_hasId_Object_Object(self, ctx: GremlinParser.TraversalMethod_hasId_Object_ObjectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_hasId_P. + def visitTraversalMethod_hasId_P(self, ctx: GremlinParser.TraversalMethod_hasId_PContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_hasKey_P. + def visitTraversalMethod_hasKey_P(self, ctx: GremlinParser.TraversalMethod_hasKey_PContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_hasKey_String_String. + def visitTraversalMethod_hasKey_String_String(self, ctx: GremlinParser.TraversalMethod_hasKey_String_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_hasLabel_P. + def visitTraversalMethod_hasLabel_P(self, ctx: GremlinParser.TraversalMethod_hasLabel_PContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_hasLabel_String_String. + def visitTraversalMethod_hasLabel_String_String( + self, ctx: GremlinParser.TraversalMethod_hasLabel_String_StringContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_hasNot. + def visitTraversalMethod_hasNot(self, ctx: GremlinParser.TraversalMethod_hasNotContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_hasValue_Object_Object. + def visitTraversalMethod_hasValue_Object_Object( + self, ctx: GremlinParser.TraversalMethod_hasValue_Object_ObjectContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_hasValue_P. + def visitTraversalMethod_hasValue_P(self, ctx: GremlinParser.TraversalMethod_hasValue_PContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_id. + def visitTraversalMethod_id(self, ctx: GremlinParser.TraversalMethod_idContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_identity. + def visitTraversalMethod_identity(self, ctx: GremlinParser.TraversalMethod_identityContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_in. + def visitTraversalMethod_in(self, ctx: GremlinParser.TraversalMethod_inContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_inE. + def visitTraversalMethod_inE(self, ctx: GremlinParser.TraversalMethod_inEContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_intersect_Object. + def visitTraversalMethod_intersect_Object(self, ctx: GremlinParser.TraversalMethod_intersect_ObjectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_inV. + def visitTraversalMethod_inV(self, ctx: GremlinParser.TraversalMethod_inVContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_index. + def visitTraversalMethod_index(self, ctx: GremlinParser.TraversalMethod_indexContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_inject. + def visitTraversalMethod_inject(self, ctx: GremlinParser.TraversalMethod_injectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_is_Object. + def visitTraversalMethod_is_Object(self, ctx: GremlinParser.TraversalMethod_is_ObjectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_is_P. + def visitTraversalMethod_is_P(self, ctx: GremlinParser.TraversalMethod_is_PContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_key. + def visitTraversalMethod_key(self, ctx: GremlinParser.TraversalMethod_keyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_label. + def visitTraversalMethod_label(self, ctx: GremlinParser.TraversalMethod_labelContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_length_Empty. + def visitTraversalMethod_length_Empty(self, ctx: GremlinParser.TraversalMethod_length_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_length_Scope. + def visitTraversalMethod_length_Scope(self, ctx: GremlinParser.TraversalMethod_length_ScopeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_limit_Scope_long. + def visitTraversalMethod_limit_Scope_long(self, ctx: GremlinParser.TraversalMethod_limit_Scope_longContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_limit_long. + def visitTraversalMethod_limit_long(self, ctx: GremlinParser.TraversalMethod_limit_longContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_local. + def visitTraversalMethod_local(self, ctx: GremlinParser.TraversalMethod_localContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_loops_Empty. + def visitTraversalMethod_loops_Empty(self, ctx: GremlinParser.TraversalMethod_loops_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_loops_String. + def visitTraversalMethod_loops_String(self, ctx: GremlinParser.TraversalMethod_loops_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_lTrim_Empty. + def visitTraversalMethod_lTrim_Empty(self, ctx: GremlinParser.TraversalMethod_lTrim_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_lTrim_Scope. + def visitTraversalMethod_lTrim_Scope(self, ctx: GremlinParser.TraversalMethod_lTrim_ScopeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_map. + def visitTraversalMethod_map(self, ctx: GremlinParser.TraversalMethod_mapContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_match. + def visitTraversalMethod_match(self, ctx: GremlinParser.TraversalMethod_matchContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_math. + def visitTraversalMethod_math(self, ctx: GremlinParser.TraversalMethod_mathContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_max_Empty. + def visitTraversalMethod_max_Empty(self, ctx: GremlinParser.TraversalMethod_max_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_max_Scope. + def visitTraversalMethod_max_Scope(self, ctx: GremlinParser.TraversalMethod_max_ScopeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_mean_Empty. + def visitTraversalMethod_mean_Empty(self, ctx: GremlinParser.TraversalMethod_mean_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_mean_Scope. + def visitTraversalMethod_mean_Scope(self, ctx: GremlinParser.TraversalMethod_mean_ScopeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_merge_Object. + def visitTraversalMethod_merge_Object(self, ctx: GremlinParser.TraversalMethod_merge_ObjectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_mergeV_empty. + def visitTraversalMethod_mergeV_empty(self, ctx: GremlinParser.TraversalMethod_mergeV_emptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_mergeV_Map. + def visitTraversalMethod_mergeV_Map(self, ctx: GremlinParser.TraversalMethod_mergeV_MapContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_mergeV_Traversal. + def visitTraversalMethod_mergeV_Traversal(self, ctx: GremlinParser.TraversalMethod_mergeV_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_mergeE_empty. + def visitTraversalMethod_mergeE_empty(self, ctx: GremlinParser.TraversalMethod_mergeE_emptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_mergeE_Map. + def visitTraversalMethod_mergeE_Map(self, ctx: GremlinParser.TraversalMethod_mergeE_MapContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_mergeE_Traversal. + def visitTraversalMethod_mergeE_Traversal(self, ctx: GremlinParser.TraversalMethod_mergeE_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_min_Empty. + def visitTraversalMethod_min_Empty(self, ctx: GremlinParser.TraversalMethod_min_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_min_Scope. + def visitTraversalMethod_min_Scope(self, ctx: GremlinParser.TraversalMethod_min_ScopeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_none_P. + def visitTraversalMethod_none_P(self, ctx: GremlinParser.TraversalMethod_none_PContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_not. + def visitTraversalMethod_not(self, ctx: GremlinParser.TraversalMethod_notContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_option_Predicate_Traversal. + def visitTraversalMethod_option_Predicate_Traversal( + self, ctx: GremlinParser.TraversalMethod_option_Predicate_TraversalContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_option_Merge_Map. + def visitTraversalMethod_option_Merge_Map(self, ctx: GremlinParser.TraversalMethod_option_Merge_MapContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_option_Merge_Map_Cardinality. + def visitTraversalMethod_option_Merge_Map_Cardinality( + self, ctx: GremlinParser.TraversalMethod_option_Merge_Map_CardinalityContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_option_Merge_Traversal. + def visitTraversalMethod_option_Merge_Traversal( + self, ctx: GremlinParser.TraversalMethod_option_Merge_TraversalContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_option_Object_Traversal. + def visitTraversalMethod_option_Object_Traversal( + self, ctx: GremlinParser.TraversalMethod_option_Object_TraversalContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_option_Traversal. + def visitTraversalMethod_option_Traversal(self, ctx: GremlinParser.TraversalMethod_option_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_optional. + def visitTraversalMethod_optional(self, ctx: GremlinParser.TraversalMethod_optionalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_or. + def visitTraversalMethod_or(self, ctx: GremlinParser.TraversalMethod_orContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_order_Empty. + def visitTraversalMethod_order_Empty(self, ctx: GremlinParser.TraversalMethod_order_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_order_Scope. + def visitTraversalMethod_order_Scope(self, ctx: GremlinParser.TraversalMethod_order_ScopeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_otherV. + def visitTraversalMethod_otherV(self, ctx: GremlinParser.TraversalMethod_otherVContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_out. + def visitTraversalMethod_out(self, ctx: GremlinParser.TraversalMethod_outContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_outE. + def visitTraversalMethod_outE(self, ctx: GremlinParser.TraversalMethod_outEContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_outV. + def visitTraversalMethod_outV(self, ctx: GremlinParser.TraversalMethod_outVContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_pageRank_Empty. + def visitTraversalMethod_pageRank_Empty(self, ctx: GremlinParser.TraversalMethod_pageRank_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_pageRank_double. + def visitTraversalMethod_pageRank_double(self, ctx: GremlinParser.TraversalMethod_pageRank_doubleContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_path. + def visitTraversalMethod_path(self, ctx: GremlinParser.TraversalMethod_pathContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_peerPressure. + def visitTraversalMethod_peerPressure(self, ctx: GremlinParser.TraversalMethod_peerPressureContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_product_Object. + def visitTraversalMethod_product_Object(self, ctx: GremlinParser.TraversalMethod_product_ObjectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_profile_Empty. + def visitTraversalMethod_profile_Empty(self, ctx: GremlinParser.TraversalMethod_profile_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_profile_String. + def visitTraversalMethod_profile_String(self, ctx: GremlinParser.TraversalMethod_profile_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_project. + def visitTraversalMethod_project(self, ctx: GremlinParser.TraversalMethod_projectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_properties. + def visitTraversalMethod_properties(self, ctx: GremlinParser.TraversalMethod_propertiesContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_property_Cardinality_Object_Object_Object. + def visitTraversalMethod_property_Cardinality_Object_Object_Object( + self, ctx: GremlinParser.TraversalMethod_property_Cardinality_Object_Object_ObjectContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_property_Cardinality_Object. + def visitTraversalMethod_property_Cardinality_Object( + self, ctx: GremlinParser.TraversalMethod_property_Cardinality_ObjectContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_property_Object_Object_Object. + def visitTraversalMethod_property_Object_Object_Object( + self, ctx: GremlinParser.TraversalMethod_property_Object_Object_ObjectContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_property_Object. + def visitTraversalMethod_property_Object(self, ctx: GremlinParser.TraversalMethod_property_ObjectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_propertyMap. + def visitTraversalMethod_propertyMap(self, ctx: GremlinParser.TraversalMethod_propertyMapContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_range_Scope_long_long. + def visitTraversalMethod_range_Scope_long_long( + self, ctx: GremlinParser.TraversalMethod_range_Scope_long_longContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_range_long_long. + def visitTraversalMethod_range_long_long(self, ctx: GremlinParser.TraversalMethod_range_long_longContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_read. + def visitTraversalMethod_read(self, ctx: GremlinParser.TraversalMethod_readContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_repeat_String_Traversal. + def visitTraversalMethod_repeat_String_Traversal( + self, ctx: GremlinParser.TraversalMethod_repeat_String_TraversalContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_repeat_Traversal. + def visitTraversalMethod_repeat_Traversal(self, ctx: GremlinParser.TraversalMethod_repeat_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_replace_String_String. + def visitTraversalMethod_replace_String_String( + self, ctx: GremlinParser.TraversalMethod_replace_String_StringContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_replace_Scope_String_String. + def visitTraversalMethod_replace_Scope_String_String( + self, ctx: GremlinParser.TraversalMethod_replace_Scope_String_StringContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_reverse_Empty. + def visitTraversalMethod_reverse_Empty(self, ctx: GremlinParser.TraversalMethod_reverse_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_rTrim_Empty. + def visitTraversalMethod_rTrim_Empty(self, ctx: GremlinParser.TraversalMethod_rTrim_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_rTrim_Scope. + def visitTraversalMethod_rTrim_Scope(self, ctx: GremlinParser.TraversalMethod_rTrim_ScopeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_sack_BiFunction. + def visitTraversalMethod_sack_BiFunction(self, ctx: GremlinParser.TraversalMethod_sack_BiFunctionContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_sack_Empty. + def visitTraversalMethod_sack_Empty(self, ctx: GremlinParser.TraversalMethod_sack_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_sample_Scope_int. + def visitTraversalMethod_sample_Scope_int(self, ctx: GremlinParser.TraversalMethod_sample_Scope_intContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_sample_int. + def visitTraversalMethod_sample_int(self, ctx: GremlinParser.TraversalMethod_sample_intContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_select_Column. + def visitTraversalMethod_select_Column(self, ctx: GremlinParser.TraversalMethod_select_ColumnContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_select_Pop_String. + def visitTraversalMethod_select_Pop_String(self, ctx: GremlinParser.TraversalMethod_select_Pop_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_select_Pop_String_String_String. + def visitTraversalMethod_select_Pop_String_String_String( + self, ctx: GremlinParser.TraversalMethod_select_Pop_String_String_StringContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_select_Pop_Traversal. + def visitTraversalMethod_select_Pop_Traversal(self, ctx: GremlinParser.TraversalMethod_select_Pop_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_select_String. + def visitTraversalMethod_select_String(self, ctx: GremlinParser.TraversalMethod_select_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_select_String_String_String. + def visitTraversalMethod_select_String_String_String( + self, ctx: GremlinParser.TraversalMethod_select_String_String_StringContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_select_Traversal. + def visitTraversalMethod_select_Traversal(self, ctx: GremlinParser.TraversalMethod_select_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_shortestPath. + def visitTraversalMethod_shortestPath(self, ctx: GremlinParser.TraversalMethod_shortestPathContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_sideEffect. + def visitTraversalMethod_sideEffect(self, ctx: GremlinParser.TraversalMethod_sideEffectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_simplePath. + def visitTraversalMethod_simplePath(self, ctx: GremlinParser.TraversalMethod_simplePathContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_skip_Scope_long. + def visitTraversalMethod_skip_Scope_long(self, ctx: GremlinParser.TraversalMethod_skip_Scope_longContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_skip_long. + def visitTraversalMethod_skip_long(self, ctx: GremlinParser.TraversalMethod_skip_longContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_split_String. + def visitTraversalMethod_split_String(self, ctx: GremlinParser.TraversalMethod_split_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_split_Scope_String. + def visitTraversalMethod_split_Scope_String(self, ctx: GremlinParser.TraversalMethod_split_Scope_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_store. + def visitTraversalMethod_store(self, ctx: GremlinParser.TraversalMethod_storeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_subgraph. + def visitTraversalMethod_subgraph(self, ctx: GremlinParser.TraversalMethod_subgraphContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_substring_int. + def visitTraversalMethod_substring_int(self, ctx: GremlinParser.TraversalMethod_substring_intContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_substring_Scope_int. + def visitTraversalMethod_substring_Scope_int(self, ctx: GremlinParser.TraversalMethod_substring_Scope_intContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_substring_int_int. + def visitTraversalMethod_substring_int_int(self, ctx: GremlinParser.TraversalMethod_substring_int_intContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_substring_Scope_int_int. + def visitTraversalMethod_substring_Scope_int_int( + self, ctx: GremlinParser.TraversalMethod_substring_Scope_int_intContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_sum_Empty. + def visitTraversalMethod_sum_Empty(self, ctx: GremlinParser.TraversalMethod_sum_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_sum_Scope. + def visitTraversalMethod_sum_Scope(self, ctx: GremlinParser.TraversalMethod_sum_ScopeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_tail_Empty. + def visitTraversalMethod_tail_Empty(self, ctx: GremlinParser.TraversalMethod_tail_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_tail_Scope. + def visitTraversalMethod_tail_Scope(self, ctx: GremlinParser.TraversalMethod_tail_ScopeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_tail_Scope_long. + def visitTraversalMethod_tail_Scope_long(self, ctx: GremlinParser.TraversalMethod_tail_Scope_longContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_tail_long. + def visitTraversalMethod_tail_long(self, ctx: GremlinParser.TraversalMethod_tail_longContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_timeLimit. + def visitTraversalMethod_timeLimit(self, ctx: GremlinParser.TraversalMethod_timeLimitContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_times. + def visitTraversalMethod_times(self, ctx: GremlinParser.TraversalMethod_timesContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_to_Direction_String. + def visitTraversalMethod_to_Direction_String(self, ctx: GremlinParser.TraversalMethod_to_Direction_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_to_String. + def visitTraversalMethod_to_String(self, ctx: GremlinParser.TraversalMethod_to_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_to_Vertex. + def visitTraversalMethod_to_Vertex(self, ctx: GremlinParser.TraversalMethod_to_VertexContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_to_Traversal. + def visitTraversalMethod_to_Traversal(self, ctx: GremlinParser.TraversalMethod_to_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_toE. + def visitTraversalMethod_toE(self, ctx: GremlinParser.TraversalMethod_toEContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_toLower_Empty. + def visitTraversalMethod_toLower_Empty(self, ctx: GremlinParser.TraversalMethod_toLower_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_toLower_Scope. + def visitTraversalMethod_toLower_Scope(self, ctx: GremlinParser.TraversalMethod_toLower_ScopeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_toUpper_Empty. + def visitTraversalMethod_toUpper_Empty(self, ctx: GremlinParser.TraversalMethod_toUpper_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_toUpper_Scope. + def visitTraversalMethod_toUpper_Scope(self, ctx: GremlinParser.TraversalMethod_toUpper_ScopeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_toV. + def visitTraversalMethod_toV(self, ctx: GremlinParser.TraversalMethod_toVContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_tree_Empty. + def visitTraversalMethod_tree_Empty(self, ctx: GremlinParser.TraversalMethod_tree_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_tree_String. + def visitTraversalMethod_tree_String(self, ctx: GremlinParser.TraversalMethod_tree_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_trim_Empty. + def visitTraversalMethod_trim_Empty(self, ctx: GremlinParser.TraversalMethod_trim_EmptyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_trim_Scope. + def visitTraversalMethod_trim_Scope(self, ctx: GremlinParser.TraversalMethod_trim_ScopeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_unfold. + def visitTraversalMethod_unfold(self, ctx: GremlinParser.TraversalMethod_unfoldContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_union. + def visitTraversalMethod_union(self, ctx: GremlinParser.TraversalMethod_unionContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_until_Predicate. + def visitTraversalMethod_until_Predicate(self, ctx: GremlinParser.TraversalMethod_until_PredicateContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_until_Traversal. + def visitTraversalMethod_until_Traversal(self, ctx: GremlinParser.TraversalMethod_until_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_value. + def visitTraversalMethod_value(self, ctx: GremlinParser.TraversalMethod_valueContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_valueMap_String. + def visitTraversalMethod_valueMap_String(self, ctx: GremlinParser.TraversalMethod_valueMap_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_valueMap_boolean_String. + def visitTraversalMethod_valueMap_boolean_String( + self, ctx: GremlinParser.TraversalMethod_valueMap_boolean_StringContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_values. + def visitTraversalMethod_values(self, ctx: GremlinParser.TraversalMethod_valuesContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_where_P. + def visitTraversalMethod_where_P(self, ctx: GremlinParser.TraversalMethod_where_PContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_where_String_P. + def visitTraversalMethod_where_String_P(self, ctx: GremlinParser.TraversalMethod_where_String_PContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_where_Traversal. + def visitTraversalMethod_where_Traversal(self, ctx: GremlinParser.TraversalMethod_where_TraversalContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_with_String. + def visitTraversalMethod_with_String(self, ctx: GremlinParser.TraversalMethod_with_StringContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_with_String_Object. + def visitTraversalMethod_with_String_Object(self, ctx: GremlinParser.TraversalMethod_with_String_ObjectContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMethod_write. + def visitTraversalMethod_write(self, ctx: GremlinParser.TraversalMethod_writeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#structureVertexLiteral. + def visitStructureVertexLiteral(self, ctx: GremlinParser.StructureVertexLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalStrategy. + def visitTraversalStrategy(self, ctx: GremlinParser.TraversalStrategyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#configuration. + def visitConfiguration(self, ctx: GremlinParser.ConfigurationContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalScope. + def visitTraversalScope(self, ctx: GremlinParser.TraversalScopeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalBarrier. + def visitTraversalBarrier(self, ctx: GremlinParser.TraversalBarrierContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalT. + def visitTraversalT(self, ctx: GremlinParser.TraversalTContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalTShort. + def visitTraversalTShort(self, ctx: GremlinParser.TraversalTShortContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalTLong. + def visitTraversalTLong(self, ctx: GremlinParser.TraversalTLongContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalMerge. + def visitTraversalMerge(self, ctx: GremlinParser.TraversalMergeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalOrder. + def visitTraversalOrder(self, ctx: GremlinParser.TraversalOrderContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalDirection. + def visitTraversalDirection(self, ctx: GremlinParser.TraversalDirectionContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalDirectionShort. + def visitTraversalDirectionShort(self, ctx: GremlinParser.TraversalDirectionShortContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalDirectionLong. + def visitTraversalDirectionLong(self, ctx: GremlinParser.TraversalDirectionLongContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalCardinality. + def visitTraversalCardinality(self, ctx: GremlinParser.TraversalCardinalityContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalColumn. + def visitTraversalColumn(self, ctx: GremlinParser.TraversalColumnContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPop. + def visitTraversalPop(self, ctx: GremlinParser.TraversalPopContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalOperator. + def visitTraversalOperator(self, ctx: GremlinParser.TraversalOperatorContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPick. + def visitTraversalPick(self, ctx: GremlinParser.TraversalPickContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalDT. + def visitTraversalDT(self, ctx: GremlinParser.TraversalDTContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate. + def visitTraversalPredicate(self, ctx: GremlinParser.TraversalPredicateContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalTerminalMethod. + def visitTraversalTerminalMethod(self, ctx: GremlinParser.TraversalTerminalMethodContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalSackMethod. + def visitTraversalSackMethod(self, ctx: GremlinParser.TraversalSackMethodContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalComparator. + def visitTraversalComparator(self, ctx: GremlinParser.TraversalComparatorContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalFunction. + def visitTraversalFunction(self, ctx: GremlinParser.TraversalFunctionContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalBiFunction. + def visitTraversalBiFunction(self, ctx: GremlinParser.TraversalBiFunctionContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_eq. + def visitTraversalPredicate_eq(self, ctx: GremlinParser.TraversalPredicate_eqContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_neq. + def visitTraversalPredicate_neq(self, ctx: GremlinParser.TraversalPredicate_neqContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_lt. + def visitTraversalPredicate_lt(self, ctx: GremlinParser.TraversalPredicate_ltContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_lte. + def visitTraversalPredicate_lte(self, ctx: GremlinParser.TraversalPredicate_lteContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_gt. + def visitTraversalPredicate_gt(self, ctx: GremlinParser.TraversalPredicate_gtContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_gte. + def visitTraversalPredicate_gte(self, ctx: GremlinParser.TraversalPredicate_gteContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_inside. + def visitTraversalPredicate_inside(self, ctx: GremlinParser.TraversalPredicate_insideContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_outside. + def visitTraversalPredicate_outside(self, ctx: GremlinParser.TraversalPredicate_outsideContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_between. + def visitTraversalPredicate_between(self, ctx: GremlinParser.TraversalPredicate_betweenContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_within. + def visitTraversalPredicate_within(self, ctx: GremlinParser.TraversalPredicate_withinContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_without. + def visitTraversalPredicate_without(self, ctx: GremlinParser.TraversalPredicate_withoutContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_not. + def visitTraversalPredicate_not(self, ctx: GremlinParser.TraversalPredicate_notContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_containing. + def visitTraversalPredicate_containing(self, ctx: GremlinParser.TraversalPredicate_containingContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_notContaining. + def visitTraversalPredicate_notContaining(self, ctx: GremlinParser.TraversalPredicate_notContainingContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_startingWith. + def visitTraversalPredicate_startingWith(self, ctx: GremlinParser.TraversalPredicate_startingWithContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_notStartingWith. + def visitTraversalPredicate_notStartingWith(self, ctx: GremlinParser.TraversalPredicate_notStartingWithContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_endingWith. + def visitTraversalPredicate_endingWith(self, ctx: GremlinParser.TraversalPredicate_endingWithContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_notEndingWith. + def visitTraversalPredicate_notEndingWith(self, ctx: GremlinParser.TraversalPredicate_notEndingWithContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_regex. + def visitTraversalPredicate_regex(self, ctx: GremlinParser.TraversalPredicate_regexContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalPredicate_notRegex. + def visitTraversalPredicate_notRegex(self, ctx: GremlinParser.TraversalPredicate_notRegexContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalTerminalMethod_explain. + def visitTraversalTerminalMethod_explain(self, ctx: GremlinParser.TraversalTerminalMethod_explainContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalTerminalMethod_hasNext. + def visitTraversalTerminalMethod_hasNext(self, ctx: GremlinParser.TraversalTerminalMethod_hasNextContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalTerminalMethod_iterate. + def visitTraversalTerminalMethod_iterate(self, ctx: GremlinParser.TraversalTerminalMethod_iterateContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalTerminalMethod_tryNext. + def visitTraversalTerminalMethod_tryNext(self, ctx: GremlinParser.TraversalTerminalMethod_tryNextContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalTerminalMethod_next. + def visitTraversalTerminalMethod_next(self, ctx: GremlinParser.TraversalTerminalMethod_nextContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalTerminalMethod_toList. + def visitTraversalTerminalMethod_toList(self, ctx: GremlinParser.TraversalTerminalMethod_toListContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalTerminalMethod_toSet. + def visitTraversalTerminalMethod_toSet(self, ctx: GremlinParser.TraversalTerminalMethod_toSetContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalTerminalMethod_toBulkSet. + def visitTraversalTerminalMethod_toBulkSet(self, ctx: GremlinParser.TraversalTerminalMethod_toBulkSetContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#withOptionKeys. + def visitWithOptionKeys(self, ctx: GremlinParser.WithOptionKeysContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#connectedComponentConstants. + def visitConnectedComponentConstants(self, ctx: GremlinParser.ConnectedComponentConstantsContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#pageRankConstants. + def visitPageRankConstants(self, ctx: GremlinParser.PageRankConstantsContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#peerPressureConstants. + def visitPeerPressureConstants(self, ctx: GremlinParser.PeerPressureConstantsContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#shortestPathConstants. + def visitShortestPathConstants(self, ctx: GremlinParser.ShortestPathConstantsContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#withOptionsValues. + def visitWithOptionsValues(self, ctx: GremlinParser.WithOptionsValuesContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#ioOptionsKeys. + def visitIoOptionsKeys(self, ctx: GremlinParser.IoOptionsKeysContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#ioOptionsValues. + def visitIoOptionsValues(self, ctx: GremlinParser.IoOptionsValuesContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#connectedComponentConstants_component. + def visitConnectedComponentConstants_component( + self, ctx: GremlinParser.ConnectedComponentConstants_componentContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#connectedComponentConstants_edges. + def visitConnectedComponentConstants_edges(self, ctx: GremlinParser.ConnectedComponentConstants_edgesContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#connectedComponentConstants_propertyName. + def visitConnectedComponentConstants_propertyName( + self, ctx: GremlinParser.ConnectedComponentConstants_propertyNameContext + ): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#pageRankConstants_edges. + def visitPageRankConstants_edges(self, ctx: GremlinParser.PageRankConstants_edgesContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#pageRankConstants_times. + def visitPageRankConstants_times(self, ctx: GremlinParser.PageRankConstants_timesContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#pageRankConstants_propertyName. + def visitPageRankConstants_propertyName(self, ctx: GremlinParser.PageRankConstants_propertyNameContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#peerPressureConstants_edges. + def visitPeerPressureConstants_edges(self, ctx: GremlinParser.PeerPressureConstants_edgesContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#peerPressureConstants_times. + def visitPeerPressureConstants_times(self, ctx: GremlinParser.PeerPressureConstants_timesContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#peerPressureConstants_propertyName. + def visitPeerPressureConstants_propertyName(self, ctx: GremlinParser.PeerPressureConstants_propertyNameContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#shortestPathConstants_target. + def visitShortestPathConstants_target(self, ctx: GremlinParser.ShortestPathConstants_targetContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#shortestPathConstants_edges. + def visitShortestPathConstants_edges(self, ctx: GremlinParser.ShortestPathConstants_edgesContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#shortestPathConstants_distance. + def visitShortestPathConstants_distance(self, ctx: GremlinParser.ShortestPathConstants_distanceContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#shortestPathConstants_maxDistance. + def visitShortestPathConstants_maxDistance(self, ctx: GremlinParser.ShortestPathConstants_maxDistanceContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#shortestPathConstants_includeEdges. + def visitShortestPathConstants_includeEdges(self, ctx: GremlinParser.ShortestPathConstants_includeEdgesContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#withOptionsConstants_tokens. + def visitWithOptionsConstants_tokens(self, ctx: GremlinParser.WithOptionsConstants_tokensContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#withOptionsConstants_none. + def visitWithOptionsConstants_none(self, ctx: GremlinParser.WithOptionsConstants_noneContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#withOptionsConstants_ids. + def visitWithOptionsConstants_ids(self, ctx: GremlinParser.WithOptionsConstants_idsContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#withOptionsConstants_labels. + def visitWithOptionsConstants_labels(self, ctx: GremlinParser.WithOptionsConstants_labelsContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#withOptionsConstants_keys. + def visitWithOptionsConstants_keys(self, ctx: GremlinParser.WithOptionsConstants_keysContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#withOptionsConstants_values. + def visitWithOptionsConstants_values(self, ctx: GremlinParser.WithOptionsConstants_valuesContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#withOptionsConstants_all. + def visitWithOptionsConstants_all(self, ctx: GremlinParser.WithOptionsConstants_allContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#withOptionsConstants_indexer. + def visitWithOptionsConstants_indexer(self, ctx: GremlinParser.WithOptionsConstants_indexerContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#withOptionsConstants_list. + def visitWithOptionsConstants_list(self, ctx: GremlinParser.WithOptionsConstants_listContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#withOptionsConstants_map. + def visitWithOptionsConstants_map(self, ctx: GremlinParser.WithOptionsConstants_mapContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#ioOptionsConstants_reader. + def visitIoOptionsConstants_reader(self, ctx: GremlinParser.IoOptionsConstants_readerContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#ioOptionsConstants_writer. + def visitIoOptionsConstants_writer(self, ctx: GremlinParser.IoOptionsConstants_writerContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#ioOptionsConstants_gryo. + def visitIoOptionsConstants_gryo(self, ctx: GremlinParser.IoOptionsConstants_gryoContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#ioOptionsConstants_graphson. + def visitIoOptionsConstants_graphson(self, ctx: GremlinParser.IoOptionsConstants_graphsonContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#ioOptionsConstants_graphml. + def visitIoOptionsConstants_graphml(self, ctx: GremlinParser.IoOptionsConstants_graphmlContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#connectedComponentStringConstant. + def visitConnectedComponentStringConstant(self, ctx: GremlinParser.ConnectedComponentStringConstantContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#pageRankStringConstant. + def visitPageRankStringConstant(self, ctx: GremlinParser.PageRankStringConstantContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#peerPressureStringConstant. + def visitPeerPressureStringConstant(self, ctx: GremlinParser.PeerPressureStringConstantContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#shortestPathStringConstant. + def visitShortestPathStringConstant(self, ctx: GremlinParser.ShortestPathStringConstantContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#withOptionsStringConstant. + def visitWithOptionsStringConstant(self, ctx: GremlinParser.WithOptionsStringConstantContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#ioOptionsStringConstant. + def visitIoOptionsStringConstant(self, ctx: GremlinParser.IoOptionsStringConstantContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#booleanArgument. + def visitBooleanArgument(self, ctx: GremlinParser.BooleanArgumentContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#integerArgument. + def visitIntegerArgument(self, ctx: GremlinParser.IntegerArgumentContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#floatArgument. + def visitFloatArgument(self, ctx: GremlinParser.FloatArgumentContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#stringArgument. + def visitStringArgument(self, ctx: GremlinParser.StringArgumentContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#stringNullableArgument. + def visitStringNullableArgument(self, ctx: GremlinParser.StringNullableArgumentContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#stringNullableArgumentVarargs. + def visitStringNullableArgumentVarargs(self, ctx: GremlinParser.StringNullableArgumentVarargsContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#dateArgument. + def visitDateArgument(self, ctx: GremlinParser.DateArgumentContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#genericArgument. + def visitGenericArgument(self, ctx: GremlinParser.GenericArgumentContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#genericArgumentVarargs. + def visitGenericArgumentVarargs(self, ctx: GremlinParser.GenericArgumentVarargsContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#genericMapArgument. + def visitGenericMapArgument(self, ctx: GremlinParser.GenericMapArgumentContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#genericMapNullableArgument. + def visitGenericMapNullableArgument(self, ctx: GremlinParser.GenericMapNullableArgumentContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#nullableGenericLiteralMap. + def visitNullableGenericLiteralMap(self, ctx: GremlinParser.NullableGenericLiteralMapContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#structureVertexArgument. + def visitStructureVertexArgument(self, ctx: GremlinParser.StructureVertexArgumentContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalStrategyVarargs. + def visitTraversalStrategyVarargs(self, ctx: GremlinParser.TraversalStrategyVarargsContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#traversalStrategyExpr. + def visitTraversalStrategyExpr(self, ctx: GremlinParser.TraversalStrategyExprContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#classTypeList. + def visitClassTypeList(self, ctx: GremlinParser.ClassTypeListContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#classTypeExpr. + def visitClassTypeExpr(self, ctx: GremlinParser.ClassTypeExprContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#nestedTraversalList. + def visitNestedTraversalList(self, ctx: GremlinParser.NestedTraversalListContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#nestedTraversalExpr. + def visitNestedTraversalExpr(self, ctx: GremlinParser.NestedTraversalExprContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#genericCollectionLiteral. + def visitGenericCollectionLiteral(self, ctx: GremlinParser.GenericCollectionLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#genericLiteralVarargs. + def visitGenericLiteralVarargs(self, ctx: GremlinParser.GenericLiteralVarargsContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#genericLiteralExpr. + def visitGenericLiteralExpr(self, ctx: GremlinParser.GenericLiteralExprContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#genericMapNullableLiteral. + def visitGenericMapNullableLiteral(self, ctx: GremlinParser.GenericMapNullableLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#genericRangeLiteral. + def visitGenericRangeLiteral(self, ctx: GremlinParser.GenericRangeLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#genericSetLiteral. + def visitGenericSetLiteral(self, ctx: GremlinParser.GenericSetLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#stringNullableLiteralVarargs. + def visitStringNullableLiteralVarargs(self, ctx: GremlinParser.StringNullableLiteralVarargsContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#genericLiteral. + def visitGenericLiteral(self, ctx: GremlinParser.GenericLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#genericMapLiteral. + def visitGenericMapLiteral(self, ctx: GremlinParser.GenericMapLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#mapKey. + def visitMapKey(self, ctx: GremlinParser.MapKeyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#mapEntry. + def visitMapEntry(self, ctx: GremlinParser.MapEntryContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#stringLiteral. + def visitStringLiteral(self, ctx: GremlinParser.StringLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#stringNullableLiteral. + def visitStringNullableLiteral(self, ctx: GremlinParser.StringNullableLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#integerLiteral. + def visitIntegerLiteral(self, ctx: GremlinParser.IntegerLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#floatLiteral. + def visitFloatLiteral(self, ctx: GremlinParser.FloatLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#numericLiteral. + def visitNumericLiteral(self, ctx: GremlinParser.NumericLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#booleanLiteral. + def visitBooleanLiteral(self, ctx: GremlinParser.BooleanLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#dateLiteral. + def visitDateLiteral(self, ctx: GremlinParser.DateLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#nullLiteral. + def visitNullLiteral(self, ctx: GremlinParser.NullLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#nanLiteral. + def visitNanLiteral(self, ctx: GremlinParser.NanLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#infLiteral. + def visitInfLiteral(self, ctx: GremlinParser.InfLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#uuidLiteral. + def visitUuidLiteral(self, ctx: GremlinParser.UuidLiteralContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#nakedKey. + def visitNakedKey(self, ctx: GremlinParser.NakedKeyContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#classType. + def visitClassType(self, ctx: GremlinParser.ClassTypeContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#variable. + def visitVariable(self, ctx: GremlinParser.VariableContext): + return self.visitChildren(ctx) + + # Visit a parse tree produced by GremlinParser#keyword. + def visitKeyword(self, ctx: GremlinParser.KeywordContext): + return self.visitChildren(ctx) + + +del GremlinParser diff --git a/text2gremlin/AST_Text2Gremlin/base/gremlin/__init__.py b/text2gremlin/AST_Text2Gremlin/base/gremlin/__init__.py new file mode 100644 index 000000000..13a83393a --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/gremlin/__init__.py @@ -0,0 +1,16 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. diff --git a/text2gremlin/AST_Text2Gremlin/base/template/schema_dict.txt b/text2gremlin/AST_Text2Gremlin/base/template/schema_dict.txt new file mode 100644 index 000000000..35e0985e7 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/template/schema_dict.txt @@ -0,0 +1,85 @@ +movie 电影 +id id +title 标题 +tagline 标签 +summary 总结 +poster_image 海报图片 +user 用户 +login 登录用户名 +genre 流派 +name 姓名 名称 名字 名 +person 人 +born 出生年份 +keyword 关键字 +is_friend 是朋友关系 +rate 打分 +duration 持续时间 +rated 评分 评价 打分 +acted_in 参演 +directed 导演 +produce 生产 出版 +write 写 +Person 人 +Company 公司 +Account 账户 +Loan 贷款 +Medium 中间 +isBlocked 是否被 +type 类型 +nickname 昵称 +phoneNumber 电话号码 +email 电子邮箱 邮箱 +freqLogintype 常用账户登录方式 +lastLoginType 上一次登录时间 +acountLavel 账户等级 +createTime 创建时间 +loanAmount 贷款金额 +balance 贷款余额 +usage 贷款用途 +insertrate 利率 +riskLevel 风险等级 +timestamp 时间戳 +amount 数额 金额 +location 地理位置 +ratio 比例 +organization 组织 +relationship 关系 +gender 性别 +birthday 生日 +country 国家 +city 城市 +business 主营业务 +description 描述 +url url +withdraw 取 +signIn 登录 +repay 偿还 付还 +deposit 支付 +apply 应用 +guarantee 担保 +invest 投资 +own 拥有 持有 +plan 计划 +content 内容 +introduce 介绍 +time 时间 +important_events 重要事件 +relation 关系 +person_person 人物关系 人物间关系 +person_plan 人物和计划间的关系 人物和计划的关系 +person_organization 人物和组织间的关系 +organization_plan 组织和计划间的关系 +organization_organization 组织间的关系 +time_time 时间上的关系 时间关系 +birthyear 出生年份 +phone 电话号码 手机号码 +City 城市 +Film 电影 影片 +HAS_CHILD 有孩子 +MARRIED 是婚姻关系 +BORN_IN 出生于 出生在 +weight 重量 +DIRECTED 导演了 +WROTE_MUSIC_FOR 写了音乐给 +ACTED_IN 参演 +charactername 角色名字 扮演的角色名称是 扮演的角色是 出演的角色是 diff --git a/text2gremlin/AST_Text2Gremlin/base/template/syn_dict.txt b/text2gremlin/AST_Text2Gremlin/base/template/syn_dict.txt new file mode 100644 index 000000000..5d4664465 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/base/template/syn_dict.txt @@ -0,0 +1,12 @@ +跳过，去除 +1 一 +3 三 +4 四 +5 五 +6 六 +7 七 +8 八 +9 九 +10 十 +相连 连接 +边 连接关系 diff --git a/text2gremlin/AST_Text2Gremlin/config_example.json b/text2gremlin/AST_Text2Gremlin/config_example.json new file mode 100644 index 000000000..232e06239 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/config_example.json @@ -0,0 +1,32 @@ +{ + "_comment": "Gremlin 查询语料库生成器配置文件", + "db_id": "movie", + "db_schema_path": { + "movie": "./db_data/schema/movie_schema.json" + }, + "data_path": "./db_data/", + "templates_file": "gremlin_templates.csv", + "output_dir": "output", + "schema_dict_path": [ + "./base/template/schema_dict.txt" + ], + "_note": "查询数量由 combination_control_config.json 中的 max_total_combinations 控制", + + "_comment_llm": "LLM 翻译配置（将泛化后的 Gremlin + 简单描述翻译为自然语言问题）", + "llm": { + "base_url": "http://your-llm-server:port/v1", + "api_key": "your-api-key", + "model": "your-model-name", + "temperature": 0.7, + "max_retries": 3, + "max_concurrency": 5, + "save_interval": 50, + "timeout": 40 + }, + + "_comment_migration": "场景迁移配置", + "migration": { + "migration_mode": "same_operation", + "same_operation_sample_count": 3 + } +} diff --git a/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_acted_in.csv b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_acted_in.csv new file mode 100644 index 000000000..72ce8b0a1 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_acted_in.csv @@ -0,0 +1,667 @@ +LABEL=acted_in,SRC_LABEL=person,DST_LABEL=movie +id:INT32:SRC_ID,id:INT32:DST_ID,role:STRING +2,1,Morpheus +2,28,Morpheus +2,68,Morpheus +3,1,Trinity +3,28,Trinity +3,68,Trinity +4,130,Old Salty Dog / Mr. Meeks / Prescient 1 +4,1,Agent Smith +4,28,Agent Smith +4,68,Agent Smith +4,641,Elrond +4,698,Elrond +4,797,Elrond +5,1,Oracle +5,28,Oracle +6,1,Cypher +7,1,Tank +8,1,Mouse +9,1,Dozer +10,1,Neo +10,28,Neo +10,68,Neo +11,1,White Rabbit Girl +12,1,Spoon Boy +29,28,The Architect +29,68,The Architect +30,28,The Merovingian +30,68,The Merovingian +31,28,Persephone +31,68,Persephone +32,28,Twin #2 +33,28,Twin #1 +34,28,Agent Johnson +35,28,Captain Ballard +35,68,Captain Ballard +36,28,The Keymaker +36,68,The Keymaker +37,28,Commander Lock +37,68,Commander Lock +38,28,Seraph +38,68,Seraph +39,28,Councillor West +39,68,Councillor West +40,28,Niobe +40,68,Niobe +41,28,Zee +41,68,Zee +42,28,Soren +43,28,Security Guard #5 +44,28,Maitre D' +45,28,Councillor Dillard +46,28,Link +46,68,Link +47,28,Cas +47,68,Cas +48,28,Kid +49,28,Axel +50,28,Rama-Kandra +50,68,Rama-Kandra +51,28,Councillor Hamann +69,68,Oracle +83,82,Butch Coolidge +84,82,Vincent Vega +85,82,Jules Winfield +85,781,Stacks Edwards +85,1412,Pat Novak +85,2055,Nick Fury +86,82,Wolf +87,82,Mia Wallace +88,82,Lance +89,82,Marsellus Wallace +90,82,Pumpkin +91,82,Honey Bunny +92,82,Fabienne +93,82,Zed +93,2767,Redfoot the Fence +94,82,Jody +95,82,Maynard +96,82,Brett +97,82,Buddy Holly +97,3106,Carl Showalter +98,82,Captain Koons +99,82,Raquel +100,82,Jimmie Dimmick +101,82,Man No. 4 +102,82,Trudi +103,82,Marvin +104,82,Roger +105,82,Dean Martin +106,82,Long Hair Yuppy Scum +107,82,Hit-and-run Witness +109,750,Martini +109,2398,The Lorax (voice) +131,130,Old Salty Dog / Mr. Meeks / Prescient 1 +131,770,Forrest Gump +132,130,Old Salty Dog / Mr. Meeks / Prescient 1 +133,130,Old Salty Dog / Mr. Meeks / Prescient 1 +133,3624,Denis Thatcher +134,130,Madame Horrox / Older Ursula / Yusouf Suleiman / Abbess +135,130,Rev. Giles Horrox / Hotel Heavy / Lloyd Hooks / Denholme Cavendish / Seer Rhee / Kona Chief +136,130,Old Salty Dog / Mr. Meeks / Prescient 1 +137,130,Old Salty Dog / Mr. Meeks / Prescient 1 +138,130,Old Salty Dog / Mr. Meeks / Prescient 1 +139,130,Adam Ewing / Poor Hotel Guest / Megan's Dad / Highlander / Hae-Joo Chang / Adam / Zachry Brother-in-Law +140,130,Cabin Boy / Robert Frobisher / Store Clerk / Georgette / Tribesman +141,130,Talbot / Hotel Manager / Yoona-939 / Rose +142,130,Autua / Lester Rey / Duophsyte +143,130,Old Salty Dog / Mr. Meeks / Prescient 1 +144,130,Mr. Boerhaave / Guard / Leary the Healer +458,457,Andy Dufresne +459,457,Ellis Boyd 'Red' Redding +459,532,Lucius Fox +459,564,Fox +459,1366,Vitruvius (voice) +460,457,Warden Samuel Norton +461,457,Heywood +462,457,Captain Byron T. Hadley +463,457,Tommy +464,457,Bogs Diamond +465,457,Brooks Hatlen +472,471,Don Vito Corleone +473,471,Michael Corleone +473,496,Don Michael Corleone +474,471,Santino 'Sonny' Corleone +474,496,Sonny Corleone +475,471,Pete Clemenza +476,471,Tom Hagen +476,496,Tom Hagen +477,471,Capt. Mark McCluskey +478,471,Emilio Barzini +479,471,Virgil 'Der Türke' Sollozzo +480,471,Kay Adams +480,496,Kay Corleone +481,471,Salvatore "Sally" Tessio +482,471,Connie Corleone Rizzi +482,496,Connie Corleone +483,471,Carlo Rizzi +484,471,Fredo Corleone +484,496,Fredo Corleone +485,471,Jack Woltz +486,471,Carmine Cuneo +487,471,Johnny Fontane +488,471,Apollonia Vitelli-Corleone +489,471,Moe Greene +490,471,Baby in baptism scene +497,496,Vito Corleone +497,781,Jimmy Conway +497,1118,Victor Tellegio +497,3680,Al Capone +498,496,Hyman Roth +499,496,Frankie Pentangeli +500,496,Senator Pat Geary +501,496,Al Neri +502,496,Don Fanucci +503,496,Young Clemenza (as B. Kirby Jr.) +504,496,Genco +504,781,Frankie Carbone +505,496,Deanna Corleone (as Mariana Hill) +506,496,Johnny Ola +507,496,Mrs. Marcia Roth +508,496,F.B.I. Man #1 +508,2055,Security Guard +509,496,Tony Rosato +510,496,Senator #2 +510,3252,FBI Director Hayden Burke +518,517,Tuco +519,517,Blondie +520,517,Sentenza/Angel Eyes +521,517,Alcoholic Union Captain +522,517,Member of Angel Eyes' Gang +523,517,Cpl. Wallace +533,532,Joker +534,532,Rachel Dawes +535,532,Harvey Dent +536,532,Lt. James Gordon +536,564,Commissioner Gordon +536,1412,Norton +537,737,Miles +537,532,Alfred +537,564,Jen +538,737,Robert Fischer +538,532,Scarecrow +538,564,Dr. Jonathan Crane / Scarecrow +539,532,Bruce Wayne +539,564,Bruce Wayne / Batman +539,1118,Irving Rosenfeld +540,532,Engel +541,532,Mayor of Gotham +541,564,The Mayor +542,532,The bank manager +542,1768,John Carlyle +543,532,Lau +544,532,Salvatore Maroni +545,532,Barbara Gordon +546,532,Chechen +547,532,Stephen +548,532,Loeb +565,564,Selina Kyle +566,737,Eames +566,564,Bane +567,737,Arthur +567,564,Blake +568,564,Jen +569,737,Mal +569,564,Miranda +570,564,Young Ra's Al Ghul +571,564,Chanter (voice) +572,564,Prisoner +573,564,Deputy Commissioner Foley +574,564,Young Talia Al Ghul +575,564,Dr. Pavel (as Alon Moni Aboutboul) +576,598,Oskar Schindler +576,564,Ra's Al Ghul +576,1366,Bad Cop/Good cop (voice) +577,564,Mercenary Security #1 +578,564,Daggett +579,564,Captain Jones +580,564,CIA Op +599,598,Itzhak Stern +599,2885,Georges Méliès +600,598,Amon Goeth +601,598,Emilie Schindler +602,598,Helen Hirsch +603,598,Julian Scherner +604,598,Rolf Czurda +605,598,Herman Toffel +606,598,Mr. Nussbaum +616,615,Juror 8 +617,615,Juror 3 +618,615,Juror 10 +619,615,Juror 4 +620,615,Juror 7 +621,615,Juror 1 +622,615,Juror 2 +623,615,Juror 5 +624,615,Juror 6 +625,615,Juror 11 +626,615,Juror 12 +642,641,Frodo Baggins +642,698,Frodo Baggins +642,797,Frodo Baggins +643,641,Gandalf the White +643,698,Gandalf the Grey +643,797,Gandalf the White +644,641,Aragorn +644,698,Aragorn +644,797,Aragorn +645,641,Arwen Evenstar +645,698,Arwen Evenstar +645,797,Arwen Evenstar +646,641,Legolas +646,698,Legolas +646,797,Legolas +647,641,Gimli & Treebeard (Voice) +647,698,Gimli +647,797,Gimli / Voice of Treebeard +648,641,Sam Gamgee +648,698,Samwise 'Sam' Gamgee +648,797,Sam Gamgee +649,641,Peregrin 'Pippin' Took +649,698,Peregrin 'Pippin' Took +649,797,Peregrin 'Pippin' Took +650,641,Meriadoc 'Merry' Brandybuck +650,698,Meriadoc 'Merry' Brandybuck +650,797,Meriadoc 'Merry' Brandybuck +651,641,Théoden King of Rohan +651,797,Théoden +652,641,Gollum +652,698,Gollum +652,797,Gollum +653,641,Éowyn +653,797,Éowyn +654,641,Faramir +654,797,Faramir +654,1097,Dillios +655,641,Éomer +655,797,Éomer +656,641,Denethor +657,641,Bilbo Baggins +657,698,Bilbo Baggins +658,641,Galadriel +658,698,Galadriel +658,797,Galadriel +658,1356,Rose Valland +659,641,Gothmog & Witchking of Angmar +659,698,Lurtz +660,641,King of the Dead +661,641,Rosie Cotton +661,698,Rose 'Rosie' Cotton +662,641,Boromir +662,698,Boromir +662,797,Boromir +663,641,Celeborn +663,698,Celeborn +682,681,The Narrator +683,681,Tyler Durden +683,1693,Bass +684,681,Marla Singer +684,3390,Queen Elizabeth +685,681,Robert 'Bob' Paulson +686,681,Angel Face +686,1596,Rayon +687,681,Richard Chesler +688,681,The Mechanic +689,681,Ricky +699,698,Saruman +699,797,Saruman +699,2885,Monsieur Labisse +700,698,Haldir +700,797,Haldir +711,710,Luke Skywalker +711,805,Luke Skywalker +712,710,Han Solo +712,805,Han Solo +713,710,Princess Leia +713,805,Leia Organa +714,710,Darth Vader +714,805,Darth Vader +715,710,Lando Calrissian +716,710,C-3PO +716,805,C-3PO +716,1366,C-3PO (voice) +717,710,Chewbacca +717,805,Chewbacca +718,710,Darth Vader (Voice) +718,805,Darth Vader (voice) +719,710,R2-D2 +719,805,R2-D2 +720,710,Yoda (Voice) +721,710,Ben 'Obi-wan' Kenobi +721,805,Obi-Wan Kenobi +722,710,Imperial Force General Veers +723,710,Rebel Force Major Derlin +738,737,Cobb +739,737,Saito +740,737,Ariadne +741,737,Browning +742,737,Nash +743,737,Yusuf +744,737,Maurice Fischer +744,2654,William Crowthorn +744,2767,Kobayashi +745,737,Blonde +751,750,Randle Patrick McMurphy +752,750,Nurse Mildred Ratched +753,750,Harding +754,750,Orderly Turkle +755,750,Billy Bibbit +755,797,Gríma Wormtongue +756,750,Taber +757,750,Chief Bromden +758,750,Ellis +759,750,Jim Sefelt +760,750,Fredrickson +771,770,Jenny Curran +771,2498,Wealthow +772,770,Lt. Dan Taylor +773,770,Pvt. Benjamin Buford 'Bubba' Blue +774,770,Mrs. Gump +775,770,Young Forrest Gump +782,781,Henry Hill +783,781,Tommy DeVito +784,781,Karen Hill +785,781,Sonny Bunz +786,781,Frenchy +787,781,Billy Batts +788,781,Sandy +789,781,Spider +790,781,Paul Cicero +798,797,Freda +806,805,Grand Moff Tarkin +807,805,Uncle Owen +808,805,Aunt Beru +809,805,Advisor to Grand Moff Tarkin +810,805,Jek Tono Porkins (Red Six) +811,805,Lt. Shann Childsen +812,805,General Willard +813,805,Red Two (Wedge) (as Dennis Lawson) +814,805,Red Three (Biggs) +815,805,Death Star Trooper (uncredited) +1073,1096,Vivi Delay +1074,1096,Ethan Runner +1074,3680,Eliot Ness +1075,1096,Zoey Renner +1076,1096,Christine Renner +1098,1097,Artemisia +1099,1097,Queen Gorgo +1100,1097,Scylias +1101,1097,Xerxes +1102,1097,Calisto +1103,1097,Ephialtes +1104,1097,Daxos +1105,1097,Aesyklos +1119,1118,Richie DiMaso +1120,1118,Syndey Prosser +1120,1550,Amy +1121,1118,Carmine Polito +1121,2232,Hansel +1121,2055,Clint Barton / Hawkeye +1122,1118,Rosalyn Rosenfeld +1123,1118,Stoddard Thorsen +1124,1118,Pete Musane +1125,1118,Paco Hernandez +1126,1118,Anthony Amado +1127,1118,Dolly Polito +1128,1118,Cosmo Girl +1129,1118,Abbie Abrams +1130,1118,Brenda +1131,1118,Carl Elway +1132,1118,Irv's Sheik Plant +1242,1241,Anna (voice) +1243,1241,Elsa (voice) +1244,1241,Olaf (voice) +1245,1241,Duke (voice) +1246,1241,Pabbie / Grandpa (voice) +1246,3459,Fletcher +1247,1241,Oaken (voice) +1248,1241,Kai (voice) +1249,1241,Gerda +1250,1241,Bishop (voice) +1251,1241,King (voice) +1294,1293,Dr. Ryan Stone +1295,1356,George Stout +1295,1293,Matt Kowalski +1296,1293,Mission Control (voice) +1357,1356,James Rorimer +1357,1768,Max +1358,1356,Richard Campbell +1358,3915,Bob Harris +1359,1356,Walter Garfield +1360,1356,Donald Jeffries +1361,1356,Jean Claude Clermont +1362,1356,Preston Savitz +1363,1356,Sam Epstein +1364,1356,Commander Elya +1367,1366,Wonder Woman (voice) +1367,2055,Agent Maria Hill +1368,1366,Superman (voice) +1369,1366,Green Lantern (voice) +1370,1366,Wyldstyle (voice) +1371,1366,President Business (voice) +1372,1366,Emmet (voice) +1372,1550,Paul +1373,1366,Batman (voice) +1374,1366,Uni-Kitty (voice) +1375,1366,Craggy (voice) +1376,1366,Spaceman Benny (voice) +1377,1366,Wally (voice) +1378,1366,Abraham Lincoln (voice) +1413,1412,RoboCop +1414,1412,Raymond Sellars +1415,1412,Pope +1416,1412,Ellen Murphy +1417,1412,Maddox +1418,1412,Liz Kline +1418,3390,Myrtle Logue +1419,1412,Karen Dean +1420,1412,Kim +1551,1550,Theodore +1552,1550,Samantha (voice) +1552,2055,Natasha Romanoff / Black Widow +1552,3915,Charlotte +1553,1550,Catherine +1554,1550,Blind Date +1555,1550,Isabella +1556,1550,Dr. Johnson +1557,1550,Alien Child +1558,1550,Chat Room Friend #2 +1559,1550,Sexy Kitten +1560,1550,Alan Watts (voice) +1597,1596,Ron Woodroof +1598,1596,Dr. Eve Saks +1599,1596,David Wayne +1600,1596,Tucker +1601,1596,T.J. +1602,1596,Dr. Vass +1603,1596,Dr. Sevard +1694,1693,Solomon Northup +1695,1693,Edwin Epps +1696,1693,Mistress Epps +1697,1693,John Tibeats +1697,3459,Paul Sunday / Eli Sunday +1698,1693,Ford +1699,1693,Armsby +1700,1693,Robert +1701,1693,Freeman +1702,1693,Mistress Harriet Shaw +1703,1693,Hamilton +1704,1693,Judge Turner +1753,1768,Delacourt +1753,3252,Clarice Starling +1754,1768,Kruger +1755,1768,Frey +1756,1768,Julio +1757,1768,Spider +1758,1768,President Patel +1759,1768,Sandro +1760,1768,Young Max +1761,1768,Manuel +1762,1768,(uncredited) +1763,1768,CCB Agent +1764,1768,CCB Agent +1765,1768,Technician +1857,1856,Nod (voice) +1858,1856,Mary Katherine (voice) +1859,1856,Ronin (voice) +1860,1856,Bomba (voice) +1861,1856,Mub (voice) +1862,1856,Queen Tara (voice) +1863,1856,Taxi Driver (voice) +1864,1856,Nim Galuu (voice) +1865,1856,Bufo (voice) +1866,1856,Mandrake (voice) +1867,1856,Pinecone Jinn (voice) +1868,1856,Thistle Jinn (voice) +1936,1935,Grug (voice) +1937,1935,Eep (voice) +1938,1935,Guy (voice) +1939,1935,Ugga (voice) +1939,3753,Harper Lee +1940,1935,Gran (voice) +1941,1935,Thunk (voice) +2009,2008,Mr. Peabody +2010,2008,Sherman +2011,2008,Penny Peterson +2012,2008,Mrs. Grunion +2013,2008,Paula Peterson +2014,2008,Paul Peterson +2015,2008,Principal Purdy +2015,2398,Uncle Ubb (voice) +2016,2008,Mason +2017,2008,wooo +2018,2008,Leonardo Da Vinci +2019,2008,Patty Pearson +2056,2055,Tony Stark / Iron Man +2057,2055,Steve Rogers / Captain America +2058,2055,Bruce Banner / The Hulk +2059,2055,Thor +2060,2055,Loki +2061,2055,Agent Phil Coulson +2061,2767,Dr. Walters +2062,2055,Selvig +2063,2055,Pepper Potts +2064,2055,Jarvis (voice) +2065,2055,World Security Council +2066,2055,Shield Pilot +2067,2055,World Security Council +2068,2055,Old Man in TV Report +2069,2055,Waitress +2070,2055,Georgi Luchkov +2071,2055,Senator Boynton +2072,2055,Young Cop +2233,2232,Gretel +2234,2232,Muriel +2235,2232,Mina +2236,2232,Edward +2237,2232,Berringer +2237,3106,Gaear Grimsrud +2238,2232,Horned Witch +2239,2232,Tall Witch +2240,2232,Red Haired Witch +2241,2232,Candy Witch +2242,2232,Father +2399,2398,Ted (voice) +2400,2398,Audrey (voice) +2401,2398,Once-ler (voice) +2402,2398,Marta (voice) +2403,2398,O'Hare +2404,2398,Grammy Norma (voice) +2405,2398,Ted's Mom (voice) +2406,2398,Once-ler's Mom (voice) +2407,2398,Aunt Grizelda (voice) +2408,2398,Brett / Chet (voice) +2423,2422,Mulan (singing voice) +2424,2422,Mushu (voice) +2425,2422,Shang (voice) +2426,2422,Mulan (voice) +2427,2422,Shan-Yu (voice) +2428,2422,Yao (voice) +2429,2422,Grandmother Fa (voice) +2430,2422,Chi Fu (voice) +2431,2422,The Matchmaker (voice) +2432,2422,The Emperor (voice) +2433,2422,Fa Zhou (voice) +2434,2422,Shang (singing voice) +2435,2422,General Li (voice) +2436,2422,First Ancestor (voice) +2437,2422,Ling (voice) +2438,2422,Khan / Cri-Kee (voice) +2499,2498,Beowulf / Golden Man / Dragon +2499,2885,Uncle Claude +2500,2498,Grendel's Mother +2501,2498,Hrothgar +2501,3252,Dr. Hannibal Lecter +2502,2498,Unferth +2503,2498,Wiglaf +2504,2498,Grendel +2505,2498,Ursula +2506,2498,Garmund +2507,2498,Wulfgar +2508,2498,Old Cain +2509,2498,Eofor +2655,2654,Solomon Kane +2656,2654,Katherine Crowthorn +2657,2654,Father Michael +2658,2654,Josiah Kane +2659,2654,Malachi +2660,2654,Meredith Crowthorn +2661,2654,Edward Crowthorn +2662,2654,Devil's Reaper +2663,2654,Skinhead +2768,2767,Roger 'Verbal' Kint +2769,2767,Michael McManus +2770,2767,Dean Keaton +2771,2767,Fred Fenster +2772,2767,Todd Hockney +2773,2767,Dave Kujan US Customs +2774,2767,Jack Baer FBI +2775,2767,Edie Finneran +2776,2767,Sgt. Jeffrey Jeff Rabin +2777,2767,Dr. Plummer +2778,2767,Smuggler +2886,2885,Hugo Cabret +2887,2885,Isabelle +2888,2885,The Station Inspector +2889,2885,Hugo's Father +2890,2885,Mama Jeanne +2891,2885,Rene Rabard +2892,2885,Lisette +2893,2885,Madame Emilie +2894,2885,Monsieur Frick +3107,3106,Jerry Lundegaard +3108,3106,Marge Gunderson +3109,3106,Wade Gustafson +3110,3106,Norm Gunderson +3111,3106,Shep Proudfoot +3253,3252,Ardelia Mapp +3254,3252,Jack Crawford +3255,3252,Dr. Frederick Chilton +3256,3252,Barney Matthews +3257,3252,Catherine Martin +3258,3252,Jame Gumb +3259,3252,Lamar +3260,3252,Roden +3261,3252,TV Anchor Man +3262,3252,Senator Ruth Martin +3263,3252,Lt. Boyle +3264,3252,SWAT Commander +3265,3252,SWAT Communicator +3266,3252,FBI Agent in Memphis (uncredited) +3391,3390,King George VI +3392,3390,Lionel Logue +3393,3390,King Edward VIII +3394,3390,Winston Churchill +3395,3390,King George V +3396,3390,Archbishop Cosmo Lang +3397,3390,Wallis Simpson +3397,3390,Princess Margaret +3460,3459,Daniel Plainview +3461,3459,Henry +3462,3459,H. B. Ailman +3463,3459,Prescott +3625,3624,Margaret Thatcher +3626,3624,Geoffrey Howe +3627,3624,Young Denis Thatcher diff --git a/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_directed.csv b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_directed.csv new file mode 100644 index 000000000..d0ed2c054 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_directed.csv @@ -0,0 +1,67 @@ +LABEL=directed,SRC_LABEL=person,DST_LABEL=movie +id:INT32:SRC_ID,id:INT32:DST_ID +13,130 +13,1 +13,28 +13,68 +14,130 +14,1 +14,28 +14,68 +100,82 +145,130 +466,457 +490,3915 +491,471 +491,496 +524,517 +549,737 +549,532 +549,564 +607,598 +627,615 +664,641 +664,698 +664,797 +690,681 +724,710 +728,805 +761,750 +776,770 +776,2498 +791,781 +791,2885 +1077,1096 +1107,1097 +1133,1118 +1252,1241 +1254,1241 +1295,1356 +1297,1293 +1379,1366 +1382,1366 +1421,1412 +1557,1550 +1604,1596 +1705,1693 +1766,1768 +1869,1856 +1942,1935 +1943,1935 +2020,2008 +2073,2055 +2243,2232 +2409,2398 +2410,2398 +2439,2422 +2440,2422 +2664,2654 +2779,2767 +3112,3106 +3113,3106 +3267,3252 +3398,3390 +3464,3459 +3630,3624 +3688,3680 +3760,3753 diff --git a/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_has_genre.csv b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_has_genre.csv new file mode 100644 index 000000000..db6393613 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_has_genre.csv @@ -0,0 +1,154 @@ +LABEL=has_genre,SRC_LABEL=movie,DST_LABEL=genre +id:INT32:SRC_ID,id:INT32:DST_ID +1,16 +1,17 +1,18 +1,19 +28,16 +28,17 +28,18 +28,19 +68,16 +68,17 +68,18 +68,19 +82,19 +82,110 +130,146 +130,18 +457,146 +457,110 +471,146 +471,110 +496,146 +496,110 +517,526 +532,146 +532,16 +532,19 +532,110 +564,146 +564,16 +564,19 +564,110 +598,146 +598,610 +598,611 +615,146 +641,16 +641,17 +641,669 +681,146 +681,16 +681,19 +698,16 +698,17 +698,669 +710,16 +710,17 +710,18 +737,16 +737,17 +737,18 +737,19 +737,746 +750,146 +770,146 +770,779 +770,780 +781,146 +781,16 +781,110 +797,16 +797,17 +797,669 +805,16 +805,17 +805,18 +1096,146 +1096,16 +1096,19 +1096,110 +1097,146 +1097,16 +1097,611 +1118,146 +1118,110 +1241,17 +1241,1256 +1241,1257 +1241,1258 +1293,146 +1293,18 +1293,19 +1356,146 +1356,16 +1356,610 +1356,611 +1366,16 +1366,779 +1366,1256 +1412,16 +1412,18 +1412,110 +1550,146 +1550,18 +1550,779 +1550,780 +1596,146 +1596,610 +1693,146 +1693,610 +1768,146 +1768,16 +1768,18 +1768,19 +1856,17 +1856,669 +1856,1256 +1856,1258 +1935,779 +1935,1256 +1935,1258 +2008,17 +2008,1256 +2008,1258 +2055,16 +2232,16 +2232,669 +2232,2246 +2398,1256 +2398,1258 +2422,17 +2422,1256 +2422,1257 +2422,1258 +2498,16 +2498,17 +2498,1256 +2654,16 +2654,17 +2654,18 +2654,669 +2767,19 +2767,110 +2767,746 +2885,146 +2885,17 +2885,1258 +3106,146 +3106,110 +3106,779 +3252,146 +3252,19 +3252,110 +3252,3270 +3390,610 +3459,146 +3624,610 +3680,146 +3680,19 +3680,110 +3680,610 +3753,146 +3915,146 diff --git a/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_has_keyword.csv b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_has_keyword.csv new file mode 100644 index 000000000..e48a54b63 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_has_keyword.csv @@ -0,0 +1,5120 @@ +LABEL=has_keyword,SRC_LABEL=movie,DST_LABEL=keyword +id:INT32:SRC_ID,id:INT32:DST_ID +1,20 +1,21 +1,22 +1,23 +1,24 +1,25 +1,26 +1,27 +28,52 +28,53 +28,54 +28,55 +28,56 +28,57 +28,58 +28,59 +28,60 +28,61 +28,62 +28,63 +28,20 +28,21 +28,22 +28,27 +28,64 +28,65 +28,66 +28,67 +68,52 +68,53 +68,54 +68,55 +68,56 +68,57 +68,58 +68,59 +68,60 +68,62 +68,63 +68,20 +68,21 +68,22 +68,64 +68,67 +68,70 +68,71 +68,72 +68,73 +68,74 +68,75 +68,76 +68,77 +68,78 +68,79 +68,80 +68,81 +82,153 +82,154 +82,159 +82,160 +82,161 +82,162 +82,163 +82,164 +82,165 +82,166 +82,167 +82,168 +82,169 +82,170 +82,171 +82,172 +82,173 +82,174 +82,175 +82,176 +82,177 +82,178 +82,179 +82,180 +82,181 +82,182 +82,183 +82,184 +82,185 +82,186 +82,187 +82,188 +82,189 +82,190 +82,191 +82,192 +82,193 +82,194 +82,195 +82,196 +82,197 +82,198 +82,199 +82,200 +82,201 +82,202 +82,203 +82,204 +82,205 +82,206 +82,207 +82,208 +82,209 +82,210 +82,211 +82,212 +82,213 +82,214 +82,215 +82,216 +82,217 +82,218 +82,219 +82,220 +82,221 +82,222 +82,223 +82,224 +82,225 +82,226 +82,227 +82,228 +82,229 +82,230 +82,231 +82,232 +82,233 +82,234 +82,235 +82,236 +82,237 +82,238 +82,239 +82,240 +82,241 +82,242 +82,243 +82,244 +82,245 +82,246 +82,247 +82,248 +82,249 +82,250 +82,251 +82,252 +82,253 +82,254 +82,255 +82,256 +82,257 +82,258 +82,259 +82,260 +82,261 +82,262 +82,263 +82,264 +82,265 +82,266 +82,267 +82,268 +82,269 +82,270 +82,271 +82,272 +82,273 +82,274 +82,275 +82,276 +82,277 +82,278 +82,279 +82,280 +82,281 +82,282 +82,283 +82,284 +82,285 +82,286 +82,287 +82,111 +82,112 +82,113 +82,114 +82,115 +82,116 +82,117 +82,118 +82,119 +82,120 +82,121 +82,122 +82,123 +82,124 +82,125 +82,126 +82,320 +82,321 +82,322 +82,323 +82,324 +82,325 +82,326 +82,327 +82,328 +82,329 +82,330 +82,331 +82,332 +82,333 +82,334 +82,335 +82,336 +82,337 +82,338 +82,339 +82,340 +82,341 +82,342 +82,343 +82,344 +82,345 +82,346 +82,347 +82,348 +82,349 +82,350 +82,351 +82,352 +82,353 +82,354 +82,355 +82,356 +82,357 +82,358 +82,359 +82,360 +82,361 +82,362 +82,363 +82,364 +82,365 +82,366 +82,367 +82,368 +82,369 +82,370 +82,371 +82,372 +82,373 +82,374 +82,375 +82,376 +82,377 +82,378 +82,379 +82,380 +82,381 +82,382 +82,383 +82,416 +82,417 +82,418 +82,419 +82,420 +82,421 +82,422 +82,423 +82,424 +82,425 +82,426 +82,427 +82,428 +82,429 +82,430 +82,431 +82,432 +82,433 +82,434 +82,435 +82,436 +82,437 +82,438 +82,439 +82,440 +82,441 +82,442 +82,443 +82,444 +82,445 +82,446 +82,447 +82,448 +82,449 +82,450 +82,451 +82,452 +82,453 +82,454 +82,455 +82,288 +82,289 +82,290 +82,291 +82,292 +82,293 +82,294 +82,295 +82,296 +82,297 +82,298 +82,299 +82,300 +82,301 +82,302 +82,303 +82,304 +82,305 +82,306 +82,307 +82,308 +82,309 +82,310 +82,311 +82,312 +82,313 +82,314 +82,315 +82,316 +82,317 +82,318 +82,319 +82,384 +82,385 +82,386 +82,387 +82,388 +82,389 +82,390 +82,391 +82,392 +82,393 +82,394 +82,395 +82,396 +82,397 +82,398 +82,399 +82,400 +82,401 +82,402 +82,403 +82,404 +82,405 +82,406 +82,407 +82,408 +82,409 +82,410 +82,411 +82,412 +82,413 +82,414 +82,415 +130,147 +130,148 +130,149 +130,150 +130,151 +130,152 +130,153 +130,154 +130,155 +130,156 +130,157 +130,158 +457,467 +457,468 +457,469 +457,470 +471,159 +471,160 +471,162 +471,179 +471,184 +471,203 +471,211 +471,220 +471,224 +471,244 +471,248 +471,250 +471,251 +471,279 +471,286 +471,114 +471,116 +471,325 +471,334 +471,340 +471,344 +471,349 +471,368 +471,373 +471,380 +471,418 +471,427 +471,468 +471,469 +471,470 +471,493 +471,494 +471,298 +471,300 +471,309 +471,385 +471,401 +471,675 +471,908 +471,909 +471,910 +471,911 +471,912 +471,913 +471,914 +471,915 +471,916 +471,917 +471,918 +471,919 +471,920 +471,921 +471,922 +471,923 +471,924 +471,925 +471,926 +471,927 +471,960 +471,961 +471,962 +471,963 +471,964 +471,965 +471,966 +471,967 +471,968 +471,969 +471,970 +471,971 +471,972 +471,973 +471,974 +471,975 +471,976 +471,977 +471,978 +471,979 +471,980 +471,981 +471,982 +471,983 +471,984 +471,985 +471,986 +471,987 +471,988 +471,989 +471,990 +471,991 +471,928 +471,929 +471,930 +471,931 +471,932 +471,933 +471,934 +471,935 +471,936 +471,937 +471,938 +471,939 +471,940 +471,941 +471,942 +471,943 +471,944 +471,945 +471,946 +471,947 +471,948 +471,949 +471,950 +471,951 +471,952 +471,953 +471,954 +471,955 +471,956 +471,957 +471,958 +471,959 +471,992 +471,993 +471,994 +471,995 +471,996 +471,997 +471,998 +471,999 +471,1000 +471,1001 +471,1002 +471,1003 +471,1004 +471,1005 +471,1006 +471,1007 +471,1008 +471,1009 +471,1010 +471,1011 +471,1012 +471,1013 +471,1014 +471,1015 +471,1016 +471,1017 +471,1018 +471,1019 +471,1020 +471,1021 +471,1022 +471,1023 +471,768 +471,837 +471,839 +471,849 +471,873 +471,891 +471,1056 +471,1057 +471,1058 +471,1059 +471,1060 +471,1061 +471,1062 +471,1063 +471,1064 +471,1065 +471,1066 +471,1067 +471,1068 +471,1069 +471,1070 +471,1071 +471,1024 +471,1025 +471,1026 +471,1027 +471,1028 +471,1029 +471,1030 +471,1031 +471,1032 +471,1033 +471,1034 +471,1035 +471,1036 +471,1037 +471,1038 +471,1039 +471,1040 +471,1041 +471,1042 +471,1043 +471,1044 +471,1045 +471,1046 +471,1047 +471,1048 +471,1049 +471,1050 +471,1051 +471,1052 +471,1053 +471,1054 +471,1055 +496,57 +496,176 +496,184 +496,72 +496,234 +496,250 +496,350 +496,418 +496,511 +496,401 +496,403 +496,637 +496,512 +496,513 +496,514 +496,896 +496,897 +496,898 +496,899 +496,900 +496,901 +496,902 +496,903 +496,904 +496,905 +496,906 +496,830 +496,831 +496,832 +496,833 +496,834 +496,835 +496,836 +496,837 +496,838 +496,839 +496,840 +496,841 +496,842 +496,843 +496,844 +496,845 +496,846 +496,847 +496,848 +496,849 +496,850 +496,851 +496,852 +496,853 +496,854 +496,855 +496,856 +496,857 +496,858 +496,859 +496,860 +496,861 +496,862 +496,863 +496,864 +496,865 +496,866 +496,867 +496,868 +496,869 +496,870 +496,871 +496,872 +496,873 +496,874 +496,875 +496,876 +496,877 +496,878 +496,879 +496,880 +496,881 +496,882 +496,883 +496,884 +496,885 +496,886 +496,887 +496,888 +496,889 +496,890 +496,891 +496,892 +496,893 +496,894 +496,895 +517,356 +517,360 +517,421 +517,527 +517,528 +517,529 +517,530 +517,531 +532,552 +532,553 +532,554 +532,555 +532,556 +532,557 +532,558 +532,559 +532,560 +532,561 +532,562 +532,563 +564,581 +564,582 +564,583 +564,584 +564,585 +564,586 +564,587 +564,588 +564,589 +564,590 +564,591 +564,592 +564,593 +564,594 +564,595 +564,596 +564,597 +564,553 +564,556 +564,557 +564,558 +564,559 +564,561 +564,562 +598,55 +598,612 +598,613 +598,614 +615,629 +615,630 +615,631 +615,632 +615,633 +615,634 +615,635 +615,636 +615,637 +615,638 +615,639 +615,640 +641,426 +641,670 +641,671 +641,672 +641,673 +641,674 +641,675 +641,676 +641,677 +641,678 +641,679 +641,680 +681,314 +681,691 +681,692 +681,693 +681,694 +681,695 +681,696 +681,697 +698,670 +698,671 +698,672 +698,701 +698,702 +698,703 +698,704 +698,705 +698,706 +698,707 +698,708 +698,709 +710,736 +710,729 +710,730 +710,731 +710,732 +710,733 +710,734 +710,735 +737,63 +737,747 +737,748 +737,749 +750,64 +750,765 +750,766 +750,767 +750,696 +750,731 +750,768 +750,769 +770,57 +770,176 +770,184 +770,72 +770,234 +770,250 +770,350 +770,418 +770,401 +770,403 +770,637 +770,896 +770,897 +770,898 +770,899 +770,900 +770,901 +770,902 +770,903 +770,904 +770,905 +770,906 +770,830 +770,831 +770,832 +770,833 +770,834 +770,835 +770,836 +770,837 +770,838 +770,839 +770,840 +770,841 +770,842 +770,843 +770,844 +770,845 +770,846 +770,847 +770,848 +770,849 +770,850 +770,851 +770,852 +770,853 +770,854 +770,855 +770,856 +770,857 +770,858 +770,859 +770,860 +770,861 +770,862 +770,863 +770,864 +770,865 +770,866 +770,867 +770,868 +770,869 +770,870 +770,871 +770,872 +770,873 +770,874 +770,875 +770,876 +770,877 +770,878 +770,879 +770,880 +770,881 +770,882 +770,883 +770,884 +770,885 +770,886 +770,887 +770,888 +770,889 +770,890 +770,891 +770,892 +770,893 +770,894 +770,895 +781,467 +781,794 +781,795 +781,796 +797,66 +797,531 +797,670 +797,671 +797,679 +797,702 +797,799 +797,800 +797,801 +797,802 +797,803 +797,804 +805,730 +805,734 +805,816 +805,817 +805,818 +805,819 +805,820 +805,821 +805,822 +805,823 +805,824 +805,825 +805,826 +805,827 +805,828 +805,829 +1096,168 +1096,177 +1096,917 +1096,935 +1096,1078 +1096,1079 +1096,1080 +1096,1081 +1096,1082 +1096,1083 +1096,1084 +1096,1085 +1096,1086 +1096,1087 +1096,1088 +1096,1089 +1096,1090 +1096,1091 +1096,1092 +1096,1093 +1097,560 +1097,1109 +1097,1110 +1097,1111 +1097,1112 +1097,1113 +1097,1114 +1097,1115 +1097,1116 +1097,1117 +1118,153 +1118,159 +1118,189 +1118,203 +1118,206 +1118,220 +1118,239 +1118,248 +1118,251 +1118,286 +1118,121 +1118,324 +1118,326 +1118,330 +1118,350 +1118,375 +1118,420 +1118,304 +1118,310 +1118,582 +1118,693 +1118,908 +1118,912 +1118,919 +1118,967 +1118,972 +1118,933 +1118,994 +1118,1009 +1118,891 +1118,1184 +1118,1185 +1118,1186 +1118,1187 +1118,1188 +1118,1189 +1118,1190 +1118,1191 +1118,1192 +1118,1193 +1118,1194 +1118,1195 +1118,1196 +1118,1197 +1118,1198 +1118,1199 +1118,1200 +1118,1201 +1118,1202 +1118,1203 +1118,1204 +1118,1205 +1118,1206 +1118,1207 +1118,1208 +1118,1209 +1118,1210 +1118,1211 +1118,1212 +1118,1213 +1118,1214 +1118,1215 +1118,1216 +1118,1217 +1118,1218 +1118,1219 +1118,1220 +1118,1221 +1118,1222 +1118,1223 +1118,1224 +1118,1225 +1118,1226 +1118,1227 +1118,1228 +1118,1229 +1118,1230 +1118,1231 +1118,1232 +1118,1233 +1118,1234 +1118,1235 +1118,1236 +1118,1237 +1118,1238 +1118,1239 +1118,1240 +1118,1135 +1118,1136 +1118,1137 +1118,1138 +1118,1139 +1118,1140 +1118,1141 +1118,1142 +1118,1143 +1118,1144 +1118,1145 +1118,1146 +1118,1147 +1118,1148 +1118,1149 +1118,1150 +1118,1151 +1118,1152 +1118,1153 +1118,1154 +1118,1155 +1118,1156 +1118,1157 +1118,1158 +1118,1159 +1118,1160 +1118,1161 +1118,1162 +1118,1163 +1118,1164 +1118,1165 +1118,1166 +1118,1167 +1118,1168 +1118,1169 +1118,1170 +1118,1171 +1118,1172 +1118,1173 +1118,1174 +1118,1175 +1118,1176 +1118,1177 +1118,1178 +1118,1179 +1118,1180 +1118,1181 +1118,1182 +1118,1183 +1241,24 +1241,368 +1241,678 +1241,945 +1241,1259 +1241,1260 +1241,1261 +1241,1262 +1241,1263 +1241,1264 +1241,1265 +1241,1266 +1241,1267 +1241,1268 +1241,1269 +1241,1270 +1241,1271 +1241,1272 +1241,1273 +1241,1274 +1241,1275 +1241,1276 +1241,1277 +1241,1278 +1241,1279 +1241,1280 +1241,1281 +1241,1282 +1241,1283 +1241,1284 +1241,1285 +1241,1286 +1241,1287 +1241,1288 +1241,1289 +1241,1290 +1241,1291 +1241,1292 +1293,24 +1293,327 +1293,368 +1293,409 +1293,912 +1293,1011 +1293,1017 +1293,852 +1293,1231 +1293,1273 +1293,1148 +1293,1153 +1293,1154 +1293,1160 +1293,1114 +1293,1344 +1293,1345 +1293,1346 +1293,1347 +1293,1348 +1293,1349 +1293,1350 +1293,1351 +1293,1352 +1293,1353 +1293,1354 +1293,1355 +1293,1312 +1293,1313 +1293,1314 +1293,1315 +1293,1316 +1293,1317 +1293,1318 +1293,1319 +1293,1320 +1293,1321 +1293,1322 +1293,1323 +1293,1324 +1293,1325 +1293,1326 +1293,1327 +1293,1328 +1293,1329 +1293,1330 +1293,1331 +1293,1332 +1293,1333 +1293,1334 +1293,1335 +1293,1336 +1293,1337 +1293,1338 +1293,1339 +1293,1340 +1293,1341 +1293,1342 +1293,1343 +1293,1281 +1293,1292 +1293,1300 +1293,1301 +1293,1302 +1293,1303 +1293,1304 +1293,1305 +1293,1306 +1293,1307 +1293,1308 +1293,1309 +1293,1310 +1293,1311 +1356,24 +1356,327 +1356,368 +1356,409 +1356,912 +1356,1011 +1356,1017 +1356,852 +1356,1231 +1356,1273 +1356,1148 +1356,1153 +1356,1154 +1356,1160 +1356,1114 +1356,1344 +1356,1345 +1356,1346 +1356,1347 +1356,1348 +1356,1349 +1356,1350 +1356,1351 +1356,1352 +1356,1353 +1356,1354 +1356,1355 +1356,1312 +1356,1313 +1356,1314 +1356,1315 +1356,1316 +1356,1317 +1356,1318 +1356,1319 +1356,1320 +1356,1321 +1356,1322 +1356,1323 +1356,1324 +1356,1325 +1356,1326 +1356,1327 +1356,1328 +1356,1329 +1356,1330 +1356,1331 +1356,1332 +1356,1333 +1356,1334 +1356,1335 +1356,1336 +1356,1337 +1356,1338 +1356,1339 +1356,1340 +1356,1341 +1356,1342 +1356,1343 +1356,1281 +1356,1292 +1356,1301 +1356,1302 +1356,1303 +1356,1304 +1356,1305 +1356,1306 +1356,1307 +1356,1308 +1356,1309 +1356,1310 +1356,1311 +1366,163 +1366,203 +1366,23 +1366,736 +1366,557 +1366,559 +1366,971 +1366,942 +1366,1017 +1366,1408 +1366,1409 +1366,1410 +1366,1411 +1366,1383 +1366,1384 +1366,1385 +1366,1386 +1366,1387 +1366,1388 +1366,1389 +1366,1390 +1366,1391 +1366,1392 +1366,1393 +1366,1394 +1366,1395 +1366,1396 +1366,1397 +1366,1398 +1366,1399 +1366,1400 +1366,1401 +1366,1402 +1366,1403 +1366,1404 +1366,1405 +1366,1406 +1366,1407 +1366,1306 +1412,159 +1412,63 +1412,160 +1412,177 +1412,189 +1412,203 +1412,204 +1412,211 +1412,217 +1412,21 +1412,224 +1412,233 +1412,251 +1412,252 +1412,255 +1412,270 +1412,286 +1412,324 +1412,340 +1412,350 +1412,356 +1412,362 +1412,438 +1412,470 +1412,299 +1412,309 +1412,316 +1412,385 +1412,613 +1412,582 +1412,556 +1412,562 +1412,906 +1412,910 +1412,967 +1412,972 +1412,986 +1412,931 +1412,933 +1412,938 +1412,942 +1412,945 +1412,1001 +1412,1011 +1412,1012 +1412,1014 +1412,1015 +1412,1017 +1412,799 +1412,843 +1412,870 +1412,876 +1412,1167 +1412,1038 +1412,1043 +1412,1472 +1412,1473 +1412,1474 +1412,1475 +1412,1476 +1412,1477 +1412,1478 +1412,1479 +1412,1480 +1412,1481 +1412,1482 +1412,1483 +1412,1484 +1412,1485 +1412,1486 +1412,1487 +1412,1488 +1412,1489 +1412,1490 +1412,1491 +1412,1492 +1412,1493 +1412,1494 +1412,1495 +1412,1496 +1412,1497 +1412,1498 +1412,1499 +1412,1500 +1412,1501 +1412,1502 +1412,1503 +1412,1347 +1412,1424 +1412,1425 +1412,1426 +1412,1427 +1412,1428 +1412,1429 +1412,1430 +1412,1431 +1412,1432 +1412,1433 +1412,1434 +1412,1435 +1412,1436 +1412,1437 +1412,1438 +1412,1439 +1412,1391 +1412,1401 +1412,1406 +1412,1318 +1412,1339 +1412,1440 +1412,1441 +1412,1442 +1412,1443 +1412,1444 +1412,1445 +1412,1446 +1412,1447 +1412,1448 +1412,1449 +1412,1450 +1412,1451 +1412,1452 +1412,1453 +1412,1454 +1412,1455 +1412,1456 +1412,1457 +1412,1458 +1412,1459 +1412,1460 +1412,1461 +1412,1462 +1412,1463 +1412,1464 +1412,1465 +1412,1466 +1412,1467 +1412,1468 +1412,1469 +1412,1470 +1412,1471 +1412,1504 +1412,1505 +1412,1506 +1412,1507 +1412,1508 +1412,1509 +1412,1510 +1412,1511 +1412,1512 +1412,1513 +1412,1514 +1412,1515 +1412,1516 +1412,1517 +1412,1518 +1412,1519 +1412,1520 +1412,1521 +1412,1522 +1412,1523 +1412,1524 +1412,1525 +1412,1526 +1412,1527 +1412,1528 +1412,1529 +1412,1530 +1412,1531 +1412,1532 +1412,1533 +1412,1534 +1412,1535 +1412,1281 +1412,1536 +1412,1537 +1412,1538 +1412,1539 +1412,1540 +1412,1541 +1412,1542 +1412,1543 +1412,1544 +1412,1545 +1412,1546 +1412,1547 +1412,1548 +1412,1549 +1550,159 +1550,21 +1550,260 +1550,324 +1550,308 +1550,309 +1550,830 +1550,1202 +1550,1231 +1550,1475 +1550,1323 +1550,1451 +1550,1281 +1550,1568 +1550,1569 +1550,1570 +1550,1571 +1550,1572 +1550,1573 +1550,1574 +1550,1575 +1550,1576 +1550,1577 +1550,1578 +1550,1579 +1550,1580 +1550,1581 +1550,1582 +1550,1583 +1550,1584 +1550,1585 +1550,1586 +1550,1587 +1550,1588 +1550,1589 +1550,1590 +1550,1591 +1550,1592 +1550,1593 +1550,1594 +1550,1595 +1550,1561 +1550,1562 +1550,1563 +1550,1564 +1550,1565 +1550,1566 +1550,1567 +1596,159 +1596,203 +1596,247 +1596,265 +1596,332 +1596,344 +1596,312 +1596,631 +1596,898 +1596,985 +1596,929 +1596,942 +1596,1015 +1596,824 +1596,841 +1596,873 +1596,876 +1596,887 +1596,888 +1596,1226 +1596,1141 +1596,1176 +1596,1404 +1596,1449 +1596,1309 +1596,1582 +1596,1595 +1596,1664 +1596,1665 +1596,1666 +1596,1667 +1596,1668 +1596,1669 +1596,1670 +1596,1671 +1596,1672 +1596,1673 +1596,1674 +1596,1675 +1596,1676 +1596,1677 +1596,1678 +1596,1679 +1596,1680 +1596,1681 +1596,1682 +1596,1683 +1596,1684 +1596,1685 +1596,1686 +1596,1687 +1596,1688 +1596,1689 +1596,1690 +1596,1691 +1596,1692 +1596,1607 +1596,1608 +1596,1609 +1596,1610 +1596,1611 +1596,1612 +1596,1613 +1596,1614 +1596,1615 +1596,1616 +1596,1617 +1596,1618 +1596,1619 +1596,1620 +1596,1621 +1596,1622 +1596,1623 +1596,1624 +1596,1625 +1596,1626 +1596,1627 +1596,1628 +1596,1629 +1596,1630 +1596,1631 +1596,1632 +1596,1633 +1596,1634 +1596,1635 +1596,1636 +1596,1637 +1596,1638 +1596,1639 +1596,1640 +1596,1641 +1596,1642 +1596,1643 +1596,1644 +1596,1645 +1596,1646 +1596,1647 +1596,1648 +1596,1649 +1596,1650 +1596,1651 +1596,1652 +1596,1653 +1596,1654 +1596,1655 +1596,1656 +1596,1657 +1596,1658 +1596,1659 +1596,1660 +1596,1661 +1596,1662 +1596,1663 +1693,227 +1693,332 +1693,349 +1693,973 +1693,870 +1693,887 +1693,1226 +1693,1707 +1693,1708 +1693,1709 +1693,1710 +1693,1711 +1693,1712 +1693,1713 +1693,1714 +1693,1715 +1693,1716 +1693,1717 +1693,1718 +1693,1719 +1693,1720 +1693,1721 +1693,1722 +1693,1723 +1693,1724 +1693,1725 +1693,1726 +1693,1727 +1693,1728 +1693,1729 +1693,1730 +1693,1731 +1693,1732 +1693,1733 +1693,1734 +1693,1735 +1693,1736 +1693,1737 +1693,1738 +1693,1739 +1693,1740 +1693,1741 +1693,1742 +1693,1743 +1693,1744 +1693,1745 +1693,1746 +1693,1747 +1693,1748 +1693,1749 +1693,1750 +1693,1751 +1693,1570 +1693,1669 +1693,1674 +1693,1662 +1768,53 +1768,160 +1768,176 +1768,177 +1768,179 +1768,190 +1768,211 +1768,221 +1768,21 +1768,24 +1768,67 +1768,72 +1768,244 +1768,251 +1768,254 +1768,255 +1768,257 +1768,280 +1768,286 +1768,338 +1768,340 +1768,350 +1768,356 +1768,373 +1768,420 +1768,452 +1768,300 +1768,736 +1768,613 +1768,562 +1768,903 +1768,912 +1768,967 +1768,972 +1768,931 +1768,933 +1768,940 +1768,945 +1768,948 +1768,1001 +1768,1011 +1768,1014 +1768,1015 +1768,1017 +1768,799 +1768,824 +1768,833 +1768,1061 +1768,1067 +1768,1195 +1768,1213 +1768,1226 +1768,1231 +1768,1235 +1768,1153 +1768,1089 +1768,1032 +1768,1479 +1768,1481 +1768,1482 +1768,1487 +1768,1488 +1768,1489 +1768,1493 +1768,1496 +1768,1497 +1768,1500 +1768,1502 +1768,1391 +1768,1401 +1768,1312 +1768,1313 +1768,1324 +1768,1343 +1768,1442 +1768,1443 +1768,1444 +1768,1450 +1768,1451 +1768,1453 +1768,1456 +1768,1458 +1768,1508 +1768,1509 +1768,1530 +1768,1281 +1768,1283 +1768,1308 +1768,1769 +1768,1770 +1768,1771 +1768,1772 +1768,1773 +1768,1774 +1768,1775 +1768,1776 +1768,1777 +1768,1778 +1768,1779 +1768,1780 +1768,1781 +1768,1782 +1768,1783 +1768,1784 +1768,1785 +1768,1786 +1768,1787 +1768,1788 +1768,1789 +1768,1790 +1768,1791 +1768,1549 +1768,1792 +1768,1793 +1768,1794 +1768,1795 +1768,1796 +1768,1797 +1768,1798 +1768,1799 +1768,1800 +1768,1801 +1768,1802 +1768,1803 +1768,1804 +1768,1805 +1768,1806 +1768,1807 +1768,1808 +1768,1809 +1768,1810 +1768,1811 +1768,1812 +1768,1813 +1768,1814 +1768,1815 +1768,1816 +1768,1817 +1768,1818 +1768,1819 +1768,1820 +1768,1821 +1768,1822 +1768,1823 +1768,1824 +1768,1825 +1768,1826 +1768,1827 +1768,1828 +1768,1829 +1768,1830 +1768,1831 +1768,1832 +1768,1833 +1768,1834 +1768,1835 +1768,1836 +1768,1837 +1768,1838 +1768,1839 +1768,1840 +1768,1841 +1768,1842 +1768,1843 +1768,1844 +1768,1845 +1768,1846 +1768,1847 +1768,1848 +1768,1849 +1768,1850 +1768,1851 +1768,1852 +1768,1853 +1768,1854 +1768,1855 +1856,67 +1856,256 +1856,366 +1856,531 +1856,917 +1856,981 +1856,1017 +1856,843 +1856,1260 +1856,1268 +1856,1039 +1856,1496 +1856,1391 +1856,1394 +1856,1462 +1856,1505 +1856,1520 +1856,1281 +1856,1839 +1856,1875 +1856,1876 +1856,1877 +1856,1878 +1856,1879 +1856,1880 +1856,1881 +1856,1882 +1856,1883 +1856,1884 +1856,1885 +1856,1886 +1856,1887 +1856,1920 +1856,1921 +1856,1922 +1856,1923 +1856,1924 +1856,1925 +1856,1926 +1856,1927 +1856,1928 +1856,1929 +1856,1930 +1856,1931 +1856,1932 +1856,1933 +1856,1934 +1856,1888 +1856,1889 +1856,1890 +1856,1891 +1856,1892 +1856,1893 +1856,1894 +1856,1895 +1856,1896 +1856,1897 +1856,1898 +1856,1899 +1856,1900 +1856,1901 +1856,1902 +1856,1903 +1856,1904 +1856,1905 +1856,1906 +1856,1907 +1856,1908 +1856,1909 +1856,1910 +1856,1911 +1856,1912 +1856,1913 +1856,1914 +1856,1915 +1856,1916 +1856,1917 +1856,1918 +1856,1919 +1935,176 +1935,187 +1935,374 +1935,589 +1935,705 +1935,917 +1935,804 +1935,894 +1935,1212 +1935,1226 +1935,1266 +1935,1277 +1935,1148 +1935,1490 +1935,1391 +1935,1309 +1935,1922 +1935,1945 +1935,1946 +1935,1947 +1935,1948 +1935,1949 +1935,1950 +1935,1951 +1935,1984 +1935,1985 +1935,1986 +1935,1987 +1935,1988 +1935,1989 +1935,1990 +1935,1991 +1935,1992 +1935,1993 +1935,1994 +1935,1995 +1935,1996 +1935,1997 +1935,1998 +1935,1999 +1935,2000 +1935,2001 +1935,2002 +1935,2003 +1935,2004 +1935,2005 +1935,2006 +1935,2007 +1935,1952 +1935,1953 +1935,1954 +1935,1955 +1935,1956 +1935,1957 +1935,1958 +1935,1959 +1935,1960 +1935,1961 +1935,1962 +1935,1963 +1935,1964 +1935,1965 +1935,1966 +1935,1967 +1935,1968 +1935,1969 +1935,1970 +1935,1971 +1935,1972 +1935,1973 +1935,1974 +1935,1975 +1935,1976 +1935,1977 +1935,1978 +1935,1979 +1935,1980 +1935,1981 +1935,1982 +1935,1983 +2008,203 +2008,937 +2008,1141 +2008,1148 +2008,1438 +2008,1663 +2008,2023 +2008,2024 +2008,2025 +2008,2026 +2008,2027 +2008,2028 +2008,2029 +2008,2030 +2008,2031 +2008,2032 +2008,2033 +2008,2034 +2008,2035 +2008,2036 +2008,2037 +2008,2038 +2008,2039 +2008,2040 +2008,2041 +2008,2042 +2008,2043 +2008,2044 +2008,2045 +2008,2046 +2008,2047 +2008,1879 +2008,1880 +2008,2048 +2008,2049 +2008,2050 +2008,2051 +2008,2052 +2008,2053 +2008,2054 +2055,154 +2055,169 +2055,176 +2055,177 +2055,189 +2055,204 +2055,211 +2055,21 +2055,66 +2055,67 +2055,71 +2055,72 +2055,231 +2055,255 +2055,256 +2055,287 +2055,122 +2055,337 +2055,340 +2055,350 +2055,356 +2055,361 +2055,420 +2055,432 +2055,309 +2055,316 +2055,385 +2055,388 +2055,736 +2055,531 +2055,557 +2055,560 +2055,563 +2055,896 +2055,903 +2055,912 +2055,919 +2055,967 +2055,972 +2055,931 +2055,933 +2055,945 +2055,947 +2055,948 +2055,954 +2055,1001 +2055,1014 +2055,1017 +2055,1018 +2055,801 +2055,839 +2055,843 +2055,891 +2055,1066 +2055,1087 +2055,1226 +2055,1236 +2055,1272 +2055,1277 +2055,1153 +2055,1154 +2055,1174 +2055,1181 +2055,1111 +2055,1112 +2055,1114 +2055,1043 +2055,1053 +2055,1488 +2055,1489 +2055,1491 +2055,1493 +2055,1495 +2055,1496 +2055,1502 +2055,1347 +2055,1431 +2055,1391 +2055,1401 +2055,1324 +2055,1338 +2055,1339 +2055,1440 +2055,1443 +2055,1445 +2055,1448 +2055,1450 +2055,1453 +2055,1454 +2055,1458 +2055,1462 +2055,1467 +2055,1469 +2055,1470 +2055,1505 +2055,1507 +2055,1518 +2055,1528 +2055,1776 +2055,1781 +2055,1785 +2055,1544 +2055,1547 +2055,1548 +2055,1646 +2055,1663 +2055,2026 +2055,1806 +2055,1807 +2055,1811 +2055,1828 +2055,1830 +2055,1833 +2055,1834 +2055,1875 +2055,1881 +2055,1882 +2055,1885 +2055,1927 +2055,1903 +2055,1907 +2055,1916 +2055,2080 +2055,2081 +2055,2082 +2055,2083 +2055,2084 +2055,2085 +2055,2086 +2055,2087 +2055,2088 +2055,2089 +2055,2090 +2055,2091 +2055,2092 +2055,2093 +2055,2094 +2055,2095 +2055,2096 +2055,2097 +2055,2098 +2055,2099 +2055,2100 +2055,2101 +2055,2102 +2055,2103 +2055,2104 +2055,2105 +2055,2106 +2055,2107 +2055,2108 +2055,2109 +2055,2110 +2055,2111 +2055,2144 +2055,2145 +2055,2146 +2055,2147 +2055,2148 +2055,2149 +2055,2150 +2055,2151 +2055,2152 +2055,2153 +2055,2154 +2055,2155 +2055,2156 +2055,2157 +2055,2158 +2055,2159 +2055,2160 +2055,2161 +2055,2162 +2055,2163 +2055,2164 +2055,2165 +2055,2166 +2055,2167 +2055,2168 +2055,2169 +2055,2170 +2055,2171 +2055,2172 +2055,2173 +2055,2174 +2055,2175 +2055,2176 +2055,2177 +2055,2178 +2055,2179 +2055,2180 +2055,2181 +2055,2182 +2055,2183 +2055,2184 +2055,2185 +2055,2186 +2055,2187 +2055,2188 +2055,2189 +2055,2190 +2055,2191 +2055,2192 +2055,2193 +2055,2194 +2055,2195 +2055,2196 +2055,2197 +2055,2198 +2055,2199 +2055,2200 +2055,2201 +2055,2202 +2055,2203 +2055,2204 +2055,2205 +2055,2206 +2055,2207 +2055,2208 +2055,2209 +2055,2210 +2055,2211 +2055,2212 +2055,2213 +2055,2214 +2055,2215 +2055,2216 +2055,2217 +2055,2218 +2055,2219 +2055,2220 +2055,2221 +2055,2222 +2055,2223 +2055,2224 +2055,2225 +2055,2226 +2055,2227 +2055,2228 +2055,2229 +2055,2230 +2055,2231 +2055,2077 +2055,2078 +2055,2079 +2055,2112 +2055,2113 +2055,2114 +2055,2115 +2055,2116 +2055,2117 +2055,2118 +2055,2119 +2055,2120 +2055,2121 +2055,2122 +2055,2123 +2055,2124 +2055,2125 +2055,2126 +2055,2127 +2055,2128 +2055,2129 +2055,2130 +2055,2131 +2055,2132 +2055,2133 +2055,2134 +2055,2135 +2055,2136 +2055,2137 +2055,2138 +2055,2139 +2055,2140 +2055,2141 +2055,2142 +2055,2143 +2232,160 +2232,182 +2232,188 +2232,190 +2232,204 +2232,217 +2232,66 +2232,67 +2232,72 +2232,231 +2232,237 +2232,251 +2232,255 +2232,256 +2232,261 +2232,286 +2232,340 +2232,346 +2232,349 +2232,350 +2232,356 +2232,373 +2232,380 +2232,420 +2232,438 +2232,452 +2232,300 +2232,308 +2232,316 +2232,393 +2232,406 +2232,414 +2232,527 +2232,582 +2232,595 +2232,676 +2232,678 +2232,912 +2232,919 +2232,967 +2232,976 +2232,981 +2232,933 +2232,942 +2232,945 +2232,948 +2232,957 +2232,1000 +2232,1001 +2232,1002 +2232,1011 +2232,1012 +2232,1014 +2232,801 +2232,843 +2232,871 +2232,872 +2232,1213 +2232,1226 +2232,1231 +2232,1264 +2232,1268 +2232,1148 +2232,1114 +2232,1488 +2232,1491 +2232,1496 +2232,1497 +2232,1502 +2232,1438 +2232,1391 +2232,1313 +2232,1335 +2232,1443 +2232,1454 +2232,1455 +2232,1458 +2232,1462 +2232,1467 +2232,1507 +2232,1283 +2232,1775 +2232,1781 +2232,1727 +2232,2033 +2232,1803 +2232,1805 +2232,1806 +2232,1819 +2232,1820 +2232,1828 +2232,1834 +2232,1839 +2232,1875 +2232,1882 +2232,1927 +2232,1928 +2232,1931 +2232,1907 +2232,2097 +2232,2100 +2232,2101 +2232,2153 +2232,2170 +2232,2181 +2232,2192 +2232,2200 +2232,2205 +2232,2213 +2232,2222 +2232,2229 +2232,2247 +2232,2248 +2232,2249 +2232,2250 +2232,2251 +2232,2252 +2232,2253 +2232,2254 +2232,2255 +2232,2256 +2232,2257 +2232,2258 +2232,2259 +2232,2260 +2232,2261 +2232,2262 +2232,2263 +2232,2264 +2232,2265 +2232,2266 +2232,2267 +2232,2268 +2232,2269 +2232,2270 +2232,2271 +2232,2131 +2232,2136 +2232,2272 +2232,2273 +2232,2274 +2232,2275 +2232,2276 +2232,2277 +2232,2278 +2232,2279 +2232,2280 +2232,2281 +2232,2282 +2232,2283 +2232,2284 +2232,2285 +2232,2286 +2232,2287 +2232,2288 +2232,2289 +2232,2290 +2232,2291 +2232,2292 +2232,2293 +2232,2294 +2232,2295 +2232,2296 +2232,2297 +2232,2298 +2232,2299 +2232,2300 +2232,2301 +2232,2302 +2232,2303 +2232,2368 +2232,2369 +2232,2370 +2232,2371 +2232,2372 +2232,2373 +2232,2374 +2232,2375 +2232,2376 +2232,2377 +2232,2378 +2232,2379 +2232,2380 +2232,2381 +2232,2382 +2232,2383 +2232,2384 +2232,2385 +2232,2386 +2232,2387 +2232,2388 +2232,2389 +2232,2390 +2232,2391 +2232,2392 +2232,2393 +2232,2394 +2232,2395 +2232,2396 +2232,2397 +2232,2304 +2232,2305 +2232,2306 +2232,2307 +2232,2308 +2232,2309 +2232,2310 +2232,2311 +2232,2312 +2232,2313 +2232,2314 +2232,2315 +2232,2316 +2232,2317 +2232,2318 +2232,2319 +2232,2320 +2232,2321 +2232,2322 +2232,2323 +2232,2324 +2232,2325 +2232,2326 +2232,2327 +2232,2328 +2232,2329 +2232,2330 +2232,2331 +2232,2332 +2232,2333 +2232,2334 +2232,2335 +2232,2336 +2232,2337 +2232,2338 +2232,2339 +2232,2340 +2232,2341 +2232,2342 +2232,2343 +2232,2344 +2232,2345 +2232,2346 +2232,2347 +2232,2348 +2232,2349 +2232,2350 +2232,2351 +2232,2352 +2232,2353 +2232,2354 +2232,2355 +2232,2356 +2232,2357 +2232,2358 +2232,2359 +2232,2360 +2232,2361 +2232,2362 +2232,2363 +2232,2364 +2232,2365 +2232,2366 +2232,2367 +2398,1167 +2398,1391 +2398,1899 +2398,2413 +2398,2414 +2398,2415 +2398,2416 +2398,2417 +2398,2418 +2398,2419 +2398,2420 +2398,2421 +2422,58 +2422,160 +2422,176 +2422,67 +2422,245 +2422,256 +2422,266 +2422,271 +2422,122 +2422,494 +2422,585 +2422,705 +2422,896 +2422,917 +2422,1001 +2422,1017 +2422,799 +2422,841 +2422,1064 +2422,1196 +2422,1232 +2422,1238 +2422,1261 +2422,1266 +2422,1148 +2422,1441 +2422,1449 +2422,1467 +2422,1281 +2422,1289 +2422,1839 +2422,1882 +2422,1923 +2422,1931 +2422,1898 +2422,1907 +2422,2153 +2422,2170 +2422,2264 +2422,2464 +2422,2465 +2422,2466 +2422,2467 +2422,2468 +2422,2469 +2422,2470 +2422,2471 +2422,2472 +2422,2473 +2422,2474 +2422,2475 +2422,2476 +2422,2477 +2422,2478 +2422,2479 +2422,2480 +2422,2481 +2422,2482 +2422,2483 +2422,2484 +2422,2485 +2422,2486 +2422,2487 +2422,2488 +2422,2489 +2422,2490 +2422,2491 +2422,2492 +2422,2493 +2422,2494 +2422,2495 +2422,2496 +2422,2497 +2422,2445 +2422,2446 +2422,2447 +2422,2448 +2422,2449 +2422,2450 +2422,2451 +2422,2452 +2422,2453 +2422,2454 +2422,2455 +2422,2456 +2422,2457 +2422,2458 +2422,2459 +2422,2460 +2422,2461 +2422,2462 +2422,2463 +2498,55 +2498,63 +2498,160 +2498,175 +2498,203 +2498,23 +2498,72 +2498,241 +2498,250 +2498,251 +2498,122 +2498,321 +2498,324 +2498,327 +2498,332 +2498,358 +2498,421 +2498,426 +2498,300 +2498,385 +2498,531 +2498,585 +2498,562 +2498,675 +2498,678 +2498,706 +2498,903 +2498,906 +2498,919 +2498,927 +2498,966 +2498,973 +2498,976 +2498,936 +2498,1005 +2498,1006 +2498,1011 +2498,1017 +2498,804 +2498,841 +2498,843 +2498,849 +2498,867 +2498,886 +2498,1057 +2498,1226 +2498,1235 +2498,1260 +2498,1264 +2498,1268 +2498,1148 +2498,1157 +2498,1167 +2498,1025 +2498,1039 +2498,1041 +2498,1047 +2498,1496 +2498,1502 +2498,1391 +2498,1467 +2498,1281 +2498,1781 +2498,1719 +2498,1574 +2498,2033 +2498,1825 +2498,1828 +2498,1834 +2498,1839 +2498,1844 +2498,1875 +2498,1877 +2498,1882 +2498,1885 +2498,1921 +2498,1927 +2498,1994 +2498,1893 +2498,1894 +2498,1900 +2498,1906 +2498,2083 +2498,2087 +2498,2101 +2498,2111 +2498,2195 +2498,2200 +2498,2077 +2498,2260 +2498,2261 +2498,2262 +2498,2263 +2498,2264 +2498,2127 +2498,2282 +2498,2297 +2498,2298 +2498,2465 +2498,2480 +2498,2484 +2498,2488 +2498,2381 +2498,2383 +2498,2384 +2498,2419 +2498,2511 +2498,2512 +2498,2513 +2498,2514 +2498,2515 +2498,2516 +2498,2517 +2498,2518 +2498,2519 +2498,2520 +2498,2521 +2498,2522 +2498,2523 +2498,2524 +2498,2525 +2498,2526 +2498,2527 +2498,2445 +2498,2350 +2498,2355 +2498,2528 +2498,2529 +2498,2530 +2498,2531 +2498,2532 +2498,2533 +2498,2534 +2498,2535 +2498,2536 +2498,2537 +2498,2538 +2498,2539 +2498,2540 +2498,2541 +2498,2542 +2498,2543 +2498,2544 +2498,2545 +2498,2546 +2498,2547 +2498,2548 +2498,2549 +2498,2550 +2498,2551 +2498,2552 +2498,2553 +2498,2554 +2498,2555 +2498,2556 +2498,2557 +2498,2558 +2498,2559 +2498,2624 +2498,2625 +2498,2626 +2498,2627 +2498,2628 +2498,2629 +2498,2630 +2498,2631 +2498,2632 +2498,2633 +2498,2634 +2498,2635 +2498,2636 +2498,2637 +2498,2638 +2498,2639 +2498,2640 +2498,2641 +2498,2642 +2498,2643 +2498,2644 +2498,2645 +2498,2646 +2498,2647 +2498,2648 +2498,2649 +2498,2650 +2498,2651 +2498,2652 +2498,2653 +2498,2560 +2498,2561 +2498,2562 +2498,2563 +2498,2564 +2498,2565 +2498,2566 +2498,2567 +2498,2568 +2498,2569 +2498,2570 +2498,2571 +2498,2572 +2498,2573 +2498,2574 +2498,2575 +2498,2576 +2498,2577 +2498,2578 +2498,2579 +2498,2580 +2498,2581 +2498,2582 +2498,2583 +2498,2584 +2498,2585 +2498,2586 +2498,2587 +2498,2588 +2498,2589 +2498,2590 +2498,2591 +2498,2592 +2498,2593 +2498,2594 +2498,2595 +2498,2596 +2498,2597 +2498,2598 +2498,2599 +2498,2600 +2498,2601 +2498,2602 +2498,2603 +2498,2604 +2498,2605 +2498,2606 +2498,2607 +2498,2608 +2498,2609 +2498,2610 +2498,2611 +2498,2612 +2498,2613 +2498,2614 +2498,2615 +2498,2616 +2498,2617 +2498,2618 +2498,2619 +2498,2620 +2498,2621 +2498,2622 +2498,2623 +2654,57 +2654,160 +2654,189 +2654,203 +2654,251 +2654,252 +2654,255 +2654,256 +2654,274 +2654,122 +2654,324 +2654,327 +2654,340 +2654,348 +2654,349 +2654,350 +2654,356 +2654,372 +2654,438 +2654,442 +2654,291 +2654,298 +2654,316 +2654,385 +2654,406 +2654,531 +2654,592 +2654,560 +2654,679 +2654,706 +2654,917 +2654,967 +2654,973 +2654,976 +2654,981 +2654,985 +2654,945 +2654,952 +2654,954 +2654,999 +2654,1000 +2654,1001 +2654,1002 +2654,1011 +2654,1017 +2654,804 +2654,843 +2654,849 +2654,852 +2654,891 +2654,894 +2654,1226 +2654,1228 +2654,1235 +2654,1263 +2654,1264 +2654,1268 +2654,1148 +2654,1167 +2654,1174 +2654,1043 +2654,1048 +2654,1481 +2654,1486 +2654,1491 +2654,1493 +2654,1496 +2654,1497 +2654,1502 +2654,1391 +2654,1443 +2654,1458 +2654,1504 +2654,1533 +2654,1291 +2654,1775 +2654,1789 +2654,1709 +2654,1710 +2654,1727 +2654,1544 +2654,2033 +2654,1805 +2654,1828 +2654,1834 +2654,1839 +2654,1850 +2654,1855 +2654,1927 +2654,1931 +2654,1894 +2654,1919 +2654,1970 +2654,1973 +2654,2083 +2654,2101 +2654,2168 +2654,2200 +2654,2204 +2654,2247 +2654,2249 +2654,2255 +2654,2262 +2654,2112 +2654,2119 +2654,2123 +2654,2282 +2654,2284 +2654,2299 +2654,2467 +2654,2391 +2654,2511 +2654,2512 +2654,2345 +2654,2350 +2654,2353 +2654,2355 +2654,2359 +2654,2528 +2654,2537 +2654,2557 +2654,2665 +2654,2666 +2654,2667 +2654,2668 +2654,2669 +2654,2670 +2654,2671 +2654,2672 +2654,2673 +2654,2674 +2654,2675 +2654,2676 +2654,2677 +2654,2678 +2654,2679 +2654,2680 +2654,2681 +2654,2682 +2654,2683 +2654,2684 +2654,2685 +2654,2686 +2654,2687 +2654,2720 +2654,2721 +2654,2722 +2654,2723 +2654,2724 +2654,2725 +2654,2726 +2654,2727 +2654,2728 +2654,2729 +2654,2730 +2654,2731 +2654,2732 +2654,2733 +2654,2734 +2654,2735 +2654,2736 +2654,2737 +2654,2738 +2654,2739 +2654,2740 +2654,2741 +2654,2742 +2654,2743 +2654,2744 +2654,2745 +2654,2746 +2654,2747 +2654,2748 +2654,2749 +2654,2750 +2654,2751 +2654,2631 +2654,2633 +2654,2634 +2654,2653 +2654,2752 +2654,2753 +2654,2754 +2654,2755 +2654,2756 +2654,2757 +2654,2758 +2654,2759 +2654,2760 +2654,2761 +2654,2762 +2654,2763 +2654,2764 +2654,2765 +2654,2766 +2654,2567 +2654,2574 +2654,2575 +2654,2579 +2654,2586 +2654,2589 +2654,2593 +2654,2600 +2654,2617 +2654,2688 +2654,2689 +2654,2690 +2654,2691 +2654,2692 +2654,2693 +2654,2694 +2654,2695 +2654,2696 +2654,2697 +2654,2698 +2654,2699 +2654,2700 +2654,2701 +2654,2702 +2654,2703 +2654,2704 +2654,2705 +2654,2706 +2654,2707 +2654,2708 +2654,2709 +2654,2710 +2654,2711 +2654,2712 +2654,2713 +2654,2714 +2654,2715 +2654,2716 +2654,2717 +2654,2718 +2654,2719 +2767,154 +2767,160 +2767,163 +2767,177 +2767,184 +2767,203 +2767,211 +2767,227 +2767,241 +2767,244 +2767,245 +2767,248 +2767,250 +2767,251 +2767,261 +2767,270 +2767,274 +2767,280 +2767,286 +2767,120 +2767,121 +2767,126 +2767,324 +2767,325 +2767,327 +2767,349 +2767,350 +2767,427 +2767,438 +2767,453 +2767,293 +2767,299 +2767,316 +2767,385 +2767,584 +2767,585 +2767,910 +2767,917 +2767,931 +2767,938 +2767,945 +2767,949 +2767,995 +2767,1002 +2767,1005 +2767,1008 +2767,1011 +2767,1018 +2767,804 +2767,839 +2767,861 +2767,871 +2767,886 +2767,1067 +2767,1235 +2767,1236 +2767,1148 +2767,1167 +2767,1181 +2767,1027 +2767,1029 +2767,1038 +2767,1477 +2767,1346 +2767,1349 +2767,1443 +2767,1447 +2767,1462 +2767,1282 +2767,1574 +2767,1671 +2767,1537 +2767,1662 +2767,1807 +2767,1815 +2767,1849 +2767,1850 +2767,1855 +2767,2114 +2767,2119 +2767,2380 +2767,2390 +2767,2496 +2767,2462 +2767,2665 +2767,2737 +2767,2633 +2767,2765 +2767,2766 +2767,2781 +2767,2782 +2767,2783 +2767,2579 +2767,2692 +2767,2696 +2767,2784 +2767,2785 +2767,2786 +2767,2787 +2767,2788 +2767,2789 +2767,2790 +2767,2791 +2767,2792 +2767,2793 +2767,2794 +2767,2795 +2767,2796 +2767,2797 +2767,2798 +2767,2799 +2767,2800 +2767,2801 +2767,2802 +2767,2803 +2767,2804 +2767,2805 +2767,2806 +2767,2807 +2767,2808 +2767,2809 +2767,2810 +2767,2811 +2767,2812 +2767,2813 +2767,2814 +2767,2815 +2767,2816 +2767,2817 +2767,2818 +2767,2819 +2767,2820 +2767,2821 +2767,2822 +2767,2823 +2767,2824 +2767,2825 +2767,2826 +2767,2827 +2767,2828 +2767,2829 +2767,2830 +2767,2831 +2767,2832 +2767,2833 +2767,2834 +2767,2835 +2767,2836 +2767,2837 +2767,2838 +2767,2839 +2767,2840 +2767,2841 +2767,2842 +2767,2843 +2767,2844 +2767,2845 +2767,2846 +2767,2847 +2767,2880 +2767,2881 +2767,2882 +2767,2883 +2767,2884 +2767,2848 +2767,2849 +2767,2850 +2767,2851 +2767,2852 +2767,2853 +2767,2854 +2767,2855 +2767,2856 +2767,2857 +2767,2858 +2767,2859 +2767,2860 +2767,2861 +2767,2862 +2767,2863 +2767,2864 +2767,2865 +2767,2866 +2767,2867 +2767,2868 +2767,2869 +2767,2870 +2767,2871 +2767,2872 +2767,2873 +2767,2874 +2767,2875 +2767,2876 +2767,2877 +2767,2878 +2767,2879 +2885,152 +2885,159 +2885,59 +2885,63 +2885,203 +2885,234 +2885,256 +2885,267 +2885,324 +2885,327 +2885,334 +2885,348 +2885,350 +2885,357 +2885,592 +2885,971 +2885,942 +2885,954 +2885,999 +2885,1017 +2885,1023 +2885,830 +2885,832 +2885,841 +2885,856 +2885,1085 +2885,1235 +2885,1263 +2885,1268 +2885,1148 +2885,1165 +2885,1167 +2885,1114 +2885,1028 +2885,1497 +2885,1388 +2885,1391 +2885,1401 +2885,1318 +2885,1340 +2885,1443 +2885,1281 +2885,1282 +2885,1283 +2885,1770 +2885,1592 +2885,1673 +2885,1562 +2885,2028 +2885,1818 +2885,1879 +2885,1988 +2885,2007 +2885,2215 +2885,2051 +2885,2465 +2885,2527 +2885,2462 +2885,2332 +2885,2361 +2885,2363 +2885,2530 +2885,2542 +2885,2569 +2885,2583 +2885,2586 +2885,2817 +2885,2898 +2885,2899 +2885,2900 +2885,2901 +2885,2902 +2885,2903 +2885,2904 +2885,2905 +2885,2906 +2885,2907 +2885,2908 +2885,2909 +2885,2910 +2885,2911 +2885,2864 +2885,2912 +2885,2913 +2885,2914 +2885,2915 +2885,2916 +2885,2917 +2885,2918 +2885,2919 +2885,2920 +2885,2921 +2885,2922 +2885,2923 +2885,2924 +2885,2925 +2885,2926 +2885,2927 +2885,2928 +2885,2929 +2885,2930 +2885,2931 +2885,2932 +2885,2933 +2885,2934 +2885,2935 +2885,2936 +2885,2937 +2885,2938 +2885,2939 +2885,2940 +2885,2941 +2885,2942 +2885,2943 +2885,2944 +2885,2945 +2885,2946 +2885,2947 +2885,2948 +2885,2949 +2885,2950 +2885,2951 +2885,2952 +2885,2953 +2885,2954 +2885,2955 +2885,2956 +2885,2957 +2885,2958 +2885,2959 +2885,2960 +2885,2961 +2885,2962 +2885,2963 +2885,2964 +2885,2965 +2885,2966 +2885,2967 +2885,2968 +2885,2969 +2885,2970 +2885,2971 +2885,2972 +2885,2973 +2885,2974 +2885,2975 +2885,2976 +2885,2977 +2885,2978 +2885,2979 +2885,2980 +2885,2981 +2885,2982 +2885,2983 +2885,2984 +2885,2985 +2885,2986 +2885,2987 +2885,2988 +2885,2989 +2885,2990 +2885,2991 +2885,2992 +2885,2993 +2885,2994 +2885,2995 +2885,2996 +2885,2997 +2885,2998 +2885,2999 +2885,3000 +2885,3001 +2885,3002 +2885,3003 +2885,3004 +2885,3005 +2885,3006 +2885,3007 +2885,3008 +2885,3009 +2885,3010 +2885,3011 +2885,3012 +2885,3013 +2885,3014 +2885,3015 +2885,3016 +2885,3017 +2885,3018 +2885,3019 +2885,3020 +2885,3021 +2885,3022 +2885,3023 +2885,3024 +2885,3025 +2885,3026 +2885,3027 +2885,3028 +2885,3029 +2885,3030 +2885,3031 +2885,3032 +2885,3033 +2885,3034 +2885,3035 +2885,3036 +2885,3037 +2885,3038 +2885,3039 +2885,3040 +2885,3041 +2885,3042 +2885,3043 +2885,3044 +2885,3045 +2885,3046 +2885,3047 +2885,3048 +2885,3049 +2885,3050 +2885,3051 +2885,3052 +2885,3053 +2885,3054 +2885,3055 +2885,3056 +2885,3057 +2885,3058 +2885,3059 +2885,3060 +2885,3061 +2885,3062 +2885,3063 +2885,3064 +2885,3065 +2885,3066 +2885,3067 +2885,3068 +2885,3069 +2885,3070 +2885,3071 +2885,3104 +2885,3105 +2885,3072 +2885,3073 +2885,3074 +2885,3075 +2885,3076 +2885,3077 +2885,3078 +2885,3079 +2885,3080 +2885,3081 +2885,3082 +2885,3083 +2885,3084 +2885,3085 +2885,3086 +2885,3087 +2885,3088 +2885,3089 +2885,3090 +2885,3091 +2885,3092 +2885,3093 +2885,3094 +2885,3095 +2885,3096 +2885,3097 +2885,3098 +2885,3099 +2885,3100 +2885,3101 +2885,3102 +2885,3103 +3106,159 +3106,160 +3106,161 +3106,189 +3106,203 +3106,204 +3106,212 +3106,217 +3106,220 +3106,79 +3106,231 +3106,245 +3106,250 +3106,251 +3106,255 +3106,266 +3106,269 +3106,273 +3106,274 +3106,279 +3106,286 +3106,324 +3106,327 +3106,328 +3106,331 +3106,332 +3106,340 +3106,346 +3106,349 +3106,358 +3106,373 +3106,417 +3106,418 +3106,420 +3106,426 +3106,432 +3106,438 +3106,446 +3106,291 +3106,299 +3106,300 +3106,308 +3106,406 +3106,414 +3106,592 +3106,917 +3106,919 +3106,925 +3106,926 +3106,966 +3106,967 +3106,983 +3106,984 +3106,987 +3106,933 +3106,935 +3106,936 +3106,937 +3106,938 +3106,942 +3106,1012 +3106,1013 +3106,872 +3106,1067 +3106,1081 +3106,1189 +3106,1204 +3106,1226 +3106,1228 +3106,1236 +3106,1240 +3106,1263 +3106,1167 +3106,1047 +3106,1477 +3106,1434 +3106,1525 +3106,1281 +3106,1284 +3106,1727 +3106,1730 +3106,1738 +3106,1671 +3106,1537 +3106,1646 +3106,2255 +3106,2287 +3106,2487 +3106,2379 +3106,2381 +3106,2680 +3106,2722 +3106,2642 +3106,2567 +3106,2797 +3106,2818 +3106,2837 +3106,2840 +3106,3232 +3106,3233 +3106,3234 +3106,3235 +3106,3236 +3106,3237 +3106,3238 +3106,3239 +3106,3240 +3106,3241 +3106,3242 +3106,3243 +3106,3244 +3106,3245 +3106,3246 +3106,3247 +3106,3248 +3106,3249 +3106,3250 +3106,3251 +3106,3114 +3106,3115 +3106,3116 +3106,3117 +3106,3118 +3106,3119 +3106,3120 +3106,3121 +3106,3122 +3106,3123 +3106,3124 +3106,3125 +3106,3126 +3106,3127 +3106,3128 +3106,3129 +3106,3130 +3106,3131 +3106,3132 +3106,3133 +3106,3134 +3106,3135 +3106,3168 +3106,3169 +3106,3170 +3106,3171 +3106,3172 +3106,3173 +3106,3174 +3106,3175 +3106,3176 +3106,3177 +3106,3178 +3106,3179 +3106,3180 +3106,3181 +3106,3182 +3106,3183 +3106,3184 +3106,3185 +3106,3186 +3106,3187 +3106,3188 +3106,3189 +3106,3190 +3106,3191 +3106,3192 +3106,3193 +3106,3194 +3106,3195 +3106,3196 +3106,3197 +3106,3198 +3106,3199 +3106,3200 +3106,3201 +3106,3202 +3106,3203 +3106,3204 +3106,3205 +3106,3206 +3106,3207 +3106,3208 +3106,3209 +3106,3210 +3106,3211 +3106,3212 +3106,3213 +3106,3214 +3106,3215 +3106,3216 +3106,3217 +3106,3218 +3106,3219 +3106,3220 +3106,3221 +3106,3222 +3106,3223 +3106,3224 +3106,3225 +3106,3226 +3106,3227 +3106,3228 +3106,3229 +3106,3230 +3106,3231 +3106,3136 +3106,3137 +3106,3138 +3106,3139 +3106,3140 +3106,3141 +3106,3142 +3106,3143 +3106,3144 +3106,3145 +3106,3146 +3106,3147 +3106,3148 +3106,3149 +3106,3150 +3106,3151 +3106,3152 +3106,3153 +3106,3154 +3106,3155 +3106,3156 +3106,3157 +3106,3158 +3106,3159 +3106,3160 +3106,3161 +3106,3162 +3106,3163 +3106,3164 +3106,3165 +3106,3166 +3106,3167 +3252,160 +3252,176 +3252,177 +3252,184 +3252,194 +3252,251 +3252,256 +3252,323 +3252,327 +3252,350 +3252,363 +3252,373 +3252,426 +3252,494 +3252,299 +3252,300 +3252,309 +3252,385 +3252,904 +3252,905 +3252,976 +3252,942 +3252,1012 +3252,841 +3252,870 +3252,873 +3252,1060 +3252,1184 +3252,1135 +3252,1165 +3252,1091 +3252,1035 +3252,1499 +3252,1435 +3252,1439 +3252,1398 +3252,1313 +3252,1441 +3252,1458 +3252,1462 +3252,1466 +3252,1283 +3252,1723 +3252,1727 +3252,1595 +3252,1673 +3252,1541 +3252,1547 +3252,1632 +3252,1663 +3252,1841 +3252,1927 +3252,1898 +3252,2109 +3252,2225 +3252,2119 +3252,2127 +3252,2278 +3252,2487 +3252,2396 +3252,2496 +3252,2322 +3252,2632 +3252,2648 +3252,2602 +3252,2617 +3252,2694 +3252,2718 +3252,2788 +3252,2795 +3252,2821 +3252,2883 +3252,3271 +3252,3272 +3252,3273 +3252,3274 +3252,3275 +3252,3276 +3252,3277 +3252,3278 +3252,3279 +3252,3280 +3252,3281 +3252,3282 +3252,3283 +3252,3284 +3252,3285 +3252,3286 +3252,3287 +3252,3288 +3252,3289 +3252,3290 +3252,3291 +3252,3292 +3252,3293 +3252,3294 +3252,3295 +3252,3296 +3252,3297 +3252,3298 +3252,3299 +3252,3300 +3252,3301 +3252,3302 +3252,3303 +3252,3304 +3252,3305 +3252,3306 +3252,3307 +3252,3308 +3252,3309 +3252,3310 +3252,3311 +3252,3312 +3252,3313 +3252,3314 +3252,3315 +3252,3316 +3252,3317 +3252,3318 +3252,3319 +3252,3320 +3252,3321 +3252,3322 +3252,3323 +3252,3324 +3252,3325 +3252,3326 +3252,3327 +3252,3232 +3252,3129 +3252,3078 +3252,3161 +3252,3328 +3252,3329 +3252,3330 +3252,3331 +3252,3332 +3252,3333 +3252,3334 +3252,3335 +3252,3336 +3252,3337 +3252,3338 +3252,3339 +3252,3340 +3252,3341 +3252,3342 +3252,3343 +3252,3344 +3252,3345 +3252,3346 +3252,3347 +3252,3348 +3252,3349 +3252,3350 +3252,3351 +3252,3352 +3252,3353 +3252,3354 +3252,3355 +3252,3356 +3252,3357 +3252,3358 +3252,3359 +3252,3360 +3252,3361 +3252,3362 +3252,3363 +3252,3364 +3252,3365 +3252,3366 +3252,3367 +3252,3368 +3252,3369 +3252,3370 +3252,3371 +3252,3372 +3252,3373 +3252,3374 +3252,3375 +3252,3376 +3252,3377 +3252,3378 +3252,3379 +3252,3380 +3252,3381 +3252,3382 +3252,3383 +3252,3384 +3252,3385 +3252,3386 +3252,3387 +3252,3388 +3252,3389 +3390,152 +3390,203 +3390,324 +3390,358 +3390,308 +3390,393 +3390,917 +3390,937 +3390,954 +3390,1010 +3390,1011 +3390,1017 +3390,1260 +3390,1167 +3390,1044 +3390,1350 +3390,1669 +3390,1686 +3390,1692 +3390,2028 +3390,1850 +3390,2511 +3390,2341 +3390,2364 +3390,2667 +3390,2720 +3390,2840 +3390,2872 +3390,2955 +3390,3456 +3390,3457 +3390,3458 +3390,3400 +3390,3401 +3390,3402 +3390,3403 +3390,3404 +3390,3405 +3390,3406 +3390,3407 +3390,3408 +3390,3409 +3390,3410 +3390,3411 +3390,3412 +3390,3413 +3390,3414 +3390,3415 +3390,3416 +3390,3417 +3390,3418 +3390,3419 +3390,3420 +3390,3421 +3390,3422 +3390,3423 +3390,3424 +3390,3425 +3390,3426 +3390,3427 +3390,3428 +3390,3429 +3390,3430 +3390,3431 +3390,3432 +3390,3433 +3390,3434 +3390,3435 +3390,3436 +3390,3437 +3390,3438 +3390,3439 +3390,3440 +3390,3441 +3390,3442 +3390,3443 +3390,3444 +3390,3445 +3390,3446 +3390,3447 +3390,3448 +3390,3449 +3390,3450 +3390,3451 +3390,3452 +3390,3453 +3390,3454 +3390,3455 +3459,147 +3459,149 +3459,151 +3459,152 +3459,159 +3459,160 +3459,184 +3459,203 +3459,220 +3459,66 +3459,245 +3459,251 +3459,255 +3459,324 +3459,334 +3459,349 +3459,350 +3459,358 +3459,373 +3459,435 +3459,438 +3459,452 +3459,454 +3459,494 +3459,305 +3459,897 +3459,905 +3459,909 +3459,919 +3459,970 +3459,985 +3459,933 +3459,937 +3459,940 +3459,954 +3459,1002 +3459,1009 +3459,1011 +3459,1017 +3459,799 +3459,849 +3459,852 +3459,860 +3459,876 +3459,1057 +3459,1067 +3459,1148 +3459,1154 +3459,1167 +3459,1039 +3459,1047 +3459,1502 +3459,1350 +3459,1341 +3459,1443 +3459,1283 +3459,1791 +3459,1574 +3459,1582 +3459,1643 +3459,2030 +3459,1975 +3459,2093 +3459,2107 +3459,2197 +3459,2127 +3459,2287 +3459,2296 +3459,2467 +3459,2476 +3459,2418 +3459,2452 +3459,2315 +3459,2332 +3459,2357 +3459,2361 +3459,2727 +3459,2741 +3459,2743 +3459,2748 +3459,2764 +3459,2585 +3459,2834 +3459,2840 +3459,2899 +3459,2873 +3459,2914 +3459,2936 +3459,2944 +3459,2945 +3459,3000 +3459,3025 +3459,3028 +3459,3033 +3459,3053 +3459,3244 +3459,3115 +3459,3175 +3459,3095 +3459,3153 +3459,3160 +3459,3520 +3459,3521 +3459,3522 +3459,3523 +3459,3524 +3459,3525 +3459,3526 +3459,3527 +3459,3528 +3459,3529 +3459,3530 +3459,3531 +3459,3532 +3459,3533 +3459,3534 +3459,3535 +3459,3536 +3459,3537 +3459,3538 +3459,3539 +3459,3540 +3459,3541 +3459,3542 +3459,3543 +3459,3544 +3459,3545 +3459,3546 +3459,3547 +3459,3548 +3459,3549 +3459,3550 +3459,3551 +3459,3465 +3459,3466 +3459,3467 +3459,3468 +3459,3469 +3459,3470 +3459,3471 +3459,3472 +3459,3473 +3459,3474 +3459,3475 +3459,3476 +3459,3477 +3459,3478 +3459,3479 +3459,3480 +3459,3481 +3459,3482 +3459,3483 +3459,3484 +3459,3485 +3459,3486 +3459,3487 +3459,3488 +3459,3489 +3459,3490 +3459,3491 +3459,3492 +3459,3493 +3459,3494 +3459,3495 +3459,3496 +3459,3497 +3459,3498 +3459,3499 +3459,3500 +3459,3501 +3459,3502 +3459,3503 +3459,3504 +3459,3505 +3459,3506 +3459,3507 +3459,3508 +3459,3509 +3459,3510 +3459,3511 +3459,3512 +3459,3513 +3459,3514 +3459,3515 +3459,3516 +3459,3517 +3459,3518 +3459,3519 +3459,3552 +3459,3553 +3459,3554 +3459,3555 +3459,3556 +3459,3557 +3459,3558 +3459,3559 +3459,3560 +3459,3561 +3459,3562 +3459,3563 +3459,3564 +3459,3565 +3459,3566 +3459,3567 +3459,3568 +3459,3569 +3459,3570 +3459,3571 +3459,3572 +3459,3573 +3459,3574 +3459,3575 +3459,3576 +3459,3577 +3459,3578 +3459,3579 +3459,3580 +3459,3581 +3459,3582 +3459,3583 +3459,3584 +3459,3585 +3459,3586 +3459,3587 +3459,3588 +3459,3589 +3459,3590 +3459,3591 +3459,3592 +3459,3593 +3459,3594 +3459,3595 +3459,3596 +3459,3597 +3459,3598 +3459,3599 +3459,3600 +3459,3601 +3459,3602 +3459,3603 +3459,3604 +3459,3605 +3459,3606 +3459,3607 +3459,3608 +3459,3609 +3459,3610 +3459,3611 +3459,3612 +3459,3613 +3459,3614 +3459,3615 +3459,3616 +3459,3617 +3459,3618 +3459,3619 +3459,3620 +3459,3621 +3459,3622 +3459,3623 +3624,153 +3624,324 +3624,326 +3624,370 +3624,467 +3624,469 +3624,995 +3624,1017 +3624,886 +3624,1192 +3624,1320 +3624,1524 +3624,1769 +3624,1575 +3624,1671 +3624,1638 +3624,1850 +3624,1898 +3624,2527 +3624,2716 +3624,2883 +3624,3430 +3624,3453 +3624,3556 +3624,3648 +3624,3649 +3624,3650 +3624,3651 +3624,3652 +3624,3653 +3624,3654 +3624,3655 +3624,3656 +3624,3657 +3624,3658 +3624,3659 +3624,3660 +3624,3661 +3624,3662 +3624,3663 +3624,3664 +3624,3665 +3624,3666 +3624,3667 +3624,3668 +3624,3669 +3624,3670 +3624,3671 +3624,3672 +3624,3673 +3624,3674 +3624,3675 +3624,3676 +3624,3677 +3624,3678 +3624,3679 +3624,3632 +3624,3633 +3624,3634 +3624,3635 +3624,3636 +3624,3637 +3624,3638 +3624,3639 +3624,3640 +3624,3641 +3624,3642 +3624,3643 +3624,3644 +3624,3645 +3624,3646 +3624,3647 +3680,152 +3680,55 +3680,160 +3680,162 +3680,175 +3680,176 +3680,177 +3680,189 +3680,220 +3680,231 +3680,248 +3680,250 +3680,251 +3680,255 +3680,279 +3680,286 +3680,116 +3680,323 +3680,340 +3680,349 +3680,380 +3680,419 +3680,426 +3680,427 +3680,452 +3680,454 +3680,470 +3680,298 +3680,300 +3680,304 +3680,309 +3680,316 +3680,385 +3680,414 +3680,903 +3680,908 +3680,912 +3680,925 +3680,967 +3680,985 +3680,930 +3680,932 +3680,935 +3680,937 +3680,938 +3680,939 +3680,942 +3680,959 +3680,1011 +3680,1014 +3680,873 +3680,887 +3680,891 +3680,1204 +3680,1235 +3680,1166 +3680,1030 +3680,1038 +3680,1052 +3680,1472 +3680,1497 +3680,1502 +3680,1429 +3680,1435 +3680,1443 +3680,1454 +3680,1465 +3680,1518 +3680,1781 +3680,1612 +3680,1646 +3680,1931 +3680,2185 +3680,2201 +3680,2127 +3680,2128 +3680,2133 +3680,2450 +3680,2326 +3680,2355 +3680,2786 +3680,2898 +3680,3294 +3680,3311 +3680,3131 +3680,3203 +3680,3208 +3680,3225 +3680,3161 +3680,3543 +3680,3487 +3680,3513 +3680,3431 +3680,3691 +3680,3692 +3680,3693 +3680,3694 +3680,3695 +3680,3696 +3680,3697 +3680,3698 +3680,3699 +3680,3700 +3680,3701 +3680,3702 +3680,3703 +3680,3704 +3680,3705 +3680,3706 +3680,3707 +3680,3708 +3680,3709 +3680,3710 +3680,3711 +3680,3744 +3680,3745 +3680,3746 +3680,3747 +3680,3748 +3680,3749 +3680,3750 +3680,3751 +3680,3752 +3680,3612 +3680,3712 +3680,3713 +3680,3714 +3680,3715 +3680,3716 +3680,3717 +3680,3718 +3680,3719 +3680,3720 +3680,3721 +3680,3722 +3680,3723 +3680,3724 +3680,3725 +3680,3726 +3680,3727 +3680,3728 +3680,3729 +3680,3730 +3680,3731 +3680,3732 +3680,3733 +3680,3734 +3680,3735 +3680,3736 +3680,3737 +3680,3738 +3680,3739 +3680,3740 +3680,3741 +3680,3742 +3680,3743 +3753,159 +3753,160 +3753,203 +3753,220 +3753,251 +3753,255 +3753,280 +3753,286 +3753,126 +3753,324 +3753,327 +3753,334 +3753,349 +3753,366 +3753,438 +3753,444 +3753,450 +3753,452 +3753,467 +3753,469 +3753,300 +3753,631 +3753,632 +3753,530 +3753,904 +3753,910 +3753,935 +3753,942 +3753,958 +3753,1002 +3753,1008 +3753,1010 +3753,1011 +3753,830 +3753,839 +3753,841 +3753,873 +3753,887 +3753,894 +3753,1228 +3753,1235 +3753,1238 +3753,1263 +3753,1141 +3753,1154 +3753,1159 +3753,1167 +3753,1181 +3753,1044 +3753,1435 +3753,1439 +3753,1471 +3753,1281 +3753,1292 +3753,1770 +3753,1729 +3753,1592 +3753,1664 +3753,1686 +3753,1537 +3753,1562 +3753,1612 +3753,1615 +3753,1625 +3753,1646 +3753,1661 +3753,1663 +3753,1826 +3753,1921 +3753,1895 +3753,2209 +3753,2252 +3753,2263 +3753,2269 +3753,2296 +3753,2497 +3753,2452 +3753,2462 +3753,2361 +3753,2528 +3753,2737 +3753,2625 +3753,2631 +3753,2583 +3753,2586 +3753,2623 +3753,2695 +3753,2696 +3753,2794 +3753,2795 +3753,2817 +3753,2840 +3753,2899 +3753,2909 +3753,2879 +3753,2914 +3753,2917 +3753,2918 +3753,2935 +3753,2936 +3753,2946 +3753,2961 +3753,2963 +3753,2982 +3753,2999 +3753,3010 +3753,3018 +3753,3025 +3753,3028 +3753,3050 +3753,3295 +3753,3232 +3753,3115 +3753,3120 +3753,3175 +3753,3180 +3753,3192 +3753,3095 +3753,3147 +3753,3149 +3753,3156 +3753,3159 +3753,3536 +3753,3546 +3753,3376 +3753,3456 +3753,3400 +3753,3416 +3753,3437 +3753,3569 +3753,3700 +3753,3708 +3753,3762 +3753,3763 +3753,3764 +3753,3765 +3753,3766 +3753,3767 +3753,3768 +3753,3769 +3753,3770 +3753,3771 +3753,3772 +3753,3773 +3753,3774 +3753,3775 +3753,3603 +3753,3776 +3753,3777 +3753,3778 +3753,3779 +3753,3780 +3753,3781 +3753,3782 +3753,3783 +3753,3784 +3753,3785 +3753,3786 +3753,3787 +3753,3788 +3753,3789 +3753,3790 +3753,3791 +3753,3792 +3753,3793 +3753,3794 +3753,3795 +3753,3796 +3753,3797 +3753,3798 +3753,3799 +3753,3800 +3753,3801 +3753,3802 +3753,3803 +3753,3804 +3753,3805 +3753,3806 +3753,3807 +3753,3808 +3753,3809 +3753,3810 +3753,3811 +3753,3812 +3753,3813 +3753,3814 +3753,3815 +3753,3816 +3753,3817 +3753,3818 +3753,3819 +3753,3820 +3753,3821 +3753,3822 +3753,3823 +3753,3824 +3753,3825 +3753,3826 +3753,3827 +3753,3828 +3753,3829 +3753,3830 +3753,3831 +3753,3832 +3753,3833 +3753,3834 +3753,3835 +3753,3836 +3753,3837 +3753,3838 +3753,3839 +3753,3714 +3753,3840 +3753,3841 +3753,3842 +3753,3843 +3753,3844 +3753,3845 +3753,3846 +3753,3847 +3753,3848 +3753,3849 +3753,3850 +3753,3851 +3753,3852 +3753,3853 +3753,3854 +3753,3855 +3753,3856 +3753,3857 +3753,3858 +3753,3859 +3753,3860 +3753,3861 +3753,3862 +3753,3863 +3753,3864 +3753,3865 +3753,3866 +3753,3867 +3753,3868 +3753,3869 +3753,3870 +3753,3871 +3753,3872 +3753,3873 +3753,3874 +3753,3875 +3753,3876 +3753,3877 +3753,3878 +3753,3879 +3753,3880 +3753,3881 +3753,3882 +3753,3883 +3753,3884 +3753,3885 +3753,3886 +3753,3887 +3753,3888 +3753,3889 +3753,3890 +3753,3891 +3753,3892 +3753,3893 +3753,3894 +3753,3895 +3753,3896 +3753,3897 +3753,3898 +3753,3899 +3753,3900 +3753,3901 +3753,3902 +3753,3903 +3753,3904 +3753,3905 +3753,3906 +3753,3907 +3753,3908 +3753,3909 +3753,3910 +3753,3911 +3753,3912 +3753,3913 +3753,3914 +3915,159 +3915,220 +3915,77 +3915,236 +3915,239 +3915,336 +3915,337 +3915,357 +3915,374 +3915,375 +3915,303 +3915,309 +3915,310 +3915,697 +3915,966 +3915,935 +3915,936 +3915,937 +3915,1006 +3915,1015 +3915,768 +3915,860 +3915,1087 +3915,1238 +3915,1157 +3915,1168 +3915,1025 +3915,1028 +3915,1474 +3915,1471 +3915,1290 +3915,1292 +3915,1592 +3915,1655 +3915,1663 +3915,1822 +3915,2198 +3915,2379 +3915,2317 +3915,2643 +3915,2568 +3915,2813 +3915,2899 +3915,2872 +3915,2917 +3915,2930 +3915,3273 +3915,3191 +3915,3153 +3915,3544 +3915,3663 +3915,3725 +3915,3881 +3915,3918 +3915,3919 +3915,3920 +3915,3921 +3915,3922 +3915,3923 +3915,3924 +3915,3925 +3915,3926 +3915,3927 +3915,3928 +3915,3929 +3915,3930 +3915,3931 +3915,3932 +3915,3933 +3915,3934 +3915,3935 +3915,3936 +3915,3937 +3915,3938 +3915,3939 +3915,3940 +3915,3941 +3915,3942 +3915,3943 +3915,3944 +3915,3945 +3915,3946 +3915,3947 +3915,3948 +3915,3949 +3915,3950 +3915,3951 +3915,3952 +3915,3953 +3915,3954 +3915,3955 +3915,3956 +3915,3957 +3915,3958 +3915,3959 +3915,3960 +3915,3961 +3915,3962 +3915,3963 +3915,3964 +3915,3965 +3915,3966 +3915,3967 +3915,3968 +3915,3969 +3915,3970 +3915,3971 +3915,3972 +3915,3973 +3915,3974 +3915,3975 +3915,3976 +3915,3977 +3915,3978 +3915,3979 +3915,3980 +3915,3981 +3915,3982 +3915,3983 +3915,3984 +3915,3985 +3915,3986 +3915,3987 +3915,3988 +3915,3989 +3915,3990 +3915,3991 +3915,3992 +3915,3993 +3915,3994 +3915,3995 +3915,3996 diff --git a/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_is_friend.csv b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_is_friend.csv new file mode 100644 index 000000000..1459f5071 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_is_friend.csv @@ -0,0 +1,701 @@ +LABEL=is_friend,SRC_LABEL=user,DST_LABEL=user +id:INT32:SRC_ID,id:INT32:DST_ID +3,882 +3,204 +3,368 +7,293 +7,597 +7,142 +8,74 +8,248 +8,662 +10,7 +10,321 +10,328 +11,54 +11,350 +11,190 +18,481 +18,197 +18,464 +19,375 +19,723 +19,831 +21,775 +21,670 +21,293 +22,579 +22,159 +22,831 +23,116 +23,579 +23,59 +25,901 +25,38 +25,621 +27,467 +27,121 +27,505 +33,467 +33,450 +33,415 +34,57 +34,854 +34,428 +36,171 +36,428 +36,421 +38,332 +38,614 +38,481 +39,319 +39,224 +39,266 +40,44 +40,464 +40,201 +44,170 +44,464 +44,33 +45,57 +45,912 +45,544 +46,587 +46,552 +46,780 +51,27 +51,256 +51,933 +52,215 +52,53 +52,313 +53,767 +53,803 +53,463 +54,584 +54,450 +54,565 +55,585 +55,248 +55,463 +57,343 +57,894 +57,230 +59,571 +59,854 +59,775 +60,770 +60,350 +60,7 +62,571 +62,661 +62,69 +66,608 +66,883 +66,223 +67,39 +67,990 +67,782 +68,552 +68,883 +68,900 +69,332 +69,775 +69,585 +74,190 +74,530 +74,54 +76,723 +76,779 +76,221 +82,186 +82,192 +82,62 +83,478 +83,210 +83,854 +94,83 +94,112 +94,584 +96,933 +96,422 +96,900 +102,27 +102,990 +102,328 +104,565 +104,40 +104,990 +109,406 +109,596 +109,897 +111,126 +111,663 +111,82 +112,7 +112,894 +112,319 +116,112 +116,199 +116,433 +117,592 +117,117 +117,82 +119,52 +119,250 +119,11 +121,7 +121,933 +121,399 +126,467 +126,178 +126,787 +131,544 +131,787 +131,27 +136,46 +136,457 +136,202 +142,190 +142,104 +142,619 +151,22 +151,457 +151,170 +153,54 +153,701 +153,25 +158,227 +158,368 +158,375 +159,394 +159,415 +159,597 +161,394 +161,373 +161,112 +170,313 +170,60 +170,82 +171,614 +171,663 +171,907 +175,900 +175,339 +175,875 +177,8 +177,399 +177,251 +178,104 +178,621 +178,326 +183,222 +183,912 +183,183 +186,592 +186,990 +186,912 +187,962 +187,44 +187,592 +190,766 +190,244 +190,159 +191,313 +191,224 +191,788 +192,579 +192,59 +192,661 +196,191 +196,7 +196,399 +197,339 +197,38 +197,594 +199,854 +199,116 +199,596 +200,7 +200,219 +200,248 +201,19 +201,565 +201,415 +202,457 +202,44 +202,738 +204,40 +204,705 +204,863 +210,433 +210,60 +210,333 +215,464 +215,780 +215,803 +218,585 +218,933 +218,464 +219,222 +219,733 +219,406 +220,104 +220,917 +220,782 +221,295 +221,588 +221,421 +222,421 +222,916 +222,932 +223,457 +223,109 +223,433 +224,76 +224,766 +224,698 +225,570 +225,738 +225,59 +227,662 +227,619 +227,388 +228,158 +228,902 +228,52 +230,33 +230,191 +230,463 +231,119 +231,658 +231,534 +238,142 +238,197 +238,652 +240,422 +240,112 +240,981 +241,831 +241,51 +241,68 +244,102 +244,519 +244,751 +246,803 +246,530 +246,38 +248,21 +248,647 +248,779 +250,657 +250,608 +250,196 +251,52 +251,902 +251,505 +256,466 +256,161 +256,902 +266,177 +266,202 +266,109 +293,826 +293,153 +293,25 +295,990 +295,710 +295,582 +296,111 +296,153 +296,541 +301,94 +301,850 +301,66 +308,767 +308,534 +308,238 +310,826 +310,241 +310,803 +313,310 +313,231 +313,894 +319,723 +319,223 +319,112 +321,136 +321,131 +321,981 +326,500 +326,295 +326,457 +328,751 +328,40 +328,588 +332,882 +332,912 +332,38 +333,333 +333,199 +333,394 +339,467 +339,66 +339,102 +343,698 +343,328 +343,8 +350,59 +350,565 +350,210 +355,62 +355,171 +355,619 +368,83 +368,222 +368,676 +373,570 +373,733 +373,621 +375,112 +375,596 +375,917 +383,592 +383,990 +383,519 +388,670 +388,698 +388,875 +394,747 +394,463 +394,210 +399,383 +399,917 +399,192 +406,131 +406,248 +406,565 +415,228 +415,161 +415,478 +421,850 +421,457 +421,738 +422,109 +422,467 +422,664 +428,21 +428,383 +428,210 +433,890 +433,463 +433,228 +434,596 +434,350 +434,36 +450,170 +450,670 +450,201 +457,69 +457,481 +457,748 +463,332 +463,588 +463,614 +464,202 +464,117 +464,614 +466,248 +466,663 +466,224 +467,53 +467,743 +467,580 +478,230 +478,111 +478,965 +481,912 +481,158 +481,647 +485,900 +485,702 +485,582 +491,52 +491,190 +491,33 +500,803 +500,321 +500,175 +505,339 +505,161 +505,250 +507,82 +507,578 +507,863 +519,787 +519,159 +519,491 +526,485 +526,902 +526,39 +530,863 +530,500 +530,933 +534,890 +534,500 +534,578 +536,202 +536,187 +536,965 +541,383 +541,238 +541,421 +544,119 +544,662 +544,27 +552,241 +552,608 +552,770 +565,578 +565,126 +565,96 +570,647 +570,570 +570,18 +571,186 +571,246 +571,53 +578,126 +578,102 +578,350 +579,661 +579,266 +579,121 +580,51 +580,933 +580,883 +582,321 +582,421 +582,76 +584,210 +584,248 +584,240 +585,582 +585,231 +585,296 +587,51 +587,965 +587,121 +588,647 +588,812 +588,178 +592,310 +592,59 +592,310 +594,33 +594,890 +594,321 +596,375 +596,119 +596,450 +597,295 +597,747 +597,94 +608,751 +608,119 +608,119 +614,210 +614,191 +614,658 +619,121 +619,580 +619,308 +621,780 +621,117 +621,541 +647,916 +647,3 +647,96 +652,373 +652,200 +652,170 +657,112 +657,770 +657,388 +658,597 +658,788 +658,8 +661,661 +661,592 +661,587 +662,579 +662,900 +662,23 +663,676 +663,227 +663,428 +664,62 +664,751 +664,733 +670,102 +670,248 +670,894 +676,621 +676,587 +676,565 +698,215 +698,224 +698,519 +701,45 +701,761 +701,765 +702,897 +702,748 +702,230 +705,51 +705,227 +705,55 +710,897 +710,192 +710,766 +723,463 +723,69 +723,55 +724,901 +724,10 +724,917 +733,246 +733,159 +733,178 +738,225 +738,256 +738,765 +743,18 +743,933 +743,863 +747,19 +747,199 +747,343 +748,68 +748,748 +748,40 +751,231 +751,251 +751,584 +761,388 +761,251 +761,112 +765,394 +765,187 +765,765 +766,584 +766,244 +766,399 +767,388 +767,701 +767,3 +770,326 +770,428 +770,112 +775,388 +775,466 +775,710 +779,916 +779,8 +779,592 +780,196 +780,187 +780,119 +782,710 +782,183 +782,10 +787,96 +787,585 +787,907 +788,434 +788,932 +788,225 +803,743 +803,200 +803,250 +812,585 +812,244 +812,159 +826,901 +826,34 +826,46 +831,76 +831,256 +831,96 +850,570 +850,104 +850,406 +854,204 +854,158 +854,765 +863,112 +863,596 +863,676 +875,44 +875,481 +875,812 +882,44 +882,608 +882,882 +883,310 +883,333 +883,661 +890,23 +890,912 +890,701 +894,863 +894,83 +894,121 +897,901 +897,183 +897,415 +900,67 +900,240 +900,310 +901,256 +901,500 +901,478 +902,244 +902,192 +902,3 +907,780 +907,990 +907,21 +912,485 +912,238 +912,159 +916,3 +916,373 +916,657 +917,883 +917,201 +917,894 +932,702 +932,406 +932,724 +933,177 +933,766 +933,301 +941,175 +941,199 +941,587 +962,301 +962,62 +962,27 +965,507 +965,204 +965,192 +975,18 +975,415 +975,250 +981,747 +981,187 +981,219 +990,11 +990,421 +990,962 diff --git a/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_produce.csv b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_produce.csv new file mode 100644 index 000000000..e5f8e4edf --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_produce.csv @@ -0,0 +1,62 @@ +LABEL=produce,SRC_LABEL=person,DST_LABEL=movie +id:INT32:SRC_ID,id:INT32:DST_ID +13,130 +14,130 +15,1 +15,28 +15,68 +106,82 +108,2498 +109,82 +145,130 +490,3915 +491,496 +491,3915 +549,737 +549,532 +549,564 +607,598 +609,598 +616,615 +664,641 +664,698 +664,797 +665,641 +665,698 +665,797 +665,3390 +666,641 +666,698 +666,797 +666,3390 +683,1693 +725,710 +725,805 +728,710 +728,805 +764,750 +776,2498 +791,2885 +793,781 +1119,1118 +1253,1241 +1295,1356 +1297,1293 +1298,1293 +1365,1356 +1371,2232 +1557,1550 +1705,1693 +1767,1768 +2021,2008 +2068,2055 +2074,2055 +2075,2055 +2243,2232 +2244,2232 +2779,2767 +2895,2885 +3113,3106 +3392,3390 +3464,3459 +3689,3680 diff --git a/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_rate.csv b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_rate.csv new file mode 100644 index 000000000..fe4cb5e02 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_rate.csv @@ -0,0 +1,297 @@ +LABEL=rate,SRC_LABEL=user,DST_LABEL=movie +id:INT32:SRC_ID,SKIP,id:INT32:DST_ID,stars:INT8 +2,William,1768,1 +3,James,615,3 +7,Joseph,82,3 +7,Joseph,532,3 +8,Thomas,698,3 +10,Robert,1693,3 +11,Edward,615,1 +18,David,1,3 +18,David,28,3 +18,David,1596,5 +18,David,2008,5 +18,David,2055,5 +18,David,3252,5 +18,David,3753,5 +18,David,3915,5 +19,Louis,1096,3 +21,Charlie,130,1 +22,Clarence,710,2 +23,Richard,68,4 +25,Daniel,737,3 +27,Will,641,4 +33,Frederick,781,3 +34,Willie,698,3 +36,Sam,681,5 +38,Herbert,82,1 +39,Jacob,68,5 +39,Jacob,641,2 +40,Tom,532,5 +44,Howard,698,1 +45,Martin,3106,5 +46,Michael,698,1 +51,Harvey,517,3 +51,Harvey,2498,3 +52,Earl,82,1 +52,Earl,598,2 +53,Eugene,517,4 +54,Ralph,737,4 +55,Ed,737,5 +57,Edwin,770,3 +59,Charley,68,4 +60,Paul,770,5 +62,Isaac,496,5 +66,Ira,471,3 +67,Patrick,1856,2 +68,Guy,1366,1 +69,Oliver,130,4 +69,Oliver,457,2 +74,August,130,1 +76,Homer,457,3 +82,Allen,471,3 +83,Archie,130,2 +94,Julius,130,1 +96,Sidney,770,2 +102,Dave,750,4 +104,Eddie,68,2 +104,Eddie,68,1 +109,Wesley,641,5 +111,Garfield,805,4 +112,Franklin,681,1 +116,Harold,3753,1 +117,Matthew,496,3 +117,Matthew,532,1 +119,Moses,564,3 +121,Lester,564,5 +121,Lester,710,1 +121,Lester,781,5 +126,Fredrick,681,4 +131,Aaron,496,2 +136,Victor,471,5 +142,Jake,598,1 +151,Claud,1366,4 +153,Sylvester,471,2 +158,Willard,710,3 +159,Irvin,496,3 +159,Irvin,564,3 +159,Irvin,781,1 +161,Jose,564,4 +161,Jose,615,5 +170,Wiley,82,2 +171,Anton,471,3 +171,Anton,781,5 +175,Augustus,1097,4 +177,Eli,598,4 +178,Nicholas,517,4 +183,Timothy,641,5 +183,Timothy,797,4 +186,Curtis,681,1 +187,Edmund,681,4 +187,Edmund,1293,4 +190,Harrison,698,5 +191,Stanley,496,3 +192,Columbus,68,2 +196,Russell,615,5 +196,Russell,1768,3 +197,Pearl,615,3 +199,Arch,737,5 +200,Asa,82,4 +201,Clayton,641,5 +202,Enoch,130,2 +202,Enoch,737,3 +204,Mathew,2498,5 +204,Mathew,2767,1 +210,Ellis,3753,5 +215,Wade,457,4 +218,Rudolph,471,3 +218,Rudolph,598,2 +218,Rudolph,770,5 +218,Rudolph,2398,5 +219,Sherman,457,3 +219,Sherman,532,3 +219,Sherman,770,2 +219,Sherman,1596,4 +219,Sherman,2008,4 +219,Sherman,2055,4 +219,Sherman,3252,4 +219,Sherman,3753,4 +219,Sherman,3915,4 +220,Austin,737,2 +221,Bill,564,3 +221,Bill,710,2 +222,Chas,750,2 +223,Lonnie,615,1 +224,Monroe,457,2 +224,Monroe,3252,1 +225,Byron,681,4 +227,Emery,532,1 +227,Emery,615,5 +228,Grant,82,3 +230,Max,1097,3 +231,Mose,598,2 +238,Gustave,698,3 +240,Lorenzo,517,3 +241,Bruce,457,5 +244,Bob,698,1 +244,Bob,750,4 +244,Bob,1550,4 +246,Donald,737,3 +248,Cecil,797,2 +250,Delbert,750,2 +251,Edmond,710,2 +251,Edmond,2654,4 +256,Luke,457,1 +266,Vincent,532,2 +293,Elisha,1693,5 +295,General,1596,1 +296,Julian,496,1 +301,Judson,641,4 +308,Forest,770,2 +310,Pink,82,4 +313,Ward,28,5 +313,Ward,68,5 +313,Ward,532,3 +313,Ward,564,3 +313,Ward,598,5 +313,Ward,1596,1 +313,Ward,2008,1 +313,Ward,2055,1 +313,Ward,2498,5 +313,Ward,3252,1 +313,Ward,3680,5 +313,Ward,3753,1 +313,Ward,3915,1 +319,Wilbert,2232,5 +321,Benjiman,2885,4 +326,Archibald,781,3 +328,Clint,770,5 +332,Mary,3459,2 +333,Merton,82,1 +339,Milo,82,3 +343,Elza,68,2 +350,Seth,598,1 +355,Washington,564,4 +368,Lafayette,496,5 +373,Abram,750,2 +375,Elliott,750,5 +383,Dallas,3753,5 +388,Lawson,457,2 +394,Erastus,598,2 +399,Stewart,641,2 +406,Clay,1356,2 +415,Jonathan,532,1 +421,Rolla,750,5 +422,Sandy,1366,1 +428,Carlos,737,2 +433,Harve,3915,2 +434,Israel,1096,2 +450,Geo,3106,5 +457,Orlando,598,4 +463,Stuart,82,1 +464,Wilburn,615,5 +466,Casper,517,2 +466,Casper,1412,5 +467,Christ,781,1 +478,Squire,82,2 +481,Wyatt,457,5 +485,Andres,1935,2 +491,Howell,496,1 +500,Reginald,130,3 +505,Benjamine,2398,5 +507,Carlton,698,2 +519,Rex,2422,4 +526,Al,641,4 +530,Art,615,5 +534,Beverly,68,4 +534,Beverly,3390,5 +536,Clair,130,2 +541,Dwight,68,4 +541,Dwight,1935,3 +544,Henderson,641,5 +552,Mortimer,1293,4 +565,Truman,598,4 +570,Wylie,805,1 +571,Alec,3915,4 +578,Colonel,1241,5 +579,Dempsey,770,3 +579,Dempsey,1097,1 +580,Early,750,4 +582,Fate,781,2 +584,Gabe,3680,1 +585,Garland,496,2 +587,Herschel,781,5 +588,Hezekiah,3252,3 +592,Olaf,3680,2 +594,Pablo,681,5 +596,Turner,681,5 +597,Verne,710,5 +608,Darius,1596,3 +614,Eric,781,3 +614,Eric,2008,1 +619,Hosea,3252,3 +621,Lonzo,1550,1 +647,Eben,770,1 +652,Finis,3624,5 +657,Hermann,532,3 +658,Isadore,2767,5 +661,June,3753,3 +662,Lacy,2654,5 +663,Lafe,517,2 +664,Leland,517,3 +670,Obie,698,1 +676,Parley,3624,2 +698,Dolphus,1412,2 +698,Dolphus,2008,2 +701,Fayette,750,2 +702,Felipe,710,2 +705,Florence,710,1 +710,Hoy,2422,1 +723,Odie,681,2 +724,Olen,737,1 +733,Richmond,710,5 +738,Shelby,641,5 +738,Shelby,1118,5 +743,Woodson,3915,1 +747,Alf,564,5 +748,Algie,517,1 +751,Bedford,130,4 +761,Clovis,517,4 +765,Duke,3459,1 +766,Eber,564,3 +767,Eligah,471,3 +770,Emmitt,737,5 +775,Harman,1241,5 +779,Jennie,532,5 +780,Len,496,3 +782,Lonie,471,1 +787,Miller,2885,5 +788,Orson,2498,5 +803,Vance,68,2 +812,Allison,1356,4 +826,Ballard,532,3 +831,Clarke,770,5 +850,Elsie,471,3 +854,Ferd,1118,2 +863,Hattie,517,1 +875,Kirk,641,5 +882,Noble,1856,3 +883,Obed,750,1 +890,Rube,471,2 +894,Sammie,457,3 +897,Stacy,517,2 +900,Thad,710,4 +901,Titus,710,4 +902,Tracy,2232,3 +907,Yee,457,2 +912,Albertus,698,1 +916,Artie,3390,3 +917,Arvid,750,4 +932,Brooks,781,5 +933,Buck,564,1 +941,Cyril,681,4 +962,Gardner,598,5 +965,Gottlieb,130,3 +975,Hermon,615,4 +981,Huey,2055,5 +990,Jodie,82,1 diff --git a/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_write.csv b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_write.csv new file mode 100644 index 000000000..825d05962 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/edge_write.csv @@ -0,0 +1,109 @@ +LABEL=write,SRC_LABEL=person,DST_LABEL=movie +id:INT32:SRC_ID,id:INT32:DST_ID +13,130 +13,1 +13,28 +13,68 +14,130 +14,1 +14,28 +14,68 +100,82 +108,82 +108,2498 +145,130 +490,3915 +491,471 +491,496 +492,471 +492,496 +495,457 +524,517 +525,517 +549,737 +549,532 +549,564 +550,532 +550,564 +551,532 +551,564 +608,598 +628,615 +664,641 +664,698 +664,797 +667,641 +667,698 +667,797 +668,641 +668,698 +668,797 +726,710 +727,710 +728,710 +728,805 +762,750 +763,750 +777,770 +778,770 +791,781 +792,781 +907,681 +1094,1096 +1095,1096 +1106,1097 +1108,1097 +1133,1118 +1134,1118 +1252,1241 +1254,1241 +1255,1241 +1295,1356 +1297,1293 +1299,1293 +1365,1356 +1379,1366 +1380,1366 +1381,1366 +1382,1366 +1422,1412 +1423,1412 +1557,1550 +1605,1596 +1606,1596 +1706,1693 +1766,1768 +1870,1856 +1871,1856 +1872,1856 +1873,1856 +1874,1856 +1942,1935 +1943,1935 +1943,2422 +1944,1935 +2022,2008 +2073,2055 +2076,2055 +2243,2232 +2245,2232 +2411,2398 +2412,2398 +2441,2422 +2442,2422 +2443,2422 +2444,2422 +2510,2498 +2664,2654 +2780,2767 +2896,2885 +2897,2885 +3112,3106 +3113,3106 +3268,3252 +3269,3252 +3399,3390 +3464,3459 +3631,3624 +3690,3680 +3761,3753 diff --git a/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/vertex_genre.csv b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/vertex_genre.csv new file mode 100644 index 000000000..0c1875d9e --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/vertex_genre.csv @@ -0,0 +1,21 @@ +LABEL=genre +id:INT32:ID,name:STRING +16,Action +17,Adventure +18,Sci-Fi +19,Thriller +110,Crime +129,Documentary +146,Drama +526,Western +610,History +611,War +669,Fantasy +746,Mystery +779,Comedy +780,Romance +1256,Animation +1257,Musical +1258,Family +2246,Horror +3270,Suspense diff --git a/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/vertex_keyword.csv b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/vertex_keyword.csv new file mode 100644 index 000000000..df1149321 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/vertex_keyword.csv @@ -0,0 +1,3255 @@ +LABEL=keyword +id:INT32:ID,name:STRING +20,saving the world +21,artificial intelligence +22,man versus machine +23,prophecy +24,self sacrifice +25,insurgence +26,messias +27,virtual reality +52,computer +53,future +54,underground world +55,hero +56,world religion +57,faith +58,kung fu +59,key +60,precognition +61,rave +62,computer virus +63,dream +64,dying and death +65,plato +66,mission +67,martial arts +70,flying +71,super computer +72,fight +73,killer robot +74,philosophy +75,rettung +76,subway +77,temple +78,machine town +79,truth +80,fortuneteller +81,sunlight +111,transporter +112,brothel +113,boxer +114,massage +115,stolen money +116,crime boss +117,dance contest +118,junkyard +119,kamikaze +120,ambiguous ending +121,briefcase +122,redemption +123,heirloom +124,pulp fiction +125,reference to al green +126,theft +147,19th century +148,clone +149,20th century +150,1850s +151,actor playing multiple roles +152,1930s +153,1970s +154,ensemble cast +155,actress playing multiple roles +156,year 2144 +157,year 1931 +158,year 1975 +159,restaurant +160,violence +161,diner +162,gangster +163,coffee +164,torso cut in half +165,chainsaw +166,male sitting on a toilet +167,bondage +168,syringe +169,hit by a car +170,shop owner +171,silencer +172,homage +173,voyeurism +174,shouting +175,corruption +176,blockbuster +177,shootout +178,voyeur +179,nurse +180,silenced machine gun +181,brushing teeth +182,shot multiple times +183,murder by gunshot +184,famous line +185,toaster +186,muzzle +187,running for your life +188,knocked out with gun butt +189,deception +190,head blown off +191,telling a joke +192,forming a square in the air +193,tongue piercing +194,basement +195,bible quote +196,snorting cocaine +197,talking to one's self in a mirror +198,mullet +199,controversy +200,movie reference +201,n word +202,garden hose +203,father son relationship +204,held at gunpoint +205,zentai +206,implied cunnilingus +207,blonde +208,interruption +209,male rape +210,anal rape +211,machine gun +212,cult director +213,chopper +214,joke +215,blowing a kiss +216,hamburger +217,shot in the leg +218,actor director +219,pack of money +220,bar +221,on the run +222,person in car trunk +223,interlinked stories +224,drug dealer +225,man wearing a pony tail +226,actor director writer +227,rape +228,impersonating buddy holly +229,pot smoking +230,pawnshop +231,shot in the face +232,bullet hole +233,motorcycle +234,uniform +235,gay rape +236,panties +237,covered in blood +238,gay sex +239,strip club +240,armed robbery +241,loyalty +242,afro +243,two man army +244,los angeles california +245,lifting someone into the air +246,restroom +247,drug use +248,organized crime +249,problem solver +250,cult film +251,murder +252,torture +253,falling asleep +254,marijuana joint +255,shot in the head +256,rescue +257,machismo +258,male in shower +259,convertible +260,director cameo +261,gun held to head +262,foot massage +263,military dress uniform +264,bloody mouth +265,cocaine +266,off screen murder +267,wristwatch +268,number 666 +269,gunshot wound +270,uzi +271,coming of age +272,blood stain +273,buddy +274,double cross +275,sprayed with water +276,blue panties +277,accidental shooting +278,bare feet +279,shot repeatedly +280,robbery +281,lingerie +282,multiple storyline +283,biblical passage +284,body piercing +285,car driving +286,shot to death +287,car crash +288,eeny meeny miny moe +289,phone booth +290,oral sex +291,mirror +292,cardiac injection +293,pump action shotgun +294,nipples visible through clothing +295,restaurant owner +296,extreme closeup +297,killed with a sword +298,shot in the forehead +299,neo noir +300,gore +301,code +302,flashback humor +303,girl in panties +304,freeze frame +305,milkshake +306,wrestler +307,sprite soda +308,f word +309,elevator +310,cleavage +311,white panties +312,drug +313,hit on the head +314,boxing +315,fool +316,interrogation +317,woman smoker +318,injection into the heart +319,fantasy sequence +320,directed by co star +321,fake blood +322,shot through a wall +323,impersonating a police officer +324,husband wife relationship +325,drug dealing +326,nonlinear timeline +327,corpse +328,watching tv +329,black suit clad killer +330,gold watch +331,assault +332,male nudity +333,no background score +334,telephone call +335,sex slave +336,shower +337,tuxedo +338,bound and gagged +339,impersonating mamie van doren +340,shot in the chest +341,hit in the face +342,joint +343,themed restaurant +344,drugs +345,claw hammer +346,black comedy +347,heroin +348,prologue +349,blood +350,flashback +351,pop tart +352,riding motorcycle +353,barefoot +354,adrenaline +355,chapterwise storytelling +356,anti hero +357,actress +358,singing +359,cult tv reference +360,moral ambiguity +361,tied to a chair +362,mexican standoff +363,two killers +364,intercom +365,drug snorting +366,taxi +367,impersonating marilyn monroe +368,near death experience +369,cocaine snorting +370,multiple time frames +371,blood on shirt +372,robber +373,blood spatter +374,upskirt +375,scantily clad female +376,piercing +377,talking while driving +378,multiple perspectives +379,homosexual rape +380,shot in the arm +381,rolling a joint +382,shot in the crotch +383,female bare feet +384,slot car racing +385,revenge +386,secret briefcase +387,celebrity impersonator +388,macguffin +389,male wearing an earring +390,apartment building +391,cup of coffee +392,humiliation +393,phonograph +394,caged human +395,nosebleed +396,two on a motorcycle +397,postmodern +398,reading book +399,number in character's name +400,secret code +401,bathroom +402,rapist +403,military officer +404,sexual reference +405,fixed fight +406,knocked out +407,vietnam veteran +408,mini dress +409,alarm +410,male with long hair +411,automatic weapon +412,trophy +413,katana +414,foot chase +415,wallet +416,katana sword +417,crime gone awry +418,racial slur +419,baseball bat +420,punched in the face +421,gold +422,blood on face +423,collision course +424,overdose +425,twist the dance +426,brutality +427,hitman +428,ball gag +429,chapter headings +430,drug addiction +431,gourmet +432,car accident +433,impersonating ed sullivan +434,slurping a drink with a straw +435,gun held to one's head +436,some scenes in black and white +437,cunnilingus +438,gun +439,drug overdose +440,head wound +441,killed with a gun +442,leather mask +443,bullet wound +444,african american +445,accidental killing +446,motel +447,abdomen slashed +448,watching the three stooges +449,finger gun +450,boyfriend girlfriend relationship +451,surrender +452,shotgun +453,zippo lighter +454,long take +455,divine intervention +467,1960s +468,1940s +469,1950s +470,police brutality +493,love at first sight +494,loss of father +511,blut +512,italo-american +513,cuba +514,praise +527,bounty hunter +528,refugee +529,1860s +530,gallows +531,army +552,chaos +553,gotham city +554,joker +555,sadism +556,crime fighter +557,superhero +558,vigilante +559,batman +560,based on comic +561,secret identity +562,tragic hero +563,super villain +581,burglar +582,mayor +583,hostage drama +584,time bomb +585,legend +586,cover up +587,villainess +588,terrorism +589,destruction +590,fictional city +591,cat burglar +592,statue +593,flood +594,hostage killed +595,woman kills man +596,football field +597,criminal underworld +612,concentration camp +613,factory +614,defense industry +629,jurors +630,court case +631,court +632,judge +633,class +634,group +635,sultriness +636,heat +637,innocence +638,death penalty +639,father murder +640,puertorican +670,elves +671,orcs +672,middle-earth (tolkien) +673,suspicion +674,bravery +675,honor +676,crushed to death +677,robe +678,troll +679,sword and sorcery +680,ghosts +691,bare knuckle boxing +692,support group +693,dual identity +694,nihilism +695,support +696,rage and hate +697,insomnia +701,dwarves +702,hobbits +703,mountains +704,mirrow +705,fireworks +706,castle +707,volcano +708,password +709,death of a friend +729,space colony +730,rebellion +731,rebel +732,space opera +733,asteroid +734,jedi +735,snow storm +736,spaceship +747,loss of lover +748,sleep +749,defense mechanism +765,individual +766,psychater +767,self-destruction +768,wheelchair +769,lunatic asylum +794,seventies +795,irish-american +796,drug traffic +799,explosive +800,fort +801,attack +802,guide +803,wizards +804,cave +816,galaxy +817,hermit +818,death star +819,lightsaber +820,empire +821,jedi knight +822,fourth part +823,planet +824,smuggler +825,the force +826,droid +827,tractor beam +828,stormtrooper +829,totalitarianism +830,love +831,bus stop +832,running +833,bus +834,simple man +835,fishing +836,jumping into water +837,cornfield +838,stock footage +839,new york city +840,single mother +841,friendship +842,loss of mother +843,battle +844,girl with glasses +845,telling someone to shut up +846,u.s. president +847,character appears on a tv talk show +848,son +849,church +850,serendipity +851,assassination of president +852,prayer +853,handicap +854,chocolate +855,calling someone an idiot +856,leg brace +857,fainting +858,climbing a tree +859,medal of honor +860,swimming +861,splatter +862,feather +863,television news +864,kindness +865,nike +866,disabled veteran +867,grave +868,male hits a female +869,interracial friendship +870,washington d.c. +871,slow motion +872,man hits a woman +873,man with glasses +874,hippie +875,character appears on magazine cover +876,doctor +877,telling someone to run +878,balcony +879,mentally impaired +880,father +881,mother +882,attempted suicide +883,diving into water +884,bully +885,legless man +886,told in flashback +887,racism +888,drug addict +889,character repeats narrator's words +890,fictional biography +891,two word title +892,park bench +893,vietnam war veteran +894,journey +895,assembling a rifle +896,war hero +897,face slap +898,loss of friend +899,woman with glasses +900,loss of virginity +901,maid +902,amputee +903,death of friend +904,based on book +905,based on novel +906,title spoken by character +908,mafia +909,wedding +910,lawyer +911,patriarch +912,character repeating someone else's dialogue +913,bronx new york city +914,smashing a camera +915,horse killed +916,melancholy +917,father daughter relationship +918,paparazzi +919,beating +920,garrotting +921,corrupt lawyer +922,motion picture executive +923,professional hit +924,symbolism +925,famous score +926,strangulation +927,vengeance +928,open hydrant +929,heart attack +930,italian american +931,exploding car +932,revolving door +933,pistol +934,knife in hand +935,hotel +936,nudity +937,marriage +938,police corruption +939,tommy gun +940,mansion +941,sicily italy +942,police +943,film producer +944,gambling syndicate +945,betrayal +946,female underage nudity +947,world war two veteran +948,assassin +949,murder of son +950,thompson gun +951,domestic violence +952,shot in the eye +953,crime family +954,brother brother relationship +955,character depth +956,undertaker +957,mercilessness +958,shooting +959,ethnic slur +960,cop killer +961,italy +962,urination +963,attorney +964,cosa nostra +965,broken rule +966,female nudity +967,shot in the back +968,dartmouth college +969,husband hits wife +970,baptism +971,cat +972,subtitled scene +973,funeral +974,marital abuse +975,las vegas nevada +976,severed head +977,teacher +978,movie theater +979,vegetable garden +980,police officer shot in the neck +981,ambush +982,italian food +983,dysfunctional family +984,falling down stairs +985,horse +986,car bomb +987,police officer shot +988,elderly man +989,part of trilogy +990,gang war +991,el train +992,picture in newspaper +993,convicted felon +994,casino +995,assassination +996,first of series +997,mob summit +998,mob hit +999,cemetery +1000,village +1001,knife +1002,brother sister relationship +1003,catholic church +1004,double murder +1005,loss of son +1006,bare breasts +1007,severed horse's head +1008,criminal +1009,adopted son +1010,christmas +1011,death +1012,police officer killed +1013,police officer shot in the head +1014,tough guy +1015,hospital +1016,stable +1017,no opening credits +1018,manhattan new york city +1019,tollbooth +1020,extramarital affair +1021,radio city music hall manhattan new york city +1022,courtship +1023,film set +1024,catholic +1025,breasts +1026,widower +1027,death of wife +1028,bathtub +1029,loss of wife +1030,italian american cop +1031,garrote +1032,stabbed in the hand +1033,shot through the eye +1034,paraplegic +1035,fbi +1036,broken jaw +1037,movie studio +1038,corrupt cop +1039,epic +1040,assassination attempt +1041,loss of husband +1042,mob boss +1043,ex soldier +1044,family relationships +1045,corleone italy +1046,pregnant woman beaten +1047,singer +1048,sibling rivalry +1049,wedding reception +1050,magnus opus +1051,protective male +1052,mob violence +1053,war veteran +1054,traitor +1055,crooked cop +1056,character appears in newspaper +1057,power +1058,beaten with a belt +1059,orange peel +1060,revolver +1061,fugitive +1062,gang warfare +1063,rise to power +1064,fish +1065,death of title character +1066,shot in the throat +1067,ex convict +1068,telephone box +1069,statue of liberty new york city +1070,invalid +1071,protection racket +1078,teenage daughter +1079,sexy woman +1080,desperation +1081,car chase +1082,central intelligence agency +1083,bicycle +1084,femme fatale +1085,paris france +1086,dance lesson +1087,american abroad +1088,cia agent +1089,terminal illness +1090,father daughter dance +1091,singing in a car +1092,terminal cancer +1093,prom +1109,number in title +1110,second part +1111,based on comic book +1112,imax +1113,based on graphic novel +1114,3 dimensional +1115,prequel +1116,digit in title +1117,dark horse comics +1135,fbi agent +1136,new jersey +1137,con artist +1138,lesbian kiss +1139,telephone conversation +1140,umbrella +1141,painting +1142,luxury hotel +1143,reference to cosmopolitan magazine +1144,cheating husband +1145,hand on thigh +1146,u.s. congressman +1147,reference to richard nixon +1148,fire +1149,drunk wife +1150,long island new york +1151,angry woman +1152,wife meets mistress +1153,lens flare +1154,critically acclaimed +1155,vinyl record +1156,teasing +1157,adultery +1158,burlesque dancer +1159,execution +1160,box office hit +1161,pool party +1162,hair curlers +1163,entrapment +1164,microwave +1165,museum +1166,mobster +1167,mother son relationship +1168,stripper +1169,butt slap +1170,double identity +1171,adulterous husband +1172,burlesque theater +1173,arabic +1174,disguise +1175,fake british accent +1176,smoking +1177,scene before opening credits +1178,scheme +1179,reference to duke ellington +1180,lost friend +1181,manipulation +1182,unexpected kiss +1183,sitting on a toilet +1184,u.s. senator +1185,toilet stall +1186,english accent +1187,turning against friends +1188,breaking a window +1189,fraud +1190,rainy day +1191,expensive gift +1192,politician +1193,private jet +1194,video surveillance +1195,bilingualism +1196,forgery +1197,dry cleaners +1198,camden new jersey +1199,fake accent +1200,wire fraud +1201,fbi chief +1202,divorce +1203,drunk woman +1204,bribery +1205,side boob +1206,wives and girlfriends +1207,italian mafia +1208,female sitting on a toilet +1209,true identity revealed +1210,fbi investigation +1211,year 1978 +1212,narrated by character +1213,young version of character +1214,reference to meyer lansky +1215,hotel suite +1216,sting operation +1217,new identity +1218,briefcase full of money +1219,public toilet +1220,blue balls +1221,reference to jimmy carter +1222,betrayal of husband +1223,phony english accent +1224,nightclub +1225,toilet +1226,bare chested male +1227,wire transfer +1228,bag over head +1229,women kissing +1230,scam +1231,written by director +1232,false identity +1233,nail polish +1234,atlantic city new jersey +1235,slow motion scene +1236,arrest +1237,women's toilet +1238,party +1239,character says i love you +1240,police investigation +1259,aftercreditsstinger +1260,queen +1261,princess +1262,snowman +1263,snow +1264,curse +1265,mountain climber +1266,mountain +1267,reindeer +1268,magic +1269,ice +1270,bechdel test passed +1271,clumsy girl +1272,villain arrested +1273,despair +1274,person in ice +1275,sister love +1276,treason +1277,scene after end credits +1278,cold +1279,based on fairy tale +1280,cheating death +1281,one word title +1282,girl +1283,orphan +1284,sacrifice +1285,deceiver +1286,falsely accused +1287,infatuation +1288,hopeless romantic +1289,disney animated feature +1290,surprise after end credits +1291,cliff +1292,isolation +1300,space +1301,trapped in space +1302,space mission +1303,oxygen +1304,medical engineer +1305,satellite +1306,astronaut +1307,adrift in space +1308,space station +1309,survival +1310,disaster +1311,spacewalk +1312,space shuttle +1313,race against time +1314,nasa +1315,alone against the odds +1316,hyperventilation +1317,fire extinguisher +1318,subjective camera +1319,houston texas +1320,hallucination +1321,space debris +1322,marooned +1323,panic +1324,outer space +1325,soliloquy +1326,woman with tragic history +1327,dream sequence +1328,weightlessness +1329,lack of oxygen +1330,hole in the head +1331,lack of gravity +1332,tension +1333,sole survivor +1334,minimal cast +1335,title at the end +1336,metaphor +1337,zero gravity +1338,parachute +1339,technology +1340,wrench +1341,underwater scene +1342,can opener +1343,earth viewed from space +1344,reference to marvin the martian +1345,kessler syndrome +1346,fear +1347,character's point of view camera shot +1348,one day +1349,death of daughter +1350,radio +1351,spinning through space +1352,spacesuit +1353,film starts with text +1354,frog +1355,bolt +1383,lego +1384,superman +1385,toys +1386,altered version of studio logo +1387,office building +1388,wizard +1389,dc comics +1390,dual personality +1391,chase +1392,ghost +1393,based on toy +1394,no title at beginning +1395,hobby +1396,teenage mutant ninja turtles +1397,twist at the end +1398,couch +1399,blind man +1400,evil businessman +1401,robot +1402,glue +1403,good cop bad cop +1404,cowboy +1405,saloon +1406,cyborg +1407,parallel worlds +1408,pirate ship +1409,pirate +1410,construction worker +1411,pig +1424,robocop +1425,sci fi movie remake +1426,drone +1427,rice field +1428,abandoned factory +1429,warehouse +1430,computer chip +1431,lasersight +1432,pentagon +1433,car motorcycle chase +1434,police chief +1435,detective +1436,reboot of series +1437,back from the dead +1438,taser +1439,investigation +1440,robot suit +1441,training +1442,social commentary +1443,explosion +1444,surveillance +1445,electrocution +1446,seizure +1447,burn victim +1448,gunfight +1449,china +1450,hand grenade +1451,futuristic +1452,virtuality +1453,helicopter +1454,action hero +1455,stylized violence +1456,shaky cam +1457,washington monument +1458,hostage +1459,maverick cop +1460,attempted murder +1461,one man army +1462,escape +1463,exposed brain +1464,police detective +1465,gun fu +1466,senator +1467,combat +1468,idealism +1469,hologram +1470,high tech +1471,press conference +1472,tough cop +1473,filmed killing +1474,urban setting +1475,rooftop +1476,general +1477,parking garage +1478,arms dealer +1479,armory +1480,islamic terrorism +1481,dark hero +1482,android +1483,tehran iran +1484,meth lab +1485,resurrection +1486,jumping from height +1487,ak 47 +1488,exploding body +1489,security camera +1490,disobeying orders +1491,mind control +1492,moral dilemma +1493,mercenary +1494,female cop +1495,laboratory +1496,warrior +1497,child in peril +1498,giant robot +1499,night vision goggles +1500,brain surgery +1501,motorcycle cop +1502,falling from height +1503,ceo +1504,heavy rain +1505,scientist +1506,war on terrorism +1507,super speed +1508,cyberpunk +1509,megacorporation +1510,detroit michigan +1511,law enforcement +1512,newspaper headline +1513,remake of american film +1514,news reporter +1515,ethics +1516,metal arm +1517,partner +1518,assault rifle +1519,guitar +1520,science +1521,undercover cop +1522,american flag +1523,tracking device +1524,politics +1525,hidden gun +1526,x rayed skeleton +1527,suburbia +1528,dual wield +1529,near future +1530,grenade launcher +1531,police vigilantism +1532,suicide bomber +1533,presumed dead +1534,media coverage +1535,armored car +1536,2020s +1537,police station +1538,undercover +1539,bleeped dialogue +1540,bullet time +1541,swat team +1542,remake +1543,white house +1544,jumping through a window +1545,cameraman +1546,tv personality +1547,news report +1548,cell phone +1549,fight the system +1561,operating system +1562,writer +1563,best friend +1564,playing video game +1565,lonely man +1566,ex husband ex wife relationship +1567,actress shares first name with character +1568,produced by director +1569,pronoun in title +1570,jealousy +1571,smoke rising from manhole +1572,woman in lingerie +1573,phone sex +1574,beach +1575,flashback sequence +1576,falling down +1577,sparkler +1578,relationship problems +1579,profanity +1580,romance with artificial intelligence +1581,manhole +1582,mustache +1583,computer tablet +1584,signing divorce papers +1585,surrogate +1586,break up +1587,video game +1588,train ride +1589,writing a letter +1590,blind date +1591,love letter +1592,loneliness +1593,los angeles skyline +1594,awkwardness +1595,masturbation +1607,hiv +1608,aids +1609,biopic +1610,fda +1611,electrician +1612,trial +1613,clinical trial +1614,hiv positive +1615,gay +1616,rodeo +1617,treatment +1618,gay community +1619,transvestite +1620,mexico +1621,pharmaceuticals +1622,dying man +1623,redneck +1624,vitamin +1625,research +1626,texas +1627,aids test +1628,emaciation +1629,thinness +1630,male underwear +1631,weight loss +1632,courthouse +1633,alternative medicine +1634,drip +1635,customs officer +1636,glasses +1637,transgender +1638,reference to ronald reagan +1639,cowboy hat +1640,prognosis +1641,gay acceptance +1642,drug prescription +1643,horse riding +1644,gay innuendo +1645,year 1986 +1646,police officer +1647,gay friend +1648,briefs +1649,homophobia +1650,fatal disease +1651,drug trial +1652,trailer +1653,transphobia +1654,gay taunting +1655,japan +1656,threesome +1657,year 1985 +1658,reference to marc bolan +1659,reference to boy george +1660,texan +1661,gay couple +1662,man crying +1663,airplane +1664,gay interest +1665,hiv aids +1666,gay character +1667,illness +1668,drag queen +1669,crying man +1670,dallas texas +1671,1980s +1672,fake priest +1673,library +1674,male rear nudity +1675,occupational injury +1676,aids activism +1677,city name in title +1678,border crossing +1679,mortality +1680,hospital gown +1681,gay slur +1682,u.s. mexican border +1683,gay black man +1684,coughing up blood +1685,activist +1686,what happened to epilogue +1687,hiv test +1688,pharmaceutical industry +1689,gay bar +1690,amsterdam netherlands +1691,gay son +1692,doctor patient relationship +1707,sold into slavery +1708,new york +1709,slavery +1710,slave +1711,abolitionist +1712,physical abuse +1713,slave owner +1714,rochester new york +1715,cotton field +1716,interracial marriage +1717,slave trade +1718,fiddle +1719,infidelity +1720,unfaithful husband +1721,crying woman +1722,forced to strip +1723,male frontal nudity +1724,year in title +1725,cotton +1726,whip +1727,kidnapping +1728,kidnapped man +1729,hanging +1730,whipping +1731,interracial romance +1732,male full frontal nudity +1733,slave labor +1734,plantation +1735,sweat +1736,jealous wife +1737,master slave relationship +1738,sex scene +1739,social injustice +1740,sexual abuse +1741,grief +1742,woman crying +1743,hairy chest +1744,1840s +1745,escape from slavery +1746,slave ship +1747,interracial rape +1748,louisiana +1749,chains +1750,undressing +1751,film starts with sex +1769,president +1770,thief +1771,radiation +1772,secretary of defense +1773,grenade +1774,year 2159 +1775,healing +1776,billionaire +1777,body armor +1778,illegal immigrant +1779,one percenter +1780,allegory +1781,brawl +1782,interracial relationship +1783,22nd century +1784,nun +1785,spacecraft +1786,corrupt official +1787,machete +1788,gun battle +1789,christ allegory +1790,title appears in writing +1791,lifting person in air +1792,place name in title +1793,death of protagonist +1794,looking at self in mirror +1795,flash drive +1796,implanted memory +1797,sick child +1798,coup +1799,class conflict +1800,home invasion +1801,south african +1802,2150s +1803,stabbed in the stomach +1804,deportation +1805,stabbed in the chest +1806,man punching a woman +1807,bodyguard +1808,overpopulation +1809,advanced technology +1810,dystopia +1811,exploding ship +1812,employer employee relationship +1813,radiation poisoning +1814,regeneration +1815,child murder +1816,surgery +1817,stabbed in the neck +1818,orphanage +1819,exploding head +1820,fist fight +1821,stabbed with glass +1822,swimming pool +1823,main character dies +1824,face blown off +1825,death of hero +1826,tattoo +1827,slum +1828,impalement +1829,parole officer +1830,forcefield +1831,class differences +1832,ecological disaster +1833,secret agent +1834,stabbed to death +1835,2100s +1836,crash landing +1837,power armor +1838,vomit +1839,sword +1840,devastated landscape +1841,sociopath +1842,unlikely hero +1843,breaking a mirror +1844,broken arm +1845,dark future +1846,spaceship crash +1847,leukemia +1848,brain machine interface +1849,heist +1850,mother daughter relationship +1851,computer hacker +1852,head ripped off +1853,man kills woman +1854,little girl +1855,death of child +1875,forest +1876,teenager +1877,quest +1878,slug +1879,dog +1880,talking animal +1881,helmet +1882,bow and arrow +1883,parchment +1884,miniature person +1885,giant +1886,parkour +1887,moon light +1888,sole black character dies cliche +1889,redhead +1890,deer +1891,ipod +1892,death of queen +1893,armor +1894,sword fight +1895,teenage girl +1896,video camera +1897,jump +1898,female protagonist +1899,tree +1900,duel +1901,swordsman +1902,saddle +1903,fictional war +1904,bud +1905,insect +1906,shot with an arrow +1907,hand to hand combat +1908,flying bat +1909,fantasy world +1910,surveillance camera +1911,moon +1912,surprise attack +1913,decay +1914,love interest +1915,mouse +1916,final battle +1917,mild violence +1918,plant +1919,sword and fantasy +1920,bat +1921,kiss +1922,bird +1923,pun +1924,siege +1925,little people +1926,riding a bird +1927,good versus evil +1928,full moon +1929,moonlight +1930,shrinking +1931,showdown +1932,samurai sword +1933,woman shot +1934,staff +1945,caveman +1946,prehistory +1947,tar +1948,dinosaur +1949,fall from height +1950,neophobia +1951,egg thief +1952,boy meets girl +1953,puppet +1954,smoke +1955,strict father +1956,death of neighbor +1957,monkey +1958,wreckage +1959,dreamworks animated film +1960,curiosity +1961,lava +1962,girl meets guy +1963,overprotective father +1964,handprint +1965,corn +1966,burned +1967,cave painting +1968,earthquake +1969,purring cat +1970,torch +1971,teenage girl in fur +1972,skeleton +1973,captive +1974,sun +1975,hunting +1976,tradition versus modernity +1977,scenic beauty +1978,complaining +1979,volcanic eruption +1980,egg +1981,hand over mouth +1982,crevice +1983,popcorn +1984,carnivorous plant +1985,homeless +1986,stuck in tar +1987,grandmother +1988,flower +1989,shell +1990,conch horn +1991,prehistoric man +1992,idea +1993,teen rebel +1994,horn +1995,firework +1996,starfish +1997,tiger +1998,counting +1999,animal costume +2000,nyctophobia +2001,story telling +2002,shoe +2003,sloth +2004,rock climbing +2005,labyrinth +2006,whale +2007,boy girl relationship +2023,time travel +2024,time machine +2025,past +2026,inventor +2027,trojan horse +2028,dancing +2029,albert einstein +2030,adoption +2031,tutankhamun +2032,time travelling machine +2033,decapitation +2034,mona lisa +2035,talking dog +2036,troy +2037,black hole +2038,space time continuum +2039,ancient troy +2040,loss of power +2041,hypnosis +2042,guillotine +2043,historical event +2044,french revolution +2045,gluttony +2046,ancient egypt +2047,pharaoh +2048,marie antoinette +2049,egypt +2050,leonardo da vinci +2051,school +2052,boyfriend +2053,cake +2054,playing music +2077,shield +2078,tesseract +2079,thor +2080,captain america +2081,captain +2082,iron man +2083,soldier +2084,super soldier +2085,alien invasion +2086,thunder +2087,monster +2088,alien +2089,fictional government agency +2090,evil sorcerer +2091,super strength +2092,marvel comic +2093,hammer +2094,grand central station manhattan new york city +2095,shot with a bow and arrow +2096,reference to stephen hawking +2097,head butt +2098,nuclear explosion +2099,human alien +2100,thrown through a wall +2101,severed arm +2102,exploding truck +2103,alien race +2104,laser gun +2105,crashing through a window +2106,prisoner +2107,rivalry +2108,fighting brothers +2109,female agent +2110,rescue mission +2111,spear +2112,transformation +2113,invisibility +2114,masked man +2115,bank +2116,street shootout +2117,little black dress +2118,space travel +2119,mask +2120,plane crash +2121,mothership +2122,philanthropist +2123,sorcerer +2124,rocket launcher +2125,aircraft carrier +2126,group name in title +2127,beaten to death +2128,body landing on a car +2129,battleship +2130,black eye patch +2131,female assassin +2132,spy +2133,fistfight +2134,secret government organization +2135,sabotage +2136,action heroine +2137,disaster in new york +2138,knife fight +2139,costumed hero +2140,walkie talkie +2141,nuclear missile +2142,jumping from an airplane +2143,scene during end credits +2144,gymnasium +2145,one eyed man +2146,exploding bus +2147,marvel comics +2148,ejector seat +2149,title appears in text +2150,eye patch +2151,russian +2152,invisibility cloak +2153,female warrior +2154,camera focus on female butt +2155,fighter jet +2156,beam of energy +2157,national guard +2158,alien attack +2159,scepter +2160,strong female character +2161,marvel entertainment +2162,cnn reporter +2163,punching bag +2164,returning character killed off +2165,fighter pilot +2166,humanity in peril +2167,hitting a woman +2168,portal +2169,exploding plane +2170,tough girl +2171,hit with a chair +2172,jumping from a plane without a parachute +2173,masked hero +2174,rocket +2175,cameo +2176,head mounted display +2177,shapeshifting +2178,government agent +2179,immortal +2180,wormhole +2181,supernatural power +2182,warrior race +2183,eye scanning +2184,eye gouging +2185,exploding building +2186,superheroine +2187,costume +2188,german +2189,marvel cinematic universe +2190,hit with a hammer +2191,world domination +2192,gatling gun +2193,bell 206 jet ranger helicopter +2194,tied up while barefoot +2195,archer +2196,banquet +2197,reference to god +2198,fish out of water +2199,nuclear threat +2200,stabbed in the back +2201,bomb +2202,hydra +2203,stuttgart germany +2204,teleportation +2205,mixed martial arts +2206,tied feet +2207,adopted brother +2208,kolkata india +2209,handcuffed +2210,missile +2211,laser +2212,power suit +2213,fighting in the air +2214,surprise during end credits +2215,orchestra +2216,chrysler building manhattan new york city +2217,genius +2218,cube +2219,crushed by a car +2220,helicopter crash +2221,returning character with different actor +2222,thrown through a window +2223,superhero team +2224,shape shifting alien +2225,sequel +2226,brooklyn bridge +2227,2010s +2228,lightning +2229,battlefield +2230,electromagnetic pulse +2231,kneeling +2247,witch +2248,hansel and gretel +2249,woods +2250,witch hunter +2251,witchcraft +2252,sheriff +2253,abduction +2254,coven +2255,axe +2256,white witch +2257,ruse +2258,walking in the dark +2259,head held under water +2260,burned alive +2261,crushed head +2262,tavern +2263,reward +2264,ritual +2265,man kicking a woman +2266,steampunk +2267,anti heroine +2268,censored rape scene +2269,scrapbook +2270,dragged along the ground +2271,self inflicted gunshot wound +2272,thrown from a cliff +2273,diabetes +2274,semiautomatic crossbow +2275,reflection in water +2276,ally +2277,injection +2278,gothic +2279,lost in the woods +2280,old dark house +2281,fan of a celebrity +2282,person on fire +2283,hit with a shovel +2284,trap +2285,pumpkin +2286,diabetic +2287,small town +2288,human sacrifice +2289,slow motion action scene +2290,skinny dipping +2291,burned at the stake +2292,porridge +2293,diabetic hero +2294,immolation +2295,woman stabbed +2296,rifle +2297,stabbed in the head +2298,lair +2299,witch burning +2300,ampersand in title +2301,superhuman strength +2302,air battle +2303,wisecrack humor +2304,spontaneous combustion +2305,potion +2306,immunity +2307,augsburg germany +2308,sunrise +2309,leather pants +2310,stun gun +2311,punched in the stomach +2312,bonfire +2313,lesson learned +2314,cabin in the woods +2315,desert +2316,hero kills a woman +2317,female rear nudity +2318,falling from a tree +2319,body torn apart +2320,black blood +2321,severed foot +2322,five word title +2323,waterfall +2324,catfight +2325,tracker +2326,shot in the shoulder +2327,woman kills woman +2328,critically bashed +2329,fireball +2330,cut into pieces +2331,hanged man +2332,lantern +2333,woman undressing +2334,hung upside down +2335,parents executed +2336,accused of witchcraft +2337,house fire +2338,hanging upside down +2339,broomstick +2340,suspended by one leg +2341,comic relief +2342,woman punching a man +2343,deputy +2344,head crushed +2345,dungeon +2346,surrealism +2347,witch hunt +2348,missing person poster +2349,forced suicide +2350,stabbed in the leg +2351,spell +2352,kid outsmarts adult +2353,burned to death +2354,invulnerability +2355,blood splatter +2356,oven +2357,farmer +2358,dead woman with eyes open +2359,black magic +2360,falling in love +2361,photograph +2362,grindhouse +2363,voice over narration +2364,punctuation in title +2365,broken nose +2366,brass knuckles +2367,hanged by the neck +2368,double crossbow +2369,insulin +2370,female killer +2371,supernatural +2372,fractured fairy tale +2373,ritual sacrifice +2374,colon in title +2375,picture of a missing child on a bottle of milk +2376,milk delivery +2377,eating a bug +2378,evil witch +2379,topless female nudity +2380,sniper +2381,dismemberment +2382,multi barreled pistol +2383,fight to the death +2384,stabbed in the arm +2385,gingerbread house +2386,wanted poster +2387,double barreled shotgun +2388,exploding house +2389,dark fantasy +2390,sniper rifle +2391,crossbow +2392,sawed off shotgun +2393,defibrillation +2394,lynching +2395,attempted rape +2396,haunted by the past +2397,minion +2413,walled city +2414,environmental +2415,money falling through the air +2416,tree cutting +2417,deforestation +2418,industry +2419,computer animation +2420,based on children's book +2421,urban sprawl +2445,dragon +2446,the huns +2447,luck +2448,matchmaker +2449,cricket +2450,public humiliation +2451,ancient china +2452,letter +2453,bo staff +2454,nose picking +2455,opening action scene +2456,northern wei dynasty +2457,female soldier +2458,gender disguise +2459,disney +2460,flaming arrow +2461,panda +2462,friend +2463,disarming someone +2464,sexism +2465,fire breathing dragon +2466,woman dressed as a man +2467,campfire +2468,beacon +2469,boot camp +2470,army life +2471,cartoon violence +2472,impersonating a soldier +2473,great wall of china +2474,two thousand year old poem +2475,wuxia fiction +2476,impersonation +2477,5th century +2478,war wound +2479,folklore +2480,archery +2481,kowtow +2482,cross dressing +2483,family dinner +2484,based on poem +2485,4th century +2486,bathing +2487,heroine +2488,6th century +2489,emperor +2490,war violence +2491,advisor +2492,secretly in love +2493,female fighter +2494,avalanche +2495,girl disguised as boy +2496,villain +2497,based on true story +2511,king +2512,demon +2513,sin +2514,danish +2515,creature +2516,promise +2517,denmark +2518,weakness +2519,thane +2520,kingdom +2521,christianity +2522,celebration +2523,candlestick +2524,human fallibility +2525,burnt face +2526,stabbed in the shoulder +2527,memory +2528,throat slitting +2529,actor plays multiple roles +2530,sadness +2531,custom +2532,stabbed in chest +2533,burning city +2534,feast +2535,sailing ship +2536,illegitimate son +2537,origin of hero +2538,slaughter +2539,death by fire +2540,falling off a cliff +2541,deformity +2542,mermaid +2543,reenactment +2544,expressionism +2545,swimming competition +2546,rite +2547,battle axe +2548,courage +2549,heart ripped out +2550,nude fight +2551,arm ripped off +2552,coronation +2553,sea +2554,leadership +2555,trampled to death +2556,wench +2557,disfigurement +2558,noble man +2559,hospitality +2560,loincloth +2561,burning building +2562,treasure chest +2563,rafter +2564,inheritance +2565,burning church +2566,claw +2567,severed leg +2568,female frontal nudity +2569,obsession +2570,sliced in two +2571,bridge +2572,necrophilia +2573,storm +2574,stabbed in the throat +2575,treasure +2576,cgi animation +2577,test of character +2578,death by sword +2579,ship +2580,animal attack +2581,crown +2582,rat +2583,drinking +2584,conquest +2585,burial +2586,drunkenness +2587,motion capture +2588,stabbing +2589,eaten alive +2590,stabbed in the eye +2591,sex +2592,hate +2593,fortress +2594,stabbed in the side +2595,martyr +2596,monster's den +2597,axe in the head +2598,monster child +2599,raider +2600,dagger +2601,seacoast +2602,suicide +2603,ancient sword +2604,dragon rider +2605,saga +2606,funeral rite +2607,burned body +2608,old english +2609,desecration +2610,golden horn +2611,bare back +2612,childlessness +2613,retelling +2614,beast's heart +2615,drinking house +2616,swamp +2617,cannibalism +2618,heir +2619,avarice +2620,fleet +2621,dwarf +2622,split in two +2623,apology +2624,frisian history +2625,shame +2626,ocean +2627,spear through chest +2628,servant +2629,heart +2630,seduction +2631,priest +2632,disembowelment +2633,massacre +2634,funeral pyre +2635,ragnarok +2636,hero worship +2637,bleeding to death +2638,mistress +2639,sword throwing +2640,norse +2641,fame +2642,buttocks +2643,reflection +2644,tragedy +2645,meadhall +2646,dark ages +2647,500s +2648,mutilation +2649,viking +2650,seductress +2651,mythology +2652,torn in half +2653,character name in title +2665,devil +2666,soul +2667,england +2668,spaniard +2669,monastery +2670,puritan +2671,fratricide +2672,disowned +2673,father son reunion +2674,mercy killing +2675,sorcery +2676,brother vs brother +2677,masked villain +2678,threatened with a knife +2679,golden coins +2680,gash in the face +2681,pagan +2682,drifter +2683,scar +2684,stabbed through the chest +2685,16th century +2686,union jack +2687,pit +2688,cloak +2689,traveller +2690,body marking +2691,animated credits +2692,dead child +2693,walking through fire +2694,human in a cage +2695,death of brother +2696,murder of family +2697,neck breaking +2698,gothic horror +2699,knife in the chest +2700,grim reaper +2701,inn +2702,hanged body +2703,horse drawn carriage +2704,demonic possession +2705,deal with the devil +2706,scottish accent +2707,hole in hand +2708,frozen lake +2709,1550s +2710,giant monster +2711,pile of gold +2712,closing credits sequence +2713,cloak and dagger +2714,stabbed through back +2715,hat +2716,british +2717,kidnapped girl +2718,dark past +2719,horse chase +2720,prince +2721,axe in the chest +2722,axe murder +2723,lord +2724,eyes blown out +2725,pushed from height +2726,epilogue +2727,revelation +2728,patricide +2729,river +2730,crucifixion +2731,reverse footage +2732,evil spirit +2733,crucifix +2734,evil versus evil +2735,brother against brother +2736,scars on back +2737,death of family +2738,ship captain +2739,1600s +2740,long haired male +2741,religion +2742,blood on camera lens +2743,bible +2744,abbey +2745,rainstorm +2746,based on pulp magazine +2747,undead +2748,mud +2749,last words +2750,wilhelm scream +2751,burning village +2752,monk +2753,head chopped off +2754,healer +2755,flaming sword +2756,self mutilation +2757,locket +2758,scroll +2759,north africa +2760,covered wagon +2761,murder of a child +2762,dreadlocks +2763,elizabethan era +2764,tent +2765,death of son +2766,independent film +2781,suspect +2782,hungarian +2783,hijacking +2784,criminal mastermind +2785,reference to albert einstein +2786,killed in an elevator +2787,lighter +2788,loss of daughter +2789,limping +2790,world trade center +2791,notice board +2792,loss of family +2793,reference to lee harvey oswald +2794,limp +2795,prison +2796,multiple endings +2797,funny accent +2798,law +2799,shot in back +2800,dock +2801,gold cigarette lighter +2802,unreliable flashback +2803,ship fire +2804,translator +2805,slitting the throat of a child +2806,unreliable narration +2807,breaking a car windshield +2808,stream of fire +2809,criminal fence +2810,emerald +2811,mystery man +2812,reference to loch ness monster +2813,fax machine +2814,car fire +2815,thieves falling out +2816,drug lord +2817,boy +2818,lifting an adult into the air +2819,masked criminal +2820,gasoline +2821,mind game +2822,checking watch +2823,urinating on a fire +2824,realization +2825,german shepherd +2826,lifting a male into the air +2827,sibling +2828,reference to pope john paul ii +2829,third degree burns +2830,mystery villain +2831,hundred dollar bill +2832,heist gone wrong +2833,cargo ship +2834,sitting +2835,wooden crate +2836,harbor +2837,mechanic +2838,bulletin board +2839,police badge +2840,cigarette smoking +2841,weapon +2842,watch +2843,murder of wife +2844,mp5 +2845,lighting a cigarette +2846,dead body in water +2847,boeing 747 +2848,woman lawyer +2849,multiple actors playing same role +2850,black mask +2851,irony +2852,burying a body +2853,relative +2854,pretending not to be leader +2855,pool hall +2856,cityscape +2857,box of money +2858,murder in elevator +2859,car +2860,reference to elvis presley +2861,dirty cop +2862,year 1981 +2863,world trade center manhattan new york city +2864,hiding +2865,turkish mafia +2866,secret character +2867,locked in jail +2868,cerebral palsy +2869,myth +2870,billiard table +2871,burnt body +2872,three word title +2873,automobile +2874,police sketch artist +2875,paint shaker +2876,evil +2877,anonymous telephone call +2878,recruiting +2879,murder of daughter +2880,homoerotic +2881,camera shot of feet +2882,customs +2883,1990s +2884,loss of child +2898,train station +2899,train +2900,clock +2901,automaton +2902,mechanical man +2903,secret +2904,toy +2905,french filmmaking +2906,toy mouse +2907,tools +2908,child +2909,camera +2910,death of uncle +2911,french film academy +2912,spotlight +2913,merry go round +2914,tears +2915,reference to the lumiere brothers +2916,eiffel tower paris +2917,photographer +2918,applause +2919,apprentice +2920,palace of glass +2921,holding hands +2922,oil can +2923,capture +2924,steam +2925,kiss on the cheek +2926,pastry +2927,reference to douglas fairbanks +2928,reference to neverland +2929,post world war one +2930,actor +2931,world war one +2932,fake dragon +2933,reference to david copperfield the novel +2934,clockwork +2935,theatre audience +2936,cafe +2937,circular staircase +2938,toy soldier +2939,being followed +2940,looking through a keyhole +2941,clock tower +2942,child's point of view +2943,standing on a chair +2944,uncle nephew relationship +2945,telephone +2946,theatre +2947,dog biting someone's pant leg +2948,reference to oz +2949,dead brother +2950,film restoration +2951,reference to charley chase +2952,toy store +2953,underfoot shot +2954,reason for living +2955,montage +2956,destroying property +2957,film director +2958,shoe heel +2959,winding a clock +2960,wicker basket +2961,author +2962,embarrassment +2963,writing +2964,pleading with praying hands +2965,year 1895 +2966,godfather goddaughter relationship +2967,following someone +2968,saving a life +2969,reference to jean valjean +2970,sliding down a pole +2971,filmmaking +2972,counting steps as ascending +2973,smelling a flower +2974,gears +2975,loudspeaker +2976,dropping a wrench +2977,graveyard +2978,nightshirt +2979,film preservation +2980,drawings floating in the air +2981,doberman pinscher +2982,drawing +2983,sliding between someone's legs +2984,movie poster +2985,godmother goddaughter relationship +2986,film historian +2987,message from dead father +2988,falling off a broken chair +2989,dancer +2990,broken chair +2991,flower lady +2992,girl trampled upon +2993,film projector +2994,shushing someone in a library +2995,name in title +2996,snowing +2997,notebook +2998,happiness +2999,policeman +3000,long underwear +3001,character says thank you +3002,fake beard +3003,train station guard +3004,wearing clothes in a bathtub +3005,purpose in life +3006,reference to christina rossetti +3007,climbing a wall +3008,picking a lock +3009,sense of time +3010,drink +3011,poetry +3012,card trick +3013,makeup +3014,silent movie +3015,doberman +3016,footlights +3017,reference to treasure island the novel +3018,book +3019,glass building +3020,toy repair +3021,bath +3022,boy on a ledge +3023,reference to hal roach +3024,pen +3025,reading +3026,enchanted castle +3027,train engine +3028,crying +3029,armoire +3030,reference to neptune +3031,muse +3032,scavenger +3033,flask +3034,magician's assistant +3035,hanging from a clock +3036,reference to harold lloyd +3037,reference to rudolph valentino +3038,silent filmmaking +3039,magic trick +3040,enigma +3041,dream within a dream within a dream +3042,mechanical heart +3043,machine +3044,reference to buster keaton +3045,reference to flanders +3046,falling +3047,film history +3048,watching a movie +3049,nightmare +3050,trust +3051,dead parents +3052,train wreck +3053,ladder +3054,dachshund +3055,train conductor +3056,street kid +3057,overhead shot +3058,reference to london england +3059,poet +3060,clockmaker +3061,3d +3062,hiding place +3063,croissant +3064,reference to robin hood the novel +3065,listening at a door +3066,drawings strewn across a floor +3067,caught on train tracks +3068,notre dame cathedral +3069,dragged by a train +3070,passion +3071,3 d +3072,movie theatre +3073,wind up toy +3074,reference to charlie chaplin +3075,seine river +3076,pocket watch +3077,film studio +3078,pursuit +3079,reference to jules verne +3080,film tinting +3081,reference to max linder +3082,cage +3083,ink +3084,sneaking into a movie +3085,lobster +3086,hand bill +3087,celluloid +3088,magician +3089,papers floating in the air +3090,falling into a bass fiddle +3091,musician +3092,carousel +3093,papers strewn across a floor +3094,train tracks +3095,dead body +3096,sideshow +3097,photography +3098,slide +3099,demitasse +3100,dog in love +3101,mechanical dragon +3102,bookstore +3103,train crashes into a train station +3104,traveling circus +3105,death of father +3114,ransom +3115,money +3116,minnesota +3117,fargo north dakota +3118,metafiction +3119,pancakes +3120,police arrest +3121,broken tv +3122,balancing family and career +3123,child swearing +3124,shooting a girl +3125,tv dinner +3126,biting +3127,small town americana +3128,playacting +3129,airport +3130,remorse +3131,pregnancy +3132,pregnant policewoman +3133,misperception +3134,engine trouble +3135,belt +3136,expectant mother +3137,car won't start +3138,cabin +3139,stolen license plate +3140,winter +3141,small town stereotype +3142,paul bunyan +3143,expectant father +3144,pastiche +3145,bruise +3146,unintended consequences +3147,lie +3148,pancake house +3149,liar +3150,false promise of the american dream +3151,devoted couple +3152,reference to mcdonald's +3153,prostitute +3154,hyperrealism +3155,north dakota +3156,tied up +3157,banker +3158,reality vs fantasy +3159,native american +3160,greed +3161,psychopath +3162,stopped by police +3163,car salesman +3164,running into a tree +3165,based on supposedly true story +3166,tall tale +3167,dumb criminal +3168,dual protagonist +3169,painter +3170,bismarck north dakota +3171,hooded victim +3172,tragic event +3173,anger +3174,pregnant wife +3175,rural setting +3176,bartender +3177,television +3178,norwegian american +3179,failure to communicate +3180,police car +3181,rage +3182,married to a police officer +3183,blurred boundaries +3184,perception +3185,botched crime +3186,middle america +3187,trickster +3188,farce +3189,body in a chipper +3190,marlboro man +3191,alienation +3192,artist +3193,buffet +3194,pregnant police officer +3195,crime scene +3196,policewoman killing +3197,shower curtain +3198,feminist +3199,body in a trunk +3200,ripping a telephone from the wall +3201,breaking and entering +3202,lifting a female into the air +3203,death threat +3204,double +3205,witness +3206,stolen car +3207,playboy magazine +3208,kicked in the face +3209,banality +3210,fast food +3211,alienated sexuality +3212,depravity +3213,knitting +3214,inner turmoil +3215,minneapolis minnesota +3216,secluded +3217,earthworm +3218,innocent person killed +3219,swedish american +3220,pair of killers +3221,breaking a glass window +3222,escort +3223,man cooking for woman +3224,overturning car +3225,accountant +3226,playing pool +3227,car dealer +3228,ice hockey +3229,ransom money +3230,deceit +3231,man in underwear +3232,pay phone +3233,hiding in a bathroom +3234,crowbar +3235,mulching someone +3236,psychological disintegration +3237,native american man +3238,premarital sex +3239,morning sickness +3240,duplicity +3241,grand guignol +3242,siren +3243,ski mask +3244,dark comedy +3245,auto mechanic +3246,epistemology +3247,crush +3248,marital fidelity +3249,woodchipper +3250,role playing +3251,duality +3271,serial killer +3272,psychiatrist +3273,agent +3274,cannibal +3275,fbi trainee +3276,case file +3277,psychologist +3278,making a public plea for information +3279,entomologist +3280,transsexual +3281,lights suddenly go out +3282,elevator shaft +3283,orchestral music score +3284,mangina +3285,rookie cop +3286,mass murderer +3287,flirting +3288,smithsonian institution +3289,female senator +3290,female lead +3291,cocoon +3292,reference to barry manilow +3293,storage facility +3294,evil man +3295,funeral home +3296,anagram +3297,graduation +3298,traumatic childhood +3299,mental institution +3300,psychoanalysis +3301,sexual identity +3302,moth +3303,maniac +3304,bahamas +3305,academy +3306,female fbi agent +3307,character appears on tv +3308,door bell +3309,baltimore maryland +3310,mace spray +3311,murder of a police officer +3312,barking dog +3313,police officer bitten +3314,murderer +3315,wake +3316,animal in title +3317,jail break +3318,murder investigation +3319,singing along with radio +3320,suspense +3321,secret past +3322,based on ed gein +3323,wearing human skin +3324,slasher +3325,illinois +3326,escape from handcuffs +3327,bad guy +3328,semen +3329,police baton +3330,maximum security mental institution +3331,mace the repellent +3332,contemporary setting +3333,west virginia +3334,tv news +3335,senator's daughter +3336,bucket +3337,music box +3338,obstacle course +3339,police training +3340,human monster +3341,sewing +3342,body count +3343,childhood flashback +3344,mental illness +3345,skinning +3346,ambulance +3347,maryland +3348,terror +3349,water well +3350,unhappy childhood +3351,singing along with a record +3352,tragic heroine +3353,autopsy +3354,psychology +3355,strait jacket +3356,animal in cast credits +3357,small dog +3358,gay stereotype +3359,stuck in a well +3360,sadistic psychopath +3361,reference to hannibal lecter +3362,psycho thriller +3363,virginia +3364,night vision sequence +3365,fat girl +3366,disguised as police +3367,severed face +3368,object made of human skin +3369,object made of body part +3370,poodle dog +3371,chess +3372,head in a jar +3373,basement pit +3374,classical music +3375,handcuffs +3376,effeminacy +3377,drugstore +3378,anthropophagus +3379,ohio +3380,tragic past +3381,muzzle flash +3382,transvestism +3383,mace +3384,mass murder +3385,homosexuality +3386,moving furniture +3387,starvation +3388,memphis tennessee +3389,pet dog +3400,speech +3401,king george vi +3402,speech therapist +3403,britain +3404,speech impediment +3405,stammering +3406,abdication +3407,unlikely friendship +3408,australian +3409,monarchy +3410,declaration of war +3411,bromance +3412,reference to duchess of windsor +3413,gargling +3414,ends with text +3415,radio speech +3416,microphone +3417,house of windsor +3418,cigarette case +3419,self confidence +3420,apostrophe in title +3421,stuttering +3422,year 1939 +3423,reference to adolf hitler +3424,royalty +3425,decorum +3426,british royal family +3427,male bonding +3428,pug dog +3429,death of king +3430,london england +3431,cigar smoking +3432,top hat +3433,radio broadcast +3434,scenario which perverts facts +3435,speech therapy +3436,voice recording +3437,christmas tree +3438,year 1934 +3439,priggishness +3440,ex actor +3441,practicing a speech +3442,stutter +3443,therapist client relationship +3444,building model airplane +3445,duke of windsor +3446,marble +3447,disability +3448,title in title +3449,reference to neville chamberlain +3450,biplane +3451,protocol +3452,archbishop of canterbury +3453,prime minister +3454,london fog +3455,friendship between men +3456,compassion +3457,underdog +3458,empowerment +3465,oil +3466,land +3467,california +3468,prospector +3469,business +3470,preacher +3471,pipeline +3472,wealth +3473,twin +3474,single father +3475,turn of the century +3476,faith healer +3477,ear exam +3478,dynamite +3479,religious fanatic +3480,false promise +3481,lighting fuse +3482,child romance +3483,bride and groom +3484,butler +3485,1900s +3486,construction +3487,bludgeoning +3488,san francisco california +3489,quail +3490,oil rig +3491,set on fire +3492,goat +3493,tuberculosis +3494,oil well +3495,building collapse +3496,ambition +3497,drilling for oil +3498,business deal +3499,1920s +3500,oil derrick +3501,control freak +3502,american +3503,false prophet +3504,child uses gun +3505,cross +3506,confession +3507,unconsciousness +3508,pipe smoking +3509,backpack +3510,food +3511,arson +3512,bowling alley +3513,baby +3514,striking oil +3515,americana +3516,accidental death +3517,digging a grave +3518,minister +3519,tower +3520,experimental soundtrack +3521,great depression +3522,mining equipment +3523,dress +3524,sermon +3525,bowling ball +3526,religious intolerance +3527,train depot +3528,ice cream parlor +3529,missionary +3530,telescope +3531,song +3532,religious zealot +3533,sparks +3534,railroad track +3535,sinner +3536,child abandonment +3537,beaten to death with a bowling pin +3538,chain gang +3539,pick axe +3540,signature +3541,silver city new mexico +3542,milk +3543,threat +3544,underwear +3545,surrogate father +3546,diary +3547,child abuse +3548,flash forward +3549,mine +3550,gospel +3551,impotence +3552,villain played by lead actor +3553,loss of hearing +3554,pickaxe +3555,hymn +3556,capitalism +3557,port wyanimi california +3558,napkin +3559,farming +3560,oil tycoon +3561,sulphur +3562,price of fame +3563,oil gusher +3564,oil industry +3565,1910s +3566,surrogate son +3567,public speaking +3568,interpreter +3569,alcoholism +3570,deafness +3571,salvation +3572,falling off a ladder +3573,blasphemy +3574,exploration +3575,male slaps male +3576,renovation +3577,lifting male in air +3578,bowling pin +3579,camp +3580,horse and wagon +3581,map +3582,misanthrope +3583,passing out +3584,death in childbirth +3585,mining +3586,half brother +3587,fon du lac wisconsin +3588,arthritis +3589,same actor playing twin role +3590,business associate +3591,freak accident +3592,firewood +3593,childbirth +3594,competition +3595,spiritual healing +3596,evangelist +3597,superstition +3598,tool +3599,irrigation +3600,injury +3601,goat farmer +3602,sign language +3603,reference to jesus christ +3604,silver mine +3605,broken leg +3606,businessman +3607,twin brother +3608,signal hill california +3609,land grabbing +3610,alcoholic +3611,claim in title +3612,railway station +3613,1890s +3614,dragged by one's hair +3615,land surveying +3616,whistling +3617,pacific ocean +3618,quail hunting +3619,impostor +3620,loss of brother +3621,waiter +3622,matches +3623,actor shares first name with character +3632,margaret thatcher +3633,conservative party +3634,parliament +3635,falklands +3636,grocer +3637,british prime minister +3638,argentina +3639,female prime minister +3640,public service +3641,dementia +3642,dinner party +3643,political party +3644,british overseas territory +3645,political campaign +3646,war propaganda +3647,mp +3648,political leader +3649,year 1982 +3650,stubbornness +3651,widow +3652,2000s +3653,right wing +3654,voice +3655,memoirs +3656,confusion +3657,foreign affairs +3658,befuddled +3659,public image +3660,international politics +3661,10 downing street +3662,election +3663,title directed by female +3664,military invasion +3665,number 10 +3666,flashbacks +3667,female politician +3668,dead husband +3669,british politics +3670,baroness +3671,cold war +3672,falklands war +3673,mourning +3674,decline +3675,premier +3676,alzheimer's disease +3677,military junta +3678,born in 1925 +3679,pearls +3691,treasury agent +3692,federal agent +3693,untouchable +3694,tax evasion +3695,prohibition +3696,baby carriage +3697,irish american +3698,shot through the mouth +3699,hit in the crotch +3700,jury +3701,speakeasy +3702,defenestration +3703,irish american cop +3704,end justifies the means +3705,switchblade +3706,chase on the roof +3707,cutting face while shaving +3708,newspaper +3709,white suit +3710,yawning +3711,money laundering +3712,bombing +3713,gun violence +3714,courtroom +3715,ledger +3716,firing range +3717,smuggling +3718,corrupt judge +3719,rule of law +3720,writing in blood +3721,prohibition repeal +3722,tax evader +3723,jury tampering +3724,staircase +3725,whiskey +3726,hit with a baseball bat +3727,police raid +3728,crime epic +3729,righteous rage +3730,roof chase +3731,reference to j. edgar hoover +3732,kicked in the crotch +3733,alley fight +3734,based on tv series +3735,suitcase +3736,year 1930 +3737,illegal business +3738,g man +3739,fighting fire with fire +3740,rooftop chase +3741,social contract +3742,drum magazine +3743,u.s. treasury agent +3744,opera +3745,royal canadian mounted police +3746,yawn +3747,intimidation +3748,u.s. canadian border +3749,alcohol +3750,criminal justice +3751,lawlessness +3752,chicago illinois +3762,kansas +3763,truman capote +3764,harper lee +3765,holcomb kansas +3766,killer +3767,homosexual +3768,farmhouse +3769,interview +3770,prairie +3771,black american +3772,kansas supreme court +3773,medical dictionary +3774,coffin +3775,reference to breakfast at tiffany's the novel +3776,wheat +3777,reference to in cold blood the book +3778,telegram +3779,cherokee tribe +3780,hunger strike +3781,cherokee +3782,harness +3783,stepfather stepson relationship +3784,blindfold +3785,park +3786,capital punishment +3787,thank you speech +3788,journalism +3789,leg deformity +3790,standing ovation +3791,execution witness +3792,leg injury +3793,body search +3794,reference to richard avedon +3795,methodist +3796,noose +3797,death of sister +3798,brooklyn new york city +3799,grocery store +3800,aspirin +3801,death row +3802,eyeglasses +3803,year 1960 +3804,multiple murder +3805,newspaper clipping +3806,hood +3807,fort leavenworth kansas +3808,leavenworth kansas +3809,prison warden +3810,teenage boy +3811,non fiction novel +3812,suicide watch +3813,reference to to kill a mockingbird the novel +3814,safe +3815,cell mate +3816,multiple homicide +3817,nursing +3818,new orleans louisiana +3819,suicide of brother +3820,stay of execution +3821,hug +3822,manuscript +3823,sketching +3824,bribe +3825,toy gun +3826,shackles +3827,jail cell +3828,no witnesses +3829,photo album +3830,costa brava spain +3831,scissors +3832,murder of mother +3833,false friend +3834,execution by hanging +3835,car rental +3836,farm +3837,legal appeal +3838,surrogate brother +3839,wheat field +3840,pornography +3841,lisp +3842,last breath +3843,lord's prayer +3844,bellcap +3845,guard +3846,public reading +3847,supreme court +3848,force feeding +3849,alabama +3850,spain +3851,tin cup +3852,frisking +3853,reference to sears roebuck +3854,publisher +3855,reversing charges on a telephone call +3856,spoon +3857,new yorker magazine +3858,feeding baby food +3859,suicide of sister +3860,new york times +3861,prison cell +3862,dressing gown +3863,rejected legal appeal +3864,eccentric +3865,magazine +3866,reading newspaper +3867,salon +3868,jail guard +3869,american midwest +3870,high school +3871,reference to walden +3872,gay lead character +3873,research assistant +3874,horn rimmed glasses +3875,taxi driver +3876,sorrow +3877,reference to elizabeth taylor +3878,reference to henry david thoreau +3879,leavenworth penitentiary +3880,reference to henri matisse +3881,limousine +3882,reference to humphrey bogart +3883,typewriter +3884,pain +3885,celebrity +3886,year 1959 +3887,cook +3888,american indian +3889,murder of husband +3890,vanity +3891,flowers +3892,porter +3893,baby food +3894,pretending to be someone's friend +3895,student +3896,neighbor +3897,reporter +3898,reference to john huston +3899,pillow +3900,death by hanging +3901,prison guard +3902,funeral parlor +3903,prison visitation +3904,amigo +3905,penitentiary +3906,train compartment +3907,martini +3908,self portrait +3909,typing +3910,book reading +3911,reference to tennessee williams +3912,boyfriend boyfriend relationship +3913,insanity plea +3914,jail +3918,meet +3919,commercial +3920,japanese +3921,yale +3922,reference to joey bishop +3923,call girl +3924,culture clash +3925,wig +3926,language barrier +3927,culture shock +3928,one night stand +3929,airhead +3930,james bond spoof scene +3931,height +3932,billboard +3933,east west +3934,film star +3935,college graduate +3936,reference to the rat pack +3937,pool +3938,city traffic +3939,hooker +3940,shrine +3941,whispering +3942,x ray +3943,karaoke +3944,mini skirt +3945,fatigue +3946,world weariness +3947,housewife +3948,television commercial +3949,ennui +3950,reference to sean connery +3951,arcade game +3952,thong +3953,bare butt +3954,lounge singer +3955,translation +3956,yale university +3957,disorientation +3958,director +3959,video arcade +3960,foot injury +3961,see through panties +3962,may december romance +3963,hotel room +3964,nylons +3965,talk show host +3966,exotic dancing +3967,stockings +3968,jet lag +3969,kyoto japan +3970,erotic dancing +3971,long distance call +3972,sauna +3973,television broadcasting +3974,nude girl +3975,bb gun +3976,exotic dancer +3977,older man younger woman relationship +3978,pink panties +3979,travel +3980,orient +3981,arcade +3982,public nudity +3983,bride +3984,reference to dean martin +3985,oriental +3986,fictional talk show +3987,business trip +3988,advertisement +3989,boredom +3990,reference to roger moore +3991,tokyo japan +3992,scotch whisky +3993,midlife crisis +3994,nude +3995,tv show in film +3996,pachinko diff --git a/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/vertex_movie.csv b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/vertex_movie.csv new file mode 100644 index 000000000..3c407a7fe --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/vertex_movie.csv @@ -0,0 +1,56 @@ +LABEL=movie +id:INT32:ID,title:STRING,tagline:STRING,summary:STRING:OPTIONAL,poster_image:STRING:OPTIONAL,duration:INT32,rated:STRING:OPTIONAL +1,The Matrix,Welcome to the Real World.,Thomas A. Anderson is a man living two lives. By day he is an average computer programmer and by night a malevolent hacker known as Neo who finds himself targeted by the police when he is contacted by Morpheus a legendary computer hacker who reveals the shocking truth about our reality.,http://image.tmdb.org/t/p/w185/gynBNzwyaHKtXqlEKKLioNkjKgN.jpg,136,R +28,The Matrix Reloaded,Free your mind.,Six months after the events depicted in The Matrix Neo has proved to be a good omen for the free humans as more and more humans are being freed from the matrix and brought to Zion the one and only stronghold of the Resistance. Neo himself has discovered his superpowers including super speed ability to see the codes of the things inside the matrix and a certain degree of pre-cognition. But a nasty piece of news hits the human resistance: 250000 machine sentinels are digging to Zion and would reach them in 72 hours. As Zion prepares for the ultimate war Neo Morpheus and Trinity are advised by the Oracle to find the Keymaker who would help them reach the Source. Meanwhile Neo's recurrent dreams depicting Trinity's death have got him worried and as if it was not enough Agent Smith has somehow escaped deletion has become more powerful than before and has fixed Neo as his next target.,http://image.tmdb.org/t/p/w185/ezIurBz2fdUc68d98Fp9dRf5ihv.jpg,138,R +68,The Matrix Revolutions,Everything that has a beginning has an end.,The human city of Zion defends itself against the massive invasion of the machines as Neo fights to end the war at another front while also opposing the rogue Agent Smith.,http://image.tmdb.org/t/p/w185/sKogjhfs5q3azmpW7DFKKAeLEG8.jpg,129,R +82,Pulp Fiction,Just because you are a character doesn't mean you have character.,placeholder text,http://image.tmdb.org/t/p/w185/dM2w364MScsjFf8pfMbaWUcWrR.jpg,154,R +130,Cloud Atlas,Everything is Connected,placeholder text,http://image.tmdb.org/t/p/w185/k9gWDjfXM80iXQLuMvPlZgSFJgR.jpg,172,R +457,The Shawshank Redemption,Fear can hold you prisoner. Hope can set you free.,placeholder text,http://image.tmdb.org/t/p/w185/9O7gLzmreU0nGkIB6K3BsJbzvNv.jpg,142,R +471,The Godfather,An offer you can't refuse.,placeholder text,http://image.tmdb.org/t/p/w185/d4KNaTrltq6bpkFS01pYtyXa09m.jpg,175,R +496,The Godfather: Part II,I don't feel I have to wipe everybody out Tom. Just my enemies.,placeholder text,http://image.tmdb.org/t/p/w185/tHbMIIF51rguMNSastqoQwR0sBs.jpg,200,R +517,The Good the Bad and the Ugly,For three men the Civil War wasn't hell. It was practice.,placeholder text,http://image.tmdb.org/t/p/w185/8PD1dgf0kQHtRawoSxp1jFemI1q.jpg,161,R +532,The Dark Knight,Why So Serious?,placeholder text,http://image.tmdb.org/t/p/w185/1hRoyzDtpgMU7Dz4JF22RANzQO7.jpg,152,PG-13 +564,The Dark Knight Rises,The Legend Ends,placeholder text,http://image.tmdb.org/t/p/w185/dEYnvnUfXrqvqeRSqvIEtmzhoA8.jpg,165,PG-13 +598,Schindler's List,Whoever saves one life saves the world entire.,placeholder text,http://image.tmdb.org/t/p/w185/tvOvW7Qjj63zbQW5TZ8CjPThAUd.jpg,195,R +615,12 Angry Men,Life is in their hands. Death is on their minds.,placeholder text,http://image.tmdb.org/t/p/w185/wvlFtIwh0GIqHRAz9F5cCch2IJD.jpg,96,NR +641,The Lord of the Rings: The Return of the King,The eye of the enemy is moving.,Aragorn is revealed as the heir to the ancient kings as he Gandalf and the other members of the broken fellowship struggle to save Gondor from Sauron's forces. Meanwhile Frodo and Sam bring the ring closer to the heart of Mordor the dark lord's realm.,http://image.tmdb.org/t/p/w185/50LoR9gJhbWZ5PpoHgi8MNTYgzd.jpg,201,PG-13 +681,Fight Club,How much can you know about yourself if you've never been in a fight?,placeholder text,http://image.tmdb.org/t/p/w185/2lECpi35Hnbpa4y46JX0aY3AWTy.jpg,139,R +698,The Lord of the Rings: The Fellowship of the Ring,One ring to rule them all,Young hobbit Frodo Baggins after inheriting a mysterious ring from his uncle Bilbo must leave his home in order to keep it from falling into the hands of its evil creator. Along the way a fellowship is formed to protect the ringbearer and make sure that the ring arrives at its final destination: Mt. Doom the only place where it can be destroyed.,http://image.tmdb.org/t/p/w185/9HG6pINW1KoFTAKY3LdybkoOKAm.jpg,178,PG-13 +710,Star Wars: Episode V - The Empire Strikes Back,The Adventure Continues...,placeholder text,http://image.tmdb.org/t/p/w185/6u1fYtxG5eqjhtCPDx04pJphQRW.jpg,124,PG +737,Inception,Your mind is the scene of the crime.,placeholder text,http://image.tmdb.org/t/p/w185/tAXARVreJnWfoANIHASmgYk4SB0.jpg,148,PG-13 +750,One Flew Over the Cuckoo's Nest,If he's crazy what does that make you?,placeholder text,http://image.tmdb.org/t/p/w185/srr59GKJdDXPwnWlew9NoYfOvYV.jpg,133,R +770,Forrest Gump,The world will never be the same once you've seen it through the eyes of Forrest Gump.,A man with a low IQ has accomplished great things in his life and been present during significant historic events - in each case far exceeding what anyone imagined he could do. Yet despite all the things he has attained his one true love eludes him. 'Forrest Gump' is the story of a man who rose above his challenges and who proved that determination courage and love are more important than ability.,http://image.tmdb.org/t/p/w185/z4ROnCrL77ZMzT0MsNXY5j25wS2.jpg,142,PG-13 +781,Goodfellas,Three Decades of Life in the Mafia.,placeholder text,http://image.tmdb.org/t/p/w185/pwpGfTImTGifEGgLb3s6LRPd4I6.jpg,146,R +797,The Lord of the Rings: The Two Towers,A New Power Is Rising.,Frodo and Sam are trekking to Mordor to destroy the One Ring of Power while Gimli Legolas and Aragorn search for the orc-captured Merry and Pippin. All along nefarious wizard Saruman awaits the Fellowship members at the Orthanc Tower in Isengard.,http://image.tmdb.org/t/p/w185/9mBjBuUmBBgnGjV1JZ2uCIYbaph.jpg,179,PG-13 +805,Star Wars: Episode IV - A New Hope,A long time ago in a galaxy far far away...,Princess Leia is captured and held hostage by the evil Imperial forces in their effort to take over the galactic Empire. Venturesome Luke Skywalker and dashing captain Han Solo team together with the loveable robot duo R2-D2 and C-3PO to rescue the beautiful princess and restore peace and justice in the Empire.,http://image.tmdb.org/t/p/w185/tvSlBzAdRE29bZe5yYWrJ2ds137.jpg,121,PG +1096,3 Days to Kill,amazing killing time,placeholder text,http://image.tmdb.org/t/p/w185/53pam1GAosXwOjefCEVNjYTvy6j.jpg,113,PG-13 +1097,300: Rise of an Empire,Amazing killing time,placeholder text,http://image.tmdb.org/t/p/w185/hrOMW22FV86te7uLyRnp3Z6Nv6e.jpg,0,R +1118,American Hustle,Everyone Hustles To Survive,placeholder text,http://image.tmdb.org/t/p/w185/mhB7C62lSMpGO2HYNaW6d7W3TVH.jpg,138,R +1241,Frozen,Amazing killing time,placeholder text,http://image.tmdb.org/t/p/w185/qb4ls8KzTJMFPEwNOfM7FotfC4Y.jpg,102,PG +1293,Gravity,Don't Let Go,placeholder text,http://image.tmdb.org/t/p/w185/2gPjLWIyrWlAn2DgKMOKTBnZYyO.jpg,91,PG-13 +1356,The Monuments Men,It was the greatest art heist in history,placeholder text,http://image.tmdb.org/t/p/w185/lhCUqVEPA3MMxnV8QTeVBTmRrP4.jpg,118,PG-13 +1366,The LEGO Movie,Assembling in 2014,placeholder text,http://image.tmdb.org/t/p/w185/lMHbadNmznKs5vgBAkHxKGHulOa.jpg,100,PG +1412,RoboCop,We've got the future under control.,placeholder text,http://image.tmdb.org/t/p/w185/hFQcC5eSSHqJfk70RdgrMMxGuYt.jpg,102,PG-13 +1550,Her,Amazing killing time,placeholder text,http://image.tmdb.org/t/p/w185/8f8Hisd36IN8jN1OpKxsxRu8i57.jpg,126,R +1596,Dallas Buyers Club,Dare to Live,placeholder text,http://image.tmdb.org/t/p/w185/ecb5z7VGKjfSQLPMwt1FOiPE5V0.jpg,117,R +1693,12 Years a Slave,The extraordinary true story of Solomon Northup,placeholder text,http://image.tmdb.org/t/p/w185/kb3X943WMIJYVg4SOAyK0pmWL5D.jpg,134,R +1768,Elysium,Amazing killing time,placeholder text,http://image.tmdb.org/t/p/w185/tHkjoAxmhp3Eau1h0Ir7maKMwUz.jpg,109,R +1856,Epic,Discover a world beyond your imagination,placeholder text,http://image.tmdb.org/t/p/w185/fdXA81BOdZ3pEyBlY8UUvuJj136.jpg,102,PG +1935,The Croods,Meet the first modern family.,placeholder text,http://image.tmdb.org/t/p/w185/mo4WQxBxs6IU7fmkIOyMOLyG3qq.jpg,98,PG +2008,Mr. Peabody & Sherman,Amazing killing time,placeholder text,http://image.tmdb.org/t/p/w185/qnmYfaopf7xJwLgVjeTdgZ4nI0v.jpg,92,PG +2055,The Avengers,Some assembly required.,placeholder text,http://image.tmdb.org/t/p/w185/cezWGskPY5x7GaglTTRN4Fugfb8.jpg,143,PG-13 +2232,Hansel & Gretel: Witch Hunters,Classic tale. New twist.,placeholder text,http://image.tmdb.org/t/p/w185/yDIVWFJqFLIeS8E1R6GG9uwPMS3.jpg,88,R +2398,The Lorax,Meet The Original Force Of Nature,placeholder text,http://image.tmdb.org/t/p/w185/6FuYtjegxaUv7n7C733hUEOQytR.jpg,86,PG +2422,Mulan,This time the princess saves the prince.,placeholder text,http://image.tmdb.org/t/p/w185/ztD0iLfeyESQZV95GwPeSE3Uyqn.jpg,88,G +2498,Beowulf,Evil breeds pain.,placeholder text,http://image.tmdb.org/t/p/w185/j90lLkvlcPNL6VVoLGQ0yzPUfJV.jpg,115,PG-13 +2654,Solomon Kane,Fight evil... With evil.,placeholder text,http://image.tmdb.org/t/p/w185/n5SHBE4ulsDDVa9gYttUYwp1VZU.jpg,104,R +2767,The Usual Suspects,Five Criminals . One Line Up . No Coincidence.,placeholder text,http://image.tmdb.org/t/p/w185/jgJoRWltoS17nD5MAQ1yK2Ztefw.jpg,106,R +2885,Hugo,One of the most legendary directors of our time takes you on an extraordinary adventure.,placeholder text,http://image.tmdb.org/t/p/w185/fkeaJr29ypea1n24gzspsc7qK44.jpg,126,PG +3106,Fargo,A lot can happen in the middle of nowhere.,placeholder text,http://image.tmdb.org/t/p/w185/aZeX4XNSqa08TdMHRB1gDLO6GOi.jpg,98,R +3252,The Silence of the Lambs,To enter the mind of a killer she must challenge the mind of a madman.,placeholder text,http://image.tmdb.org/t/p/w185/qjAyTj2BSth1EQ89vNfo0JYVPFN.jpg,118,R +3390,The King's Speech,Find your voice.,placeholder text,http://image.tmdb.org/t/p/w185/v8M5Sytbut7vBXyZ1HDy8lUVVcB.jpg,118,R +3459,There Will Be Blood,There Will Be Greed. There Will Be Vengeance.,placeholder text,http://image.tmdb.org/t/p/w185/bFgqkuAFBHNuq0oTtewHwuLVWSO.jpg,158,R +3624,The Iron Lady,Never compromise,placeholder text,http://image.tmdb.org/t/p/w185/e67tal4u66eFz8yGnJGTO5FYRxY.jpg,105,PG-13 +3680,The Untouchables,What are you prepared to do?,placeholder text,http://image.tmdb.org/t/p/w185/nv7FOs90Y3Cq5tBhEITEV8Zebyw.jpg,119,R +3753,Capote,In Cold Blood,placeholder text,http://image.tmdb.org/t/p/w185/bf3nxeLglBvXH5jAnMLmhc56muB.jpg,114,R +3915,Lost in Translation,Everyone wants to be found.,placeholder text,http://image.tmdb.org/t/p/w185/5T8VvuFTdaawKLJk34i69Utaw7o.jpg,102,R diff --git a/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/vertex_person.csv b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/vertex_person.csv new file mode 100644 index 000000000..adb7ac464 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/vertex_person.csv @@ -0,0 +1,667 @@ +LABEL=person +id:INT32:ID,name:STRING,born:INT32:OPTIONAL,poster_image:STRING:OPTIONAL +2,Laurence Fishburne,1961,https://image.tmdb.org/t/p/w185/mh0lZ1XsT84FayMNiT6Erh91mVu.jpg +3,Carrie-Anne Moss,1967,https://image.tmdb.org/t/p/w185/8iATAc5z5XOKFFARLsvaawa8MTY.jpg +4,Hugo Weaving,1960,https://image.tmdb.org/t/p/w185/3DKJSeTucd7krnxXkwcir6PgT88.jpg +5,Gloria Foster,1933,https://image.tmdb.org/t/p/w185/ahwiARgfOYctk6sOLBBk5w7cfH5.jpg +6,Joe Pantoliano,1951,https://image.tmdb.org/t/p/w185/zBvDX2HWepvW9im6ikgoyOL2Xj0.jpg +7,Marcus Chong,1967,https://image.tmdb.org/t/p/w185/zYfXjMszFajTb93phn2Fi6LwEGN.jpg +8,Matt Doran,1976,https://image.tmdb.org/t/p/w185/gLpWm3azLiXgDPRWo23AnG5WM7O.jpg +9,Anthony Ray Parker,1958,https://image.tmdb.org/t/p/w185/iMHr0onfM8v4uVdPVnXxXx2xwwN.jpg +10,Keanu Reeves,1964,https://image.tmdb.org/t/p/w185/id1qIb7cZs2eQno90KsKwG8VLGN.jpg +11,Ada Nicodemou,1977,https://image.tmdb.org/t/p/w185/xSHiqKAoEHy7i2csyqyLfb86L0O.jpg +12,Rowan Witt,1988,https://image.tmdb.org/t/p/w185/kJot5sckPZRFVzkKEEJtaod423s.jpg +13,Lily Wachowski,1967,https://image.tmdb.org/t/p/w185/nh5SBuv9cm1FByTc7dlV0zyO3GO.jpg +14,Lana Wachowski,1965,https://image.tmdb.org/t/p/w185/8mbcXfOpmOiDLk6ZWfMsBGHEnet.jpg +15,Joel Silver,1952,https://image.tmdb.org/t/p/w185/1LIjLDXGRhwXohHL2jKhyvLv0rZ.jpg +29,Helmut Bakaitis,1944,https://image.tmdb.org/t/p/w185/y6ICnJGyavStO2wrbqpf5hABwPj.jpg +30,Lambert Wilson,1958,https://image.tmdb.org/t/p/w185/p4tfJZVGZmc4S22bKCzHaUVUiqa.jpg +31,Monica Bellucci,1964,https://image.tmdb.org/t/p/w185/z3sLuRKP7hQVrvSTsqdLjGSldwG.jpg +32,Adrian Rayment,1970,https://image.tmdb.org/t/p/w185/c3ExwLos7XIsLUuEzwFjOd1wYWo.jpg +33,Neil Rayment,1970,https://image.tmdb.org/t/p/w185/yXV3FgDENpm5P9m62GugJNGhczH.jpg +34,Daniel Bernhardt,1965,https://image.tmdb.org/t/p/w185/gsIWvByH4lzQdTgMswQWqiAQOql.jpg +35,Roy Jones Jr.,1969,https://image.tmdb.org/t/p/w185/fgsHZRBpMinLbRninT1RcApxEnA.jpg +36,Randall Duk Kim,1943,https://image.tmdb.org/t/p/w185/9AWMELz25S915kaUr5OzHJN4Xtm.jpg +37,Harry Lennix,1964,https://image.tmdb.org/t/p/w185/uwpRytLjzz1IvjNanYNlplPVal9.jpg +38,Collin Chou,1967,https://image.tmdb.org/t/p/w185/Ug1pqZuUcQjW4y9ljgBpFnHpcA.jpg +39,Cornel West,1953,https://image.tmdb.org/t/p/w185/lMOn0gg1tTphBE974NARiTmqTES.jpg +40,Jada Pinkett Smith,1971,https://image.tmdb.org/t/p/w185/9F9om3LeN7xM1yPcUn9e2qSpkDh.jpg +41,Nona Gaye,1974,https://image.tmdb.org/t/p/w185/tNwU5M0ylEuDtxqFLpNnNE7jFKb.jpg +42,Steve Bastoni,1966,https://image.tmdb.org/t/p/w185/pL2atjQ6ZnUzvlI4r3LeT6h3OW6.jpg +43,Nash Edgerton,1973,https://image.tmdb.org/t/p/w185/1lKEZ4rvjYzfSm5a3W7lIm8k3YN.jpg +44,David Franklin,1962,https://image.tmdb.org/t/p/w185/n5W2C8Fir0wdQg8HmBeBpmvpCfH.jpg +45,Robyn Nevin,1942,https://image.tmdb.org/t/p/w185/5tqOX7iKTWaf3KDN4hiHXXN7wmI.jpg +46,Harold Perrineau Jr.,1963,https://image.tmdb.org/t/p/w185/kHdfkvm6KAmYQaoCMegLp9303D2.jpg +47,Gina Torres,1969,https://image.tmdb.org/t/p/w185/z43hy1X1vRD26vNDh0lzxg1rcBl.jpg +48,Clayton Watson,1977,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +49,Leigh Whannell,1977,https://image.tmdb.org/t/p/w185/cEy5gYVsjC7YL5Q53lkwjqYWP22.jpg +50,Bernard White,1959,https://image.tmdb.org/t/p/w185/1DEmHQyjfMLQssEE8PeFOtTYGn3.jpg +51,Anthony Zerbe,1936,https://image.tmdb.org/t/p/w185/hCxhuiCamxs0SOoQH46psnjT8xJ.jpg +69,Mary Alice,1941,https://image.tmdb.org/t/p/w185/2h20nF8gvhqhgVDV6Lru55dKB44.jpg +83,Bruce Willis,1955,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +84,John Travolta,1954,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +85,Samuel L. Jackson,1948,https://image.tmdb.org/t/p/w185/dlW6prW9HwYDsIRXNoFYtyHpSny.jpg +86,Harvey Keitel,1939,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +87,Uma Thurman,1970,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +88,Eric Stoltz,1961,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +89,Ving Rhames,1959,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +90,Tim Roth,1961,https://image.tmdb.org/t/p/w185/r4jtlboNqWPz2dOHafrPJE4Yd94.jpg +91,Amanda Plummer,1957,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +92,Maria de Medeiros,1965,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +93,Peter Greene,1965,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +94,Rosanna Arquette,1959,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +95,Duane Whitaker,1959,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +96,Frank Whaley,1963,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +97,Steve Buscemi,1957,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +98,Christopher Walken,1943,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +99,Julia Sweeney,1959,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +100,Quentin Tarantino,1963,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +101,Alexis Arquette,1969,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +102,Bronagh Gallagher,1972,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +103,Phil LaMarr,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +104,Burr Steers,1965,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +105,Joseph Pilato,1949,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +106,Lawrence Bender,1957,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +107,Kathy Griffin,1960,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +108,Roger Avary,1965,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +109,Danny DeVito,1944,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +128,Gabriela Cowperthwaite,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +131,Tom Hanks,1956,https://image.tmdb.org/t/p/w185/xxPMucou2wRDxLrud8i2D4dsywh.jpg +132,Halle Berry,1966,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +133,Jim Broadbent,1949,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +134,Susan Sarandon,1946,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +135,Hugh Grant,1960,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +136,Keith David,1956,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +137,James D'Arcy,1975,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +138,Bae Doona,1979,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +139,Jim Sturgess,1978,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +140,Ben Whishaw,1980,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +141,Zhou Xun,1976,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +142,David Gyasi,1980,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +143,Robert Fyfe,1925,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +144,Martin Wuttke,1962,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +145,Tom Tykwer,1965,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +458,Tim Robbins,1958,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +459,Morgan Freeman,1937,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +460,Bob Gunton,1945,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +461,William Sadler,1950,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +462,Clancy Brown,1959,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +463,Gil Bellows,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +464,Mark Rolston,1956,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +465,James Whitmore,1921,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +466,Frank Darabont,1959,https://image.tmdb.org/t/p/w185/9KVvZtDyy8DXacw2TTsjC9VLxQi.jpg +472,Marlon Brando,1924,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +473,Al Pacino,1940,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +474,James Caan,1940,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +475,Richard S. Castellano,1933,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +476,Robert Duvall,1931,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +477,Sterling Hayden,1916,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +478,Richard Conte,1910,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +479,Al Lettieri,1928,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +480,Diane Keaton,1946,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +481,Abe Vigoda,1921,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +482,Talia Shire,1946,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +483,Gianni Russo,1943,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +484,John Cazale,1935,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +485,John Marley,1907,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +486,Rudy Bond,1912,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +487,Al Martino,1927,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +488,Simonetta Stefanelli,1954,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +489,Alex Rocco,1936,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +490,Sofia Coppola,1971,https://image.tmdb.org/t/p/w185/zG1WS4sS5jvYkObHMxsK6fGK7Uk.jpg +491,Francis Ford Coppola,1939,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +492,Mario Puzo,1920,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +495,Stephen King,1000,https://image.tmdb.org/t/p/w185/qCGKepqazqcurcD39eIiQZHLosz.jpg +497,Robert De Niro,1943,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +498,Lee Strasberg,1901,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +499,Michael V. Gazzo,1923,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +500,G. D. Spradlin,1920,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +501,Richard Bright,1937,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +502,Gastone Moschin,1929,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +503,Bruno Kirby,1949,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +504,Frank Sivero,1952,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +505,Marianna Hill,1941,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +506,Dominic Chianese,1931,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +507,Fay Spain,1932,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +508,Harry Dean Stanton,1926,https://image.tmdb.org/t/p/w185/nDSav6v9Z8dSJSXoooT2g0LjbCd.jpg +509,Danny Aiello,1933,https://image.tmdb.org/t/p/w185/UvPalkz4ynJJrTcrbpfD05gVoO.jpg +510,Roger Corman,1926,https://image.tmdb.org/t/p/w185/gCfEvxl7jTv2dBo8HvwWVMi3auz.jpg +516,Drew Maxwell,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +518,Eli Wallach,1915,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +519,Clint Eastwood,1930,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +520,Lee Van Cleef,1925,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +521,Aldo Giuffrè,1924,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +522,Aldo Sambrell,1931,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +523,Mario Brega,1923,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +524,Sergio Leone,1929,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +525,Luciano Vincenzoni,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +533,Heath Ledger,1979,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +534,Maggie Gyllenhaal,1977,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +535,Aaron Eckhart,1968,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +536,Gary Oldman,1958,https://image.tmdb.org/t/p/w185/kCWUeBkZ2sf8LObSpUFgRngawQb.jpg +537,Michael Caine,1933,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +538,Cillian Murphy,1976,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +539,Christian Bale,1974,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +540,Anthony Michael Hall,1968,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +541,Nestor Carbonell,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +542,William Fichtner,1956,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +543,Chin Han,1969,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +544,Eric Roberts,1956,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +545,Melinda McGraw,1963,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +546,Ritchie Coster,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +547,Keith Szarabajka,1952,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +548,Colin McFarlane,1961,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +549,Christopher Nolan,1970,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +550,Jonathan Nolan,1976,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +551,David S. Goyer,1965,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +565,Anne Hathaway,1982,https://image.tmdb.org/t/p/w185/jUMOKwSUBnTcMeN1HfhutiY49Ad.jpg +566,Tom Hardy,1977,https://image.tmdb.org/t/p/w185/5HZSvW12xIWqdxasIL92pIiTSkY.jpg +567,Joseph Gordon-Levitt,1981,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +568,Juno Temple,1989,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +569,Marion Cotillard,1975,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +570,Josh Pence,1982,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +571,Vincent van Ommen,1982,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +572,Tom Conti,1941,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +573,Matthew Modine,1959,https://image.tmdb.org/t/p/w185/tEQG1Us5IuoKYtufZe6waWtxfeg.jpg +574,Joey King,1999,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +575,Alon Aboutboul,1965,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +576,Liam Neeson,1952,https://image.tmdb.org/t/p/w185/oxCCVmDSxWcqIyMknRoOAZkvb6D.jpg +577,Warren Brown,1978,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +578,Ben Mendelsohn,1969,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +579,Daniel Sunjata,1971,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +580,Aiden Gillen,1968,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +599,Ben Kingsley,1943,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +600,Ralph Fiennes,1962,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +601,Caroline Goodall,1959,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +602,Embeth Davidtz,1965,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +603,Andrzej Seweryn,1946,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +604,Friedrich von Thun,1942,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +605,Krzysztof Luft,1958,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +606,Michael Gordon,1909,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +607,Steven Spielberg,1946,https://image.tmdb.org/t/p/w185/pOK15UNaw75Bzj7BQO1ulehbPPm.jpg +608,Steven Zaillian,1953,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +609,Gerald R. Molen,1935,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +616,Henry Fonda,1905,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +617,Lee J. Cobb,1911,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +618,Ed Begley,1901,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +619,E. G. Marshall,1914,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +620,Jack Warden,1920,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +621,Martin Balsam,1919,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +622,John Fiedler,1925,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +623,Jack Klugman,1922,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +624,Edward Binns,1916,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +625,George Voskovec,1905,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +626,Robert Webber,1924,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +627,Sidney Lumet,1924,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +628,Reginald Rose,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +642,Elijah Wood,1981,https://image.tmdb.org/t/p/w185/c4fB3WAS7jN78rihw2kB81v6sez.jpg +643,Ian McKellen,1939,https://image.tmdb.org/t/p/w185/c51mP46oPgAgFf7bFWVHlScZynM.jpg +644,Viggo Mortensen,1958,https://image.tmdb.org/t/p/w185/hKMk7FsqzBDkQt72fOAOLePZEko.jpg +645,Liv Tyler,1977,https://image.tmdb.org/t/p/w185/lD2YnrKdnRUvFDMSiK2pw13ZMIB.jpg +646,Orlando Bloom,1977,https://image.tmdb.org/t/p/w185/vq90ECKinICxJYYZpbga4pMwch.jpg +647,John Rhys-Davies,1944,https://image.tmdb.org/t/p/w185/zZ67PuoFfik9QlZyfaEsFBC1yVJ.jpg +648,Sean Astin,1971,https://image.tmdb.org/t/p/w185/ezv9hRbgrR6Uuz4xWqX22cpiRXJ.jpg +649,Billy Boyd,1968,https://image.tmdb.org/t/p/w185/vNhUoHhBqyjDVuc0nxJHanTKA2E.jpg +650,Dominic Monaghan,1976,https://image.tmdb.org/t/p/w185/sXkqoK3v1nfCudXIcxKVwDc0imw.jpg +651,Bernard Hill,1944,https://image.tmdb.org/t/p/w185/vnepbY1BOJ2AX20bkngAT7ehJP.jpg +652,Andy Serkis,1964,https://image.tmdb.org/t/p/w185/nQRsxFveJaUIlZ4GYWDe9uJ6u2f.jpg +653,Miranda Otto,1967,https://image.tmdb.org/t/p/w185/l3BzUjJMK3JbqvCiCIFP4beMChS.jpg +654,David Wenham,1965,https://image.tmdb.org/t/p/w185/hOG5mAd5pzT30V6adkwkpe87HY7.jpg +655,Karl Urban,1972,https://image.tmdb.org/t/p/w185/tHYOUO33K7iaDw8nXyqRvDIkVuM.jpg +656,John Noble,1948,https://image.tmdb.org/t/p/w185/4A2mSS9Bea5I2bNur8ZlQZXu0H9.jpg +657,Ian Holm,1931,https://image.tmdb.org/t/p/w185/uq6Wx7PaLgaw969avH7tLHnSb0Q.jpg +658,Cate Blanchett,1969,https://image.tmdb.org/t/p/w185/X3CMrI6lkzLdS5ZQqQWeRJkAGU.jpg +659,Lawrence Makoare,1968,https://image.tmdb.org/t/p/w185/yVHInaWXU4ynUnNE3qa59hvsFAJ.jpg +660,Paul Norell,1952,https://image.tmdb.org/t/p/w185/dLjsu7vVkgXLLQ8QfqRb6iDRxvH.jpg +661,Sarah McLeod,1971,https://image.tmdb.org/t/p/w185/8BFVSAmPX0sjyqelYCtJktF0Vk6.jpg +662,Sean Bean,1959,https://image.tmdb.org/t/p/w185/vWQjx4ESW7T3iKjIbZfi933yI1g.jpg +663,Marton Csokas,1966,https://image.tmdb.org/t/p/w185/y3I1CjTRIqVJnz3HlrnVBDcwWhN.jpg +664,Peter Jackson,1961,https://image.tmdb.org/t/p/w185/hTUqZAjH7SHXb0EXEA1I9EoJFnF.jpg +665,Bob Weinstein,1954,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +666,Harvey Weinstein,1952,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +667,Fran Walsh,1959,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +668,Philippa Boyens,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +682,Edward Norton,1969,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +683,Brad Pitt,1963,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +684,Helena Bonham Carter,1966,https://image.tmdb.org/t/p/w185/y09R1VSKmjO43PLocRMZQ9vJihh.jpg +685,Meat Loaf,1947,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +686,Jared Leto,1971,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +687,Zach Grenier,1954,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +688,Holt McCallany,1964,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +689,Eion Bailey,1976,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +690,David Fincher,1962,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +699,Christopher Lee,1922,https://image.tmdb.org/t/p/w185/7YwjaHLmuy1isK6oh3TnBDd6Oml.jpg +700,Craig Parker,1970,https://image.tmdb.org/t/p/w185/amJPcZnpWIABjbaN5FzW5vvTIEk.jpg +711,Mark Hamill,1951,https://image.tmdb.org/t/p/w185/klQrOckrIuUluOEp7g0osOfTgWI.jpg +712,Harrison Ford,1942,https://image.tmdb.org/t/p/w185/7CcoVFTogQgex2kJkXKMe8qHZrC.jpg +713,Carrie Fisher,1956,https://image.tmdb.org/t/p/w185/1Kpvl1B7SRrdLKjqDfT6kb7nyRB.jpg +714,David Prowse,1935,https://image.tmdb.org/t/p/w185/a2RoHYMSiRqV6hXL6Z5CXtNyDkt.jpg +715,Billy Dee Williams,1937,https://image.tmdb.org/t/p/w185/kkAotKJL1s3Kvh9bRNELDfAOZHs.jpg +716,Anthony Daniels,1946,https://image.tmdb.org/t/p/w185/cljvryjb3VwTsNR7fjQKjNPMaBB.jpg +717,Peter Mayhew,1944,https://image.tmdb.org/t/p/w185/hAavH3DKfzia7b3CTFkHd8HLgCz.jpg +718,James Earl Jones,1931,https://image.tmdb.org/t/p/w185/pxC7jiRTHArPldgkqSneXRsrRJ9.jpg +719,Kenny Baker,1934,https://image.tmdb.org/t/p/w185/wnTrBdbJr23GWApnmARg0F7Gpja.jpg +720,Frank Oz,1944,https://image.tmdb.org/t/p/w185/9KqCa2wS4EO2yymrVIgMiFHh6M4.jpg +721,Alec Guinness,1914,https://image.tmdb.org/t/p/w185/nv3ppxgUQJytFGXZNde4f9ZlshB.jpg +722,Julian Glover,1935,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +723,John Ratzenberger,1947,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +724,Irvin Kershner,1923,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +725,Gary Kurtz,1940,https://image.tmdb.org/t/p/w185/qMuYGnSQn4V5PSfEpEjLCOeWPM0.jpg +726,Leigh Brackett,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +727,Lawrence Kasdan,1949,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +728,George Lucas,1944,https://image.tmdb.org/t/p/w185/rJ1zvSeZfge0mHtLnzJn4Mkw18S.jpg +738,Leonardo DiCaprio,1974,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +739,Ken Watanabe,1959,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +740,Ellen Page,1987,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +741,Tom Berenger,1949,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +742,Lukas Haas,1976,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +743,Dileep Rao,1973,https://image.tmdb.org/t/p/w185/f9xQkvWw5guOePcCxkso1i09w12.jpg +744,Pete Postlethwaite,1945,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +745,Talulah Riley,1985,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +751,Jack Nicholson,1937,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +752,Louise Fletcher,1934,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +753,William Redfield,1927,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +754,Scatman Crothers,1910,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +755,Brad Dourif,1950,https://image.tmdb.org/t/p/w185/6pqeGxtWEdDjYsnQfUkmzXLlDvs.jpg +756,Christopher Lloyd,1938,https://image.tmdb.org/t/p/w185/iQzG9apaIsHnn7iGrer3YEDp8Zo.jpg +757,Will Sampson,1933,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +758,Michael Berryman,1948,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +759,William Duell,1923,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +760,Vincent Schiavelli,1948,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +761,Miloš Forman,1932,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +762,Bo Goldman,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +763,Lawrence Hauben,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +764,Michael Douglas,1944,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +771,Robin Wright,1966,https://image.tmdb.org/t/p/w185/cke0NNZP4lHRtOethRy2XGSOp3E.jpg +772,Gary Sinise,1955,https://image.tmdb.org/t/p/w185/n5AbjoNfONICaggp2f1QhYAjAoZ.jpg +773,Mykelti Williamson,1960,https://image.tmdb.org/t/p/w185/8TTxzpuvvpw2tB8xZBCDslYupNU.jpg +774,Sally Field,1946,https://image.tmdb.org/t/p/w185/ymhpsxujOO3a9qaGYSpkenCt9Le.jpg +775,Haley Joel Osment,1988,https://image.tmdb.org/t/p/w185/znbiMgFoGnY3NMANOa8u13wJqFm.jpg +776,Robert Zemeckis,1951,https://image.tmdb.org/t/p/w185/jJpbvGw4xTC8lWMqNYpLVCMMVV.jpg +777,Winston Groom,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +778,Eric Roth,1945,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +782,Ray Liotta,1954,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +783,Joe Pesci,1943,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +784,Lorraine Bracco,1954,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +785,Tony Darrow,1938,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +786,Mike Starr,1950,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +787,Frank Vincent,1939,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +788,Debi Mazar,1964,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +789,Michael Imperioli,1966,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +790,Paul Sorvino,1939,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +791,Martin Scorsese,1942,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +792,Nicholas Pileggi,1933,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +793,Irwin Winkler,1931,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +798,Olivia Tennet,1991,https://image.tmdb.org/t/p/w185/hv8zCPSiju8YpVXXjv17osV2pV7.jpg +806,Peter Cushing,1913,https://image.tmdb.org/t/p/w185/iFE9Xi5B0eZcNFqvCx78UUzmUfI.jpg +807,Phil Brown,1916,https://image.tmdb.org/t/p/w185/exkyN66HiZWJDmpcOza2hWoswOo.jpg +808,Shelagh Fraser,1920,https://image.tmdb.org/t/p/w185/xNfiibBvknHztEnL0g7dcdrxOKq.jpg +809,Roger Lloyd-Pack,1944,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +810,William Hootkins,1948,https://image.tmdb.org/t/p/w185/lGPSg64fsqbWS5PUFKsUKLNOqsx.jpg +811,Malcolm Tierney,1938,https://image.tmdb.org/t/p/w185/fe7Cz6sxTLt9qSQANRpAAaYcPlV.jpg +812,Eddie Byrne,1911,https://image.tmdb.org/t/p/w185/mSwNawI6Ou8m99Y05WjctoTWYUK.jpg +813,Denis Lawson,1947,https://image.tmdb.org/t/p/w185/78Yl1gcn5TpS6WsZ1tjwdX8j7Vd.jpg +814,Garrick Hagon,1939,https://image.tmdb.org/t/p/w185/lZYitsCPzlwevNuHzqaSZMQiuUa.jpg +815,Joe Johnston,1950,https://image.tmdb.org/t/p/w185/dBLdJJo551G2WH0TPv6ze0FC1ei.jpg +907,Chuck Palahniuk,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1073,Amber Heard,1986,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1074,Kevin Costner,1955,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1075,Hailee Steinfeld,1996,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1076,Connie Nielsen,1965,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1077,Joseph McGinty Nichol,1968,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1094,Luc Besson,1959,https://image.tmdb.org/t/p/w185/2TzRsqSx0xb1DK3HsEQKSXhRGcu.jpg +1095,Adi Hasak,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1098,Eva Green,1980,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1099,Lena Headey,1973,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1100,Callan Mulvey,1975,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1101,Rodrigo Santoro,1975,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1102,Jack O'Connell,1990,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1103,Andrew Tiernan,1965,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1104,Andrew Pleavin,1968,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1105,Hans Matheson,1975,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1106,Zach Snyder,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1107,Noam Murro,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1108,Kurt Johnstad,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1119,Bradley Cooper,1975,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1120,Amy Adams,1974,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1121,Jeremy Renner,1971,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1122,Jennifer Lawrence,1990,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1123,Louis C.K.,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1124,Jack Huston,1982,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1125,Michael Peña,1976,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1126,Alessandro Nivola,1972,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1127,Elisabeth Röhm,1973,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1128,Dawn Olivieri,1981,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1129,Erica McDermott,1973,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1130,Colleen Camp,1953,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1131,Shea Whigham,1969,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1132,Saïd Taghmaoui,1973,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1133,David O. Russell,1958,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1134,Eric Singer,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1242,Kristen Bell,1980,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1243,Idina Menzel,1971,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1244,Josh Gad,1981,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1245,Alan Tudyk,1971,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1246,Ciarán Hinds,1953,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1247,Christopher Williams,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1248,Stephen J. Anderson,1970,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1249,Edie McClurg,1951,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1250,Robert Pine,1941,https://image.tmdb.org/t/p/w185/dZTRdcp57vdnCtxIp8vNYR6pOtp.jpg +1251,Maurice LaMarche,1958,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1252,Chris Buck,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1253,John Lasseter,1957,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1254,Jennifer Lee,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1255,Shane Morris,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1294,Sandra Bullock,1964,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1295,George Clooney,1961,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1296,Ed Harris,1950,https://image.tmdb.org/t/p/w185/a9ITc3shCAWjV4qKf3rgR0Opu3y.jpg +1297,Alfonso Cuarón,1961,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1298,David Heyman,1961,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1299,Jonás Cuarón,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1357,Matt Damon,1970,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1358,Bill Murray,1950,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1359,John Goodman,1952,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1360,Hugh Bonneville,1963,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1361,Jean Dujardin,1972,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1362,Bob Balaban,1945,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1363,Dimitri Leonidas,1987,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1364,Zahary Baharov,1980,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1365,Grant Heslov,1963,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1367,Cobie Smulders,1982,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1368,Channing Tatum,1980,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1369,Jonah Hill,1983,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1370,Elizabeth Banks,1974,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1371,Will Ferrell,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1372,Chris Pratt,1979,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1373,Will Arnett,1970,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1374,Alison Brie,1982,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1375,Nick Offerman,1970,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1376,Charlie Day,1976,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1377,Dave Franco,1985,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1378,Will Forte,1970,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1379,Phil Lord,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1380,Dan Hageman,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1381,Kevin Hageman,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1382,Chris Miller,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1413,Joel Kinnaman,1979,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1414,Michael Keaton,1951,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1415,Jay Baruchel,1982,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1416,Abbie Cornish,1982,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1417,Jackie Earle Haley,1961,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1418,Jennifer Ehle,1969,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1419,Marianne Jean-Baptiste,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1420,Aimee Garcia,1978,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1421,José Padilha,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1422,Nick Schenk,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1423,Joshua Zetumer,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1551,Joaquin Phoenix,1974,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1552,Scarlett Johansson,1984,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1553,Rooney Mara,1985,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1554,Olivia Wilde,1984,https://image.tmdb.org/t/p/w185/3d69fgT1QOTDJxqy7FpBBAQxoM0.jpg +1555,Portia Doubleday,1988,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1556,Sam Jaeger,1977,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1557,Spike Jonze,1969,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1558,Bill Hader,1978,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1559,Kristen Wiig,1973,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1560,Brian Cox,1946,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1597,Matthew McConaughey,1969,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1598,Jennifer Garner,1972,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1599,Dallas Roberts,1970,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1600,Steve Zahn,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1601,Kevin Rankin,1976,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1602,Griffin Dunne,1955,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1603,Denis O'Hare,1962,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1604,Jean-Marc Vallée,1963,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1605,Craig Borten,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1606,Melisa Wallack,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1694,Chiwetel Ejiofor,1977,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1695,Michael Fassbender,1977,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1696,Sarah Paulson,1974,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1697,Paul Dano,1984,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1698,Benedict Cumberbatch,1976,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1699,Garret Dillahunt,1964,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1700,Michael K. Williams,1966,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1701,Paul Giamatti,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1702,Alfre Woodard,1952,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1703,Taran Killam,1982,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1704,Bryan Batt,1963,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1705,Steve McQueen,1969,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1706,John Ridley,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1753,Jodie Foster,1962,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1754,Sharlto Copley,1973,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1755,Alice Braga,1983,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1756,Diego Luna,1979,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1757,Wagner Moura,1976,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1758,Faran Tahir,1963,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1759,Jose Pablo Cantillo,1979,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1760,Maxwell Perry Cotton,2000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1761,Adrian Holmes,1974,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1762,Talisa Soto,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1763,Michael Shanks,1970,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1764,Carly Pope,1980,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1765,Terry Chen,1975,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1766,Neill Blomkamp,1979,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1767,Simon Kinberg,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1857,Josh Hutcherson,1992,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1858,Amanda Seyfried,1985,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1859,Colin Farrell,1976,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1860,Jason Sudeikis,1975,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1861,Aziz Ansari,1983,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1862,Beyoncé Knowles,1981,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1863,Judah Friedlander,1969,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1864,Steven Tyler,1948,https://image.tmdb.org/t/p/w185/fWZw1OWKHwg5NZ3cRb0S7GaXteO.jpg +1865,Pitbull,1981,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1866,Christoph Waltz,1956,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1867,John DiMaggio,1968,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1868,Troy Evans,1948,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1869,Chris Wedge,1957,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1870,Tom J. Astle,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1871,Matt Ember,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1872,James V. Hart,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1873,William Joyce,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1874,Daniel Shere,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1936,Nicolas Cage,1964,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1937,Emma Stone,1988,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1938,Ryan Reynolds,1976,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1939,Catherine Keener,1959,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1940,Cloris Leachman,1926,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1941,Clark Duke,1985,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1942,Kirk De Micco,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1943,Chris Sanders,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +1944,John Cleese,1939,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2009,Ty Burrell,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2010,Max Charles,2003,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2011,Ariel Winter,1998,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2012,Allison Janney,1959,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2013,Ellie Kemper,1980,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2014,Stephen Colbert,1964,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2015,Stephen Tobolowsky,1951,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2016,Karan Brar,1999,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2017,Adam Alexi-Malle,1964,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2018,Stanley Tucci,1960,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2019,Leslie Mann,1972,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2020,Rob Minkoff,1962,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2021,Jason Clarke,1969,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2022,Craig Wright,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2056,Robert Downey Jr.,1965,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2057,Chris Evans,1981,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2058,Mark Ruffalo,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2059,Chris Hemsworth,1983,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2060,Tom Hiddleston,1981,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2061,Clark Gregg,1962,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2062,Stellan Skarsgård,1951,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2063,Gwyneth Paltrow,1972,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2064,Paul Bettany,1971,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2065,Jenny Agutter,1952,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2066,Walter Perez,1982,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2067,Powers Boothe,1948,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2068,Stan Lee,1922,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2069,Ashley Johnson,1983,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2070,Jerzy Skolimowski,1938,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2071,James Eckhouse,1955,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2072,Enver Gjokaj,1980,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2073,Joss Whedon,1964,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2074,Jon Favreau,1966,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2075,Kevin Feige,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2076,Zak Penn,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2233,Gemma Arterton,1986,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2234,Famke Janssen,1965,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2235,Pihla Viitala,1982,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2236,Derek Mears,1972,https://image.tmdb.org/t/p/w185/jsHyZmBZEmhrmK5XBDFJWsPsTwL.jpg +2237,Peter Stormare,1953,https://image.tmdb.org/t/p/w185/dDR0brp5L7fXDyEywrhjQv01LSg.jpg +2238,Ingrid Bolsø Berdal,1980,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2239,Zoë Bell,1978,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2240,Joanna Kulig,1982,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2241,Monique Ganderton,1980,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2242,Thomas Scharff,1970,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2243,Tommy Wirkola,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2244,Adam McKay,1968,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2245,Dante Harper,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2399,Zac Efron,1987,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2400,Taylor Swift,1989,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2401,Ed Helms,1974,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2402,Willow Smith,2000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2403,Rob Riggle,1970,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2404,Betty White,1922,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2405,Jenny Slate,1982,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2406,Nasim Pedrad,1981,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2407,Elmarie Wendel,1939,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2408,Danny Cooksey,1975,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2409,Chris Renaud,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2410,Kyle Balda,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2411,Cinco Paul,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2412,Ken Daurio,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2423,Lea Salonga,1971,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2424,Eddie Murphy,1961,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2425,BD Wong,1960,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2426,Ming-Na Wen,1963,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2427,Miguel Ferrer,1955,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2428,Harvey Fierstein,1952,https://image.tmdb.org/t/p/w185/7AN3n6TENCrRhU5pKxEM6W0mCjg.jpg +2429,June Foray,1917,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2430,James Hong,1929,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2431,Miriam Margolyes,1941,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2432,Pat Morita,1932,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2433,Soon-Tek Oh,1943,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2434,Donny Osmond,1957,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2435,James Shigeta,1933,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2436,George Takei,1937,https://image.tmdb.org/t/p/w185/yXQsJ0ahBXsbxzJUYjwyCxpJHgp.jpg +2437,Gedde Watanabe,1955,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2438,Frank Welker,1946,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2439,Tony Bancroft,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2440,Barry Cook,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2441,Rita Hsiao,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2442,Philip LaZebnik,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2443,Raymond Singer,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2444,Eugenia Bostwick-Singer,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2499,Ray Winstone,1957,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2500,Angelina Jolie,1975,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2501,Anthony Hopkins,1937,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2502,John Malkovich,1953,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2503,Brendan Gleeson,1955,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2504,Crispin Glover,1964,https://image.tmdb.org/t/p/w185/thA5rOv5XE1oFpxD9DSp0tDrIIR.jpg +2505,Alison Lohman,1979,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2506,Greg Ellis,1968,https://image.tmdb.org/t/p/w185/qQvPe0TO5yYJCSNIM8KRf55F5cw.jpg +2507,Sebastian Roché,1964,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2508,Dominic Keating,1962,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2509,Rik Young,1978,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2510,Neil Gaiman,1960,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2655,James Purefoy,1964,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2656,Alice Krige,1954,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2657,Mackenzie Crook,1971,https://image.tmdb.org/t/p/w185/pkBBzUyeJSI8OY8rf6TM6Dz0NXL.jpg +2658,Max von Sydow,1929,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2659,Jason Flemyng,1966,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2660,Rachel Hurd-Wood,1990,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2661,Anthony Wilks,1983,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2662,Ian Whyte,1971,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2663,James Babson,1974,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2664,Michael J. Bassett,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2768,Kevin Spacey,1959,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2769,Stephen Baldwin,1966,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2770,Gabriel Byrne,1950,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2771,Benicio del Toro,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2772,Kevin Pollak,1957,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2773,Chazz Palminteri,1952,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2774,Giancarlo Esposito,1958,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2775,Suzy Amis,1962,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2776,Dan Hedaya,1940,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2777,Christine Estabrook,1952,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2778,Paul Bartel,1938,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2779,Bryan Singer,1965,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2780,Christopher McQuarrie,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2886,Asa Butterfield,1997,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2887,Chloë Grace Moretz,1997,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2888,Sacha Baron Cohen,1971,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2889,Jude Law,1972,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2890,Helen McCrory,1968,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2891,Michael Stuhlbarg,1968,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2892,Emily Mortimer,1971,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2893,Frances de la Tour,1944,https://image.tmdb.org/t/p/w185/8PvwBlVzzS2sRSLlElRLNG7CYRE.jpg +2894,Richard Griffiths,1947,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2895,Johnny Depp,1963,https://image.tmdb.org/t/p/w185/5sc2pu4YWItxCaXSvrFpg64zN9J.jpg +2896,John Logan,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +2897,Brian Selznick,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3107,William H. Macy,1950,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3108,Frances McDormand,1957,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3109,Harve Presnell,1933,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3110,John Carroll Lynch,1963,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3111,Steve Reevis,1962,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3112,Joel Coen,1954,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3113,Ethan Coen,1957,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3253,Kasi Lemmons,1961,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3254,Scott Glenn,1941,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3255,Anthony Heald,1944,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3256,Frankie Faison,1949,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3257,Brooke Smith,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3258,Ted Levine,1957,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3259,Tracey Walter,1947,https://image.tmdb.org/t/p/w185/kRFzCvB08MVF9T8pLT0V1GiXzXF.jpg +3260,Dan Butler,1954,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3261,Obba Babatunde,1951,https://image.tmdb.org/t/p/w185/vUYCsIIoasA6rnxGuN7ZjaRIBrn.jpg +3262,Diane Baker,1938,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3263,Charles Napier,1936,https://image.tmdb.org/t/p/w185/hZ3bCBxnHc7Zvrm3Rt2CPgXSLLT.jpg +3264,Chris Isaak,1956,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3265,Daniel von Bargen,1950,https://image.tmdb.org/t/p/w185/fFiiZCvBCqQ4xmCzYpMJQ7xboP3.jpg +3266,George A. Romero,1940,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3267,Jonathan Demme,1944,https://image.tmdb.org/t/p/w185/suxo4qCWhq2Giep8UKhrf8bF4vc.jpg +3268,Ted Tally,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3269,Thomas Harris,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3391,Colin Firth,1960,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3392,Geoffrey Rush,1951,https://image.tmdb.org/t/p/w185/c0jbNjWb9DHm5xfBIeEtHZdZJmI.jpg +3393,Guy Pearce,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3394,Timothy Spall,1957,https://image.tmdb.org/t/p/w185/wqPqtdxObseJikozhcWLNDU5Pao.jpg +3395,Michael Gambon,1940,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3396,Derek Jacobi,1938,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3397,Ramona Marquez,2001,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3398,Tom Hooper,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3399,David Seidler,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3460,Daniel Day-Lewis,1957,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3461,Kevin J. O'Connor,1963,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3462,Barry Del Sherman,1962,https://image.tmdb.org/t/p/w185/8uUOdG0fTnPYNkSgPpQDhzxSrjw.jpg +3463,Paul F. Tompkins,1968,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3464,Paul Thomas Anderson,1970,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3625,Meryl Streep,1949,https://image.tmdb.org/t/p/w185/oTJj6bLpbmseLww03MOn0eDqYuh.jpg +3626,Anthony Stewart Head,1954,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3627,Harry Lloyd,1983,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3628,Iain Glen,1961,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3629,Olivia Colman,1974,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3630,Phyllida Lloyd,1957,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3631,Abi Morgan,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3681,Sean Connery,1930,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3682,Andy García,1956,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3683,Charles Martin Smith,1953,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3684,Richard Bradford,1937,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3685,Billy Drago,1949,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3686,Patricia Clarkson,1959,https://image.tmdb.org/t/p/w185/10ZSyaUqzUlKTd60HmeiGhlytZG.jpg +3687,Don Harvey,1960,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3688,Brian De Palma,1940,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3689,Art Linson,1000,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3690,David Mamet,1947,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3754,Philip Seymour Hoffman,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3755,Kwesi Ameyaw,1975,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3756,Chris Cooper,1951,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3757,Clifton Collins Jr.,1970,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3758,Mark Pellegrino,1965,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3759,Amy Ryan,1969,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3760,Bennett Miller,1966,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3761,Dan Futterman,1967,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3916,Anna Faris,1976,https://assets.tmdb.org/assets/7f29bd8b3370c71dd379b0e8b570887c/images/no-poster-w185-v2.png +3917,Giovanni Ribisi,1974,https://image.tmdb.org/t/p/w185/mLQrEU7X7GD5V7i1clGRqpg8PVk.jpg diff --git a/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/vertex_user.csv b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/vertex_user.csv new file mode 100644 index 000000000..28de596e4 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/db_data/movie/raw_data/vertex_user.csv @@ -0,0 +1,236 @@ +LABEL=user +id:INT32:ID,login:STRING +2,William +3,James +7,Joseph +8,Thomas +10,Robert +11,Edward +18,David +19,Louis +21,Charlie +22,Clarence +23,Richard +25,Daniel +27,Will +33,Frederick +34,Willie +36,Sam +38,Herbert +39,Jacob +40,Tom +44,Howard +45,Martin +46,Michael +51,Harvey +52,Earl +53,Eugene +54,Ralph +55,Ed +57,Edwin +59,Charley +60,Paul +62,Isaac +66,Ira +67,Patrick +68,Guy +69,Oliver +74,August +76,Homer +82,Allen +83,Archie +94,Julius +96,Sidney +102,Dave +104,Eddie +109,Wesley +111,Garfield +112,Franklin +116,Harold +117,Matthew +119,Moses +121,Lester +126,Fredrick +131,Aaron +136,Victor +142,Jake +151,Claud +153,Sylvester +158,Willard +159,Irvin +161,Jose +170,Wiley +171,Anton +175,Augustus +177,Eli +178,Nicholas +183,Timothy +186,Curtis +187,Edmund +190,Harrison +191,Stanley +192,Columbus +196,Russell +197,Pearl +199,Arch +200,Asa +201,Clayton +202,Enoch +204,Mathew +210,Ellis +215,Wade +218,Rudolph +219,Sherman +220,Austin +221,Bill +222,Chas +223,Lonnie +224,Monroe +225,Byron +227,Emery +228,Grant +230,Max +231,Mose +238,Gustave +240,Lorenzo +241,Bruce +244,Bob +246,Donald +248,Cecil +250,Delbert +251,Edmond +256,Luke +266,Vincent +293,Elisha +295,General +296,Julian +301,Judson +308,Forest +310,Pink +313,Ward +319,Wilbert +321,Benjiman +326,Archibald +328,Clint +332,Mary +333,Merton +339,Milo +343,Elza +350,Seth +355,Washington +368,Lafayette +373,Abram +375,Elliott +383,Dallas +388,Lawson +394,Erastus +399,Stewart +406,Clay +415,Jonathan +421,Rolla +422,Sandy +428,Carlos +433,Harve +434,Israel +450,Geo +457,Orlando +463,Stuart +464,Wilburn +466,Casper +467,Christ +478,Squire +481,Wyatt +485,Andres +491,Howell +500,Reginald +505,Benjamine +507,Carlton +519,Rex +526,Al +530,Art +534,Beverly +536,Clair +541,Dwight +544,Henderson +552,Mortimer +565,Truman +570,Wylie +571,Alec +578,Colonel +579,Dempsey +580,Early +582,Fate +584,Gabe +585,Garland +587,Herschel +588,Hezekiah +592,Olaf +594,Pablo +596,Turner +597,Verne +608,Darius +614,Eric +619,Hosea +621,Lonzo +647,Eben +652,Finis +657,Hermann +658,Isadore +661,June +662,Lacy +663,Lafe +664,Leland +670,Obie +676,Parley +698,Dolphus +701,Fayette +702,Felipe +705,Florence +710,Hoy +723,Odie +724,Olen +733,Richmond +738,Shelby +743,Woodson +747,Alf +748,Algie +751,Bedford +761,Clovis +765,Duke +766,Eber +767,Eligah +770,Emmitt +775,Harman +779,Jennie +780,Len +782,Lonie +787,Miller +788,Orson +803,Vance +812,Allison +826,Ballard +831,Clarke +850,Elsie +854,Ferd +863,Hattie +875,Kirk +882,Noble +883,Obed +890,Rube +894,Sammie +897,Stacy +900,Thad +901,Titus +902,Tracy +907,Yee +912,Albertus +916,Artie +917,Arvid +932,Brooks +933,Buck +941,Cyril +962,Gardner +965,Gottlieb +975,Hermon +981,Huey +990,Jodie diff --git a/text2gremlin/AST_Text2Gremlin/db_data/reference/schemas_data.json b/text2gremlin/AST_Text2Gremlin/db_data/reference/schemas_data.json new file mode 100644 index 000000000..143dc143d --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/db_data/reference/schemas_data.json @@ -0,0 +1,1801 @@ +{ + "description": "20个场景schema库", + "total_scenarios": 20, + "scenarios": { + "1_ecommerce": { + "index": 1, + "name_zh": "电商", + "domain": "ecommerce", + "schema": { + "domain": "ecommerce", + "description": "电商商品、用户行为与类目标签图", + "vertex_labels": [ + "customer", + "product", + "category", + "brand", + "tag", + "order", + "seller" + ], + "edge_labels": [ + { + "name": "view", + "from": "customer", + "to": "product" + }, + { + "name": "purchase", + "from": "customer", + "to": "product" + }, + { + "name": "add_to_cart", + "from": "customer", + "to": "product" + }, + { + "name": "place_order", + "from": "customer", + "to": "order" + }, + { + "name": "contain_product", + "from": "order", + "to": "product" + }, + { + "name": "belong_category", + "from": "product", + "to": "category" + }, + { + "name": "has_tag", + "from": "product", + "to": "tag" + }, + { + "name": "has_brand", + "from": "product", + "to": "brand" + }, + { + "name": "sold_by", + "from": "product", + "to": "seller" + } + ], + "properties": { + "customer": [ + "customer_id", + "name", + "age", + "gender", + "city" + ], + "product": [ + "product_id", + "name", + "price", + "stock", + "rating" + ], + "category": [ + "category_id", + "name" + ], + "brand": [ + "brand_id", + "name" + ], + "tag": [ + "tag_id", + "name" + ], + "order": [ + "order_id", + "amount", + "status", + "created_at" + ], + "seller": [ + "seller_id", + "name", + "level" + ] + } + } + }, + "2_social": { + "index": 2, + "name_zh": "社交", + "domain": "social", + "schema": { + "domain": "social", + "description": "社交用户、帖子、话题与互动关系图", + "vertex_labels": [ + "user", + "post", + "comment", + "topic", + "group", + "tag" + ], + "edge_labels": [ + { + "name": "follow", + "from": "user", + "to": "user" + }, + { + "name": "create_post", + "from": "user", + "to": "post" + }, + { + "name": "like_post", + "from": "user", + "to": "post" + }, + { + "name": "comment_on", + "from": "user", + "to": "post" + }, + { + "name": "reply_comment", + "from": "comment", + "to": "comment" + }, + { + "name": "has_topic", + "from": "post", + "to": "topic" + }, + { + "name": "has_tag", + "from": "post", + "to": "tag" + }, + { + "name": "join_group", + "from": "user", + "to": "group" + } + ], + "properties": { + "user": [ + "user_id", + "name", + "city", + "register_time" + ], + "post": [ + "post_id", + "title", + "content", + "publish_time", + "like_count" + ], + "comment": [ + "comment_id", + "content", + "publish_time" + ], + "topic": [ + "topic_id", + "name" + ], + "group": [ + "group_id", + "name" + ], + "tag": [ + "tag_id", + "name" + ] + } + } + }, + "3_academic": { + "index": 3, + "name_zh": "学术", + "domain": "academic", + "schema": { + "domain": "academic", + "description": "作者、论文、期刊会议和关键词图", + "vertex_labels": [ + "author", + "paper", + "venue", + "institution", + "keyword", + "field" + ], + "edge_labels": [ + { + "name": "write", + "from": "author", + "to": "paper" + }, + { + "name": "cite", + "from": "paper", + "to": "paper" + }, + { + "name": "publish_in", + "from": "paper", + "to": "venue" + }, + { + "name": "affiliated_with", + "from": "author", + "to": "institution" + }, + { + "name": "has_keyword", + "from": "paper", + "to": "keyword" + }, + { + "name": "belongs_field", + "from": "paper", + "to": "field" + }, + { + "name": "collaborate", + "from": "author", + "to": "author" + } + ], + "properties": { + "author": [ + "author_id", + "name", + "h_index" + ], + "paper": [ + "paper_id", + "title", + "year", + "citation_count" + ], + "venue": [ + "venue_id", + "name", + "type" + ], + "institution": [ + "institution_id", + "name", + "country" + ], + "keyword": [ + "keyword_id", + "name" + ], + "field": [ + "field_id", + "name" + ] + } + } + }, + "4_enterprise": { + "index": 4, + "name_zh": "企业组织", + "domain": "enterprise", + "schema": { + "domain": "enterprise", + "description": "员工、部门、项目、技能与组织结构图", + "vertex_labels": [ + "employee", + "department", + "project", + "skill", + "role", + "office" + ], + "edge_labels": [ + { + "name": "belongs_department", + "from": "employee", + "to": "department" + }, + { + "name": "work_on", + "from": "employee", + "to": "project" + }, + { + "name": "has_skill", + "from": "employee", + "to": "skill" + }, + { + "name": "report_to", + "from": "employee", + "to": "employee" + }, + { + "name": "has_role", + "from": "employee", + "to": "role" + }, + { + "name": "located_in", + "from": "department", + "to": "office" + }, + { + "name": "require_skill", + "from": "project", + "to": "skill" + } + ], + "properties": { + "employee": [ + "employee_id", + "name", + "level", + "hire_date" + ], + "department": [ + "department_id", + "name" + ], + "project": [ + "project_id", + "name", + "status", + "priority" + ], + "skill": [ + "skill_id", + "name" + ], + "role": [ + "role_id", + "name" + ], + "office": [ + "office_id", + "city", + "country" + ] + } + } + }, + "5_medical": { + "index": 5, + "name_zh": "医疗", + "domain": "medical", + "schema": { + "domain": "medical", + "description": "患者、疾病、症状、药物与检查图", + "vertex_labels": [ + "patient", + "disease", + "symptom", + "drug", + "doctor", + "department", + "test" + ], + "edge_labels": [ + { + "name": "has_symptom", + "from": "patient", + "to": "symptom" + }, + { + "name": "diagnosed_with", + "from": "patient", + "to": "disease" + }, + { + "name": "prescribed", + "from": "doctor", + "to": "drug" + }, + { + "name": "visit_doctor", + "from": "patient", + "to": "doctor" + }, + { + "name": "belongs_department", + "from": "doctor", + "to": "department" + }, + { + "name": "treats", + "from": "drug", + "to": "disease" + }, + { + "name": "requires_test", + "from": "disease", + "to": "test" + }, + { + "name": "take_test", + "from": "patient", + "to": "test" + } + ], + "properties": { + "patient": [ + "patient_id", + "name", + "age", + "gender" + ], + "disease": [ + "disease_id", + "name", + "severity" + ], + "symptom": [ + "symptom_id", + "name" + ], + "drug": [ + "drug_id", + "name", + "type" + ], + "doctor": [ + "doctor_id", + "name", + "title" + ], + "department": [ + "department_id", + "name" + ], + "test": [ + "test_id", + "name" + ] + } + } + }, + "6_logistics": { + "index": 6, + "name_zh": "物流", + "domain": "logistics", + "schema": { + "domain": "logistics", + "description": "订单、包裹、仓库、运输与路线图", + "vertex_labels": [ + "customer", + "shipment", + "warehouse", + "vehicle", + "route", + "city", + "carrier" + ], + "edge_labels": [ + { + "name": "create_shipment", + "from": "customer", + "to": "shipment" + }, + { + "name": "stored_in", + "from": "shipment", + "to": "warehouse" + }, + { + "name": "transport_by", + "from": "shipment", + "to": "vehicle" + }, + { + "name": "follow_route", + "from": "shipment", + "to": "route" + }, + { + "name": "from_city", + "from": "route", + "to": "city" + }, + { + "name": "to_city", + "from": "route", + "to": "city" + }, + { + "name": "operated_by", + "from": "vehicle", + "to": "carrier" + } + ], + "properties": { + "customer": [ + "customer_id", + "name" + ], + "shipment": [ + "shipment_id", + "status", + "weight", + "created_at" + ], + "warehouse": [ + "warehouse_id", + "name", + "city" + ], + "vehicle": [ + "vehicle_id", + "type", + "capacity" + ], + "route": [ + "route_id", + "distance" + ], + "city": [ + "city_id", + "name" + ], + "carrier": [ + "carrier_id", + "name" + ] + } + } + }, + "7_iot": { + "index": 7, + "name_zh": "IoT", + "domain": "iot", + "schema": { + "domain": "iot", + "description": "设备、传感器、位置、告警与网关图", + "vertex_labels": [ + "device", + "sensor", + "gateway", + "location", + "alarm", + "metric" + ], + "edge_labels": [ + { + "name": "has_sensor", + "from": "device", + "to": "sensor" + }, + { + "name": "connect_gateway", + "from": "device", + "to": "gateway" + }, + { + "name": "located_in", + "from": "device", + "to": "location" + }, + { + "name": "trigger_alarm", + "from": "device", + "to": "alarm" + }, + { + "name": "collect_metric", + "from": "sensor", + "to": "metric" + }, + { + "name": "gateway_in", + "from": "gateway", + "to": "location" + } + ], + "properties": { + "device": [ + "device_id", + "name", + "status", + "type" + ], + "sensor": [ + "sensor_id", + "name", + "sensor_type" + ], + "gateway": [ + "gateway_id", + "name" + ], + "location": [ + "location_id", + "name", + "region" + ], + "alarm": [ + "alarm_id", + "level", + "created_at" + ], + "metric": [ + "metric_id", + "name", + "value" + ] + } + } + }, + "8_gaming": { + "index": 8, + "name_zh": "游戏", + "domain": "gaming", + "schema": { + "domain": "gaming", + "description": "玩家、游戏、道具、任务与公会图", + "vertex_labels": [ + "player", + "game", + "item", + "quest", + "guild", + "achievement", + "character" + ], + "edge_labels": [ + { + "name": "play_game", + "from": "player", + "to": "game" + }, + { + "name": "own_item", + "from": "player", + "to": "item" + }, + { + "name": "complete_quest", + "from": "player", + "to": "quest" + }, + { + "name": "join_guild", + "from": "player", + "to": "guild" + }, + { + "name": "unlock_achievement", + "from": "player", + "to": "achievement" + }, + { + "name": "use_character", + "from": "player", + "to": "character" + }, + { + "name": "reward_item", + "from": "quest", + "to": "item" + } + ], + "properties": { + "player": [ + "player_id", + "name", + "level", + "region" + ], + "game": [ + "game_id", + "name", + "genre" + ], + "item": [ + "item_id", + "name", + "rarity" + ], + "quest": [ + "quest_id", + "name", + "difficulty" + ], + "guild": [ + "guild_id", + "name" + ], + "achievement": [ + "achievement_id", + "name" + ], + "character": [ + "character_id", + "name", + "class" + ] + } + } + }, + "9_recommendation": { + "index": 9, + "name_zh": "推荐", + "domain": "recommendation", + "schema": { + "domain": "recommendation", + "description": "用户、物品、标签、类目与行为图", + "vertex_labels": [ + "user", + "item", + "category", + "tag", + "session", + "creator" + ], + "edge_labels": [ + { + "name": "click", + "from": "user", + "to": "item" + }, + { + "name": "like", + "from": "user", + "to": "item" + }, + { + "name": "favorite", + "from": "user", + "to": "item" + }, + { + "name": "belongs_category", + "from": "item", + "to": "category" + }, + { + "name": "has_tag", + "from": "item", + "to": "tag" + }, + { + "name": "created_by", + "from": "item", + "to": "creator" + }, + { + "name": "has_session", + "from": "user", + "to": "session" + }, + { + "name": "interact_item", + "from": "session", + "to": "item" + } + ], + "properties": { + "user": [ + "user_id", + "name" + ], + "item": [ + "item_id", + "name", + "score", + "publish_time" + ], + "category": [ + "category_id", + "name" + ], + "tag": [ + "tag_id", + "name" + ], + "session": [ + "session_id", + "start_time" + ], + "creator": [ + "creator_id", + "name" + ] + } + } + }, + "10_risk_control": { + "index": 10, + "name_zh": "金融风控", + "domain": "risk_control", + "schema": { + "domain": "risk_control", + "description": "账户、设备、交易、商户与风险关系图", + "vertex_labels": [ + "account", + "transaction", + "device", + "merchant", + "ip", + "card", + "risk_tag" + ], + "edge_labels": [ + { + "name": "initiate_txn", + "from": "account", + "to": "transaction" + }, + { + "name": "use_device", + "from": "account", + "to": "device" + }, + { + "name": "use_ip", + "from": "account", + "to": "ip" + }, + { + "name": "bind_card", + "from": "account", + "to": "card" + }, + { + "name": "pay_merchant", + "from": "transaction", + "to": "merchant" + }, + { + "name": "has_risk_tag", + "from": "account", + "to": "risk_tag" + }, + { + "name": "txn_has_risk_tag", + "from": "transaction", + "to": "risk_tag" + } + ], + "properties": { + "account": [ + "account_id", + "name", + "status", + "risk_score" + ], + "transaction": [ + "txn_id", + "amount", + "time", + "status" + ], + "device": [ + "device_id", + "type" + ], + "merchant": [ + "merchant_id", + "name", + "category" + ], + "ip": [ + "ip_id", + "address" + ], + "card": [ + "card_id", + "bin" + ], + "risk_tag": [ + "tag_id", + "name", + "level" + ] + } + } + }, + "11_cybersecurity": { + "index": 11, + "name_zh": "网络安全", + "domain": "cybersecurity", + "schema": { + "domain": "cybersecurity", + "description": "主机、进程、文件、IP、告警与漏洞图", + "vertex_labels": [ + "host", + "process", + "file", + "ip", + "alert", + "vulnerability", + "user" + ], + "edge_labels": [ + { + "name": "run_process", + "from": "host", + "to": "process" + }, + { + "name": "access_file", + "from": "process", + "to": "file" + }, + { + "name": "connect_ip", + "from": "host", + "to": "ip" + }, + { + "name": "trigger_alert", + "from": "host", + "to": "alert" + }, + { + "name": "has_vulnerability", + "from": "host", + "to": "vulnerability" + }, + { + "name": "login_host", + "from": "user", + "to": "host" + }, + { + "name": "parent_process", + "from": "process", + "to": "process" + } + ], + "properties": { + "host": [ + "host_id", + "hostname", + "os" + ], + "process": [ + "process_id", + "name", + "pid" + ], + "file": [ + "file_id", + "path", + "type" + ], + "ip": [ + "ip_id", + "address" + ], + "alert": [ + "alert_id", + "level", + "type" + ], + "vulnerability": [ + "vuln_id", + "cve", + "severity" + ], + "user": [ + "user_id", + "name" + ] + } + } + }, + "12_manufacturing": { + "index": 12, + "name_zh": "制造", + "domain": "manufacturing", + "schema": { + "domain": "manufacturing", + "description": "工厂、产线、设备、工单、零件与供应商图", + "vertex_labels": [ + "factory", + "production_line", + "machine", + "work_order", + "part", + "supplier", + "product" + ], + "edge_labels": [ + { + "name": "has_line", + "from": "factory", + "to": "production_line" + }, + { + "name": "has_machine", + "from": "production_line", + "to": "machine" + }, + { + "name": "execute_order", + "from": "machine", + "to": "work_order" + }, + { + "name": "produce_product", + "from": "work_order", + "to": "product" + }, + { + "name": "use_part", + "from": "work_order", + "to": "part" + }, + { + "name": "supply_part", + "from": "supplier", + "to": "part" + }, + { + "name": "located_in", + "from": "factory", + "to": "factory" + } + ], + "properties": { + "factory": [ + "factory_id", + "name", + "city" + ], + "production_line": [ + "line_id", + "name" + ], + "machine": [ + "machine_id", + "name", + "status" + ], + "work_order": [ + "order_id", + "status", + "priority" + ], + "part": [ + "part_id", + "name", + "type" + ], + "supplier": [ + "supplier_id", + "name" + ], + "product": [ + "product_id", + "name" + ] + } + } + }, + "13_education": { + "index": 13, + "name_zh": "教育", + "domain": "education", + "schema": { + "domain": "education", + "description": "学生、课程、教师、专业、知识点与作业图", + "vertex_labels": [ + "student", + "course", + "teacher", + "major", + "knowledge_point", + "assignment", + "classroom" + ], + "edge_labels": [ + { + "name": "enroll_course", + "from": "student", + "to": "course" + }, + { + "name": "teach_course", + "from": "teacher", + "to": "course" + }, + { + "name": "belong_major", + "from": "student", + "to": "major" + }, + { + "name": "has_knowledge_point", + "from": "course", + "to": "knowledge_point" + }, + { + "name": "submit_assignment", + "from": "student", + "to": "assignment" + }, + { + "name": "course_has_assignment", + "from": "course", + "to": "assignment" + }, + { + "name": "hold_in", + "from": "course", + "to": "classroom" + } + ], + "properties": { + "student": [ + "student_id", + "name", + "grade" + ], + "course": [ + "course_id", + "name", + "credit" + ], + "teacher": [ + "teacher_id", + "name", + "title" + ], + "major": [ + "major_id", + "name" + ], + "knowledge_point": [ + "kp_id", + "name" + ], + "assignment": [ + "assignment_id", + "title", + "deadline" + ], + "classroom": [ + "classroom_id", + "name", + "building" + ] + } + } + }, + "14_recruitment": { + "index": 14, + "name_zh": "招聘", + "domain": "recruitment", + "schema": { + "domain": "recruitment", + "description": "候选人、职位、公司、技能与面试流程图", + "vertex_labels": [ + "candidate", + "job", + "company", + "skill", + "interview", + "recruiter", + "department" + ], + "edge_labels": [ + { + "name": "apply_job", + "from": "candidate", + "to": "job" + }, + { + "name": "has_skill", + "from": "candidate", + "to": "skill" + }, + { + "name": "require_skill", + "from": "job", + "to": "skill" + }, + { + "name": "posted_by", + "from": "job", + "to": "company" + }, + { + "name": "schedule_interview", + "from": "candidate", + "to": "interview" + }, + { + "name": "handled_by", + "from": "interview", + "to": "recruiter" + }, + { + "name": "belongs_department", + "from": "job", + "to": "department" + } + ], + "properties": { + "candidate": [ + "candidate_id", + "name", + "experience_years" + ], + "job": [ + "job_id", + "title", + "salary_min", + "salary_max" + ], + "company": [ + "company_id", + "name" + ], + "skill": [ + "skill_id", + "name" + ], + "interview": [ + "interview_id", + "round", + "status" + ], + "recruiter": [ + "recruiter_id", + "name" + ], + "department": [ + "department_id", + "name" + ] + } + } + }, + "15_content_platform": { + "index": 15, + "name_zh": "内容平台", + "domain": "content_platform", + "schema": { + "domain": "content_platform", + "description": "用户、内容、作者、专题、标签与互动图", + "vertex_labels": [ + "user", + "content", + "creator", + "topic", + "tag", + "playlist", + "comment" + ], + "edge_labels": [ + { + "name": "view_content", + "from": "user", + "to": "content" + }, + { + "name": "like_content", + "from": "user", + "to": "content" + }, + { + "name": "favorite_content", + "from": "user", + "to": "content" + }, + { + "name": "create_content", + "from": "creator", + "to": "content" + }, + { + "name": "has_topic", + "from": "content", + "to": "topic" + }, + { + "name": "has_tag", + "from": "content", + "to": "tag" + }, + { + "name": "add_playlist", + "from": "playlist", + "to": "content" + }, + { + "name": "comment_content", + "from": "user", + "to": "comment" + } + ], + "properties": { + "user": [ + "user_id", + "name" + ], + "content": [ + "content_id", + "title", + "duration", + "publish_time" + ], + "creator": [ + "creator_id", + "name" + ], + "topic": [ + "topic_id", + "name" + ], + "tag": [ + "tag_id", + "name" + ], + "playlist": [ + "playlist_id", + "name" + ], + "comment": [ + "comment_id", + "text", + "publish_time" + ] + } + } + }, + "16_aiops": { + "index": 16, + "name_zh": "运维监控", + "domain": "aiops", + "schema": { + "domain": "aiops", + "description": "服务、实例、日志、指标、告警与依赖关系图", + "vertex_labels": [ + "service", + "instance", + "host", + "metric", + "log", + "alert", + "cluster" + ], + "edge_labels": [ + { + "name": "has_instance", + "from": "service", + "to": "instance" + }, + { + "name": "deploy_on", + "from": "instance", + "to": "host" + }, + { + "name": "emit_metric", + "from": "instance", + "to": "metric" + }, + { + "name": "generate_log", + "from": "instance", + "to": "log" + }, + { + "name": "trigger_alert", + "from": "instance", + "to": "alert" + }, + { + "name": "belongs_cluster", + "from": "service", + "to": "cluster" + }, + { + "name": "depends_on", + "from": "service", + "to": "service" + } + ], + "properties": { + "service": [ + "service_id", + "name", + "tier" + ], + "instance": [ + "instance_id", + "status" + ], + "host": [ + "host_id", + "hostname", + "ip" + ], + "metric": [ + "metric_id", + "name", + "value" + ], + "log": [ + "log_id", + "level", + "timestamp" + ], + "alert": [ + "alert_id", + "severity", + "timestamp" + ], + "cluster": [ + "cluster_id", + "name" + ] + } + } + }, + "17_travel": { + "index": 17, + "name_zh": "旅游", + "domain": "travel", + "schema": { + "domain": "travel", + "description": "游客、景点、城市、酒店、路线与标签图", + "vertex_labels": [ + "traveler", + "attraction", + "city", + "hotel", + "route", + "tag", + "booking" + ], + "edge_labels": [ + { + "name": "visit_attraction", + "from": "traveler", + "to": "attraction" + }, + { + "name": "book_hotel", + "from": "traveler", + "to": "hotel" + }, + { + "name": "book_trip", + "from": "traveler", + "to": "booking" + }, + { + "name": "located_in", + "from": "attraction", + "to": "city" + }, + { + "name": "hotel_in", + "from": "hotel", + "to": "city" + }, + { + "name": "has_tag", + "from": "attraction", + "to": "tag" + }, + { + "name": "follow_route", + "from": "booking", + "to": "route" + } + ], + "properties": { + "traveler": [ + "traveler_id", + "name" + ], + "attraction": [ + "attraction_id", + "name", + "rating" + ], + "city": [ + "city_id", + "name", + "country" + ], + "hotel": [ + "hotel_id", + "name", + "star" + ], + "route": [ + "route_id", + "name" + ], + "tag": [ + "tag_id", + "name" + ], + "booking": [ + "booking_id", + "status", + "price" + ] + } + } + }, + "18_local_service": { + "index": 18, + "name_zh": "本地生活", + "domain": "local_service", + "schema": { + "domain": "local_service", + "description": "用户、商户、门店、服务、订单与评价图", + "vertex_labels": [ + "user", + "merchant", + "store", + "service", + "order", + "review", + "category" + ], + "edge_labels": [ + { + "name": "place_order", + "from": "user", + "to": "order" + }, + { + "name": "order_service", + "from": "order", + "to": "service" + }, + { + "name": "provided_by", + "from": "service", + "to": "merchant" + }, + { + "name": "has_store", + "from": "merchant", + "to": "store" + }, + { + "name": "review_service", + "from": "user", + "to": "review" + }, + { + "name": "belongs_category", + "from": "service", + "to": "category" + }, + { + "name": "store_in", + "from": "store", + "to": "store" + } + ], + "properties": { + "user": [ + "user_id", + "name", + "city" + ], + "merchant": [ + "merchant_id", + "name" + ], + "store": [ + "store_id", + "name", + "district" + ], + "service": [ + "service_id", + "name", + "price" + ], + "order": [ + "order_id", + "status", + "amount" + ], + "review": [ + "review_id", + "score", + "content" + ], + "category": [ + "category_id", + "name" + ] + } + } + }, + "19_legal_compliance": { + "index": 19, + "name_zh": "法务合规", + "domain": "legal_compliance", + "schema": { + "domain": "legal_compliance", + "description": "案件、法规、条款、主体与风险事件图", + "vertex_labels": [ + "case", + "law", + "clause", + "entity", + "risk_event", + "court", + "lawyer" + ], + "edge_labels": [ + { + "name": "related_law", + "from": "case", + "to": "law" + }, + { + "name": "contains_clause", + "from": "law", + "to": "clause" + }, + { + "name": "involves_entity", + "from": "case", + "to": "entity" + }, + { + "name": "handled_by", + "from": "case", + "to": "lawyer" + }, + { + "name": "tried_in", + "from": "case", + "to": "court" + }, + { + "name": "has_risk_event", + "from": "entity", + "to": "risk_event" + }, + { + "name": "related_clause", + "from": "risk_event", + "to": "clause" + } + ], + "properties": { + "case": [ + "case_id", + "name", + "status" + ], + "law": [ + "law_id", + "name" + ], + "clause": [ + "clause_id", + "name" + ], + "entity": [ + "entity_id", + "name", + "type" + ], + "risk_event": [ + "event_id", + "name", + "level" + ], + "court": [ + "court_id", + "name" + ], + "lawyer": [ + "lawyer_id", + "name" + ] + } + } + }, + "20_supply_chain": { + "index": 20, + "name_zh": "供应链", + "domain": "supply_chain", + "schema": { + "domain": "supply_chain", + "description": "供应商、工厂、仓库、商品、订单与运输图", + "vertex_labels": [ + "supplier", + "factory", + "warehouse", + "product", + "purchase_order", + "shipment", + "retailer" + ], + "edge_labels": [ + { + "name": "supply_product", + "from": "supplier", + "to": "product" + }, + { + "name": "produce_product", + "from": "factory", + "to": "product" + }, + { + "name": "store_product", + "from": "warehouse", + "to": "product" + }, + { + "name": "create_po", + "from": "retailer", + "to": "purchase_order" + }, + { + "name": "contain_product", + "from": "purchase_order", + "to": "product" + }, + { + "name": "deliver_shipment", + "from": "supplier", + "to": "shipment" + }, + { + "name": "shipment_for", + "from": "shipment", + "to": "purchase_order" + } + ], + "properties": { + "supplier": [ + "supplier_id", + "name" + ], + "factory": [ + "factory_id", + "name" + ], + "warehouse": [ + "warehouse_id", + "name", + "city" + ], + "product": [ + "product_id", + "name", + "category" + ], + "purchase_order": [ + "po_id", + "status", + "amount" + ], + "shipment": [ + "shipment_id", + "status" + ], + "retailer": [ + "retailer_id", + "name" + ] + } + } + } + } +} \ No newline at end of file diff --git a/text2gremlin/AST_Text2Gremlin/db_data/schema/movie_schema.json b/text2gremlin/AST_Text2Gremlin/db_data/schema/movie_schema.json new file mode 100644 index 000000000..2f52859d1 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/db_data/schema/movie_schema.json @@ -0,0 +1,316 @@ +{ + "schema": [ + { + "label": "person", + "type": "VERTEX", + "primary": "id", + "properties": [ + { + "name": "id", + "type": "INT32" + }, + { + "name": "name", + "type": "STRING" + }, + { + "name": "born", + "type": "INT32", + "optional": true + }, + { + "name": "poster_image", + "type": "STRING", + "optional": true + } + ] + }, + { + "label": "genre", + "type": "VERTEX", + "primary": "id", + "properties": [ + { + "name": "id", + "type": "INT32" + }, + { + "name": "name", + "type": "STRING" + } + ] + }, + { + "label": "keyword", + "primary": "id", + "type": "VERTEX", + "properties": [ + { + "name": "id", + "type": "INT32" + }, + { + "name": "name", + "type": "STRING" + } + ] + }, + { + "label": "movie", + "primary": "id", + "type": "VERTEX", + "properties": [ + { + "name": "id", + "type": "INT32" + }, + { + "name": "title", + "type": "STRING", + "index": true + }, + { + "name": "tagline", + "type": "STRING" + }, + { + "name": "summary", + "type": "STRING", + "optional": true + }, + { + "name": "poster_image", + "type": "STRING", + "optional": true + }, + { + "name": "duration", + "type": "INT32" + }, + { + "name": "rated", + "type": "STRING", + "optional": true + } + ] + }, + { + "label": "user", + "primary": "id", + "type": "VERTEX", + "properties": [ + { + "name": "id", + "type": "INT32" + }, + { + "name": "login", + "type": "STRING", + "index": true + } + ] + }, + { + "label": "acted_in", + "type": "EDGE", + "properties": [ + { + "name": "role", + "type": "STRING" + } + ] + }, + { + "label": "rate", + "type": "EDGE", + "properties": [ + { + "name": "stars", + "type": "INT8" + } + ] + }, + { + "label": "directed", + "type": "EDGE" + }, + { + "label": "is_friend", + "type": "EDGE" + }, + { + "label": "has_genre", + "type": "EDGE" + }, + { + "label": "has_keyword", + "type": "EDGE" + }, + { + "label": "produce", + "type": "EDGE" + }, + { + "label": "write", + "type": "EDGE" + } + ], + "files": [ + { + "path": "movie/raw_data/vertex_person.csv", + "format": "CSV", + "label": "person", + "header": 2, + "columns": [ + "id", + "name", + "born", + "poster_image" + ] + }, + { + "path": "movie/raw_data/vertex_genre.csv", + "format": "CSV", + "label": "genre", + "header": 2, + "columns": [ + "id", + "name" + ] + }, + { + "path": "movie/raw_data/vertex_keyword.csv", + "format": "CSV", + "label": "keyword", + "header": 2, + "columns": [ + "id", + "name" + ] + }, + { + "path": "movie/raw_data/vertex_movie.csv", + "format": "CSV", + "label": "movie", + "header": 2, + "columns": [ + "id", + "title", + "tagline", + "summary", + "poster_image", + "duration", + "rated" + ] + }, + { + "path": "movie/raw_data/vertex_user.csv", + "format": "CSV", + "label": "user", + "header": 2, + "columns": [ + "id", + "login" + ] + }, + { + "path": "movie/raw_data/edge_acted_in.csv", + "format": "CSV", + "label": "acted_in", + "header": 2, + "SRC_ID": "person", + "DST_ID": "movie", + "columns": [ + "SRC_ID", + "DST_ID", + "role" + ] + }, + { + "path": "movie/raw_data/edge_rate.csv", + "format": "CSV", + "label": "rate", + "header": 2, + "SRC_ID": "user", + "DST_ID": "movie", + "columns": [ + "SRC_ID", + "SKIP", + "DST_ID", + "stars" + ] + }, + { + "path": "movie/raw_data/edge_directed.csv", + "format": "CSV", + "label": "directed", + "header": 2, + "SRC_ID": "person", + "DST_ID": "movie", + "columns": [ + "SRC_ID", + "DST_ID" + ] + }, + { + "path": "movie/raw_data/edge_is_friend.csv", + "format": "CSV", + "label": "is_friend", + "header": 2, + "SRC_ID": "user", + "DST_ID": "user", + "columns": [ + "SRC_ID", + "DST_ID" + ] + }, + { + "path": "movie/raw_data/edge_has_genre.csv", + "format": "CSV", + "label": "has_genre", + "header": 2, + "SRC_ID": "movie", + "DST_ID": "genre", + "columns": [ + "SRC_ID", + "DST_ID" + ] + }, + { + "path": "movie/raw_data/edge_has_keyword.csv", + "format": "CSV", + "label": "has_keyword", + "header": 2, + "SRC_ID": "movie", + "DST_ID": "keyword", + "columns": [ + "SRC_ID", + "DST_ID" + ] + }, + { + "path": "movie/raw_data/edge_produce.csv", + "format": "CSV", + "label": "produce", + "header": 2, + "SRC_ID": "person", + "DST_ID": "movie", + "columns": [ + "SRC_ID", + "DST_ID" + ] + }, + { + "path": "movie/raw_data/edge_write.csv", + "format": "CSV", + "label": "write", + "header": 2, + "SRC_ID": "person", + "DST_ID": "movie", + "columns": [ + "SRC_ID", + "DST_ID" + ] + } + ] +} \ No newline at end of file diff --git a/text2gremlin/AST_Text2Gremlin/generate_corpus.py b/text2gremlin/AST_Text2Gremlin/generate_corpus.py new file mode 100644 index 000000000..c8f778c50 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/generate_corpus.py @@ -0,0 +1,192 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +""" +Gremlin 查询语料库生成脚本 + +从模板生成 Gremlin 查询语料库的命令行工具。 + +用法: + # 使用默认配置（推荐） + python generate_corpus.py + + # 自定义参数 + python generate_corpus.py --templates my_templates.csv --num-queries 50 +""" + +import argparse +import json +import os +import sys +from datetime import datetime +from pathlib import Path + +# 添加 base 包到 Python 路径 +sys.path.insert(0, str(Path(__file__).parent)) + +from base import generate_gremlin_corpus + + +def load_config(config_path="config.json"): + """加载配置文件""" + try: + with open(config_path, encoding="utf-8") as f: + return json.load(f) + except Exception as e: + print(f"❌ 错误: 无法加载配置文件 {config_path}: {e}") + sys.exit(1) + + +def main(): + parser = argparse.ArgumentParser( + description="生成 Gremlin 查询语料库", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +示例: + # 使用默认配置 + python generate_corpus.py + + # 使用自定义模板文件 + python generate_corpus.py --templates my_templates.csv + + # 使用自定义配置文件 + python generate_corpus.py --config my_config.json + + # 完全自定义 + python generate_corpus.py --templates templates.csv --schema schema.json --data data/ --output output.json + +配置说明: + config.json 中的配置项： + - templates_file: 模板文件路径（默认: gremlin_templates.csv） + - db_schema_path: schema 文件路径 + - data_path: 数据目录路径（默认: db_data/） + - output_dir: 输出目录（默认: output） + + 查询数量控制: + - 由 combination_control_config.json 中的 max_total_combinations 控制 + - 根据查询复杂度自动调整（short/medium/long/ultra） + +注意: + - 输出文件自动命名为 output/generated_corpus_YYYYMMDD_HHMMSS.json + - 每次运行生成新文件，不会覆盖旧文件 + """, + ) + + parser.add_argument("--config", default="config.json", help="配置文件路径 (JSON格式，默认: config.json)") + + parser.add_argument("--templates", help="模板文件路径 (CSV格式，默认从 config.json 读取)") + + parser.add_argument("--schema", help="图数据库模式文件路径 (JSON格式，默认从 config.json 读取)") + + parser.add_argument("--data", help="数据目录路径 (默认从 config.json 读取)") + + parser.add_argument("--output", help="输出文件路径 (JSON格式，默认: output/generated_corpus_YYYYMMDD_HHMMSS.json)") + + args = parser.parse_args() + + # 加载配置文件 + config = load_config(args.config) + + # 从配置文件或命令行参数获取值（命令行参数优先） + templates_file = args.templates or config.get("templates_file", "gremlin_templates.csv") + db_id = config.get("db_id", "movie") + schema_path = args.schema or config.get("db_schema_path", {}).get(db_id, "db_data/schema/movie_schema.json") + data_path = args.data or config.get("data_path", "db_data/") + output_dir = config.get("output_dir", "output") + + # 更新 args 对象 + args.templates = templates_file + args.schema = schema_path + args.data = data_path + + # 验证输入文件 + if not os.path.exists(args.templates): + print(f"❌ 错误: 模板文件不存在: {args.templates}") + print(f"💡 提示: 请创建 {args.templates} 文件，或使用 --templates 指定其他文件") + sys.exit(1) + + if not os.path.exists(args.config): + print(f"❌ 错误: 配置文件不存在: {args.config}") + sys.exit(1) + + if not os.path.exists(args.schema): + print(f"❌ 错误: 模式文件不存在: {args.schema}") + sys.exit(1) + + if not os.path.exists(args.data): + print(f"❌ 错误: 数据目录不存在: {args.data}") + sys.exit(1) + + # 如果没有指定输出文件，使用默认路径 + if not args.output: + # 确保输出目录存在 + os.makedirs(output_dir, exist_ok=True) + + # 生成带时间戳的文件名 + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + args.output = f"{output_dir}/generated_corpus_{timestamp}.json" + + try: + print("=" * 60) + print("🚀 Gremlin 查询语料库生成器") + print("=" * 60) + print("\n📋 配置信息:") + print(f" 模板文件: {args.templates}") + print(f" 配置文件: {args.config}") + print(f" 模式文件: {args.schema}") + print(f" 数据目录: {args.data}") + print(f" 输出文件: {args.output}") + + print("\n" + "-" * 60) + + # 调用生成器 + result = generate_gremlin_corpus( + templates=args.templates, + config_path=args.config, + schema_path=args.schema, + data_path=args.data, + output_file=args.output, + ) + + print("\n" + "=" * 60) + print("✅ 生成完成！") + print("=" * 60) + print("\n📊 统计信息:") + print(f" 总模板数: {result['total_templates']}") + print(f" 成功处理: {result['successful_templates']}") + print(f" 处理失败: {result['failed_templates']}") + print(f" 生成查询数: {result['total_unique_queries']}") + + if "output_file" in result: + print(f"\n💾 结果已保存到: {result['output_file']}") + print("\n💡 提示:") + print(f" - 可以在 {args.templates} 中添加更多模板") + print(" - 查询数量由 combination_control_config.json 控制") + else: + print(f"\n生成了 {len(result['queries'])} 个查询 (未保存到文件)") + + except Exception as e: + print(f"❌ 错误: {e!s}") + import traceback + + traceback.print_exc() + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/text2gremlin/AST_Text2Gremlin/gremlin_templates.csv b/text2gremlin/AST_Text2Gremlin/gremlin_templates.csv new file mode 100644 index 000000000..201ce9f23 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/gremlin_templates.csv @@ -0,0 +1,252 @@ +gremlin_query +"g.V()" +"g.E()" +"g.V().hasLabel('person')" +"g.V().hasLabel('movie')" +"g.V().hasLabel('user')" +"g.V().hasLabel('genre')" +"g.V().hasLabel('keyword')" +"g.V().has('name', 'Tom Hanks')" +"g.V().has('title', 'The Matrix')" +"g.V().has('born', 1960)" +"g.V().has('duration', 120)" +"g.V().has('stars', 5)" +"g.V().has('name', P.eq('Tom Hanks'))" +"g.V().has('born', P.gt(1960))" +"g.V().has('born', P.lt(1980))" +"g.V().has('born', P.gte(1960))" +"g.V().has('born', P.lte(1980))" +"g.V().has('born', P.between(1960, 1980))" +"g.V().has('born', P.inside(1960, 1980))" +"g.V().has('born', P.outside(1950, 1990))" +"g.V().has('name', P.within('Tom Hanks', 'Keanu Reeves'))" +"g.V().has('name', P.without('Tom Hanks', 'Keanu Reeves'))" +"g.V().has('name', TextP.startingWith('Tom'))" +"g.V().has('name', TextP.endingWith('Hanks'))" +"g.V().has('name', TextP.containing('Tom'))" +"g.V().has('title', TextP.regex('Matrix.*'))" +"g.V().hasLabel('person').has('name', 'Tom Hanks')" +"g.V().hasLabel('movie').has('title', 'The Matrix')" +"g.V().hasLabel('person').has('born', P.gt(1960))" +"g.V().hasId(1)" +"g.V().hasKey('name')" +"g.V().hasValue('Tom Hanks')" +"g.V().out('acted_in')" +"g.V().out('directed')" +"g.V().out('produce')" +"g.V().out('write')" +"g.V().in('acted_in')" +"g.V().in('directed')" +"g.V().both('acted_in')" +"g.V().outE('acted_in')" +"g.V().inE('acted_in')" +"g.V().bothE('acted_in')" +"g.V().outE('acted_in').inV()" +"g.V().inE('acted_in').outV()" +"g.V().bothE('acted_in').bothV()" +"g.V().outE('acted_in').otherV()" +"g.V().hasLabel('person').out('acted_in')" +"g.V().hasLabel('movie').in('acted_in')" +"g.V().hasLabel('person').out('acted_in').has('title', 'The Matrix')" +"g.V().has('name', 'Tom Hanks').out('acted_in')" +"g.V().has('title', 'The Matrix').in('acted_in')" +"g.V().hasLabel('person').out('acted_in').in('has_genre')" +"g.V().limit(10)" +"g.V().skip(5)" +"g.V().tail(10)" +"g.V().sample(5)" +"g.V().range(0, 10)" +"g.V().coin(0.5)" +"g.V().hasLabel('person').limit(10)" +"g.V().out('acted_in').limit(5)" +"g.V().values('name')" +"g.V().values('title')" +"g.V().values('born')" +"g.V().values('name', 'born')" +"g.V().properties('name')" +"g.V().valueMap()" +"g.V().valueMap('name', 'born')" +"g.V().elementMap()" +"g.V().hasLabel('person').values('name')" +"g.V().hasLabel('movie').valueMap()" +"g.V().id()" +"g.V().label()" +"g.V().count()" +"g.V().hasLabel('person').count()" +"g.V().out('acted_in').count()" +"g.V().dedup()" +"g.V().hasLabel('person').dedup()" +"g.V().values('name').dedup()" +"g.V().order()" +"g.V().order().by('name')" +"g.V().order().by('born', desc)" +"g.V().hasLabel('person').order().by('born')" +"g.V().simplePath()" +"g.V().cyclicPath()" +"g.V().hasLabel('person').out('acted_in').simplePath()" +"g.V().group()" +"g.V().group().by('name')" +"g.V().groupCount()" +"g.V().groupCount().by(label)" +"g.V().hasLabel('person').groupCount().by('born')" +"g.V().values('born').sum()" +"g.V().values('born').mean()" +"g.V().values('born').min()" +"g.V().values('born').max()" +"g.V().hasLabel('movie').values('duration').sum()" +"g.V().as('a').out('acted_in').as('b').select('a', 'b')" +"g.V().as('person').out('acted_in').as('movie').select('person')" +"g.V().where(out('acted_in'))" +"g.V().where(__.out('acted_in').count().is(P.gt(5)))" +"g.V().not(out('acted_in'))" +"g.V().and(hasLabel('person'), has('born', P.gt(1960)))" +"g.V().or(hasLabel('person'), hasLabel('movie'))" +"g.V().filter(out('acted_in'))" +"g.V().is('Tom Hanks')" +"g.V().constant('value')" +"g.V().identity()" +"g.V().barrier()" +"g.V().fold()" +"g.V().unfold()" +"g.V().path()" +"g.V().hasLabel('person').out('acted_in').path()" +"g.V().project('name', 'born').by('name').by('born')" +"g.V().hasLabel('person').project('name').by('name')" +"g.V().repeat(out('acted_in')).times(2)" +"g.V().repeat(out('acted_in')).until(hasLabel('genre'))" +"g.V().emit().repeat(out('acted_in')).times(2)" +"g.V().hasLabel('person').repeat(out()).times(2)" +"g.V().choose(hasLabel('person'), out('acted_in'), out('has_genre'))" +"g.V().coalesce(out('acted_in'), out('directed'))" +"g.V().optional(out('acted_in'))" +"g.V().union(out('acted_in'), out('directed'))" +"g.V().local(out('acted_in').limit(1))" +"g.V().flatMap(out('acted_in'))" +"g.V().map(out('acted_in'))" +"g.V().aggregate('x').out('acted_in')" +"g.V().store('x').out('acted_in')" +"g.V().aggregate('x').cap('x')" +"g.V().sideEffect(out('acted_in'))" +"g.V().tree()" +"g.V().hasLabel('person').out('acted_in').tree()" +"g.V().drop()" +"g.V().has('name', 'Test').drop()" +"g.V().iterate()" +"g.V().explain()" +"g.V().profile()" +"g.addV('person')" +"g.addV('person').property('name', 'New Person')" +"g.addV('person').property('name', 'New Person').property('born', 1990)" +"g.addV('movie').property('title', 'New Movie')" +"g.V().has('name', 'Tom Hanks').addE('acted_in').to(V().has('title', 'New Movie'))" +"g.V().has('name', 'Tom Hanks').addE('acted_in').to(V().has('title', 'New Movie')).property('role', 'Actor')" +"g.V().has('name', 'Tom Hanks').property('born', 1960)" +"g.V().has('title', 'The Matrix').property('duration', 136)" +"g.V().hasLabel('person').has('name', 'Tom Hanks').property('born', 1960).property('poster_image', 'url')" +"g.V().match(__.as('a').out('acted_in').as('b'), __.as('b').in('directed').as('c'))" +"g.V().hasLabel('person').out('acted_in').hasLabel('movie').in('has_genre').hasLabel('genre')" +"g.V().hasLabel('person').out('acted_in').dedup().count()" +"g.V().hasLabel('movie').in('acted_in').groupCount().by('name')" +"g.V().hasLabel('person').out('acted_in').order().by('title').limit(10)" +"g.V().hasLabel('person').where(out('acted_in').count().is(P.gt(5)))" +"g.V().hasLabel('person').as('p').out('acted_in').as('m').select('p', 'm').by('name').by('title')" +"g.V().hasLabel('person').repeat(out()).times(2).dedup()" +"g.V().hasLabel('movie').union(in('acted_in'), in('directed')).dedup()" +"g.V().hasLabel('person').choose(has('born', P.gt(1970)), out('acted_in'), out('directed'))" +"g.V().hasLabel('person').coalesce(out('acted_in'), out('directed'), out('produce'))" +"g.V().hasLabel('person').local(out('acted_in').limit(1))" +"g.V().hasLabel('movie').values('title', 'duration').fold()" +"g.V().hasLabel('person').out('acted_in').path().by('name').by('title')" +"g.V().hasLabel('person').out('acted_in').aggregate('movies').out('has_genre').dedup().where(within('movies'))" +"g.V().hasLabel('person').outE('acted_in').has('role', 'Neo').inV()" +"g.V().hasLabel('user').outE('rate').has('stars', P.gte(4)).inV()" +"g.V().hasLabel('movie').inE('rate').values('stars').mean()" +"g.V().hasLabel('person').out('acted_in').in('acted_in').where(neq('person')).dedup()" +"g.V().hasLabel('movie').as('m').in('acted_in').out('acted_in').where(neq('m')).dedup()" +"g.V().hasLabel('person').out('acted_in').in('has_genre').groupCount().by('name').order(local).by(values, desc)" +"g.V().hasLabel('person').filter(out('acted_in').count().is(P.gt(10)))" +"g.V().hasLabel('movie').filter(in('acted_in').count().is(P.gt(5)))" +"g.V().hasLabel('person').and(has('born', P.gt(1960)), out('acted_in').count().is(P.gt(5)))" +"g.V().hasLabel('movie').or(has('duration', P.gt(120)), in('rate').values('stars').mean().is(P.gt(4)))" +"g.V().hasLabel('person').out('acted_in').simplePath().limit(10)" +"g.V().hasLabel('person').repeat(out()).until(hasLabel('genre')).path()" +"g.V().hasLabel('person').emit().repeat(out()).times(3).dedup()" +"g.V().hasLabel('movie').project('title', 'actors', 'genres').by('title').by(in('acted_in').count()).by(out('has_genre').values('name').fold())" +"g.V().hasLabel('person').optional(out('acted_in').has('title', 'The Matrix'))" +"g.V().hasLabel('person').flatMap(union(out('acted_in'), out('directed'), out('produce'))).dedup()" +"g.V().hasLabel('movie').map(union(in('acted_in'), in('directed')).dedup().count())" +"g.V().hasLabel('person').sideEffect(properties().drop()).out('acted_in')" +"g.V().hasLabel('person').out('acted_in').tree().by('name')" +"g.V().hasLabel('person').has('born', P.between(1960, 1980)).out('acted_in').has('duration', P.gt(100)).dedup()" +"g.V().hasLabel('movie').where(and(has('duration', P.gt(100)), in('acted_in').count().is(P.gt(5))))" +"g.V().hasLabel('person').where(or(out('acted_in').count().is(P.gt(10)), out('directed').count().is(P.gt(2))))" +"g.V().hasLabel('person').as('p').out('acted_in').as('m').out('has_genre').as('g').select('p', 'm', 'g').by('name').by('title').by('name')" +"g.V().hasLabel('person').out('acted_in').groupCount().by('title').order(local).by(values, desc).limit(local, 10)" +"g.V().hasLabel('movie').in('acted_in').dedup().groupCount().by('name').order(local).by(values, desc)" +"g.V().hasLabel('person').repeat(out()).emit().times(3).dedup().path().by(label)" +"g.V().hasLabel('person').union(out('acted_in'), out('directed'), out('produce')).groupCount().by(label)" +"g.V().hasLabel('movie').choose(has('duration', P.gt(120)), constant('long'), constant('short'))" +"g.V().hasLabel('person').coalesce(out('acted_in').has('title', 'The Matrix'), out('directed'), out('produce'))" +"g.V().hasLabel('person').local(union(out('acted_in'), out('directed')).dedup().limit(5))" +"g.V().hasLabel('movie').values('title', 'duration', 'rated').fold()" +"g.V().hasLabel('person').out('acted_in').path().by('name').by('title').limit(10)" +"g.V().hasLabel('person').out('acted_in').aggregate('all').out('has_genre').where(within('all')).dedup()" +"g.V().hasLabel('person').outE('acted_in').has('role', TextP.containing('Neo')).inV()" +"g.V().hasLabel('user').outE('rate').has('stars', P.between(4, 5)).inV().dedup()" +"g.V().hasLabel('movie').inE('rate').group().by(inV()).by(values('stars').mean())" +"g.V().hasLabel('person').out('acted_in').in('acted_in').where(neq('person')).dedup().limit(10)" +"g.V().hasLabel('movie').as('m').in('acted_in').out('acted_in').where(neq('m')).groupCount().by('title')" +"g.V().hasLabel('person').out('acted_in').in('has_genre').groupCount().by('name').order(local).by(values, desc).limit(local, 5)" + +"g.addV('genre').property('name', 'Sci-Fi')" +"g.addV('keyword').property('name', 'adventure')" +"g.addV('user').property('login', 'newuser')" +"g.addV('movie').property('title', 'New Movie').property('tagline', 'A great movie').property('duration', 120).property('rated', 'PG-13')" +"g.addV('person').property('name', 'Director A').property('born', 1970).as('d').addV('movie').property('title', 'Movie X').as('m').addE('directed').from('d').to('m')" +"g.V().has('name', 'Tom Hanks').as('a').V().has('title', 'The Matrix').addE('acted_in').from('a').property('role', 'Neo')" +"g.V().hasLabel('person').has('name', 'Tom Hanks').addE('directed').to(V().has('title', 'The Matrix'))" +"g.V().hasLabel('user').has('login', 'newuser').addE('rate').to(V().has('title', 'The Matrix')).property('stars', 5)" +"g.V().hasLabel('user').has('login', 'newuser').addE('is_friend').to(V().has('login', 'otheruser'))" +"g.V().hasLabel('movie').has('title', 'The Matrix').addE('has_genre').to(V().hasLabel('genre').has('name', 'Sci-Fi'))" +"g.V().hasLabel('movie').has('title', 'The Matrix').addE('has_keyword').to(V().hasLabel('keyword').has('name', 'adventure'))" +"g.V().hasLabel('person').has('name', 'Tom Hanks').addE('produce').to(V().has('title', 'The Matrix'))" +"g.V().hasLabel('person').has('name', 'Tom Hanks').addE('write').to(V().has('title', 'The Matrix'))" +"g.V().hasLabel('movie').has('title', 'The Matrix').property('tagline', 'Welcome to the Real World').property('duration', 136)" +"g.V().hasLabel('person').has('born', P.gt(1980)).property('poster_image', 'http://example.com/photo.jpg')" +"g.V().hasLabel('movie').has('duration', P.gt(120)).property('rated', 'R')" +"g.V().hasLabel('person').out('acted_in').has('title', 'The Matrix').property('tagline', 'Updated tagline')" +"g.V().hasLabel('person').has('name', 'Tom Hanks').outE('acted_in').property('role', 'Updated Role')" +"g.V().hasLabel('user').outE('rate').has('stars', P.lt(3)).property('stars', 3)" +"g.V().hasLabel('person').has('born', P.gt(1960)).limit(5).property('poster_image', 'updated.jpg')" +"g.V().hasLabel('movie').has('rated', 'R').order().by('duration').limit(3).property('tagline', 'Updated')" +"g.V().hasLabel('person').where(__.out('acted_in').count().is(P.gt(5))).property('poster_image', 'star.jpg')" +"g.V().hasLabel('movie').in('acted_in').dedup().limit(1).property('poster_image', 'actor.jpg')" +"g.V().hasLabel('person').has('name', 'Test Person').drop()" +"g.V().hasLabel('movie').has('title', 'Test Movie').drop()" +"g.E().hasLabel('acted_in').drop()" +"g.E().hasLabel('rate').drop()" +"g.E().hasLabel('directed').drop()" +"g.V().hasLabel('person').has('name', 'Tom Hanks').outE('acted_in').drop()" +"g.V().hasLabel('movie').has('title', 'The Matrix').inE('rate').drop()" +"g.V().hasLabel('movie').has('title', 'The Matrix').inE().drop()" +"g.V().hasLabel('user').has('login', 'testuser').outE('is_friend').drop()" +"g.V().hasLabel('movie').has('title', 'The Matrix').properties('tagline').drop()" +"g.V().hasLabel('person').has('name', 'Tom Hanks').properties('poster_image').drop()" +"g.V().hasLabel('person').has('name', 'Tom Hanks').outE('acted_in').has('role', 'Forrest Gump').drop()" +"g.V().hasLabel('user').outE('rate').has('stars', P.lt(3)).drop()" +"g.V().hasLabel('movie').has('duration', P.lt(60)).drop()" +"g.V().hasLabel('person').has('born', P.lt(1950)).outE().drop()" +"g.V().hasLabel('person').out('acted_in').in('directed').dedup().as('d').V().hasLabel('movie').has('title', 'New Movie').addE('directed').from('d')" +"g.V().hasLabel('movie').has('rated', P.eq('R')).limit(10).drop()" +"g.V().hasLabel('person').not(__.out('acted_in')).drop()" +"g.V().hasLabel('movie').where(__.inE('rate').count().is(P.eq(0))).drop()" +"g.V().hasLabel('person').has('born', P.gt(1980)).out('acted_in').dedup().property('summary', 'Updated')" +"g.V().hasLabel('movie').order().by('duration', desc).limit(5).property('rated', 'Classic')" +"g.V().hasLabel('person').and(has('born', P.gt(1960)), has('born', P.lt(1980))).property('poster_image', 'retro.jpg')" +"g.V().hasLabel('user').out('rate').has('stars', P.gt(4)).in('rate').dedup().property('tagline', 'Popular')" +"g.V().hasLabel('person').out('acted_in').groupCount().by('title').order(local).by(values, desc).limit(local, 1).unfold().select(keys).property('summary', 'Top movie')" +"g.V().hasLabel('movie').has('duration', P.gt(180)).properties('summary').drop()" +"g.V().hasLabel('person').out('acted_in').dedup().has('duration', P.lt(90)).drop()" +"g.V().hasLabel('user').out('is_friend').out('rate').dedup().inE('rate').has('stars', P.lt(2)).drop()" +"g.V().hasLabel('movie').in('acted_in').dedup().has('born', P.lt(1940)).outE().drop()" +"g.V().hasLabel('person').out('acted_in').in('has_genre').dedup().has('name', 'Drama').inE('has_genre').drop()" diff --git a/text2gremlin/AST_Text2Gremlin/llm_augment/__init__.py b/text2gremlin/AST_Text2Gremlin/llm_augment/__init__.py new file mode 100644 index 000000000..c772eed42 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/llm_augment/__init__.py @@ -0,0 +1,26 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +""" +LLM 增强数据生成包 + +基于大语言模型对 AST 泛化后的 Gremlin 语料进行多阶段增强： + 1. generalize_llm — 多风格自然语言翻译 + 2. migrate_scenario — 多场景迁移 + 3. merge_dataset — 数据集合并与统计 + 4. generate_dpo_data — DPO 偏好数据生成 +""" diff --git a/text2gremlin/AST_Text2Gremlin/llm_augment/generalize_llm.py b/text2gremlin/AST_Text2Gremlin/llm_augment/generalize_llm.py new file mode 100644 index 000000000..8efb1d235 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/llm_augment/generalize_llm.py @@ -0,0 +1,516 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + + +""" +Gremlin 查询 LLM 多风格翻译脚本 + +读取 AST 泛化阶段生成的语料库（Gremlin query + 简单描述）， +通过 LLM 将每条查询翻译为 6 种不同风格的自然语言表达： + - 4 种固定风格：中文正式、中文口语、英文正式、英文口语 + - 2 种随机风格：从中英混合、省略表达、问答/指令/片段式、错别字中随机选取 + +用法: + # 使用默认配置，自动找到最新的泛化结果 + python -m llm_augment.generalize_llm + + # 指定输入文件 + python -m llm_augment.generalize_llm --input output/generated_corpus_xxx.json +""" + +import argparse +import asyncio +import json +import os +import random +import sys +import time +from datetime import datetime +from glob import glob + +from openai import AsyncOpenAI +from pydantic import ValidationError, create_model + +# 4 种固定风格（每条必须生成） +FIXED_STYLES = ["zh_formal", "zh_casual", "en_formal", "en_casual"] + +# 4 种可选风格（每条随机选 2 种） +OPTIONAL_STYLES = ["mixed_lang", "abbreviated", "interactive", "typo"] + +# 风格描述（用于 prompt） +STYLE_DESCRIPTIONS = { + "zh_formal": "中文正式：用规范的书面中文描述查询意图", + "zh_casual": "中文口语：用日常口语化的中文表达", + "en_formal": "英文正式：用规范的英文描述查询意图", + "en_casual": "英文口语：用日常口语化的英文表达", + "mixed_lang": "中英混合：中英文混用，像开发者日常交流", + "abbreviated": "省略表达：极度精简，只保留核心关键词", + "interactive": "问答式/指令式/片段式：像用户在对话中提问或下指令", + "typo": "夹杂错别字：在中文表达中故意引入1-2个错别字（同音字或形近字），但不影响语义", +} + +# 风格示例（用于 prompt 示例部分） +STYLE_EXAMPLES = { + "zh_formal": "查询所有电影关联的不重复流派名称", + "zh_casual": "电影都有哪些类型啊", + "en_formal": "Retrieve distinct genre names associated with all movies.", + "en_casual": "What genres do the movies belong to?", + "mixed_lang": "查一下 movie 关联的 genre name，去重", + "abbreviated": "电影 流派 去重", + "interactive": "给我查一下电影都有哪些类型", + "typo": "电映都有那些类形", +} + + +def create_translation_model(styles: list[str]): + """动态创建 Pydantic 模型，字段名为实际风格名""" + fields = dict.fromkeys(styles, (str, ...)) + return create_model("TranslationResult", **fields) + + +def load_config(config_path: str = "config.json") -> dict: + """加载配置文件""" + with open(config_path, encoding="utf-8") as f: + return json.load(f) + + +def get_llm_config(config: dict) -> dict: + """ + 获取 LLM 配置。 + + 所有必需参数必须在 config.json 的 "llm" 字段中正确配置， + 缺少字段或仍为占位符值时抛出 ValueError。 + """ + llm_cfg = config.get("llm") + if not llm_cfg: + raise ValueError( + "config.json 中缺少 'llm' 配置块，请添加以下配置:\n" + ' "llm": {\n' + ' "base_url": "http://your-llm-server:port/v1",\n' + ' "api_key": "your-api-key",\n' + ' "model": "your-model-name",\n' + " ...\n" + " }" + ) + + required_fields = { + "base_url": ["your-llm-server"], + "api_key": ["your-api-key"], + "model": ["your-model-name"], + } + + missing = [f for f in required_fields if f not in llm_cfg] + if missing: + raise ValueError(f"config.json 的 'llm' 配置中缺少必需字段: {missing}\n请在 config.json 中补充这些字段。") + + placeholder_fields = [] + for field, placeholders in required_fields.items(): + val = str(llm_cfg.get(field, "")) + if any(p in val for p in placeholders): + placeholder_fields.append(field) + + if placeholder_fields: + details = ", ".join(f'{f}="{llm_cfg[f]}"' for f in placeholder_fields) + raise ValueError( + f"config.json 的 'llm' 配置中以下字段仍为占位符，请修改为实际值: {placeholder_fields}\n 当前值: {details}" + ) + + return { + "base_url": llm_cfg["base_url"], + "api_key": llm_cfg["api_key"], + "model": llm_cfg["model"], + "temperature": llm_cfg.get("temperature", 0.7), + "max_retries": llm_cfg.get("max_retries", 3), + "max_concurrency": llm_cfg.get("max_concurrency", 20), + "save_interval": llm_cfg.get("save_interval", 50), + "timeout": llm_cfg.get("timeout", 40), + } + + +def find_latest_corpus(output_dir: str = "output") -> str | None: + """找到 output 目录下最新的泛化结果文件""" + pattern = os.path.join(output_dir, "generated_corpus_*.json") + files = sorted(glob(pattern), key=os.path.getmtime) + return files[-1] if files else None + + +def load_corpus(input_path: str) -> list[dict]: + """加载泛化结果文件，返回 corpus 列表""" + with open(input_path, encoding="utf-8") as f: + data = json.load(f) + return data.get("corpus", []) + + +def pick_random_styles(n: int = 2) -> list[str]: + """从可选风格中随机选取 n 种""" + return random.sample(OPTIONAL_STYLES, n) + + +def build_translation_prompt(item: dict, all_styles: list[str]) -> str: + """ + 构建单条翻译 prompt。 + + Args: + item: 待翻译的 (query, description) + all_styles: 6 种风格名列表（4 固定 + 2 随机，已确定） + """ + # 构建风格要求部分 + styles_text = "\n".join(f"{i}. {style}: {STYLE_DESCRIPTIONS[style]}" for i, style in enumerate(all_styles, 1)) + + # 构建输出格式 + output_fields = ",\n ".join(f'"{style}": "..."' for style in all_styles) + + # 构建示例输出 + example_fields = ",\n ".join(f'"{style}": "{STYLE_EXAMPLES[style]}"' for style in all_styles) + + prompt = f"""你是一个图数据库专家，需要将 Gremlin 查询语句翻译为图数据库使用者可能提出的自然语言问题。 +### 任务 +给你一条 Gremlin 查询及其简单描述，将 Gremlin 查询翻译为 6 种风格的自然语言。 + +### 风格要求： +{styles_text} + +### 输出要求 +1. 准确反映查询语义，不遗漏过滤条件、排序、限制数量等 +2. 各风格表达方式要有明显差异，长度要自然，可根据风格适当变化 +3. 专有名词保持原样，不要出现 Gremlin 术语 +4. typo 风格只引入 1-2 个错别字，不影响语义 +5. abbreviated 风格极度精简到核心关键词 +6. interactive 风格从问答式、指令式、片段式中选一种 + +### 输出格式（严格 JSON） +```json +{{ + {output_fields} +}} +``` + +### 示例 +输入: +Gremlin: g.V().hasLabel('movie').out('has_genre').dedup().values('name') +描述: 从图中开始查找所有顶点，过滤出'电影'类型的顶点，沿'has_genre'边out方向遍历，去重，获取'名称'属性值 + +输出: +```json +{{ + {example_fields} +}} +``` + +### 实际输入 +结合以上要求，将以下输入的gremlin语句进行翻译： +Gremlin: {item["query"]} +简单描述: {item["description"]} +""" + + return prompt + + +async def translate_one( + client: AsyncOpenAI, + item: dict, + semaphore: asyncio.Semaphore, + llm_config: dict, +) -> dict: + """ + 翻译单条 Gremlin 查询为多风格表达。 + + Returns: + 包含 query, description, translations 的结果 + """ + max_retries = llm_config["max_retries"] + + # 确定 6 种风格（4 固定 + 2 随机） + extra_styles = pick_random_styles(2) + all_styles = FIXED_STYLES + extra_styles + + async with semaphore: + for attempt in range(max_retries): + try: + prompt = build_translation_prompt(item, all_styles) + + response = await asyncio.wait_for( + client.chat.completions.create( + model=llm_config["model"], + messages=[{"role": "user", "content": prompt}], + temperature=llm_config["temperature"], + ), + timeout=llm_config.get("timeout", 40), + ) + + content = response.choices[0].message.content + if not content or not content.strip(): + raise ValueError("LLM 返回内容为空") + + # 提取 JSON + json_str = content + if "```json" in json_str: + json_str = json_str.split("```json")[1].split("```")[0] + elif "```" in json_str: + json_str = json_str.split("```")[1].split("```")[0] + + data = json.loads(json_str.strip()) + + # Pydantic 验证 + TranslationModel = create_translation_model(all_styles) + validated = TranslationModel(**data) + + # 组装结果 + translations = [] + for style in all_styles: + text = getattr(validated, style) + translations.append({"style": style, "text": text}) + + return { + "query": item["query"], + "description": item["description"], + "translations": translations, + } + + except (json.JSONDecodeError, ValueError, KeyError, ValidationError) as e: + if attempt < max_retries - 1: + continue + else: + return _fallback_result(item, all_styles, error=f"翻译失败(重试{max_retries}次): {e}") + except Exception as e: + if attempt < max_retries - 1: + await asyncio.sleep(min(2**attempt, 8) + random.random() * 0.25) + continue + return _fallback_result(item, all_styles, error=f"翻译异常: {e}") + + +def _fallback_result(item: dict, all_styles: list[str], error: str | None = None) -> dict: + """生成兜底结果（翻译失败时用描述填充）""" + desc = item["description"] + result = { + "query": item["query"], + "description": desc, + "translations": [{"style": style, "text": desc} for style in all_styles], + } + if error: + result["_error"] = error + return result + + +async def translate_all( + corpus: list[dict], + llm_config: dict, + output_path: str, + input_path: str, + save_interval: int = 50, +) -> list[dict]: + """ + 流水线并发翻译所有语料，支持增量保存。 + """ + req_timeout = llm_config.get("timeout", 40) + client = AsyncOpenAI( + base_url=llm_config["base_url"], + api_key=llm_config["api_key"], + timeout=req_timeout, + ) + + semaphore = asyncio.Semaphore(llm_config["max_concurrency"]) + results = [] + completed = 0 + last_save = 0 + start_time = time.time() + + print(f" 共 {len(corpus)} 条，流水线并发") + print(" 已加载 LLM 运行配置（敏感字段不显示）") + print(" 已启用增量保存") + print(" 每条生成 6 种风格翻译 (4固定 + 2随机)") + + # 创建所有任务 + tasks = { + asyncio.create_task(translate_one(client, item, semaphore, llm_config)): idx for idx, item in enumerate(corpus) + } + pending = set(tasks.keys()) + + while pending: + done, pending = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED) + + for task in done: + result = task.result() + results.append(result) + completed += 1 + + elapsed = time.time() - start_time + speed = completed / elapsed if elapsed > 0 else 0 + print(f"\r 进度: {completed}/{len(corpus)} ({speed:.1f} 条/秒)", end="", flush=True) + + if completed - last_save >= save_interval: + _incremental_save(results, output_path, input_path, elapsed) + last_save = completed + print(f" [已保存 {completed} 条]", end="", flush=True) + + print() + return results + + +def _incremental_save(results: list[dict], output_path: str, input_path: str, elapsed: float): + """增量保存当前结果""" + success_count = sum(1 for r in results if "_error" not in r) + + style_counts = {} + for r in results: + for t in r["translations"]: + style_counts[t["style"]] = style_counts.get(t["style"], 0) + 1 + + output_data = { + "metadata": { + "source_file": input_path, + "total_queries": len(results), + "total_translations": sum(len(r["translations"]) for r in results), + "translations_per_query": 6, + "fixed_styles": FIXED_STYLES, + "optional_styles": OPTIONAL_STYLES, + "style_distribution": style_counts, + "success_count": success_count, + "fail_count": len(results) - success_count, + "elapsed_seconds": round(elapsed, 2), + "generation_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + "status": "in_progress", + }, + "corpus": results, + } + + os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True) + with open(output_path, "w", encoding="utf-8") as f: + json.dump(output_data, f, ensure_ascii=False, indent=2) + + +def save_results(results: list[dict], output_path: str, input_path: str, elapsed: float): + """保存最终翻译结果""" + success_count = sum(1 for r in results if "_error" not in r) + total_translations = sum(len(r["translations"]) for r in results) + + style_counts = {} + for r in results: + for t in r["translations"]: + style = t["style"] + style_counts[style] = style_counts.get(style, 0) + 1 + + output_data = { + "metadata": { + "source_file": input_path, + "total_queries": len(results), + "total_translations": total_translations, + "translations_per_query": 6, + "fixed_styles": FIXED_STYLES, + "optional_styles": OPTIONAL_STYLES, + "style_distribution": style_counts, + "success_count": success_count, + "fail_count": len(results) - success_count, + "elapsed_seconds": round(elapsed, 2), + "generation_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + "status": "completed", + }, + "corpus": results, + } + + os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True) + with open(output_path, "w", encoding="utf-8") as f: + json.dump(output_data, f, ensure_ascii=False, indent=2) + + +def main(): + parser = argparse.ArgumentParser( + description="将泛化后的 Gremlin 查询通过 LLM 翻译为多风格自然语言表达", + ) + parser.add_argument("--config", default="config.json", help="配置文件路径") + parser.add_argument("--input", default=None, help="泛化结果文件路径（不指定则自动找最新的）") + parser.add_argument("--output", default=None, help="输出文件路径") + args = parser.parse_args() + + # 加载配置 + config = load_config(args.config) + llm_config = get_llm_config(config) + output_dir = config.get("output_dir", "output") + + # 定位输入文件 + input_path = args.input + if not input_path: + input_path = find_latest_corpus(output_dir) + if not input_path: + print(f"❌ 在 {output_dir}/ 下未找到泛化结果文件 (generated_corpus_*.json)") + sys.exit(1) + + if not os.path.exists(input_path): + print(f"❌ 输入文件不存在: {input_path}") + sys.exit(1) + + # 确定输出文件 + output_path = args.output + if not output_path: + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + output_path = os.path.join(output_dir, f"llm_translated_{timestamp}.json") + + # 加载语料 + corpus = load_corpus(input_path) + if not corpus: + print(f"❌ 输入文件中没有语料数据: {input_path}") + sys.exit(1) + + print("=" * 60) + print("🚀 Gremlin LLM 多风格翻译器") + print("=" * 60) + print("\n📋 配置:") + print(f" 输入文件: {input_path}") + print(f" 输出文件: {output_path}") + print(" LLM 配置: 已加载（敏感字段不显示）") + print(" 每条翻译数: 6 (4固定 + 2随机)") + print(" 重试与保存策略: 使用配置文件设置") + print(f"\n 语料条数: {len(corpus)}") + print(f" 预计生成: {len(corpus) * 6} 条翻译") + print("-" * 60) + + # 执行翻译 + start_time = time.time() + results = asyncio.run( + translate_all(corpus, llm_config, output_path, input_path, save_interval=llm_config["save_interval"]) + ) + elapsed = time.time() - start_time + + # 保存结果 + save_results(results, output_path, input_path, elapsed) + + # 统计 + success_count = sum(1 for r in results if "_error" not in r) + fail_count = len(results) - success_count + total_translations = sum(len(r["translations"]) for r in results) + + style_counts = {} + for r in results: + for t in r["translations"]: + style_counts[t["style"]] = style_counts.get(t["style"], 0) + 1 + + print("\n" + "=" * 60) + print("✅ 翻译完成") + print("=" * 60) + print(f" 总耗时: {elapsed:.2f} 秒") + print(f" 成功: {success_count}，失败: {fail_count}") + print(f" 生成翻译总数: {total_translations}") + print(f" 吞吐量: {len(results) / elapsed:.2f} 条/秒") + print("\n📊 风格分布:") + for style, count in sorted(style_counts.items(), key=lambda x: -x[1]): + label = STYLE_DESCRIPTIONS.get(style, style).split("：")[0] + print(f" {label}: {count}") + print(f"\n💾 结果已保存到: {output_path}") + + +if __name__ == "__main__": + main() diff --git a/text2gremlin/AST_Text2Gremlin/llm_augment/generate_dpo_data.py b/text2gremlin/AST_Text2Gremlin/llm_augment/generate_dpo_data.py new file mode 100644 index 000000000..62e84dafd --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/llm_augment/generate_dpo_data.py @@ -0,0 +1,1093 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +""" +DPO 偏好数据生成脚本 + +基于已有的 text2gremlin 数据，生成 Groovy vs Gremlin 的偏好对齐训练数据。 +支持 movie 领域（从 text2gremlin_pairs_*.json）和 20 个迁移领域（从 migrated_*.json）。 + +三类任务： + A 类：多任务组合 — 选 2~5 条简单 gremlin 合成 groovy（chosen）和纯 gremlin（rejected） + B 类：单任务 — 纯 gremlin（chosen）vs 包一层 groovy（rejected），数量为 A/C 的 1/3 + C 类：复杂长链拆解 — groovy 拆步骤（chosen）vs 原始长链（rejected） + +用法: + python -m llm_augment.generate_dpo_data + python -m llm_augment.generate_dpo_data --input output/text2gremlin_pairs_xxx.json + python -m llm_augment.generate_dpo_data --migrated output/migrated_xxx.json +""" + +import argparse +import asyncio +import json +import os +import random +import sys +import time +from datetime import datetime +from glob import glob + +from base.generator import check_gremlin_syntax +from openai import AsyncOpenAI +from pydantic import BaseModel, Field, ValidationError + +from llm_augment.generalize_llm import get_llm_config, load_config + + +class DPOCandidate(BaseModel): + """DPO 候选（chosen 或 rejected）""" + + style: str = Field(description="groovy 或 gremlin") + code: str = Field(description="代码内容") + + +class DPOSampleAWithReject(BaseModel): + """A 类：多任务组合的 LLM 输出（支持拒绝）""" + + reject: bool = Field(default=False, description="是否拒绝合成（命令冲突或无法合成）") + reject_reason: str | None = Field(default=None, description="拒绝原因") + instruction: str | None = Field(default=None, description="合成的自然语言任务描述") + chosen: DPOCandidate | None = None + rejected: DPOCandidate | None = None + preference_reason: list[str] | None = None + + +class DPOSampleA(BaseModel): + """A 类：多任务组合的 LLM 输出""" + + instruction: str = Field(description="合成的自然语言任务描述") + chosen: DPOCandidate + rejected: DPOCandidate + preference_reason: list[str] = Field(description="偏好原因") + + +class DPOSampleB(BaseModel): + """B 类：单任务的 LLM 输出""" + + chosen: DPOCandidate + rejected: DPOCandidate + preference_reason: list[str] = Field(description="偏好原因") + + +class DPOSampleC(BaseModel): + """C 类：复杂长链拆解的 LLM 输出""" + + chosen: DPOCandidate + preference_reason: list[str] = Field(description="偏好原因") + + +class DPOSampleCWithSkip(BaseModel): + """C 类带跳过标识""" + + skip: bool = Field(description="是否跳过（该语句不适合改写为 groovy）") + chosen: DPOCandidate | None = None + preference_reason: list[str] | None = None + + +def load_pairs(input_path: str) -> list[dict]: + with open(input_path, encoding="utf-8") as f: + data = json.load(f) + return data.get("pairs", []) + + +def find_latest_pairs(output_dir: str = "output") -> str | None: + pattern = os.path.join(output_dir, "text2gremlin_pairs_*.json") + files = sorted(glob(pattern), key=os.path.getmtime) + return files[-1] if files else None + + +def find_latest_migrated(output_dir: str = "output") -> str | None: + """查找最新的迁移数据文件""" + pattern = os.path.join(output_dir, "migrated_*.json") + files = sorted(glob(pattern), key=os.path.getmtime) + return files[-1] if files else None + + +def load_migrated_data(migrated_path: str) -> dict: + """加载迁移数据并按领域分组""" + with open(migrated_path, encoding="utf-8") as f: + data = json.load(f) + + migrations = data.get("migrations", []) + domain_data = {} + + for m in migrations: + domain = m.get("target_domain") + if not domain: + continue + + samples = m.get("generated_samples", []) + if not samples: + continue + + if domain not in domain_data: + domain_data[domain] = [] + + for s in samples: + # 转换为与 pairs 相同的格式 + pair = { + "text": s.get("natural_language", ""), + "gremlin": s.get("query", ""), + "style": s.get("language_style", ""), + "operation": s.get("operation", ""), + } + if pair["text"] and pair["gremlin"]: + domain_data[domain].append(pair) + + return domain_data + + +def count_gremlin_steps(gremlin: str) -> int: + """粗略统计 gremlin 语句的步数（以 '.' 分隔的方法调用数）""" + in_str = False + dots = 0 + for _i, ch in enumerate(gremlin): + if ch in ("'", '"'): + in_str = not in_str + elif ch == "." and not in_str: + dots += 1 + return dots + + +def classify_pairs(pairs: list[dict]) -> dict: + """将数据按步数分类。""" + short, medium, long_ = [], [], [] + for p in pairs: + steps = count_gremlin_steps(p["gremlin"]) + p["_steps"] = steps + if steps <= 5: + short.append(p) + elif steps > 8: + long_.append(p) + else: + medium.append(p) + return {"short": short, "medium": medium, "long": long_} + + +def select_related_group(short_pairs: list[dict], n: int, check_duplicate_gremlin: bool = False) -> list[dict]: + """从短查询中选取 n 条相关的查询（同 label 或同操作类型优先）。 + + Args: + short_pairs: 短查询列表 + n: 需要选取的数量 + check_duplicate_gremlin: 是否检查重复 gremlin（用于 A 类任务避免选择同一查询的不同语气版本） + """ + label_groups = {} + for p in short_pairs: + g = p["gremlin"] + labels = [] + idx = 0 + while True: + pos = g.find("hasLabel('", idx) + if pos == -1: + break + start = pos + len("hasLabel('") + end = g.find("'", start) + if end != -1: + labels.append(g[start:end]) + idx = end + 1 if end != -1 else len(g) + + key = tuple(sorted(set(labels))) if labels else ("_no_label",) + label_groups.setdefault(key, []).append(p) + + candidates = sorted(label_groups.values(), key=len, reverse=True) + + for group in candidates: + if len(group) >= n: + if check_duplicate_gremlin: + # 对于 A 类任务，需要确保选取的查询 gremlin 不重复 + # 先按 gremlin 去重，每个 gremlin 只保留一条 + gremlin_to_pair = {} + for p in group: + gremlin = p["gremlin"] + if gremlin not in gremlin_to_pair: + gremlin_to_pair[gremlin] = p + unique_pairs = list(gremlin_to_pair.values()) + if len(unique_pairs) >= n: + return random.sample(unique_pairs, n) + else: + return random.sample(group, n) + + # 如果没有足够大的组，从所有数据中选取 + if check_duplicate_gremlin: + gremlin_to_pair = {} + for p in short_pairs: + gremlin = p["gremlin"] + if gremlin not in gremlin_to_pair: + gremlin_to_pair[gremlin] = p + unique_pairs = list(gremlin_to_pair.values()) + return random.sample(unique_pairs, min(n, len(unique_pairs))) + + return random.sample(short_pairs, min(n, len(short_pairs))) + + +def build_prompt_type_a(selected_pairs: list[dict]) -> str: + """A 类 prompt：多任务组合，合成 groovy 和纯 gremlin""" + queries_text = "" + for i, p in enumerate(selected_pairs, 1): + op = p.get("operation", "unknown") + queries_text += f" {i}. [操作类型: {op}] 自然语言: {p['text']}\n Gremlin: {p['gremlin']}\n" + + styles = [p.get("style", "") for p in selected_pairs] + style_hint = "" + if any("zh" in s for s in styles): + style_hint = "中文" + elif any("en" in s for s in styles): + style_hint = "英文" + else: + style_hint = "与原始输入语句的语言风格保持一致" + + prompt = f"""你是一个图数据库专家，擅长 Gremlin 和 Groovy 编程。 + +## 任务 +给你 {len(selected_pairs)} 条来自同一场景的简单 Gremlin 查询及其自然语言描述。 +请你先分析这些命令是否可以合理地组合成一个复合任务，然后决定是否生成。 + +## 原始子查询 +{queries_text} + +## 第一步：分析命令是否可以合成 +请检查以下情况： +1. **操作冲突**：如果存在删除某元素后又更新/查询该元素的情况，需要调整顺序或拒绝 +2. **依赖关系**：如果命令之间有依赖（如先创建再查询），需要按正确顺序组合 +3. **语义冲突**：如果命令之间存在语义矛盾（如先删除后修改同一元素），当你不能转化为合理的命令和语句时，应拒绝 +4. **无法合成**：如果这些命令完全不相关，无法形成有意义的复合任务，应拒绝 + +如果可以合成，请调整命令顺序使其合理（如：创建 → 更新 → 查询 → 删除）。 +如果无法合成，请设置 reject=true 并说明原因。 + +## 第二步：如果可以合成 +1. 将这些查询组合成一个复合任务，生成一段自然语言描述（instruction） +2. 用 Groovy 命令式写法实现这个复合任务（chosen，style=groovy） +3. 用纯 Gremlin 函数式写法实现同样的任务（rejected，style=gremlin） +4. 说明为什么 Groovy 写法更优 + +## 要求 +1. instruction 必须是一个自然的复合任务描述，语言风格为{style_hint}，像真实用户会说的话 +2. Groovy 写法：用 def 定义中间变量，每条 traversal 调用 .next() 或 .toList()，最后返回一个 map +3. 纯 Gremlin 写法：用 project/union/inject 等方式强行写成一条语句，要体现出复杂和难读 +4. 两种写法的语义必须等价 +5. Groovy 中的变量命名要统一、清晰 +6. preference_reason 说明 Groovy 更优的具体原因 +7. **重要**：生成的 Gremlin 代码必须语法正确，可以被 ANTLR 解析 +8. **禁止注释**：代码中不要包含任何注释（// 或 /* */），只输出纯代码 + +## 输出格式（严格 JSON） + +如果可以合成： +```json +{{ + "reject": false, + "instruction": "...", + "chosen": {{ + "style": "groovy", + "code": "..." + }}, + "rejected": {{ + "style": "gremlin", + "code": "..." + }}, + "preference_reason": ["...", "..."] +}} +``` + +如果无法合成： +```json +{{ + "reject": true, + "reject_reason": "说明为什么无法合成，如：删除操作在更新操作之前，存在逻辑冲突" +}} +```""" + return prompt + + +def build_prompt_type_b(pair: dict) -> str: + """B 类 prompt：单任务，纯 gremlin 更好，生成包一层 groovy 的负样本""" + prompt = f"""你是一个图数据库专家，擅长 Gremlin 和 Groovy 编程。 + +## 任务 +给你一条简单的 Gremlin 查询，这条查询用单条 Gremlin 就能很好地完成。 +请你生成一个"过度工程化"的 Groovy 写法作为负样本。 + +## 原始查询 +自然语言: {pair["text"]} +Gremlin: {pair["gremlin"]} + +## 要求 +1. rejected 的 Groovy 写法要体现"过度包装"：用 def 变量、.next()、返回 map 等，但实际上完全没必要 +2. chosen 就是原始的 Gremlin 语句 +3. preference_reason 说明为什么单条 Gremlin 更好 +4. **禁止注释**：代码中不要包含任何注释（// 或 /* */），只输出纯代码 + +## 输出格式（严格 JSON） +```json +{{ + "chosen": {{ + "style": "gremlin", + "code": "..." + }}, + "rejected": {{ + "style": "groovy", + "code": "..." + }}, + "preference_reason": ["...", "..."] +}} +```""" + return prompt + + +def build_prompt_type_c(pair: dict) -> str: + """C 类 prompt：复杂长链拆解为 groovy""" + prompt = f"""你是一个图数据库专家，擅长 Gremlin 和 Groovy 编程。 + +## 任务 +给你一条复杂的长链 Gremlin 查询。请判断： +- 如果这条查询适合拆解为多步 Groovy 写法（更清晰、更易读），请生成 Groovy 版本 +- 如果这条查询用 Gremlin 写已经是最优的（无法有意义地拆分），请标记 skip=true + +## 原始查询 +自然语言: {pair["text"]} +Gremlin: {pair["gremlin"]} + +## 要求 +1. 如果适合改写： + - chosen 的 Groovy 写法要把长链拆成多个有意义的中间步骤 + - 用 def 定义中间变量，变量命名清晰 + - 最后返回结果 + - preference_reason 说明为什么拆解后更好 +2. 如果不适合改写（skip=true）： + - chosen 和 preference_reason 可以不填 + - 不要强行包一层 Groovy +3. **禁止注释**：代码中不要包含任何注释（// 或 /* */），只输出纯代码 + +## 输出格式（严格 JSON） + +适合改写时： +```json +{{ + "skip": false, + "chosen": {{ + "style": "groovy", + "code": "..." + }}, + "preference_reason": ["...", "..."] +}} +``` + +不适合改写时： +```json +{{ + "skip": true +}} +```""" + return prompt + + +async def call_llm( + client: AsyncOpenAI, + prompt: str, + llm_config: dict, + max_connection_retries: int = 5, +) -> str: + """统一的 LLM 调用，返回原始文本内容，带连接错误重试""" + from openai import APIConnectionError, APITimeoutError, RateLimitError + + for attempt in range(max_connection_retries): + try: + response = await client.chat.completions.create( + model=llm_config["model"], + messages=[{"role": "user", "content": prompt}], + temperature=llm_config["temperature"], + ) + content = response.choices[0].message.content + + if not content or not content.strip(): + raise ValueError("LLM 返回内容为空") + return content + except (APIConnectionError, APITimeoutError, RateLimitError): + if attempt < max_connection_retries - 1: + wait_time = 2 ** (attempt + 1) + await asyncio.sleep(wait_time) + continue + raise + + +def extract_json(content: str) -> dict: + """从 LLM 返回内容中提取 JSON""" + json_str = content + if "```json" in json_str: + json_str = json_str.split("```json")[1].split("```")[0] + elif "```" in json_str: + json_str = json_str.split("```")[1].split("```")[0] + return json.loads(json_str.strip()) + + +def extract_gremlin_from_groovy(groovy_code: str) -> list[str]: + """从 Groovy 代码中提取所有 g.V()/g.E()/g.addV() 等 Gremlin 语句""" + import re + + gremlins = [] + # 匹配 g.V()... 或 g.E()... 或 g.addV()... 等模式 + pattern = r"g\.[VEa][^;}\n]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*\([^)]*\))*" + matches = re.findall(pattern, groovy_code) + for m in matches: + # 清理末尾的 .next() 或 .toList() 等 Groovy 特有方法 + cleaned = re.sub(r"\.(next|toList|iterate|tryNext)\(\)$", "", m.strip()) + if cleaned: + gremlins.append(cleaned) + return gremlins + + +def validate_gremlin_code(code: str, style: str) -> tuple[bool, str]: + """验证代码中的 Gremlin 语法 + + Args: + code: 代码内容 + style: "gremlin" 或 "groovy" + + Returns: + (is_valid, error_message) + """ + if style == "gremlin": + # 纯 Gremlin，直接检查 + return check_gremlin_syntax(code) + # elif style == "groovy": + # # Groovy 代码，提取其中的 Gremlin 语句检查 + # gremlins = extract_gremlin_from_groovy(code) + # if not gremlins: + # # 没有提取到 Gremlin，可能是纯 Groovy 逻辑，跳过检查 + # return True, "No Gremlin found in Groovy code" + + # for g in gremlins: + # ok, msg = check_gremlin_syntax(g) + # if not ok: + # return False, f"Gremlin syntax error in: {g[:50]}... - {msg}" + # return True, "All Gremlin statements OK" + elif style == "groovy": + # Groovy 代码中的 Gremlin 会使用变量名，ANTLR 纯 Gremlin 语法解析器无法识别 + # 跳过 Groovy 中的 Gremlin 语法检查 + return True, "Groovy code, skipped ANTLR check" + else: + return True, "Unknown style, skipped" + + +def _error_result(task_id: str, task_type: str, domain: str, error: str) -> dict: + """生成错误结果""" + return { + "task_id": task_id, + "task_type": task_type, + "domain": domain, + "_error": error, + } + + +# ---- 单条任务处理 ---- + + +async def process_type_a( + client: AsyncOpenAI, + task: dict, + semaphore: asyncio.Semaphore, + llm_config: dict, +) -> dict | None: + """处理 A 类任务：多任务组合""" + max_retries = llm_config["max_retries"] + domain = task.get("domain", "movie") + + async with semaphore: + for attempt in range(max_retries): + try: + prompt = build_prompt_type_a(task["pairs"]) + content = await call_llm(client, prompt, llm_config) + data = extract_json(content) + + # 先用支持拒绝的模型验证 + validated = DPOSampleAWithReject(**data) + + # 如果 LLM 拒绝合成 + if validated.reject: + return { + "task_id": task["task_id"], + "task_type": "A", + "domain": domain, + "source_queries": [{"text": p["text"], "gremlin": p["gremlin"]} for p in task["pairs"]], + "_rejected": True, + "_reject_reason": validated.reject_reason or "LLM 拒绝合成", + } + + # 验证必要字段 + if not validated.instruction or not validated.chosen or not validated.rejected: + raise ValueError("reject=false 但缺少必要字段") + + # 语法检查：A 类必须检查 + # 检查 rejected（纯 Gremlin） + ok, msg = validate_gremlin_code(validated.rejected.code, validated.rejected.style) + if not ok: + raise ValueError(f"rejected Gremlin 语法错误: {msg}") + + # 检查 chosen（Groovy 中的 Gremlin） + ok, msg = validate_gremlin_code(validated.chosen.code, validated.chosen.style) + if not ok: + raise ValueError(f"chosen Groovy 中 Gremlin 语法错误: {msg}") + + return { + "task_id": task["task_id"], + "task_type": "A", + "domain": domain, + "source_queries": [{"text": p["text"], "gremlin": p["gremlin"]} for p in task["pairs"]], + "input": {"instruction": validated.instruction}, + "chosen": validated.chosen.model_dump(), + "rejected": validated.rejected.model_dump(), + "preference_reason": validated.preference_reason, + } + except (json.JSONDecodeError, ValueError, KeyError, ValidationError) as e: + if attempt < max_retries - 1: + continue + return _error_result(task["task_id"], "A", domain, f"A 类失败(重试{max_retries}次): {e}") + except Exception as e: + if attempt < max_retries - 1: + await asyncio.sleep(2 ** (attempt + 1)) + continue + return _error_result(task["task_id"], "A", domain, f"A 类异常(重试{max_retries}次): {e}") + + +async def process_type_b( + client: AsyncOpenAI, + task: dict, + semaphore: asyncio.Semaphore, + llm_config: dict, +) -> dict | None: + """处理 B 类任务：单任务，纯 gremlin 更好""" + max_retries = llm_config["max_retries"] + pair = task["pair"] + domain = task.get("domain", "movie") + + async with semaphore: + for attempt in range(max_retries): + try: + prompt = build_prompt_type_b(pair) + content = await call_llm(client, prompt, llm_config) + data = extract_json(content) + validated = DPOSampleB(**data) + + # B 类语法检查：检查 LLM 生成的 chosen（应该是原始 gremlin）和 rejected（groovy） + # chosen 是原始 gremlin，理论上已经验证过，但 LLM 可能抄错 + ok, msg = validate_gremlin_code(validated.chosen.code, validated.chosen.style) + if not ok: + raise ValueError(f"chosen Gremlin 语法错误: {msg}") + + # rejected 是 groovy，检查其中的 gremlin + ok, msg = validate_gremlin_code(validated.rejected.code, validated.rejected.style) + if not ok: + raise ValueError(f"rejected Groovy 中 Gremlin 语法错误: {msg}") + + return { + "task_id": task["task_id"], + "task_type": "B", + "domain": domain, + "input": {"instruction": pair["text"]}, + "chosen": validated.chosen.model_dump(), + "rejected": validated.rejected.model_dump(), + "preference_reason": validated.preference_reason, + } + except (json.JSONDecodeError, ValueError, KeyError, ValidationError) as e: + if attempt < max_retries - 1: + continue + return _error_result(task["task_id"], "B", domain, f"B 类失败(重试{max_retries}次): {e}") + except Exception as e: + if attempt < max_retries - 1: + await asyncio.sleep(2 ** (attempt + 1)) + continue + return _error_result(task["task_id"], "B", domain, f"B 类异常(重试{max_retries}次): {e}") + + +async def process_type_c( + client: AsyncOpenAI, + task: dict, + semaphore: asyncio.Semaphore, + llm_config: dict, +) -> dict | None: + """处理 C 类任务：复杂长链拆解""" + max_retries = llm_config["max_retries"] + pair = task["pair"] + domain = task.get("domain", "movie") + + async with semaphore: + for attempt in range(max_retries): + try: + prompt = build_prompt_type_c(pair) + content = await call_llm(client, prompt, llm_config) + data = extract_json(content) + validated = DPOSampleCWithSkip(**data) + + if validated.skip: + return None + + if not validated.chosen or not validated.preference_reason: + raise ValueError("skip=false 但缺少 chosen 或 preference_reason") + + # C 类语法检查：检查 LLM 生成的 chosen（groovy） + ok, msg = validate_gremlin_code(validated.chosen.code, validated.chosen.style) + if not ok: + raise ValueError(f"chosen Groovy 中 Gremlin 语法错误: {msg}") + + return { + "task_id": task["task_id"], + "task_type": "C", + "domain": domain, + "input": {"instruction": pair["text"]}, + "chosen": validated.chosen.model_dump(), + "rejected": { + "style": "gremlin", + "code": pair["gremlin"], + }, + "preference_reason": validated.preference_reason, + } + except (json.JSONDecodeError, ValueError, KeyError, ValidationError) as e: + if attempt < max_retries - 1: + continue + return _error_result(task["task_id"], "C", domain, f"C 类失败(重试{max_retries}次): {e}") + except Exception as e: + if attempt < max_retries - 1: + await asyncio.sleep(2 ** (attempt + 1)) + continue + return _error_result(task["task_id"], "C", domain, f"C 类异常(重试{max_retries}次): {e}") + + +def prepare_tasks( + classified: dict, + num_a: int, + num_b: int, + num_c: int | None = None, + domain: str = "movie", + check_duplicate_gremlin: bool = False, +) -> list[dict]: + """准备所有任务。 + + Args: + classified: 分类后的数据 + num_a: A 类任务数量 + num_b: B 类任务数量 + num_c: C 类任务数量（默认 None 表示使用所有长链） + domain: 领域名称 + check_duplicate_gremlin: 是否检查重复 gremlin（用于迁移领域的 A 类任务） + """ + tasks = [] + task_counter = 0 + domain_prefix = domain[:4].upper() # 取前4个字符作为前缀 + + short_pairs = classified["short"] + long_pairs = classified["long"] + medium_pairs = classified["medium"] + + # A 类：从 short 中选取相关组 + for _i in range(num_a): + n = random.randint(2, 5) + group = select_related_group(short_pairs, n, check_duplicate_gremlin=check_duplicate_gremlin) + if len(group) < 2: # 至少需要 2 条才能组合 + continue + task_counter += 1 + tasks.append( + { + "task_id": f"pref_{domain_prefix}_A_{task_counter:04d}", + "type": "A", + "domain": domain, + "pairs": group, + } + ) + + # B 类：从 short + medium 中选单条 + b_pool = short_pairs + medium_pairs + b_selected = random.sample(b_pool, min(num_b, len(b_pool))) + for pair in b_selected: + task_counter += 1 + tasks.append( + { + "task_id": f"pref_{domain_prefix}_B_{task_counter:04d}", + "type": "B", + "domain": domain, + "pair": pair, + } + ) + + # C 类：从 long 中选取（如果指定了 num_c 则随机选取，否则全部） + c_selected = random.sample(long_pairs, num_c) if num_c is not None and num_c < len(long_pairs) else long_pairs + + for pair in c_selected: + task_counter += 1 + tasks.append( + { + "task_id": f"pref_{domain_prefix}_C_{task_counter:04d}", + "type": "C", + "domain": domain, + "pair": pair, + } + ) + + return tasks + + +async def run_pipeline( + tasks: list[dict], + llm_config: dict, + output_path: str, + input_path: str, + save_interval: int = 50, + migrated_path: str | None = None, +) -> list[dict]: + """流水线并发处理所有任务""" + req_timeout = llm_config.get("timeout", 40) + client = AsyncOpenAI( + base_url=llm_config["base_url"], + api_key=llm_config["api_key"], + timeout=req_timeout, + ) + + semaphore = asyncio.Semaphore(llm_config["max_concurrency"]) + handler_map = {"A": process_type_a, "B": process_type_b, "C": process_type_c} + + results = [] + completed = 0 + last_save = 0 + skipped = 0 + start_time = time.time() + + print(f" 共 {len(tasks)} 个任务") + print(" 已加载 LLM 运行配置（敏感字段不显示）") + print(" 已启用增量保存") + + # 分批处理，每批最多 100 个任务 + batch_size = 100 + task_queue = list(tasks) + + pending = set() + task_index = 0 + + def add_tasks(n: int): + """添加 n 个新任务到 pending 集合""" + nonlocal task_index + added = 0 + while task_index < len(task_queue) and added < n: + task = task_queue[task_index] + handler = handler_map[task["type"]] + coro = handler(client, task, semaphore, llm_config) + async_task = asyncio.create_task(coro) + pending.add(async_task) + task_index += 1 + added += 1 + + # 初始添加一批任务 + add_tasks(batch_size) + + while pending: + done, pending = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED) + + for task in done: + result = task.result() + completed += 1 + + if result is None: + skipped += 1 + else: + results.append(result) + + elapsed = time.time() - start_time + speed = completed / elapsed if elapsed > 0 else 0 + # 统计：有效样本（无 _error 且无 _rejected） + valid = len([r for r in results if "_error" not in r and "_rejected" not in r]) + rejected = len([r for r in results if "_rejected" in r]) + print( + f"\r 进度: {completed}/{len(task_queue)} (有效:{valid} 拒绝:{rejected} 跳过:{skipped} {speed:.1f}条/秒)", + end="", + flush=True, + ) + + if len(results) - last_save >= save_interval and results: + _incremental_save(results, output_path, input_path, elapsed, migrated_path) + last_save = len(results) + print(" [已保存]", end="", flush=True) + + # 补充新任务，保持 pending 队列有足够的任务 + if task_index < len(task_queue): + add_tasks(len(done)) + + print() + return results + + +def _incremental_save( + results: list[dict], output_path: str, input_path: str, elapsed: float, migrated_path: str | None = None +): + # 分类：成功、拒绝、错误（拒绝的不保存到文件） + success = [r for r in results if "_error" not in r and "_rejected" not in r] + rejected_count = sum(1 for r in results if "_rejected" in r) + errors = [r for r in results if "_error" in r] + + type_counts = {} + domain_counts = {} + for r in success: + t = r.get("task_type", "?") + type_counts[t] = type_counts.get(t, 0) + 1 + d = r.get("domain", "?") + domain_counts[d] = domain_counts.get(d, 0) + 1 + + output_data = { + "metadata": { + "source_file": input_path, + "migrated_file": migrated_path, + "total_samples": len(success), + "rejected_count": rejected_count, + "error_count": len(errors), + "type_distribution": type_counts, + "domain_distribution": domain_counts, + "elapsed_seconds": round(elapsed, 2), + "generation_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + "status": "in_progress", + }, + "samples": success, + "errors": errors, + } + + os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True) + with open(output_path, "w", encoding="utf-8") as f: + json.dump(output_data, f, ensure_ascii=False, indent=2) + + +def save_results( + results: list[dict], output_path: str, input_path: str, elapsed: float, migrated_path: str | None = None +): + # 分类：成功、拒绝、错误（拒绝的不保存到文件） + success = [r for r in results if "_error" not in r and "_rejected" not in r] + rejected_count = sum(1 for r in results if "_rejected" in r) + errors = [r for r in results if "_error" in r] + + type_counts = {} + domain_counts = {} + for r in success: + t = r.get("task_type", "?") + type_counts[t] = type_counts.get(t, 0) + 1 + d = r.get("domain", "?") + domain_counts[d] = domain_counts.get(d, 0) + 1 + + output_data = { + "metadata": { + "source_file": input_path, + "migrated_file": migrated_path, + "total_samples": len(success), + "rejected_count": rejected_count, + "error_count": len(errors), + "type_distribution": type_counts, + "domain_distribution": domain_counts, + "elapsed_seconds": round(elapsed, 2), + "generation_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + "status": "completed", + }, + "samples": success, + "errors": errors, + } + + os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True) + with open(output_path, "w", encoding="utf-8") as f: + json.dump(output_data, f, ensure_ascii=False, indent=2) + + +def main(): + parser = argparse.ArgumentParser(description="生成 DPO 偏好训练数据 (Groovy vs Gremlin)") + parser.add_argument("--config", default="config.json", help="配置文件路径") + parser.add_argument("--input", default=None, help="text2gremlin 数据文件 (movie 领域)") + parser.add_argument("--migrated", default=None, help="迁移数据文件 (20 个领域)") + parser.add_argument("--output", default=None, help="输出文件路径") + # 默认参数说明： + # - 目标有效总量：7000-8000 条 + # - A 类是主力，约 50% 拒绝率 + # - B 类有效约 2000 条 + # - C 类有效约 2000 条（15% 跳过率） + # 预估有效总量： + # A 类: 7000 任务 × 50% = 3500 有效 (46.7%) + # B 类: 2000 任务 = 2000 有效 (26.7%) + # C 类: 2353 任务 × 85% = 2000 有效 (26.7%) + # 总计约 7,500 有效样本 + parser.add_argument("--num-a", type=int, default=350, help="A 类任务数量（多任务组合，movie 领域）") + parser.add_argument("--num-b", type=int, default=100, help="B 类任务数量（单任务，movie 领域）") + parser.add_argument("--num-c", type=int, default=72, help="C 类任务数量（长链拆解，movie 领域）") + parser.add_argument("--migrated-num-a", type=int, default=333, help="每个迁移领域的 A 类任务数量") + parser.add_argument("--migrated-num-b", type=int, default=95, help="每个迁移领域的 B 类任务数量") + parser.add_argument("--migrated-num-c", type=int, default=115, help="每个迁移领域的 C 类任务数量") + parser.add_argument("--skip-movie", action="store_true", help="跳过 movie 领域，只处理迁移领域") + parser.add_argument("--skip-migrated", action="store_true", help="跳过迁移领域，只处理 movie 领域") + args = parser.parse_args() + + config = load_config(args.config) + llm_config = get_llm_config(config) + output_dir = config.get("output_dir", "output") + + # 确定输出路径 + output_path = args.output + if not output_path: + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + pref_dir = os.path.join(output_dir, "preference_data") + output_path = os.path.join(pref_dir, f"dpo_data_{timestamp}.json") + + all_tasks = [] + input_path = None + migrated_path = None + + # 处理 movie 领域 + if not args.skip_movie: + input_path = args.input or find_latest_pairs(output_dir) + if input_path and os.path.exists(input_path): + pairs = load_pairs(input_path) + if pairs: + classified = classify_pairs(pairs) + num_a = args.num_a + num_b = args.num_b + num_c = args.num_c + + movie_tasks = prepare_tasks( + classified, num_a, num_b, num_c=num_c, domain="movie", check_duplicate_gremlin=False + ) + + actual_c = len(classified["long"]) if num_c is None else min(num_c, len(classified["long"])) + print("\n📊 Movie 领域数据分类:") + print(f" 短查询 (≤5步): {len(classified['short'])} 条 → A/B 类") + print(f" 中等查询 (6-8步): {len(classified['medium'])} 条 → B 类") + print(f" 长查询 (>8步): {len(classified['long'])} 条 → C 类") + print(f" 任务数: A={num_a}, B={num_b}, C={actual_c}") + print(f" 总计: {len(movie_tasks)} 个任务") + + all_tasks.extend(movie_tasks) + else: + print(f"⚠️ Movie 数据文件为空: {input_path}") + else: + print("⚠️ 未找到 movie 领域数据文件") + + # 处理 20 个迁移领域 + if not args.skip_migrated: + migrated_path = args.migrated or find_latest_migrated(output_dir) + if migrated_path and os.path.exists(migrated_path): + domain_data = load_migrated_data(migrated_path) + + if domain_data: + migrated_num_a = args.migrated_num_a + migrated_num_b = args.migrated_num_b + migrated_num_c = args.migrated_num_c + + c_desc = "全部" if migrated_num_c is None else str(migrated_num_c) + print(f"\n📊 迁移领域数据 ({len(domain_data)} 个领域):") + print(f" 每领域任务数: A={migrated_num_a}, B={migrated_num_b}, C={c_desc}") + + for domain, pairs in sorted(domain_data.items()): + # 为每个领域的数据分类 + classified = classify_pairs(pairs) + + # 迁移领域需要检查重复 gremlin（因为同一查询有多种语气版本） + domain_tasks = prepare_tasks( + classified, + migrated_num_a, + migrated_num_b, + num_c=migrated_num_c, + domain=domain, + check_duplicate_gremlin=True, + ) + + print( + f" {domain}: {len(pairs)} 条数据 → " + f"short={len(classified['short'])}, " + f"medium={len(classified['medium'])}, " + f"long={len(classified['long'])} → " + f"{len(domain_tasks)} 任务" + ) + + all_tasks.extend(domain_tasks) + else: + print(f"⚠️ 迁移数据文件为空: {migrated_path}") + else: + print("⚠️ 未找到迁移数据文件") + + if not all_tasks: + print("❌ 没有任务可执行") + sys.exit(1) + + # 打乱所有任务 + random.shuffle(all_tasks) + + # 统计任务分布 + task_type_counts = {} + domain_counts = {} + for t in all_tasks: + task_type_counts[t["type"]] = task_type_counts.get(t["type"], 0) + 1 + domain_counts[t.get("domain", "?")] = domain_counts.get(t.get("domain", "?"), 0) + 1 + + print("\n" + "=" * 60) + print("🚀 DPO 偏好数据生成器") + print("=" * 60) + print("\n📋 配置:") + print(f" Movie 数据: {input_path or '无'}") + print(f" 迁移数据: {migrated_path or '无'}") + print(f" 输出文件: {output_path}") + print(" LLM 配置: 已加载（敏感字段不显示）") + print(" 重试与保存策略: 使用配置文件设置") + print("\n📊 任务分布:") + print(f" 类型: {task_type_counts}") + print(f" 领域: {len(domain_counts)} 个") + print(f" 总计: {len(all_tasks)} 个任务") + print("-" * 60) + + start_time = time.time() + results = asyncio.run( + run_pipeline( + all_tasks, + llm_config, + output_path, + input_path or "", + save_interval=llm_config["save_interval"], + migrated_path=migrated_path, + ) + ) + elapsed = time.time() - start_time + + save_results(results, output_path, input_path or "", elapsed, migrated_path) + + # 分类统计 + success = [r for r in results if "_error" not in r and "_rejected" not in r] + rejected = [r for r in results if "_rejected" in r] + errors = [r for r in results if "_error" in r] + + type_counts = {} + domain_counts = {} + for r in success: + t = r.get("task_type", "?") + type_counts[t] = type_counts.get(t, 0) + 1 + d = r.get("domain", "?") + domain_counts[d] = domain_counts.get(d, 0) + 1 + + print("\n" + "=" * 60) + print("✅ DPO 数据生成完成") + print("=" * 60) + print(f" 总耗时: {elapsed:.2f} 秒") + print(f" 有效样本: {len(success)}") + print(f" 拒绝合成: {len(rejected)} (命令冲突/无法合成)") + print(f" 调用失败: {len(errors)}") + print(f" 类型分布: {type_counts}") + print(f" 领域数: {len(domain_counts)}") + print(f" 吞吐量: {len(results) / elapsed:.2f} 条/秒" if elapsed > 0 else "") + print(f"\n💾 结果已保存到: {output_path}") + + +if __name__ == "__main__": + main() diff --git a/text2gremlin/AST_Text2Gremlin/llm_augment/merge_dataset.py b/text2gremlin/AST_Text2Gremlin/llm_augment/merge_dataset.py new file mode 100644 index 000000000..2130134a7 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/llm_augment/merge_dataset.py @@ -0,0 +1,237 @@ +#!/usr/bin/env python3 +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +""" +数据集合并脚本 + +从 llm_translated 和 migrated 文件中提取所有 text2gremlin 数据对， +合并为统一数据集，并统计 CRUD 分布。 + +用法: + python -m llm_augment.merge_dataset + python -m llm_augment.merge_dataset --translated output/llm_translated_xxx.json --migrated output/migrated_xxx.json +""" + +import argparse +import json +import os +import re +import sys +from collections import Counter +from datetime import datetime +from glob import glob + + +def find_latest_translated(output_dir: str = "output") -> str | None: + pattern = os.path.join(output_dir, "llm_translated_*.json") + files = sorted(glob(pattern), key=os.path.getmtime) + return files[-1] if files else None + + +def find_latest_migrated(output_dir: str = "output") -> str | None: + pattern = os.path.join(output_dir, "migrated_*.json") + files = sorted(glob(pattern), key=os.path.getmtime) + return files[-1] if files else None + + +def load_from_translated(path: str) -> list[dict]: + """从 llm_translated 文件提取数据对。 + 每条 gremlin 对应多种语气翻译，展开为多条。 + """ + with open(path, encoding="utf-8") as f: + data = json.load(f) + + corpus = data.get("corpus", []) + pairs = [] + for item in corpus: + query = item.get("query", "") + if not query: + continue + translations = item.get("translations", []) + for t in translations: + text = t.get("text", "") + style = t.get("style", "unknown") + if text: + pairs.append( + { + "text": text, + "gremlin": query, + "source": "llm_translated", + "language_style": style, + "domain": "movie", + } + ) + return pairs + + +def load_from_migrated(path: str) -> list[dict]: + """从 migrated 文件提取所有场景迁移后的数据对。""" + with open(path, encoding="utf-8") as f: + data = json.load(f) + + migrations = data.get("migrations", []) + pairs = [] + for m in migrations: + domain = m.get("target_domain", "unknown") + for sample in m.get("generated_samples", []): + query = sample.get("query", "") + nl = sample.get("natural_language", "") + if query and nl: + pairs.append( + { + "text": nl, + "gremlin": query, + "source": "migrated", + "language_style": sample.get("language_style", "unknown"), + "domain": domain, + "operation": sample.get("operation", "unknown"), + } + ) + return pairs + + +def guess_operation(gremlin: str) -> str: + """基于简单规则猜测 CRUD 类型。""" + has_add = bool(re.search(r"\.(addV|addE)\s*\(", gremlin)) + has_drop = bool(re.search(r"\.drop\s*\(", gremlin)) + has_property = bool(re.search(r"\.property\s*\(", gremlin)) + + if has_add: + return "create" + if has_drop: + return "delete" + if has_property and not has_add: + return "update" + return "read" + + +def compute_crud_stats(pairs: list[dict]) -> dict: + """统计 CRUD 分布。""" + counter = Counter() + for p in pairs: + op = p.get("operation") + if not op or op == "unknown": + op = guess_operation(p["gremlin"]) + p["operation"] = op + counter[op] += 1 + return dict(counter.most_common()) + + +def main(): + parser = argparse.ArgumentParser(description="合并 text2gremlin 数据集") + parser.add_argument("--translated", default=None, help="llm_translated 文件路径（不指定则自动找最新的）") + parser.add_argument("--migrated", default=None, help="migrated 文件路径（不指定则自动找最新的）") + parser.add_argument("--output-dir", default="output", help="输出目录") + args = parser.parse_args() + + translated_path = args.translated or find_latest_translated(args.output_dir) + migrated_path = args.migrated or find_latest_migrated(args.output_dir) + + if not translated_path or not os.path.exists(translated_path): + print("❌ 未找到 llm_translated 文件，请用 --translated 指定", file=sys.stderr) + sys.exit(1) + if not migrated_path or not os.path.exists(migrated_path): + print("❌ 未找到 migrated 文件，请用 --migrated 指定", file=sys.stderr) + sys.exit(1) + + print("=" * 60) + print("📦 合并 text2gremlin 数据集") + print("=" * 60) + + print(f"\n📂 加载 llm_translated: {translated_path}") + translated_pairs = load_from_translated(translated_path) + print(f" 提取: {len(translated_pairs)} 条") + + print(f"\n📂 加载 migrated: {migrated_path}") + migrated_pairs = load_from_migrated(migrated_path) + print(f" 提取: {len(migrated_pairs)} 条") + + all_pairs = translated_pairs + migrated_pairs + print(f"\n📊 合并总数: {len(all_pairs)} 条") + + # CRUD 统计 + print("\n" + "-" * 60) + print("📊 CRUD 分布统计") + print("-" * 60) + + translated_crud = compute_crud_stats(translated_pairs) + migrated_crud = compute_crud_stats(migrated_pairs) + total_crud = compute_crud_stats(all_pairs) + + print(f"\n llm_translated ({len(translated_pairs)} 条, 规则推断):") + for op, cnt in translated_crud.items(): + pct = cnt / len(translated_pairs) * 100 + print(f" {op:8s}: {cnt:6d} ({pct:.1f}%)") + + print(f"\n migrated ({len(migrated_pairs)} 条, 标签统计):") + for op, cnt in migrated_crud.items(): + pct = cnt / len(migrated_pairs) * 100 + print(f" {op:8s}: {cnt:6d} ({pct:.1f}%)") + + print(f"\n 总计 ({len(all_pairs)} 条):") + for op, cnt in total_crud.items(): + pct = cnt / len(all_pairs) * 100 + print(f" {op:8s}: {cnt:6d} ({pct:.1f}%)") + + domain_counter = Counter(p["domain"] for p in all_pairs) + print(f"\n📊 领域分布 ({len(domain_counter)} 个领域):") + for domain, cnt in domain_counter.most_common(): + print(f" {domain:20s}: {cnt:6d}") + + # 保存 + ts = datetime.now().strftime("%Y%m%d_%H%M%S") + output_path = os.path.join(args.output_dir, f"text2gremlin_dataset_{ts}.json") + os.makedirs(args.output_dir, exist_ok=True) + + output_data = { + "metadata": { + "total": len(all_pairs), + "sources": { + "llm_translated": {"file": translated_path, "count": len(translated_pairs)}, + "migrated": {"file": migrated_path, "count": len(migrated_pairs)}, + }, + "crud_distribution": total_crud, + "domain_distribution": dict(domain_counter.most_common()), + "generation_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + }, + "corpus": [ + { + "query": p["gremlin"], + "text": p["text"], + "domain": p["domain"], + "operation": p["operation"], + "language_style": p["language_style"], + "source": p["source"], + } + for p in all_pairs + ], + } + + with open(output_path, "w", encoding="utf-8") as f: + json.dump(output_data, f, ensure_ascii=False, indent=2) + + print(f"\n💾 数据集已保存: {output_path}") + print(" (corpus 格式兼容 analyze_syntax.py)") + + print("\n" + "=" * 60) + print("✅ 完成") + print("=" * 60) + + +if __name__ == "__main__": + main() diff --git a/text2gremlin/AST_Text2Gremlin/llm_augment/migrate_scenario.py b/text2gremlin/AST_Text2Gremlin/llm_augment/migrate_scenario.py new file mode 100644 index 000000000..7eeabf57c --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/llm_augment/migrate_scenario.py @@ -0,0 +1,761 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +""" +Gremlin 场景迁移脚本 + +包含两个阶段： + 1. 数据准备：从 LLM 翻译结果中提取 text2gremlin 数据对 + 2. 场景迁移：将数据迁移到其他业务场景（每条 × 4 个场景，轮转分配） + +用法: + # 自动从最新翻译结果提取数据并迁移 + python -m llm_augment.migrate_scenario + + # 指定翻译结果文件 + python -m llm_augment.migrate_scenario --translated output/llm_translated_xxx.json + + # 跳过数据准备，直接用已有的 pairs 文件迁移 + python -m llm_augment.migrate_scenario --input output/text2gremlin_pairs_xxx.json +""" + +import argparse +import asyncio +import json +import os +import random +import sys +import time +from datetime import datetime +from glob import glob + +from base.generator import check_gremlin_syntax +from openai import AsyncOpenAI +from pydantic import BaseModel, Field, ValidationError + +from llm_augment.generalize_llm import get_llm_config, load_config + + +class GeneratedSample(BaseModel): + """单条迁移生成的样本""" + + operation: str = Field(description="操作类型: read/create/update/delete") + language_style: str = Field(description="语言风格") + query: str = Field(description="Gremlin 查询") + natural_language: str = Field(description="自然语言描述") + + +class MigrationResult(BaseModel): + """单次迁移的 LLM 输出""" + + source_pattern: str = Field(description="原始查询模式") + source_intent: str = Field(description="原始查询意图") + target_domain: str = Field(description="目标领域") + mapping_explanation: str = Field(description="映射说明") + generated_samples: list[GeneratedSample] = Field(min_length=1) + + +def load_schemas(path: str = "db_data/reference/schemas_data.json") -> list[dict]: + """加载场景 schema 列表，按 index 排序""" + with open(path, encoding="utf-8") as f: + data = json.load(f) + scenarios = data.get("scenarios", {}) + result = [] + for key, val in scenarios.items(): + result.append( + { + "key": key, + "index": val["index"], + "name_zh": val["name_zh"], + "domain": val["domain"], + "schema": val["schema"], + } + ) + result.sort(key=lambda x: x["index"]) + return result + + +PICK_STYLES = ["zh_formal", "zh_casual", "en_formal", "en_casual"] +MIGRATION_MODES = ("same_operation", "mixed_operations") +DEFAULT_MIGRATION_MODE = "same_operation" +DEFAULT_SAME_OPERATION_SAMPLE_COUNT = 3 + + +def infer_operation_type(query: str) -> str: + """Infer the broad Gremlin operation type used by migration prompts.""" + normalized = query.replace(" ", "").lower() + if "addv(" in normalized or "adde(" in normalized: + return "create" + if ".drop(" in normalized: + return "delete" + if ".property(" in normalized: + return "update" + return "read" + + +def operation_query_example(operation: str) -> str: + """Return a query example that matches the requested operation type.""" + examples = { + "read": "g.V().hasLabel('target_label')", + "create": "g.addV('target_label').property('name', 'value')", + "update": "g.V().hasLabel('target_label').has('id', 'value').property('name', 'new_value')", + "delete": "g.V().hasLabel('target_label').has('id', 'value').drop()", + } + return examples.get(operation, examples["read"]) + + +def get_migration_config(config: dict) -> dict: + """Read scenario migration options from config with stable defaults.""" + migration_cfg = config.get("migration", {}) + migration_mode = migration_cfg.get("migration_mode", DEFAULT_MIGRATION_MODE) + if migration_mode not in MIGRATION_MODES: + raise ValueError(f"migration.migration_mode must be one of {MIGRATION_MODES}, got: {migration_mode}") + + sample_count = migration_cfg.get("same_operation_sample_count", DEFAULT_SAME_OPERATION_SAMPLE_COUNT) + if not isinstance(sample_count, int) or sample_count <= 0: + raise ValueError("migration.same_operation_sample_count must be a positive integer") + + return { + "migration_mode": migration_mode, + "same_operation_sample_count": sample_count, + } + + +def filter_generated_samples(samples: list[GeneratedSample], source_operation: str, migration_mode: str) -> list[dict]: + """Filter validated samples according to migration mode semantics.""" + valid_samples = [] + for sample in samples: + if migration_mode == "same_operation": + if sample.operation != source_operation: + continue + if infer_operation_type(sample.query) != source_operation: + continue + valid_samples.append(sample.model_dump()) + return valid_samples + + +def find_latest_translated(output_dir: str = "output") -> str | None: + """找到 output 目录下最新的 LLM 翻译结果文件""" + pattern = os.path.join(output_dir, "llm_translated_*.json") + files = sorted(glob(pattern), key=os.path.getmtime) + return files[-1] if files else None + + +def prepare_pairs(translated_path: str, output_dir: str = "output") -> tuple[str, list[dict]]: + """ + 从 LLM 翻译结果中提取 text2gremlin 数据对。 + + 对每条数据，从 zh_formal/zh_casual/en_formal/en_casual 中随机选一个作为 text， + 与 gremlin query 组成一对，打乱后保存。 + """ + with open(translated_path, encoding="utf-8") as f: + data = json.load(f) + + corpus = data.get("corpus", []) + pairs = [] + style_counts = {} + + for item in corpus: + if "_error" in item: + continue + + style_map = {t["style"]: t["text"] for t in item["translations"]} + available = [s for s in PICK_STYLES if s in style_map] + if not available: + continue + + chosen_style = random.choice(available) + pairs.append( + { + "text": style_map[chosen_style], + "gremlin": item["query"], + "style": chosen_style, + } + ) + style_counts[chosen_style] = style_counts.get(chosen_style, 0) + 1 + + random.shuffle(pairs) + + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + pairs_path = os.path.join(output_dir, f"text2gremlin_pairs_{timestamp}.json") + + output_data = { + "metadata": { + "source_file": translated_path, + "total_pairs": len(pairs), + "style_distribution": style_counts, + "generation_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + }, + "pairs": pairs, + } + + os.makedirs(os.path.dirname(os.path.abspath(pairs_path)), exist_ok=True) + with open(pairs_path, "w", encoding="utf-8") as f: + json.dump(output_data, f, ensure_ascii=False, indent=2) + + print(f"✅ 数据准备完成: {len(pairs)} 条 text2gremlin 数据") + print(f" 风格分布: {style_counts}") + print(f" 已保存到: {pairs_path}") + + return pairs_path, pairs + + +def find_latest_pairs(output_dir: str = "output") -> str | None: + pattern = os.path.join(output_dir, "text2gremlin_pairs_*.json") + files = sorted(glob(pattern), key=os.path.getmtime) + return files[-1] if files else None + + +def load_pairs(input_path: str) -> list[dict]: + with open(input_path, encoding="utf-8") as f: + data = json.load(f) + return data.get("pairs", []) + + +def build_migration_prompt( + source_nl: str, + source_query: str, + target_schema: dict, + migration_mode: str = DEFAULT_MIGRATION_MODE, + sample_count: int = DEFAULT_SAME_OPERATION_SAMPLE_COUNT, +) -> str: + """构建场景迁移 prompt""" + if migration_mode not in MIGRATION_MODES: + raise ValueError(f"migration_mode must be one of {MIGRATION_MODES}, got: {migration_mode}") + if sample_count <= 0: + raise ValueError("sample_count must be a positive integer") + + schema_json = json.dumps(target_schema, ensure_ascii=False, indent=2) + source_operation = infer_operation_type(source_query) + + if migration_mode == "same_operation": + query_example = operation_query_example(source_operation) + operation_goal = f"4. 只生成与原始 Gremlin 同类型的 {source_operation} 操作。" + generation_requirements = f"""1. 生成 {sample_count} 条样本。 +2. 每条样本都必须是 {source_operation} 类型，operation 字段固定填写 "{source_operation}"。 +3. 保持或近似保持原始查询的核心模式，并迁移到目标 schema 中合理的节点、边和属性。 +4. 如果无法高质量生成 {sample_count} 条，可以少生成，但不要编造。""" + output_example = f"""{{ + "source_pattern": "...", + "source_intent": "...", + "target_domain": "...", + "mapping_explanation": "...", + "generated_samples": [ + {{ + "operation": "{source_operation}", + "language_style": "...", + "query": "{query_example}", + "natural_language": "..." + }} + ] +}}""" + else: + operation_goal = "4. 可生成 read / create / update / delete 四类操作。" + generation_requirements = """1. 生成 5 条样本，优先包含： + - 2 条 read类型语句 + - 1 条 create类型语句 + - 1 条 update类型 + - 1 条 delete类型语句 +2. 若 create / update / delete 三种类型不适合，请全部生成 read类型语句，但要保证模式多样化。 +3. 在常见场景之外，部分生成的样本可以考虑不常见或难度高的场景和 Gremlin 用法，以增加泛化性。 +4. 如果某条样本无法高质量生成，请不要编造。""" + output_example = """{ + "source_pattern": "...", + "source_intent": "...", + "target_domain": "...", + "mapping_explanation": "...", + "generated_samples": [ + { + "operation": "read", + "language_style": "...", + "query": "g.V()...", + "natural_language": "..." + }, + { + "operation": "read", + "language_style": "...", + "query": "g.V()...", + "natural_language": "..." + }, + { + "operation": "create", + "language_style": "...", + "query": "g.addV()...", + "natural_language": "..." + }, + { + "operation": "update", + "language_style": "...", + "query": "...", + "natural_language": "..." + }, + { + "operation": "delete", + "language_style": "...", + "query": "...", + "natural_language": "..." + } + ] +}""" + + prompt = f"""你是一个专门做 text2gremlin 数据增强的助手。 + +## 【你的任务】 +给定一条来自电影领域的 text2gremlin 样本，以及一个目标业务场景的 graph schema， +你需要先识别原始 Gremlin 查询的"查询模式"，再在目标 schema 中生成若干条合法、自然、可执行的 Gremlin 样本及对应自然语言。 + +## 【目标】 +1. 保持或近似保持原始查询的核心模式，可以适当增加多样性 +2. 迁移到目标场景时，尽量使用目标 schema 中定义的节点、边、属性，可以为了增加多样性适当增加一些节点、边、属性，但必须要符合当前的schema场景。 +3. 生成的自然语言要像真实用户会说的话，而不是 Gremlin 逐步解释。 +{operation_goal} +5. 若原模式不适合生成某类操作，可以少生成或跳过，不要强行凑数。 + +## 【输入】 +原始领域：movie +### 原始自然语言： +{source_nl} + +### 原始 Gremlin： +{source_query} + +### 目标 schema： +{schema_json} + +## 【请先完成以下分析】 +1. 识别原始查询的 pattern，格式例如： + - start_vertex + - one_hop_traversal + - two_hop_traversal + - reverse_traversal + - filter_by_property + - dedup + - count + - group + - order_limit + - path_query +2. 用一句话说明原始查询的业务意图。 +3. 判断该模式在目标 schema 中最适合映射到哪些节点和边。 + +## 【生成要求】 +{generation_requirements} +5. 每条样本必须： + - query 合法 + - 符合目标 schema 定义场景 + - 自然语言与 query 严格对应 +6. 每条gremlin的自然语言字段随机选择下面的一个语气类型进行生成： + - zh_formal：中文正式的语气 + - zh_casual：中文口语的语气 + - en_formal：英文正式的语气 + - en_casual：英文口语的语气 + +## 【Gremlin 风格要求】 +1. 尽量简洁。 +2. 语句运行效率高效。 + +## 【输出格式】 +严格输出 JSON： +```json +{output_example} +```""" + return prompt + + +async def migrate_one( + client: AsyncOpenAI, + pair: dict, + target_schema: dict, + semaphore: asyncio.Semaphore, + llm_config: dict, + migration_config: dict, +) -> dict: + """ + 将单条 text2gremlin 数据迁移到一个目标场景。 + + 生成后对每条 gremlin 做语法检查： + - 至少有一条通过语法检查才算成功，只保留通过的 + - 全部语法错误则重试 + """ + max_retries = llm_config["max_retries"] + + async with semaphore: + for attempt in range(max_retries): + try: + prompt = build_migration_prompt( + pair["text"], + pair["gremlin"], + target_schema["schema"], + migration_mode=migration_config["migration_mode"], + sample_count=migration_config["same_operation_sample_count"], + ) + + response = await client.chat.completions.create( + model=llm_config["model"], + messages=[{"role": "user", "content": prompt}], + temperature=llm_config["temperature"], + ) + content = response.choices[0].message.content + + if not content or not content.strip(): + raise ValueError("LLM 返回内容为空") + + # 提取 JSON + json_str = content + if "```json" in json_str: + json_str = json_str.split("```json")[1].split("```")[0] + elif "```" in json_str: + json_str = json_str.split("```")[1].split("```")[0] + + data = json.loads(json_str.strip()) + + # Pydantic 验证 + validated = MigrationResult(**data) + source_operation = infer_operation_type(pair["gremlin"]) + + # 语法检查：过滤掉语法错误的 sample + syntax_valid_samples = [] + for s in validated.generated_samples: + ok, _msg = check_gremlin_syntax(s.query) + if ok: + syntax_valid_samples.append(s) + valid_samples = filter_generated_samples( + syntax_valid_samples, source_operation, migration_config["migration_mode"] + ) + + if not valid_samples: + raise ValueError(f"所有 {len(validated.generated_samples)} 条 gremlin 语法检查均失败") + + return { + "source_text": pair["text"], + "source_gremlin": pair["gremlin"], + "target_domain": target_schema["domain"], + "target_name_zh": target_schema["name_zh"], + "source_pattern": validated.source_pattern, + "source_intent": validated.source_intent, + "mapping_explanation": validated.mapping_explanation, + "generated_samples": valid_samples, + } + + except (json.JSONDecodeError, ValueError, KeyError, ValidationError) as e: + if attempt < max_retries - 1: + continue + else: + return _fallback_migration(pair, target_schema, f"迁移失败(重试{max_retries}次): {e}") + except Exception as e: + return _fallback_migration(pair, target_schema, f"迁移异常: {e}") + + +def _fallback_migration(pair: dict, target_schema: dict, error: str) -> dict: + return { + "source_text": pair["text"], + "source_gremlin": pair["gremlin"], + "target_domain": target_schema["domain"], + "target_name_zh": target_schema["name_zh"], + "source_pattern": "", + "source_intent": "", + "mapping_explanation": "", + "generated_samples": [], + "_error": error, + } + + +async def migrate_all( + pairs: list[dict], + schemas: list[dict], + llm_config: dict, + output_path: str, + input_path: str, + migration_config: dict, + save_interval: int = 50, +) -> list[dict]: + """ + 流水线并发迁移所有数据。 + + 每条数据迁移到 4 个场景，场景按顺序轮转。 + """ + req_timeout = llm_config.get("timeout", 40) + client = AsyncOpenAI( + base_url=llm_config["base_url"], + api_key=llm_config["api_key"], + timeout=req_timeout, + ) + + semaphore = asyncio.Semaphore(llm_config["max_concurrency"]) + num_schemas = len(schemas) + total_tasks = len(pairs) * 4 + + print(f" 共 {len(pairs)} 条数据 × 4 场景 = {total_tasks} 个迁移任务") + print(" 已加载 LLM 运行配置（敏感字段不显示）") + print(" 已启用增量保存") + print(f" 场景数: {num_schemas}，轮转分配") + + # 创建所有任务：每条数据迁移到 4 个连续场景 + tasks = {} + for idx, pair in enumerate(pairs): + base_schema_idx = (idx * 4) % num_schemas + for j in range(4): + schema_idx = (base_schema_idx + j) % num_schemas + target_schema = schemas[schema_idx] + task = asyncio.create_task( + migrate_one(client, pair, target_schema, semaphore, llm_config, migration_config) + ) + tasks[task] = (idx, j) + + pending = set(tasks.keys()) + results = [] + completed = 0 + last_save = 0 + start_time = time.time() + + while pending: + done, pending = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED) + + for task in done: + result = task.result() + results.append(result) + completed += 1 + + elapsed = time.time() - start_time + speed = completed / elapsed if elapsed > 0 else 0 + print(f"\r 进度: {completed}/{total_tasks} ({speed:.1f} 条/秒)", end="", flush=True) + + if completed - last_save >= save_interval: + _incremental_save(results, output_path, input_path, elapsed, migration_config) + last_save = completed + print(f" [已保存 {completed} 条]", end="", flush=True) + + print() + return results + + +def _load_existing_keys(output_path: str) -> set: + """从已保存的文件中加载已有的 (gremlin, language_style) 集合""" + if not os.path.exists(output_path): + return set() + try: + with open(output_path, encoding="utf-8") as f: + data = json.load(f) + keys = set() + for m in data.get("migrations", []): + for s in m.get("generated_samples", []): + keys.add((s["query"], s["language_style"])) + return keys + except (json.JSONDecodeError, KeyError): + return set() + + +def _dedup_results(results: list[dict], existing_keys: set) -> tuple[list[dict], set]: + """对 results 中的 generated_samples 去重。""" + deduped = [] + for r in results: + if "_error" in r: + deduped.append(r) + continue + + unique_samples = [] + for s in r["generated_samples"]: + key = (s["query"], s["language_style"]) + if key not in existing_keys: + existing_keys.add(key) + unique_samples.append(s) + + r_copy = dict(r) + r_copy["generated_samples"] = unique_samples + deduped.append(r_copy) + + return deduped, existing_keys + + +def _incremental_save( + results: list[dict], output_path: str, input_path: str, elapsed: float, migration_config: dict | None = None +): + existing_keys = _load_existing_keys(output_path) + deduped, _ = _dedup_results(results, existing_keys) + + success_count = sum(1 for r in deduped if "_error" not in r) + total_samples = sum(len(r["generated_samples"]) for r in deduped) + + output_data = { + "metadata": { + "source_file": input_path, + "total_migrations": len(deduped), + "total_generated_samples": total_samples, + "success_count": success_count, + "fail_count": len(deduped) - success_count, + "elapsed_seconds": round(elapsed, 2), + "generation_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + "status": "in_progress", + "migration_config": migration_config or {}, + }, + "migrations": deduped, + } + + os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True) + with open(output_path, "w", encoding="utf-8") as f: + json.dump(output_data, f, ensure_ascii=False, indent=2) + + +def save_results(results: list[dict], output_path: str, input_path: str, elapsed: float, migration_config: dict): + existing_keys = set() + deduped, _ = _dedup_results(results, existing_keys) + + success_count = sum(1 for r in deduped if "_error" not in r) + total_samples = sum(len(r["generated_samples"]) for r in deduped) + + domain_counts = {} + for r in deduped: + d = r["target_domain"] + domain_counts[d] = domain_counts.get(d, 0) + 1 + + output_data = { + "metadata": { + "source_file": input_path, + "total_migrations": len(deduped), + "total_generated_samples": total_samples, + "success_count": success_count, + "fail_count": len(deduped) - success_count, + "domain_distribution": domain_counts, + "elapsed_seconds": round(elapsed, 2), + "generation_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + "status": "completed", + "migration_config": migration_config, + }, + "migrations": deduped, + } + + os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True) + with open(output_path, "w", encoding="utf-8") as f: + json.dump(output_data, f, ensure_ascii=False, indent=2) + + +def main(): + parser = argparse.ArgumentParser(description="将 text2gremlin 数据迁移到多个业务场景") + parser.add_argument("--config", default="config.json", help="配置文件路径") + parser.add_argument("--translated", default=None, help="LLM 翻译结果文件（自动提取 pairs）") + parser.add_argument("--input", default=None, help="已有的 text2gremlin pairs 文件（跳过数据准备）") + parser.add_argument("--schemas", default="db_data/reference/schemas_data.json", help="场景 schema 文件") + parser.add_argument("--output", default=None, help="输出文件路径") + parser.add_argument( + "--migration-mode", + choices=MIGRATION_MODES, + default=None, + help="场景迁移模式: same_operation 只生成同类型语句, mixed_operations 生成混合 CRUD", + ) + parser.add_argument( + "--same-operation-sample-count", type=int, default=None, help="同类型迁移模式下每次生成的样本数" + ) + args = parser.parse_args() + + config = load_config(args.config) + llm_config = get_llm_config(config) + migration_config = get_migration_config(config) + if args.migration_mode: + migration_config["migration_mode"] = args.migration_mode + if args.same_operation_sample_count is not None: + if args.same_operation_sample_count <= 0: + raise ValueError("--same-operation-sample-count must be a positive integer") + migration_config["same_operation_sample_count"] = args.same_operation_sample_count + output_dir = config.get("output_dir", "output") + + # 加载 schema + schemas = load_schemas(args.schemas) + print(f"📋 加载了 {len(schemas)} 个场景 schema") + + # ---- 阶段 1: 数据准备 ---- + if args.input: + input_path = args.input + if not os.path.exists(input_path): + print(f"❌ 文件不存在: {input_path}") + sys.exit(1) + pairs = load_pairs(input_path) + print(f"📂 直接使用已有数据: {input_path} ({len(pairs)} 条)") + else: + translated_path = args.translated or find_latest_translated(output_dir) + if translated_path and os.path.exists(translated_path): + print(f"\n{'=' * 60}") + print("📦 阶段 1: 数据准备") + print(f"{'=' * 60}") + print(f" 翻译结果: {translated_path}") + input_path, pairs = prepare_pairs(translated_path, output_dir) + else: + input_path = find_latest_pairs(output_dir) + if not input_path or not os.path.exists(input_path): + print("❌ 未找到翻译结果或 text2gremlin 数据文件") + sys.exit(1) + pairs = load_pairs(input_path) + print(f"📂 使用已有数据: {input_path} ({len(pairs)} 条)") + + if not pairs: + print("❌ 数据为空") + sys.exit(1) + + # ---- 阶段 2: 场景迁移 ---- + output_path = args.output + if not output_path: + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + output_path = os.path.join(output_dir, f"migrated_{timestamp}.json") + + total_tasks = len(pairs) * 4 + + print(f"\n{'=' * 60}") + print("🚀 阶段 2: 场景迁移") + print("=" * 60) + print("\n📋 配置:") + print(f" 输入文件: {input_path}") + print(f" 输出文件: {output_path}") + print(" LLM 配置: 已加载（敏感字段不显示）") + print(" 重试与保存策略: 使用配置文件设置") + print(f" 迁移模式: {migration_config['migration_mode']}") + print(f" 同类型迁移样本数: {migration_config['same_operation_sample_count']}") + print(f"\n 数据条数: {len(pairs)}") + print(" 每条迁移: 4 个场景") + print(f" 总任务数: {total_tasks}") + print(f" 场景数: {len(schemas)}") + print("-" * 60) + + start_time = time.time() + results = asyncio.run( + migrate_all( + pairs, + schemas, + llm_config, + output_path, + input_path, + migration_config, + save_interval=llm_config["save_interval"], + ) + ) + elapsed = time.time() - start_time + + save_results(results, output_path, input_path, elapsed, migration_config) + + success_count = sum(1 for r in results if "_error" not in r) + fail_count = len(results) - success_count + total_samples = sum(len(r["generated_samples"]) for r in results) + + print("\n" + "=" * 60) + print("✅ 场景迁移完成") + print("=" * 60) + print(f" 总耗时: {elapsed:.2f} 秒") + print(f" 成功: {success_count}，失败: {fail_count}") + print(f" 生成样本总数: {total_samples}") + print(f" 吞吐量: {len(results) / elapsed:.2f} 条/秒") + print(f"\n💾 结果已保存到: {output_path}") + + +if __name__ == "__main__": + main() diff --git a/text2gremlin/AST_Text2Gremlin/requirements.txt b/text2gremlin/AST_Text2Gremlin/requirements.txt new file mode 100644 index 000000000..df500204f --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/requirements.txt @@ -0,0 +1,5 @@ +antlr4-python3-runtime==4.13.1 +openai>=1.30.0 +pandas>=2.0.0 +pydantic>=2.0.0 +pytest>=8.0.0 diff --git a/text2gremlin/AST_Text2Gremlin/run_llm_pipeline.py b/text2gremlin/AST_Text2Gremlin/run_llm_pipeline.py new file mode 100644 index 000000000..123728860 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/run_llm_pipeline.py @@ -0,0 +1,169 @@ +#!/usr/bin/env python3 +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +""" +LLM 增强数据生成流水线统一入口 + +按顺序执行 4 个阶段（可通过 --stage 指定从某阶段开始）： + 1. translate — 多风格自然语言翻译 (generalize_llm) + 2. migrate — 多场景迁移 (migrate_scenario) + 3. merge — 数据集合并与统计 (merge_dataset) + 4. dpo — DPO 偏好数据生成 (generate_dpo_data) + +用法: + # 从头执行全部阶段 + python run_llm_pipeline.py + + # 从第 2 阶段开始（跳过翻译） + python run_llm_pipeline.py --stage migrate + + # 只执行合并 + python run_llm_pipeline.py --stage merge --stop merge + + # 各阶段也可独立运行 + python -m llm_augment.generalize_llm --help + python -m llm_augment.migrate_scenario --help + python -m llm_augment.merge_dataset --help + python -m llm_augment.generate_dpo_data --help +""" + +import argparse +import subprocess +import sys + +STAGES = ["translate", "migrate", "merge", "dpo"] + +STAGE_MODULES = { + "translate": "llm_augment.generalize_llm", + "migrate": "llm_augment.migrate_scenario", + "merge": "llm_augment.merge_dataset", + "dpo": "llm_augment.generate_dpo_data", +} + +STAGE_NAMES = { + "translate": "多风格翻译", + "migrate": "场景迁移", + "merge": "数据集合并", + "dpo": "DPO 偏好数据", +} + +STAGE_OPTION_OWNERS = { + "--migration-mode": "migrate", + "--same-operation-sample-count": "migrate", +} + + +def run_stage(stage: str, extra_args: list[str]) -> int: + """运行单个阶段，返回 exit code""" + module = STAGE_MODULES[stage] + name = STAGE_NAMES[stage] + print(f"\n{'=' * 60}") + print(f"▶ 阶段: {name} ({module})") + print(f"{'=' * 60}\n") + + cmd = [sys.executable, "-m", module, *extra_args] + # Keep child stdout/stderr attached so stage logs stream in order. + result = subprocess.run(cmd, check=False) + return result.returncode + + +def get_stage_extra_args(stage: str, stages_to_run: list[str], extra_args: list[str]) -> list[str]: + """Route known stage-specific args and keep unknown args on the first stage.""" + stage_args = {selected_stage: [] for selected_stage in stages_to_run} + first_stage_args = stage_args[stages_to_run[0]] + index = 0 + while index < len(extra_args): + arg = extra_args[index] + option = arg.split("=", 1)[0] + owner = STAGE_OPTION_OWNERS.get(option) + target = stage_args.get(owner) if owner else first_stage_args + if target is None: + target = first_stage_args + target.append(arg) + + has_inline_value = "=" in arg + has_separate_value = index + 1 < len(extra_args) and not extra_args[index + 1].startswith("--") + if owner and not has_inline_value and has_separate_value: + index += 1 + target.append(extra_args[index]) + index += 1 + + return stage_args[stage] + + +def main(): + parser = argparse.ArgumentParser( + description="LLM 增强数据生成流水线", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +阶段说明: + translate 多风格自然语言翻译（generalize_llm） + migrate 多场景迁移（migrate_scenario） + merge 数据集合并与统计（merge_dataset） + dpo DPO 偏好数据生成（generate_dpo_data） + +示例: + python run_llm_pipeline.py # 全部阶段 + python run_llm_pipeline.py --stage migrate # 从迁移开始 + python run_llm_pipeline.py --stage merge --stop merge # 只合并 + """, + ) + parser.add_argument( + "--stage", + choices=STAGES, + default="translate", + help="从哪个阶段开始（默认: translate）", + ) + parser.add_argument( + "--stop", + choices=STAGES, + default=None, + help="在哪个阶段停止（含该阶段，默认: 执行到最后）", + ) + + args, extra = parser.parse_known_args() + + start_idx = STAGES.index(args.stage) + stop_idx = STAGES.index(args.stop) if args.stop else len(STAGES) - 1 + + if start_idx > stop_idx: + print(f"❌ --stage ({args.stage}) 不能在 --stop ({args.stop}) 之后") + sys.exit(1) + + stages_to_run = STAGES[start_idx : stop_idx + 1] + + print("=" * 60) + print("🚀 LLM 增强数据生成流水线") + print("=" * 60) + print(f" 执行阶段: {' → '.join(stages_to_run)}") + if extra: + print(f" 额外参数: {extra}") + + for stage in stages_to_run: + rc = run_stage(stage, get_stage_extra_args(stage, stages_to_run, extra)) + if rc != 0: + print(f"\n❌ 阶段 {stage} 失败 (exit code: {rc})，流水线中止") + sys.exit(rc) + + print(f"\n{'=' * 60}") + print("✅ 流水线全部完成") + print("=" * 60) + + +if __name__ == "__main__": + main() diff --git a/text2gremlin/AST_Text2Gremlin/tests/test_analyze_syntax.py b/text2gremlin/AST_Text2Gremlin/tests/test_analyze_syntax.py new file mode 100644 index 000000000..6b68c9c43 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/tests/test_analyze_syntax.py @@ -0,0 +1,52 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +# ruff: noqa: E402 + +import sys +from collections import Counter +from pathlib import Path + +PROJECT_DIR = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(PROJECT_DIR)) + +from analyze_syntax import analyze_query, print_results + + +def test_analyze_query_counts_start_step_once_and_keeps_group_step(): + stats = analyze_query("g.V().group().by('name')") + + assert stats["steps"]["V"] == 1 + assert stats["steps"]["group"] == 1 + assert stats["steps"]["by"] == 1 + assert stats["step_count"] == 3 + + +def test_print_results_honors_top_n(capsys): + stats = { + "steps": Counter({"has": 3, "out": 2}), + "predicates": Counter(), + "text_predicates": Counter(), + "step_counts": [1, 2], + } + + print_results(stats, total_queries=2, top_n=1) + + out = capsys.readouterr().out + assert "Top 1" in out + assert "has" in out + assert "out" not in out diff --git a/text2gremlin/AST_Text2Gremlin/tests/test_generalize_llm.py b/text2gremlin/AST_Text2Gremlin/tests/test_generalize_llm.py new file mode 100644 index 000000000..df393680f --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/tests/test_generalize_llm.py @@ -0,0 +1,86 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +# ruff: noqa: E402 + +import asyncio +import sys +from pathlib import Path +from types import SimpleNamespace + +PROJECT_DIR = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(PROJECT_DIR)) + +from llm_augment import generalize_llm + + +def test_translation_prompt_has_complete_length_requirement(): + prompt = generalize_llm.build_translation_prompt( + {"query": "g.V()", "description": "查询所有顶点"}, + [*generalize_llm.FIXED_STYLES, "mixed_lang", "abbreviated"], + ) + + assert "各风格表达方式要有明显差异，长度要自然" in prompt + assert "各风格表达方式要有明显差异，长度\n" not in prompt + assert "}\n```\n\n### 实际输入" in prompt + + +def test_translate_one_retries_transient_llm_exception(monkeypatch): + monkeypatch.setattr(generalize_llm, "pick_random_styles", lambda n=2: ["mixed_lang", "abbreviated"]) + monkeypatch.setattr(generalize_llm.random, "random", lambda: 0) + + async def no_sleep(_seconds): + return None + + monkeypatch.setattr(generalize_llm.asyncio, "sleep", no_sleep) + + class FakeCompletions: + def __init__(self): + self.calls = 0 + + async def create(self, **_kwargs): + self.calls += 1 + if self.calls == 1: + raise RuntimeError("temporary network error") + return SimpleNamespace( + choices=[ + SimpleNamespace( + message=SimpleNamespace( + content=( + '{"zh_formal":"q1","zh_casual":"q2","en_formal":"q3",' + '"en_casual":"q4","mixed_lang":"q5","abbreviated":"q6"}' + ) + ) + ) + ] + ) + + completions = FakeCompletions() + client = SimpleNamespace(chat=SimpleNamespace(completions=completions)) + + result = asyncio.run( + generalize_llm.translate_one( + client, + {"query": "g.V()", "description": "查询所有顶点"}, + asyncio.Semaphore(1), + {"model": "test", "temperature": 0, "max_retries": 2, "timeout": 1}, + ) + ) + + assert completions.calls == 2 + assert "_error" not in result + assert len(result["translations"]) == 6 diff --git a/text2gremlin/AST_Text2Gremlin/tests/test_generate_corpus.py b/text2gremlin/AST_Text2Gremlin/tests/test_generate_corpus.py new file mode 100644 index 000000000..9def9cf96 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/tests/test_generate_corpus.py @@ -0,0 +1,38 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +# ruff: noqa: E402 + +import sys +from pathlib import Path + +import pytest + +PROJECT_DIR = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(PROJECT_DIR)) + +from generate_corpus import load_config + + +def test_load_config_exits_nonzero_for_invalid_json(tmp_path): + config_path = tmp_path / "bad_config.json" + config_path.write_text("{invalid json", encoding="utf-8") + + with pytest.raises(SystemExit) as exc: + load_config(str(config_path)) + + assert exc.value.code == 1 diff --git a/text2gremlin/AST_Text2Gremlin/tests/test_gremlin_base.py b/text2gremlin/AST_Text2Gremlin/tests/test_gremlin_base.py new file mode 100644 index 000000000..dc413cf27 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/tests/test_gremlin_base.py @@ -0,0 +1,72 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +# ruff: noqa: E402 + +import sys +from pathlib import Path + +PROJECT_DIR = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(PROJECT_DIR)) + +from base.GremlinBase import GremlinBase + + +class SchemaOnlyConfig: + def __init__(self, schema_dict_path: str): + self.schema_dict_path = schema_dict_path + + def get_schema_dict_path(self): + return [self.schema_dict_path] + + def get_syn_dict_path(self): + return None + + +def test_schema_and_syn_dictionaries_fall_back_independently(tmp_path): + schema_dict = tmp_path / "schema_dict.txt" + schema_dict.write_text("custom 自定义\n", encoding="utf-8") + + gremlin_base = GremlinBase(SchemaOnlyConfig(str(schema_dict))) + + assert gremlin_base.schema_dict["custom"] == ["自定义"] + assert gremlin_base.schema_dict["1"] == ["一"] + + +def test_default_dictionary_entries_are_loadable(): + class DefaultConfig: + def get_schema_dict_path(self): + return None + + def get_syn_dict_path(self): + return None + + gremlin_base = GremlinBase(DefaultConfig()) + + assert gremlin_base.schema_dict["insertrate"] == ["利率"] + assert gremlin_base.schema_dict["person_organization"] == ["人物和组织间的关系"] + + for dictionary_path in PROJECT_DIR.glob("base/template/*_dict.txt"): + for line in dictionary_path.read_text(encoding="utf-8").splitlines(): + assert line == line.rstrip() + + schema_dict_path = PROJECT_DIR / "base/template/schema_dict.txt" + schema_keys = [] + for line in schema_dict_path.read_text(encoding="utf-8").splitlines(): + assert len(line.split()) >= 2 + schema_keys.append(line.split()[0]) + assert len(schema_keys) == len(set(schema_keys)) diff --git a/text2gremlin/AST_Text2Gremlin/tests/test_merge_dataset.py b/text2gremlin/AST_Text2Gremlin/tests/test_merge_dataset.py new file mode 100644 index 000000000..0fde65f4e --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/tests/test_merge_dataset.py @@ -0,0 +1,61 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +# ruff: noqa: E402 + +import subprocess +import sys +from pathlib import Path + +PROJECT_DIR = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(PROJECT_DIR)) + +from llm_augment.merge_dataset import compute_crud_stats, guess_operation + + +def test_guess_operation_classifies_common_gremlin_operations(): + assert guess_operation("g.addV('person').property('name', 'marko')") == "create" + assert guess_operation("g.V().addE('knows').to(__.V().has('id', 1))") == "create" + assert guess_operation("g.V().has('id', 1).property('name', 'josh')") == "update" + assert guess_operation("g.V().has('id', 1).drop()") == "delete" + assert guess_operation("g.V().hasLabel('person')") == "read" + + +def test_compute_crud_stats_fills_unknown_operations_in_place(): + pairs = [ + {"operation": "unknown", "gremlin": "g.V().hasLabel('person')"}, + {"operation": "", "gremlin": "g.V().has('id', 1).property('name', 'josh')"}, + {"operation": "delete", "gremlin": "g.V().has('id', 1).drop()"}, + ] + + stats = compute_crud_stats(pairs) + + assert stats == {"read": 1, "update": 1, "delete": 1} + assert [pair["operation"] for pair in pairs] == ["read", "update", "delete"] + + +def test_main_exits_nonzero_when_required_inputs_are_missing(tmp_path): + result = subprocess.run( + [sys.executable, "-m", "llm_augment.merge_dataset", "--output-dir", str(tmp_path)], + cwd=PROJECT_DIR, + check=False, + capture_output=True, + text=True, + ) + + assert result.returncode == 1 + assert "未找到 llm_translated" in result.stderr diff --git a/text2gremlin/AST_Text2Gremlin/tests/test_migrate_scenario.py b/text2gremlin/AST_Text2Gremlin/tests/test_migrate_scenario.py new file mode 100644 index 000000000..1b24b8b02 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/tests/test_migrate_scenario.py @@ -0,0 +1,157 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +# ruff: noqa: E402,I001 + +import sys +import types +from pathlib import Path + +PROJECT_DIR = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(PROJECT_DIR)) + +base_module = types.ModuleType("base") +generator_module = types.ModuleType("base.generator") +generator_module.check_gremlin_syntax = lambda query: (True, "Syntax OK") +sys.modules.setdefault("base", base_module) +sys.modules.setdefault("base.generator", generator_module) + +from llm_augment.migrate_scenario import ( + GeneratedSample, + build_migration_prompt, + filter_generated_samples, + get_migration_config, + infer_operation_type, +) + + +SIMPLE_SCHEMA = { + "vertices": [{"label": "user", "properties": ["name"]}], + "edges": [], +} + + +def test_same_operation_prompt_is_default_and_uses_configured_sample_count(): + config = get_migration_config({}) + + assert config["migration_mode"] == "same_operation" + assert config["same_operation_sample_count"] == 3 + + prompt = build_migration_prompt( + "Find all users", + "g.V().hasLabel('user')", + SIMPLE_SCHEMA, + migration_mode=config["migration_mode"], + sample_count=config["same_operation_sample_count"], + ) + + assert "生成 3 条样本" in prompt + assert "只生成与原始 Gremlin 同类型的 read 操作" in prompt + assert "2 条 read类型语句" not in prompt + assert "1 条 create类型语句" not in prompt + + +def test_same_operation_prompt_uses_operation_matching_examples(): + create_prompt = build_migration_prompt( + "Create a movie", + "g.addV('movie').property('title', 'Dune')", + SIMPLE_SCHEMA, + migration_mode="same_operation", + ) + update_prompt = build_migration_prompt( + "Update a movie title", + "g.V().hasLabel('movie').property('title', 'Dune 2')", + SIMPLE_SCHEMA, + migration_mode="same_operation", + ) + delete_prompt = build_migration_prompt( + "Delete a movie", + "g.V().hasLabel('movie').drop()", + SIMPLE_SCHEMA, + migration_mode="same_operation", + ) + + assert '"operation": "create"' in create_prompt + assert '"query": "g.addV' in create_prompt + assert '"operation": "update"' in update_prompt + assert ".property(" in update_prompt + assert '"operation": "delete"' in delete_prompt + assert ".drop()" in delete_prompt + + +def test_migration_config_can_override_mode_and_sample_count(): + config = get_migration_config( + { + "migration": { + "migration_mode": "mixed_operations", + "same_operation_sample_count": 5, + } + } + ) + + assert config["migration_mode"] == "mixed_operations" + assert config["same_operation_sample_count"] == 5 + + +def test_mixed_operations_prompt_keeps_crud_distribution_guidance(): + prompt = build_migration_prompt( + "Find all users", + "g.V().hasLabel('user')", + SIMPLE_SCHEMA, + migration_mode="mixed_operations", + sample_count=3, + ) + + assert "2 条 read类型语句" in prompt + assert "1 条 create类型语句" in prompt + assert "1 条 update类型" in prompt + assert "1 条 delete类型语句" in prompt + + +def test_infer_operation_type_from_gremlin(): + assert infer_operation_type("g.addV('person').property('name', 'marko')") == "create" + assert infer_operation_type("g.V().has('id', 1).property('name', 'josh')") == "update" + assert infer_operation_type("g.V().has('id', 1).drop()") == "delete" + assert infer_operation_type("g.V().hasLabel('person')") == "read" + + +def test_same_operation_filter_rejects_mismatched_operation_and_query_type(): + samples = [ + GeneratedSample( + operation="read", + language_style="zh_formal", + query="g.V().hasLabel('person')", + natural_language="查询所有人", + ), + GeneratedSample( + operation="create", + language_style="zh_formal", + query="g.addV('person')", + natural_language="创建一个人", + ), + GeneratedSample( + operation="read", + language_style="zh_formal", + query="g.V().hasLabel('person').drop()", + natural_language="删除人", + ), + ] + + filtered = filter_generated_samples(samples, "read", "same_operation") + + assert len(filtered) == 1 + assert filtered[0]["query"] == "g.V().hasLabel('person')" diff --git a/text2gremlin/AST_Text2Gremlin/tests/test_run_llm_pipeline.py b/text2gremlin/AST_Text2Gremlin/tests/test_run_llm_pipeline.py new file mode 100644 index 000000000..a5d16afc5 --- /dev/null +++ b/text2gremlin/AST_Text2Gremlin/tests/test_run_llm_pipeline.py @@ -0,0 +1,45 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +# ruff: noqa: E402 + +import sys +from pathlib import Path + +PROJECT_DIR = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(PROJECT_DIR)) + +from run_llm_pipeline import get_stage_extra_args + + +def test_unknown_extra_args_only_apply_to_first_selected_stage(): + stages = ["migrate", "merge", "dpo"] + extra = ["--input", "pairs.json"] + + assert get_stage_extra_args("migrate", stages, extra) == extra + assert get_stage_extra_args("merge", stages, extra) == [] + assert get_stage_extra_args("dpo", stages, extra) == [] + + +def test_migration_args_are_routed_to_migrate_stage(): + stages = ["translate", "migrate", "merge", "dpo"] + extra = ["--migration-mode", "same_operation", "--same-operation-sample-count=3"] + + assert get_stage_extra_args("translate", stages, extra) == [] + assert get_stage_extra_args("migrate", stages, extra) == extra + assert get_stage_extra_args("merge", stages, extra) == [] + assert get_stage_extra_args("dpo", stages, extra) == []