diff --git a/.github/workflows/dev.yml b/.github/workflows/dev.yml new file mode 100644 index 0000000..d9a22b5 --- /dev/null +++ b/.github/workflows/dev.yml @@ -0,0 +1,119 @@ +name: Dev CI + +on: + push: + branches: [ "main", "dev" ] + pull_request: + branches: [ "main", "dev" ] + workflow_dispatch: + +jobs: + environment-test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - name: install dependencies + run: | + pip install networkx[default] + pip install beautifulsoup4 + pip install pandas + pip install antlr4-tools + pip install antlr4-python3-runtime==4.13.1 + antlr4 -v 4.13.1 + - name: test hello.py + run: python tests/scripts/hello.py + - name: test dep.py + run: python tests/scripts/dep.py + + parser-test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - name: install dependencies + run: | + pip install networkx[default] + pip install beautifulsoup4 + pip install pandas + pip install antlr4-tools + pip install antlr4-python3-runtime==4.13.1 + antlr4 -v 4.13.1 + - name: test parsing.py + run: PYTHONPATH="./" python ./tests/scripts/parsing.py + + detector-test-divz: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - name: install dependencies + run: | + pip install networkx[default] + pip install beautifulsoup4 + pip install pandas + pip install antlr4-tools + pip install antlr4-python3-runtime==4.13.1 + antlr4 -v 4.13.1 + - name: test divz + run: PYTHONPATH="./" python ./tests/scripts/test-divz.py + + detector-test-infoleak: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - name: install dependencies + run: | + pip install networkx[default] + pip install beautifulsoup4 + pip install pandas + pip install antlr4-tools + pip install antlr4-python3-runtime==4.13.1 + antlr4 -v 4.13.1 + - name: test infoleak + run: PYTHONPATH="./" python ./tests/scripts/test-infoleak.py + + detector-test-rtcnst: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - name: install dependencies + run: | + pip install networkx[default] + pip install beautifulsoup4 + pip install pandas + pip install antlr4-tools + pip install antlr4-python3-runtime==4.13.1 + antlr4 -v 4.13.1 + - name: test rtcnst + run: PYTHONPATH="./" python ./tests/scripts/test-rtcnst.py + + detector-test-unused: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - name: install dependencies + run: | + pip install networkx[default] + pip install beautifulsoup4 + pip install pandas + pip install antlr4-tools + pip install antlr4-python3-runtime==4.13.1 + antlr4 -v 4.13.1 + - name: test unused + run: PYTHONPATH="./" python ./tests/scripts/test-unused.py \ No newline at end of file diff --git a/.gitignore b/.gitignore index f20ae7b..b802d2b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,24 +1,3 @@ -.DS_Store - -# ====================== # -# ======== Rust ======== # -# ====================== # - -# Generated by Cargo -# will have compiled files and executables -debug/ -target/ - -# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries -# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html -Cargo.lock - -# These are backup files generated by rustfmt -**/*.rs.bk - -# MSVC Windows builds of rustc generate these, which store debugging information -*.pdb - # ======================== # # ======== Python ======== # # ======================== # @@ -182,4 +161,11 @@ cython_debug/ # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. -#.idea/ \ No newline at end of file +#.idea/ + +# ===================================== # +# ======== customized override ======== # +# ===================================== # +.DS_Store +# exclude aleo build for benchmarks +!tests/public/**/build/ \ No newline at end of file diff --git a/README.md b/README.md index 22e9060..f6025a1 100644 --- a/README.md +++ b/README.md @@ -6,40 +6,36 @@ This repo hosts an open-source Python branch of the static analysis tool Vanguar The following libraries are required for running (different components of) the tool: -- Rust (1.73+) for running `aleo2json` - Python (3.10+) for running Vanguard and its Aleo detectors - - [NetworkX](https://networkx.org/documentation/stable/install.html) (2.8.4+) for speeding up graph reachability in detectors + - [NetworkX](https://networkx.org/documentation/stable/install.html) (3.2.1+) for speeding up graph reachability in detectors + - [Antlr](https://www.antlr.org/) (4.13.1) and its Python binding for loading and parsing Aleo programs + - `pip install antlr4-python3-runtime==4.13.1` + - `pip install antlr4-tools` + - [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/) (4.12.2+) for crawling benchmarks from public explorers in test suite + - [pandas](https://pandas.pydata.org/) (2.1.4+) for data analysis in test suite - Leo (**7ac50d8**) for compiling and running all benchmarks enclosed + - The tools is tested under this version, but newer version of Lao may also work. -## The Aleo to JSON Compiler - -Running of Vanguard for Aleo relies on a compiler that converts Aleo programs into JSON, which allows the program to be further analyzed by various tools and extensions. It's adapted from Aleo's [snarkVM](https://github.com/AleoHQ/snarkVM/). To allow Vanguard to directly process Aleo programs, we recommend installing the compiler while testing out the tool via: - -```bash -git clone https://github.com/Veridise/aleo2json.git -cd aleo2json/ -cargo install --path . --bin aleo2json -``` - -To remove it in the future, simply do: +## Vanguard for Aleo -```bash -cargo uninstall -p snarkvm --bin aleo2json -``` +The library of Vanguard for Aleo provides common vulnerability detectors and basic utilities for writing detectors based on static analysis. To use the tool, you can call it directly from the repo or install it as a library. -### Usage +### Calling from Source -The `aleo2json` tool takes as input a path to `*.aleo` file, and directly outputs the compiled JSON, which includes enhanced information of the program and basic analysis results (e.g., variable types, visibilities, etc.): +To call the detectors directly from source code, first make sure all prerequisites are satisfied, and call from the repo root directly: -```bash -aleo2json +```python +from .vanguard.aleo.grammar import AleoEnvironment +from .vanguard.aleo.detectors import detector_divz + +project_name = "divz0" +function_name = "ex1" +build_path = f"./tests/public/{project_name}/build/" +env = AleoEnvironment(build_path) # load project +detector_divz(env, env.main.id, function_name, readable=True) # detect ``` -## Vanguard for Aleo - -The library of Vanguard for Aleo provides both integration with the `aleo2json` tool, as well as basic utilities for writing detectors based on static analysis. We've also included detectors for several common vulnerabilities. - -### Library Usage +### Calling as Library The analyzer can be installed via `pip` setup tools by running: @@ -53,43 +49,57 @@ and if you want to remove it: pip uninstall vanguard ``` -You can write detectors by simply utilizing some functions provided by the analyzer. Here's an example that analyze and get all public outputs/signals from a given Aleo program: +You can write detectors by simply utilizing some functions provided by the analyzer. Here's an example that loads a project called `divz0` and call the division-by-zero detector: ```python -from vanguard.aleo.common import aleo2json -from vanguard.aleo.detectors.divz import detector_divz - -aleo_path = ... -aleo_json = aleo2json(aleo_path) - -out, info = detector_divz(ap, "main") +from vanguard.aleo.grammar import AleoEnvironment +from vanguard.aleo.detectors import detector_divz + +project_name = "divz0" +function_name = "ex1" +build_path = f"./tests/public/{project_name}/build/" +env = AleoEnvironment(build_path) # load project +detector_divz(env, env.main.id, function_name, readable=True) # detect ``` ## Detectors Available ```python -from vanguard.aleo.detectors.infoleak import detector_infoleak -from vanguard.aleo.detectors.rtcnst import detector_rtcnst -from vanguard.aleo.detectors.unused import detector_unused -from vanguard.aleo.detectors.divz import detector_divz - +from vanguard.aleo.detectors import detector_infoleak +from vanguard.aleo.detectors import detector_rtcnst +from vanguard.aleo.detectors import detector_unused +from vanguard.aleo.detectors import detector_divz ... ``` -(more coming soon...) +(More coming soon...) ## Example Leo/Aleo Vulnerabilities -You can find examples showing Leo/Aleo vulnerabilities with comments and annotations in projects in `tests/`: +You can find examples showing Leo/Aleo vulnerabilities with comments and annotations in projects in `tests/public/`: + +| Project | Vulnerability Description | +| ----------- | ----------------------------- | +| divrd0/ | Division truncation/rounddown | +| divz0/ | Division by zero | +| downcast0/ | Type downcast | +| infoleak0/ | Information leakage | +| overflow0/ | Arithmetic overflow | +| rtcnst0/ | Returning constant | +| underflow0/ | Arithmetic underflow | +| unused0/ | Unused variable/signal | + +## Parser/Lexer Generation + +In case the parser is not compatible with your environment, you can generate it again using Antlr: + +```bash +cd ./vanguard/aleo/parser/ +antlr4 -v 4.13.1 -Dlanguage=Python3 ./Aleo.g4 +``` + +The parser/lexer file is located in `./vanguard/aleo/parser/Aleo.g4`. -| Project | Vulnerability Description | -| ----------- | --------------------------------------- | -| divrd0/ | Division round-down/truncation (part 0) | -| divz0/ | Division by zero (part 0) | -| downcast0/ | Division downcast (part 0) | -| infoleak0/ | Information leakage (part 0) | -| overflow0/ | Arithmetic overflow (part 0) | -| rtcnst0/ | Returning constant (part 0) | -| underflow0/ | Arithmetic underflow (part 0) | -| unused0/ | Unused variable/signal (part 0) | +## Test Suite and Static Analysis APIs +(Coming soon...) diff --git a/pyproject.toml b/pyproject.toml index e9eeaee..bb7ea75 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "vanguard" -version = "0.0.1" +version = "0.0.2" authors = [ { name="Yanju Chen", email="yanju@veridise.com" }, ] @@ -13,5 +13,13 @@ classifiers = [ "Operating System :: OS Independent", ] +dependencies = [ + "networkx[default]>=3.2.1", + "beautifulsoup4>=4.12.2", + "antlr4-python3-runtime==4.13.1", + "pandas>=2.1.4", + "antlr4-tools", +] + [project.urls] "Homepage" = "https://veridise.com/" \ No newline at end of file diff --git a/tests/public/divrd0/build/main.aleo b/tests/public/divrd0/build/main.aleo new file mode 100644 index 0000000..74fbb71 --- /dev/null +++ b/tests/public/divrd0/build/main.aleo @@ -0,0 +1,50 @@ +program divrd0.aleo; + + + +function vanguard_helper: + cast true true false true false true true into r0 as [boolean; 7u32]; + output r0 as [boolean; 7u32].private; + + +function ex0: + div 225u8 16u8 into r0; + output r0 as u8.private; + + +function ex1: + div 15u8 2u8 into r0; + mul r0 2u8 into r1; + output r1 as u8.private; + + +function ex2: + div 16u8 2u8 into r0; + mul r0 2u8 into r1; + output r1 as u8.private; + + +function ex3: + input r0 as u8.private; + div r0 2u8 into r1; + mul r1 2u8 into r2; + output r2 as u8.private; + + +function ex4: + mul 15u8 2u8 into r0; + div r0 2u8 into r1; + output r1 as u8.private; + + +function ex5: + input r0 as u8.private; + mul r0 2u8 into r1; + div r1 2u8 into r2; + output r2 as u8.private; + + +function ex6: + mul 15u8 2u8 into r0; + div r0 9u8 into r1; + output r1 as u8.private; diff --git a/tests/public/divrd0/build/program.json b/tests/public/divrd0/build/program.json new file mode 100644 index 0000000..1490b84 --- /dev/null +++ b/tests/public/divrd0/build/program.json @@ -0,0 +1,6 @@ +{ + "program": "divrd0.aleo", + "version": "0.0.0", + "description": "", + "license": "MIT" +} diff --git a/tests/public/divz0/build/imports/helpers.aleo b/tests/public/divz0/build/imports/helpers.aleo new file mode 100644 index 0000000..7eb6bb4 --- /dev/null +++ b/tests/public/divz0/build/imports/helpers.aleo @@ -0,0 +1,9 @@ +program helpers.aleo; + + + +function division: + input r0 as u8.private; + input r1 as u8.private; + div r0 r1 into r2; + output r2 as u8.private; diff --git a/tests/public/divz0/build/main.aleo b/tests/public/divz0/build/main.aleo new file mode 100644 index 0000000..9810cb2 --- /dev/null +++ b/tests/public/divz0/build/main.aleo @@ -0,0 +1,242 @@ +import helpers.aleo; +program divz0.aleo; + +struct struct_ex16: + a as u8; + b as u8; + +record rec_ex19: + owner as address.private; + data as u8.private; + + +mapping account_ex8: + key as u8.public; + value as u8.public; + + +mapping account_ex9: + key as u8.public; + value as u8.public; + + +mapping account_ex13: + key as u8.public; + value as u8.public; + +function vanguard_helper: + cast true true true true false true true false true false false true true true true true true true true true true true true true true true into r0 as [boolean; 26u32]; + output r0 as [boolean; 26u32].private; + + +function ex0: + div 225u8 0u8 into r0; + output r0 as u8.private; + + +function ex1: + div 225u8 0u8 into r0; + output r0 as u8.private; + + +function ex2: + input r0 as u8.private; + div 255u8 r0 into r1; + output r1 as u8.private; + + +function ex3: + div 255u8 0u8 into r0; + output r0 as u8.private; + + +function ex4: + input r0 as u8.private; + is.neq r0 0u8 into r1; + assert.eq r1 true; + div 255u8 r0 into r2; + output r2 as u8.private; + + +function ex5: + div.w 255u8 0u8 into r0; + output r0 as u8.private; + + +closure helper_ex6: + input r0 as u8; + input r1 as u8; + div r0 r1 into r2; + output r2 as u8; + + +function ex6: + input r0 as u8.private; + input r1 as u8.private; + call helper_ex6 r0 r1 into r2; + output r2 as u8.private; + + +function ex7: + div 225u8 0u8 into r0; + output r0 as u8.private; + + +function ex8: + input r0 as u8.private; + input r1 as u8.private; + add r0 r1 into r2; + async ex8 r0 r1 into r3; + output r2 as u8.private; + output r3 as divz0.aleo/ex8.future; + +finalize ex8: + input r0 as u8.public; + input r1 as u8.public; + add r0 r1 into r2; + div r0 r1 into r3; + set r3 into account_ex8[r2]; + + +function ex9: + input r0 as u8.private; + input r1 as u8.private; + add r0 r1 into r2; + async ex9 r0 r1 into r3; + output r2 as u8.private; + output r3 as divz0.aleo/ex9.future; + +finalize ex9: + input r0 as u8.public; + input r1 as u8.public; + add r0 r1 into r2; + mul r0 r1 into r3; + set r3 into account_ex9[r2]; + + +function ex10: + div 255u8 5u8 into r0; + output r0 as u8.private; + + +closure helper_ex11: + input r0 as u8; + input r1 as u8; + div r0 r1 into r2; + output r2 as u8; + + +function ex11: + call helper_ex11 225u8 0u8 into r0; + output r0 as u8.private; + + + + +function ex12: + div 225u8 0u8 into r0; + output r0 as u8.private; + + +function ex13: + input r0 as u8.private; + input r1 as u8.private; + add r0 r1 into r2; + async ex13 r0 r1 into r3; + output r2 as u8.private; + output r3 as divz0.aleo/ex13.future; + +finalize ex13: + input r0 as u8.public; + input r1 as u8.public; + div r0 r1 into r2; + assert.eq true true; + + +function ex14: + input r0 as u8.private; + div r0 0u8 into r1; + output r1 as u8.private; + + +function ex15: + input r0 as u8.private; + async ex15 r0 0u8 into r1; + output 0u8 as u8.private; + output r1 as divz0.aleo/ex15.future; + +finalize ex15: + input r0 as u8.public; + input r1 as u8.public; + div r0 r1 into r2; + + +function ex16: + cast 7u8 0u8 into r0 as struct_ex16; + div r0.a r0.b into r1; + output r1 as u8.private; + + +function ex17: + cast 3u8 2u8 1u8 0u8 into r0 as [u8; 4u32]; + cast 4u8 3u8 2u8 1u8 into r1 as [u8; 4u32]; + div r1[0u32] r0[0u32] into r2; + div r1[1u32] r0[1u32] into r3; + div r1[2u32] r0[2u32] into r4; + div r1[3u32] r0[3u32] into r5; + output true as boolean.private; + + +function ex18: + div 1u8 0u8 into r0; + output r0 as u8.private; + + +function ex19: + cast aleo1ezamst4pjgj9zfxqq0fwfj8a4cjuqndmasgata3hggzqygggnyfq6kmyd4 0u8 into r0 as rec_ex19.record; + div 128u8 r0.data into r1; + output r1 as u8.private; + + +function ex20: + cast true into r0 as u8; + cast false into r1 as u8; + div r0 r1 into r2; + output r2 as u8.private; + + +function ex21: + async ex21 into r0; + output r0 as divz0.aleo/ex21.future; + +finalize ex21: + rand.chacha into r0 as u32; + rand.chacha into r1 as u32; + div r0 r1 into r2; + + +function ex22: + input r0 as u8.private; + is.eq r0 0u8 into r1; + ternary r1 1u8 0u8 into r2; + div 128u8 r2 into r3; + output r3 as u8.private; + + +function ex23: + input r0 as u8.private; + is.eq r0 0u8 into r1; + ternary r1 1u8 0u8 into r2; + div 128u8 r2 into r3; + output r3 as u8.private; + + +function ex24: + div 123field 0field into r0; + cast r0 into r1 as u8; + output r1 as u8.private; + + +function ex25: + call helpers.aleo/division 224u8 0u8 into r0; + output r0 as u8.private; diff --git a/tests/public/divz0/build/program.json b/tests/public/divz0/build/program.json new file mode 100644 index 0000000..735a750 --- /dev/null +++ b/tests/public/divz0/build/program.json @@ -0,0 +1,13 @@ +{ + "program": "divz0.aleo", + "version": "0.0.0", + "description": "", + "license": "MIT", + "dependencies": [ + { + "name": "helpers.aleo", + "location": "local", + "path": "imports/helpers" + } + ] +} diff --git a/tests/public/divz0/imports/helpers/build/main.aleo b/tests/public/divz0/imports/helpers/build/main.aleo new file mode 100644 index 0000000..7eb6bb4 --- /dev/null +++ b/tests/public/divz0/imports/helpers/build/main.aleo @@ -0,0 +1,9 @@ +program helpers.aleo; + + + +function division: + input r0 as u8.private; + input r1 as u8.private; + div r0 r1 into r2; + output r2 as u8.private; diff --git a/tests/public/divz0/imports/helpers/build/program.json b/tests/public/divz0/imports/helpers/build/program.json new file mode 100644 index 0000000..cb644d8 --- /dev/null +++ b/tests/public/divz0/imports/helpers/build/program.json @@ -0,0 +1,6 @@ +{ + "program": "helpers.aleo", + "version": "0.0.0", + "description": "", + "license": "MIT" +} diff --git a/tests/public/divz0/src/main.leo b/tests/public/divz0/src/main.leo index e0848e0..7117c09 100644 --- a/tests/public/divz0/src/main.leo +++ b/tests/public/divz0/src/main.leo @@ -86,7 +86,7 @@ program divz0.aleo { } // compilable, runnable - // label: good + // label: bad const label_ex7: bool = false; transition ex7() -> u8 { let a: u8 = 225u8; diff --git a/tests/public/downcast0/build/main.aleo b/tests/public/downcast0/build/main.aleo new file mode 100644 index 0000000..828989d --- /dev/null +++ b/tests/public/downcast0/build/main.aleo @@ -0,0 +1,17 @@ +program downcast0.aleo; + + + +function vanguard_helper: + cast true true into r0 as [boolean; 2u32]; + output r0 as [boolean; 2u32].private; + + +function ex0: + cast 65530u16 into r0 as u8; + output r0 as u8.private; + + +function ex1: + cast 65530u16 into r0 as u8; + output r0 as u8.private; diff --git a/tests/public/downcast0/build/program.json b/tests/public/downcast0/build/program.json new file mode 100644 index 0000000..6a85c89 --- /dev/null +++ b/tests/public/downcast0/build/program.json @@ -0,0 +1,6 @@ +{ + "program": "downcast0.aleo", + "version": "0.0.0", + "description": "", + "license": "MIT" +} diff --git a/tests/public/infoleak0/build/main.aleo b/tests/public/infoleak0/build/main.aleo new file mode 100644 index 0000000..ef2d16b --- /dev/null +++ b/tests/public/infoleak0/build/main.aleo @@ -0,0 +1,258 @@ +program infoleak0.aleo; + +record rec: + owner as address.private; + +struct struct_ex19: + a as u8; + b as u8; + +struct struct_ex20: + a as u8; + b as u8; + +struct struct_ex21: + a as u8; + b as u8; + +struct struct_ex22: + a as u8; + b as u8; + +struct struct_ex22_box: + content as struct_ex22; + +record rec_ex23: + owner as address.private; + data as u8.private; + +record rec_ex24: + owner as address.public; + data as u8.public; + + +mapping account_leak5: + key as u8.public; + value as boolean.public; + + +mapping account_ex10: + key as u8.public; + value as u8.public; + + +mapping account_ex11: + key as u8.public; + value as u8.public; + +function vanguard_helper: + cast true false true true true true true false true true true false true true true true true true true true true true true true true into r0 as [boolean; 25u32]; + output r0 as [boolean; 25u32].private; + + +function generate_record: + cast aleo15g9c69urtdhvfml0vjl8px07txmxsy454urhgzk57szmcuttpqgq5cvcdy into r0 as rec.record; + output r0 as rec.record; + + +function ex0: + input r0 as u8.private; + output r0 as u8.public; + + +function ex1: + input r0 as u8.private; + hash.keccak256 1u8 into r1 as address; + output r1 as address.public; + + +function ex2: + input r0 as i8.private; + abs r0 into r1; + output r1 as i8.public; + + +function ex3: + input r0 as u8.private; + add r0 3u8 into r1; + output r1 as u8.public; + + +function ex4: + input r0 as u8.private; + input r1 as u8.private; + add r0 r1 into r2; + output r2 as u8.public; + + +function ex5: + input r0 as u8.private; + input r1 as u8.public; + async ex5 r0 into r2; + output r1 as u8.public; + output r2 as infoleak0.aleo/ex5.future; + +finalize ex5: + input r0 as u8.public; + set true into account_leak5[r0]; + + +closure helper_ex6: + input r0 as u8; + add r0 3u8 into r1; + output r1 as u8; + + +function ex6: + input r0 as u8.private; + call helper_ex6 r0 into r1; + output r1 as u8.public; + + +closure helper_ex7: + input r0 as u8; + add r0 3u8 into r1; + output r1 as u8; + + +function ex7: + input r0 as u8.private; + input r1 as u8.public; + call helper_ex7 r1 into r2; + output r2 as u8.public; + + +function ex8: + input r0 as [boolean; 2u32].private; + add 100u8 10u8 into r1; + ternary r0[0u32] r1 100u8 into r2; + add r2 10u8 into r3; + ternary r0[1u32] r3 r2 into r4; + output r4 as u8.public; + + +function ex9: + input r0 as u8.private; + input r1 as u8.public; + add r0 8u8 into r2; + mul r2 r1 into r3; + add r1 8u8 into r4; + mul r4 r1 into r5; + add r3 r5 into r6; + output r6 as u8.public; + + +function ex10: + input r0 as u8.private; + input r1 as u8.private; + add r0 r1 into r2; + async ex10 r0 r1 into r3; + output r2 as u8.private; + output r3 as infoleak0.aleo/ex10.future; + +finalize ex10: + input r0 as u8.public; + input r1 as u8.public; + add r0 r1 into r2; + div r0 r1 into r3; + set r3 into account_ex10[r2]; + + +function ex11: + input r0 as u8.private; + input r1 as u8.private; + add r0 r1 into r2; + output r2 as u8.public; + + +function ex12: + input r0 as address.private; + async ex12 r0 into r1; + output r1 as infoleak0.aleo/ex12.future; + +finalize ex12: + input r0 as address.public; + assert.eq true true; + + +function ex13: + input r0 as address.private; + async ex13 r0 into r1; + output r1 as infoleak0.aleo/ex13.future; + +finalize ex13: + input r0 as address.public; + assert.eq true true; + + +function ex14: + input r0 as u8.private; + cast r0 into r1 as u32; + output r1 as u32.public; + + +function ex15: + input r0 as u16.private; + cast r0 into r1 as u8; + output r1 as u8.public; + + +function ex16: + input r0 as u8.private; + is.eq r0 10u8 into r1; + ternary r1 10u8 r0 into r2; + output r2 as u8.public; + + +closure helper_ex17: + input r0 as u8; + add r0 0u8 into r1; + output r1 as u8; + + +function ex17: + input r0 as u8.private; + call helper_ex17 r0 into r1; + output r1 as u8.public; + + + + +function ex18: + input r0 as u8.private; + output r0 as u8.public; + + +function ex19: + input r0 as struct_ex19.private; + output r0.a as u8.public; + + +function ex20: + input r0 as struct_ex20.private; + add r0.a 8u8 into r1; + cast r1 r0.b into r2 as struct_ex20; + output r2.b as u8.public; + + +function ex21: + input r0 as struct_ex21.private; + add r0.a 8u8 into r1; + cast r1 r0.b into r2 as struct_ex21; + output r2 as struct_ex21.public; + + +function ex22: + input r0 as struct_ex22_box.private; + output r0.content as struct_ex22.public; + + +function ex23: + input r0 as rec_ex23.record; + output r0.data as u8.public; + + +function ex24: + input r0 as rec_ex24.record; + cast r0.owner r0.data into r1 as rec_ex24.record; + output r1 as rec_ex24.record; diff --git a/tests/public/infoleak0/build/program.json b/tests/public/infoleak0/build/program.json new file mode 100644 index 0000000..3c52930 --- /dev/null +++ b/tests/public/infoleak0/build/program.json @@ -0,0 +1,6 @@ +{ + "program": "infoleak0.aleo", + "version": "0.0.0", + "description": "", + "license": "MIT" +} diff --git a/tests/public/overflow0/build/main.aleo b/tests/public/overflow0/build/main.aleo new file mode 100644 index 0000000..277dc58 --- /dev/null +++ b/tests/public/overflow0/build/main.aleo @@ -0,0 +1,12 @@ +program overflow0.aleo; + + + +function vanguard_helper: + cast true into r0 as [boolean; 1u32]; + output r0 as [boolean; 1u32].private; + + +function ex0: + add 255u8 255u8 into r0; + output r0 as u8.private; diff --git a/tests/public/overflow0/build/program.json b/tests/public/overflow0/build/program.json new file mode 100644 index 0000000..b4da081 --- /dev/null +++ b/tests/public/overflow0/build/program.json @@ -0,0 +1,6 @@ +{ + "program": "overflow0.aleo", + "version": "0.0.0", + "description": "", + "license": "MIT" +} diff --git a/tests/public/rtcnst0/build/main.aleo b/tests/public/rtcnst0/build/main.aleo new file mode 100644 index 0000000..1c23f25 --- /dev/null +++ b/tests/public/rtcnst0/build/main.aleo @@ -0,0 +1,81 @@ +program rtcnst0.aleo; + + + +mapping map_ex3: + key as u8.public; + value as u8.public; + + +mapping map_ex4: + key as u8.public; + value as u8.public; + +function vanguard_helper: + cast true true false true false true true false into r0 as [boolean; 8u32]; + output r0 as [boolean; 8u32].private; + + +function ex0: + output 0u8 as u8.private; + + +function ex1: + input r0 as u8.private; + output r0 as u8.private; + + +function ex2: + input r0 as u8.private; + input r1 as u8.private; + add r0 r1 into r2; + output r2 as u8.private; + + +function ex3: + async ex3 7u8 into r0; + output 7u8 as u8.private; + output r0 as rtcnst0.aleo/ex3.future; + +finalize ex3: + input r0 as u8.public; + set r0 into map_ex3[r0]; + + +function ex4: + input r0 as u8.private; + input r1 as u8.private; + mul r0 r1 into r2; + add r0 r1 into r3; + async ex4 r3 into r4; + output r2 as u8.private; + output r4 as rtcnst0.aleo/ex4.future; + +finalize ex4: + input r0 as u8.public; + set r0 into map_ex4[r0]; + + +closure helper_ex5: + input r0 as u8; + add r0 0u8 into r1; + output r1 as u8; + + +function ex5: + call helper_ex5 7u8 into r0; + output r0 as u8.private; + + +function ex6: + input r0 as u8.private; + gt r0 10u8 into r1; + ternary r1 true true into r2; + output r2 as boolean.private; + + +function ex7: + input r0 as u8.private; + gt r0 10u8 into r1; + ternary r1 true false into r2; + output r2 as boolean.private; diff --git a/tests/public/rtcnst0/build/program.json b/tests/public/rtcnst0/build/program.json new file mode 100644 index 0000000..93f5918 --- /dev/null +++ b/tests/public/rtcnst0/build/program.json @@ -0,0 +1,6 @@ +{ + "program": "rtcnst0.aleo", + "version": "0.0.0", + "description": "", + "license": "MIT" +} diff --git a/tests/public/uncat0/build/main.aleo b/tests/public/uncat0/build/main.aleo new file mode 100644 index 0000000..d378fba --- /dev/null +++ b/tests/public/uncat0/build/main.aleo @@ -0,0 +1,32 @@ +program uncat0.aleo; + + + +function vanguard_helper: + cast true true true into r0 as [boolean; 3u32]; + output r0 as [boolean; 3u32].private; + + +function ex0: + input r0 as u8.private; + is.eq r0 0u8 into r1; + div 224u8 r0 into r2; + ternary r1 1u8 r2 into r3; + output r3 as u8.private; + + +function ex1: + input r0 as u8.private; + is.eq r0 0u8 into r1; + div 224u8 1u8 into r2; + div 224u8 r0 into r3; + ternary r1 r2 r3 into r4; + output r4 as u8.private; + + +function ex2: + input r0 as u8.private; + gte r0 200u8 into r1; + add 56u8 r0 into r2; + ternary r1 r0 r2 into r3; + output r3 as u8.private; diff --git a/tests/public/uncat0/build/program.json b/tests/public/uncat0/build/program.json new file mode 100644 index 0000000..261e21b --- /dev/null +++ b/tests/public/uncat0/build/program.json @@ -0,0 +1,6 @@ +{ + "program": "uncat0.aleo", + "version": "0.0.0", + "description": "", + "license": "MIT" +} diff --git a/tests/public/underflow0/build/main.aleo b/tests/public/underflow0/build/main.aleo new file mode 100644 index 0000000..7749ac3 --- /dev/null +++ b/tests/public/underflow0/build/main.aleo @@ -0,0 +1,19 @@ +program underflow0.aleo; + + + +function vanguard_helper: + cast true true into r0 as [boolean; 2u32]; + output r0 as [boolean; 2u32].private; + + +function ex0: + sub 0u8 1u8 into r0; + output r0 as u8.private; + + +function ex1: + input r0 as u8.private; + input r1 as u8.private; + sub r0 r1 into r2; + output r2 as u8.private; diff --git a/tests/public/underflow0/build/program.json b/tests/public/underflow0/build/program.json new file mode 100644 index 0000000..c41ef8b --- /dev/null +++ b/tests/public/underflow0/build/program.json @@ -0,0 +1,6 @@ +{ + "program": "underflow0.aleo", + "version": "0.0.0", + "description": "", + "license": "MIT" +} diff --git a/tests/public/unused0/build/main.aleo b/tests/public/unused0/build/main.aleo new file mode 100644 index 0000000..90d4cf3 --- /dev/null +++ b/tests/public/unused0/build/main.aleo @@ -0,0 +1,84 @@ +program unused0.aleo; + +struct St1: + a0 as u8; + a1 as u8; + + +mapping accounts3: + key as u8.public; + value as boolean.public; + + +mapping accounts4: + key as u8.public; + value as boolean.public; + +function vanguard_helper: + cast false true true false true false true into r0 as [boolean; 7u32]; + output r0 as [boolean; 7u32].private; + + +function ex0: + output 255u8 as u8.private; + + +function ex1: + input r0 as St1.public; + output r0.a0 as u8.private; + + +function ex2: + input r0 as u8.private; + input r1 as u8.private; + output r0 as u8.private; + + +function ex3: + input r0 as u8.private; + input r1 as u8.private; + async ex3 r1 into r2; + output r0 as u8.private; + output r2 as unused0.aleo/ex3.future; + +finalize ex3: + input r0 as u8.public; + set true into accounts3[r0]; + + +function ex4: + input r0 as u8.private; + input r1 as u8.private; + async ex4 r0 r1 into r2; + output r0 as u8.private; + output r2 as unused0.aleo/ex4.future; + +finalize ex4: + input r0 as u8.public; + input r1 as u8.public; + set true into accounts4[r0]; + + +function ex5: + input r0 as [boolean; 6u32].private; + add 0u8 1u8 into r1; + ternary r0[0u32] r1 0u8 into r2; + add r2 1u8 into r3; + ternary r0[1u32] r3 r2 into r4; + add r4 1u8 into r5; + ternary r0[2u32] r5 r4 into r6; + add r6 1u8 into r7; + ternary r0[3u32] r7 r6 into r8; + add r8 1u8 into r9; + ternary r0[4u32] r9 r8 into r10; + add r10 1u8 into r11; + ternary r0[5u32] r11 r10 into r12; + output r12 as u8.private; + + +function ex6: + input r0 as [u8; 4u32].private; + input r1 as u8.private; + gt r1 9u8 into r2; + ternary r2 r0[0u32] r0[1u32] into r3; + output r3 as u8.private; diff --git a/tests/public/unused0/build/program.json b/tests/public/unused0/build/program.json new file mode 100644 index 0000000..1eaaa3f --- /dev/null +++ b/tests/public/unused0/build/program.json @@ -0,0 +1,6 @@ +{ + "program": "unused0.aleo", + "version": "0.0.0", + "description": "", + "license": "MIT" +} diff --git a/tests/scripts/dep.py b/tests/scripts/dep.py new file mode 100644 index 0000000..f5cc78e --- /dev/null +++ b/tests/scripts/dep.py @@ -0,0 +1,7 @@ +import networkx +import bs4 +import pandas +import antlr4 + +if __name__ == "__main__": + print("Hello World!") \ No newline at end of file diff --git a/tests/scripts/hello.py b/tests/scripts/hello.py new file mode 100644 index 0000000..d98b69f --- /dev/null +++ b/tests/scripts/hello.py @@ -0,0 +1,2 @@ +if __name__ == "__main__": + print("Hello World!") \ No newline at end of file diff --git a/tests/scripts/parsing.py b/tests/scripts/parsing.py new file mode 100644 index 0000000..114a9ac --- /dev/null +++ b/tests/scripts/parsing.py @@ -0,0 +1,8 @@ +from vanguard.aleo.grammar import AleoEnvironment + +if __name__ == "__main__": + project_name = "divz0" + build_path = f"./tests/public/{project_name}/build/" + env = AleoEnvironment(build_path) + main = env.main + print("# Done.") \ No newline at end of file diff --git a/tests/scripts/test-divz.py b/tests/scripts/test-divz.py new file mode 100644 index 0000000..4515bd8 --- /dev/null +++ b/tests/scripts/test-divz.py @@ -0,0 +1,11 @@ +from vanguard.aleo.grammar import AleoEnvironment +from vanguard.aleo.detectors import detector_divz + +if __name__ == "__main__": + project_name = "divz0" + build_path = f"./tests/public/{project_name}/build/" + env = AleoEnvironment(build_path) + main = env.main + fid = "ex0" + res, info = detector_divz(env, main.id, fid) + assert res, f"Test failed for {fid}, expected: True, got: {res}" \ No newline at end of file diff --git a/tests/scripts/test-infoleak.py b/tests/scripts/test-infoleak.py new file mode 100644 index 0000000..cc3deaa --- /dev/null +++ b/tests/scripts/test-infoleak.py @@ -0,0 +1,16 @@ +from vanguard.aleo.grammar import AleoEnvironment +from vanguard.aleo.detectors import detector_infoleak + +if __name__ == "__main__": + project_name = "infoleak0" + build_path = f"./tests/public/{project_name}/build/" + env = AleoEnvironment(build_path) + main = env.main + + fid = "ex0" + res, info = detector_infoleak(env, main.id, fid) + assert res, f"Test failed for {fid}, expected: True, got: {res}" + + fid = "ex1" + res, info = detector_infoleak(env, main.id, fid) + assert not res, f"Test failed for {fid}, expected: False, got: {res}" \ No newline at end of file diff --git a/tests/scripts/test-rtcnst.py b/tests/scripts/test-rtcnst.py new file mode 100644 index 0000000..360bfb2 --- /dev/null +++ b/tests/scripts/test-rtcnst.py @@ -0,0 +1,11 @@ +from vanguard.aleo.grammar import AleoEnvironment +from vanguard.aleo.detectors import detector_rtcnst + +if __name__ == "__main__": + project_name = "rtcnst0" + build_path = f"./tests/public/{project_name}/build/" + env = AleoEnvironment(build_path) + main = env.main + fid = "ex0" + res, info = detector_rtcnst(env, main.id, fid) + assert res, f"Test failed for {fid}, expected: True, got: {res}" \ No newline at end of file diff --git a/tests/scripts/test-unused.py b/tests/scripts/test-unused.py new file mode 100644 index 0000000..704a8d9 --- /dev/null +++ b/tests/scripts/test-unused.py @@ -0,0 +1,16 @@ +from vanguard.aleo.grammar import AleoEnvironment +from vanguard.aleo.detectors import detector_unused + +if __name__ == "__main__": + project_name = "unused0" + build_path = f"./tests/public/{project_name}/build/" + env = AleoEnvironment(build_path) + main = env.main + + fid = "ex0" + res, info = detector_unused(env, main.id, fid) + assert not res, f"Test failed for {fid}, expected: False, got: {res}" + + fid = "ex1" + res, info = detector_unused(env, main.id, fid) + assert res, f"Test failed for {fid}, expected: True, got: {res}" \ No newline at end of file diff --git a/tests/test0.ipynb b/tests/test0.ipynb deleted file mode 100644 index 483b2c3..0000000 --- a/tests/test0.ipynb +++ /dev/null @@ -1,181 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "0df863b2-27ae-4e50-b81e-a4bd02ba9c4d", - "metadata": {}, - "outputs": [], - "source": [ - "# only run once every time kernel restarts\n", - "import os\n", - "os.chdir(\"..\")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "780fea9e-9270-462e-9e0a-879f633a2404", - "metadata": {}, - "outputs": [], - "source": [ - "from vanguard.aleo.common import aleo2json, get_ifg_edges, get_public_inputs, get_public_outputs\n", - "from vanguard.aleo.detectors.ileak import detector_simple_ileak" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "103d2086-9fbf-403d-af13-556af98d4150", - "metadata": {}, - "outputs": [], - "source": [ - "obj = aleo2json(\"./tests/test0.aleo\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "8fab8ca7-1ce8-41be-a667-d29dfa400dd6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys(['type', 'id', 'identifiers', 'imports', 'mappings', 'structs', 'records', 'closures', 'functions'])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "obj.keys()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "dc68b5fe-ef34-443b-bf2b-e0bb338afeea", - "metadata": {}, - "outputs": [], - "source": [ - "f0 = obj[\"functions\"][\"ex_leak3\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "f93f95d4-4faf-4baa-aa81-3a5be4a4dcfe", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[('r0', 'r1'), ('3u8', 'r1')]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "get_ifg_edges(f0)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "f2afff84-ea2c-4d1d-b62f-8196e40bf87f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['r0']" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "get_public_inputs(f0)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "c9f37f3c-0980-40e0-8e91-a63e7cd94b7c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['r1']" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "get_public_outputs(f0)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "73a88f6c-25db-4e0f-9bac-acbe01b0d629", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[('r0', 'r1')]" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "detector_ileak(f0)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9120076b-8475-4909-9a59-4d421713d6d8", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.0" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tests/test1.ipynb b/tests/test1.ipynb deleted file mode 100644 index 0f1b099..0000000 --- a/tests/test1.ipynb +++ /dev/null @@ -1,254 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "6c52d804-5982-4fe1-8ebe-0b40481e273b", - "metadata": {}, - "outputs": [], - "source": [ - "# only run once every time kernel restarts\n", - "import os\n", - "os.chdir(\"..\")" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "b3988b02-3591-4e8b-b2fa-c141d19eb4fa", - "metadata": {}, - "outputs": [], - "source": [ - "from vanguard.aleo.common import aleo2json, get_ifg_edges\n", - "from vanguard.aleo.grammar import AleoProgram\n", - "from vanguard.aleo.detectors.infoleak import detector_infoleak\n", - "from vanguard.aleo.detectors.rtcnst import detector_rtcnst\n", - "from vanguard.aleo.detectors.unused import detector_unused\n", - "from vanguard.aleo.detectors.divz import detector_divz" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "807ff5c7-5ce1-4f07-8279-0c371a9172b3", - "metadata": {}, - "outputs": [], - "source": [ - "# obj = aleo2json(\"./tests/aleoswap06.aleo\")\n", - "# obj = aleo2json(\"./tests/rtcnst0/build/main.aleo\")\n", - "# obj = aleo2json(\"./tests/unused0/build/main.aleo\")\n", - "obj = aleo2json(\"./tests/divz0/build/main.aleo\")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "c832a668-f15e-4bfd-b670-7b469cfb815b", - "metadata": {}, - "outputs": [], - "source": [ - "ap = AleoProgram(json=obj)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ebae5887-a20d-45c4-b919-099e5cb7bea3", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "ce8990c5-06b6-404a-a1ce-0fbbff1ef701", - "metadata": { - "scrolled": true, - "tags": [] - }, - "outputs": [], - "source": [ - "# detector_rtcnst(ap, \"ex0\")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "2724440f-3b21-42b2-a8e6-ade5c4c44295", - "metadata": {}, - "outputs": [], - "source": [ - "# detector_unused(ap, \"ex2\")" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "0759f5de-120e-4fe1-a23f-7a81e023f5b7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(True, ['div 225u8 0u8 into r0;'])" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "detector_divz(ap, \"ex1\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ae5cdbc3-a603-405a-a296-52d48864960b", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "f641a59b-0025-4650-aead-743bbcaa40ed", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['r0', 'r1']" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ap.get_function_arguments(\"join\", \"private\", \"inputs\")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "8369758b-4077-449f-97d6-e26c3954a6e9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['r0', 'r1']" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ap.get_function_arguments(\"join\", \"private\", \"inputs\")" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "bac7b43c-f409-4ed6-abf3-7d9a1ef5da51", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ap.get_function_arguments(\"join\", \"public\", \"outputs\")" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "499c69c5-95fb-4095-9ea8-9daa31ffeda7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[('r0.token', 'r1.token'),\n", - " ('r1.token', 'r0.token'),\n", - " ('r0.amount', 'r2'),\n", - " ('r1.amount', 'r2'),\n", - " ('r0.owner', 'r3'),\n", - " ('r0.token', 'r3'),\n", - " ('r2', 'r3')]" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "get_ifg_edges(ap, \"join\")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "e9d2567b-d425-4c70-a485-fbd9aa4ce1d4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(False, [])" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "detector_simple_infoleak(ap, \"join\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9c23816d-2177-40bf-9bc2-e8c7ea3d97bb", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.0" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tests/test2.ipynb b/tests/test2.ipynb deleted file mode 100644 index 32985fb..0000000 --- a/tests/test2.ipynb +++ /dev/null @@ -1,101 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "e5608577-0d21-4c83-8742-52ab389b55b7", - "metadata": {}, - "outputs": [], - "source": [ - "# only run once every time kernel restarts\n", - "import os\n", - "os.chdir(\"..\")" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "40e3922c-d800-4c6b-acda-77c8cc5a0fc2", - "metadata": {}, - "outputs": [], - "source": [ - "from vanguard.aleo.common import aleo2json\n", - "from vanguard.aleo.grammar import AleoProgram\n", - "from vanguard.aleo.detectors.infoleak import detector_infoleak\n", - "from vanguard.aleo.detectors.rtcnst import detector_rtcnst\n", - "from vanguard.aleo.detectors.unused import detector_unused\n", - "from vanguard.aleo.detectors.divz import detector_divz\n", - "from vanguard.aleo.detectors.divrd import detector_divrd" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "6392985b-7be1-403e-8f75-ef10de6dda0e", - "metadata": {}, - "outputs": [], - "source": [ - "obj = aleo2json(\"./tests/unused0/build/main.aleo\")\n", - "ap = AleoProgram(json=obj)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "194a1768-84a5-4c18-a96d-836cd8a00152", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(True, ['r1'])" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "detector_unused(ap, \"ex4\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "884d3f2c-4600-44f5-a0cb-c4f3d4d8c771", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a70a148e-c86f-4184-ad3f-9ba6288e6263", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.0" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tests/test3.ipynb b/tests/test3.ipynb new file mode 100644 index 0000000..aa21aef --- /dev/null +++ b/tests/test3.ipynb @@ -0,0 +1,100 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "4c8e2fda-c143-4942-b20d-48ebfe6b5b2d", + "metadata": {}, + "outputs": [], + "source": [ + "# only run once every time kernel restarts\n", + "import json\n", + "import os\n", + "os.chdir(\"..\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1bd6be3d-a5e1-4ee0-b63f-5c5314c97be1", + "metadata": {}, + "outputs": [], + "source": [ + "from vanguard.aleo.testing import crawl_from_haruka_explorer, crawl_from_aleo_explorer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "92552997-9c7a-4338-b83a-d0fca318fb33", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# crawl_from_haruka_explorer(1, 16, \"tests/explorer/haruka/\")\n", + "crawl_from_aleo_explorer(\"tests/explorer/aleo/\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "458ed9da-df04-4fe2-bdfb-bdef4b4766df", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13cab74f-7fdc-41ac-8b1f-1e0831158e6a", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import time\n", + "os.chdir(\"..\")\n", + "from vanguard.aleo.common import aleo2json\n", + "\n", + "# for dp, _, fns in os.walk(\"tests/explorer/haruka/\"):\n", + "for dp, _, fns in os.walk(\"tests/explorer/aleo/\"):\n", + " for fn in fns:\n", + " p = os.path.abspath(os.path.join(dp, fn))\n", + " print(f\"# parsing: {p} ... \", end=\"\")\n", + " s = time.time()\n", + " obj = aleo2json(p)\n", + " e = time.time()\n", + " print(f\"{e-s}s\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aad44479-9c1f-4784-acff-006dd4f27ce4", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/test4.ipynb b/tests/test4.ipynb new file mode 100644 index 0000000..abfd78f --- /dev/null +++ b/tests/test4.ipynb @@ -0,0 +1,185 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "8c6764a1-8835-4b6f-8ff2-32700801ffb9", + "metadata": {}, + "outputs": [], + "source": [ + "# only run once every time kernel restarts\n", + "import json\n", + "import os\n", + "os.chdir(\"..\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b34815c6-9610-4ef1-a7d2-4ee62cd30ae7", + "metadata": {}, + "outputs": [], + "source": [ + "from vanguard.aleo.grammar import AleoProgram, AleoEnvironment\n", + "\n", + "from vanguard.aleo.detectors import detector_infoleak\n", + "from vanguard.aleo.detectors import detector_rtcnst\n", + "from vanguard.aleo.detectors import detector_unused\n", + "from vanguard.aleo.detectors import detector_divz\n", + "\n", + "from vanguard.aleo.testing import run_test_suite" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b4849e3a-50d8-4fd4-83e5-5fa5b16ae96e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# [debug] deploy: main.aleo\n", + "# [debug] deploy: helpers.aleo\n" + ] + } + ], + "source": [ + "project_name = \"divz0\"\n", + "# project_name = \"infoleak0\"\n", + "# project_name = \"unused0\"\n", + "# project_name = \"rtcnst0\"\n", + "build_path = f\"./tests/public/{project_name}/build/\"\n", + "env = AleoEnvironment(build_path)\n", + "main = env.main" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d4d3f42f-b9be-4cf1-bcdd-19a93576df0f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0dc6fcff-f8b2-44cb-8919-fda9b23c0b49", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(False, [])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fid = \"ex1\"\n", + "detector_infoleak(env, main.id, fid, readable=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e895857f-8473-4e0e-a561-3553469ceceb", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a983f9b5-286c-4748-b2c7-b450ff0d7948", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# [debug] deploy: main.aleo\n", + "# [debug] deploy: helpers.aleo\n", + "# [✓][test] pid: divz0.aleo, fid: ex0, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex1, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex2, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex3, expected: True, actual: True\n", + "# [✗][test] pid: divz0.aleo, fid: ex4, expected: False, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex5, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex6, expected: True, actual: True\n", + "# [✗][test] pid: divz0.aleo, fid: ex7, expected: False, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex8, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex9, expected: False, actual: False\n", + "# [✓][test] pid: divz0.aleo, fid: ex10, expected: False, actual: False\n", + "# [✓][test] pid: divz0.aleo, fid: ex11, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex12, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex13, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex14, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex15, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex16, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex17, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex18, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex19, expected: True, actual: True\n", + "# [✗][test] pid: divz0.aleo, fid: ex20, expected: True, actual: False\n", + "# [✓][test] pid: divz0.aleo, fid: ex21, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex22, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex23, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex24, expected: True, actual: True\n", + "# [✓][test] pid: divz0.aleo, fid: ex25, expected: True, actual: True\n", + "# [test] accuracy: 23/26 (0.8846)\n", + "# [test] confusion matrix:\n", + " actual False True \n", + "expected \n", + "False 2 2\n", + "True 1 21\n", + "# [test] normalized confusion matrix:\n", + " actual False True \n", + "expected \n", + "False 0.500000 0.500000\n", + "True 0.045455 0.954545\n" + ] + } + ], + "source": [ + "r = run_test_suite(\"./tests/public/divz0/build/\", detector_divz, verbose=True)\n", + "# r = run_test_suite(\"./tests/public/infoleak0/build/\", detector_infoleak, verbose=True)\n", + "# r = run_test_suite(\"./tests/public/rtcnst0/build/\", detector_rtcnst, verbose=True)\n", + "# r = run_test_suite(\"./tests/public/unused0/build/\", detector_unused, verbose=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "82d7efec-e329-4e1d-ab12-eb0890c072d3", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/test5.ipynb b/tests/test5.ipynb new file mode 100644 index 0000000..88119af --- /dev/null +++ b/tests/test5.ipynb @@ -0,0 +1,212 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "557e4813-95f6-476b-b2ec-ca6749c8d3b6", + "metadata": {}, + "outputs": [], + "source": [ + "# only run once every time kernel restarts\n", + "import json\n", + "import os\n", + "import sys\n", + "from antlr4 import *\n", + "os.chdir(\"..\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "034cb799-a6c9-41b4-9206-6988f3365648", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "54fc49a6-75c4-4101-82dc-9582094cd02f", + "metadata": {}, + "outputs": [], + "source": [ + "from vanguard.aleo.common import aleo2json" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5d222e5-e222-41e6-88dd-3034083e27a4", + "metadata": {}, + "outputs": [], + "source": [ + "project_name = \"infoleak0\"\n", + "tree = aleo2json(f\"./tests/public/{project_name}/build/main.aleo\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e473553b-daef-4a63-becf-f0546421167f", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "print(json.dumps(tree))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "510f838c-d698-492a-b467-2e673b8c8ba0", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8e3fece-9b3c-4ae7-adfb-9da153925bfa", + "metadata": {}, + "outputs": [], + "source": [ + "from vanguard.aleo.parser.AleoLexer import AleoLexer\n", + "from vanguard.aleo.parser.AleoParser import AleoParser\n", + "from vanguard.aleo.parser.AleoListener import AleoListener" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "83e090b1-3ec3-4ce5-b668-342a538aebba", + "metadata": {}, + "outputs": [], + "source": [ + "project_name = \"infoleak0\"\n", + "input_stream = FileStream(f\"./tests/public/{project_name}/build/main.aleo\")\n", + "lexer = AleoLexer(input_stream)\n", + "stream = CommonTokenStream(lexer)\n", + "parser = AleoParser(stream)\n", + "tree = parser.start()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b957145-83b5-4b02-9ecc-ee1e5bf18fff", + "metadata": {}, + "outputs": [], + "source": [ + "linterp = AleoListener()\n", + "walker = ParseTreeWalker()\n", + "walker.walk(linterp, tree)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "21f93588-daa7-4cd5-b7d1-7c5d55fbeb61", + "metadata": {}, + "outputs": [], + "source": [ + "from antlr4.tree.Trees import Trees" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "11b3d4eb-6115-45a2-bf0d-423e8aa15cdc", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "print(Trees.toStringTree(tree, None, parser))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "33e25c47-0217-47d8-85b8-33bd24cb3481", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4b0500e8-7593-443d-8cae-ced63fdc27f6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "186bc3e1-b0c2-45c0-8930-c5afecd272f3", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "96c409b0-77f2-4a54-8c29-793e81e1563d", + "metadata": {}, + "outputs": [], + "source": [ + "lexer.literalNames[129]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c98f643-c8f8-4416-9c72-33158e101c4e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5df0e3a2-8bff-46bb-b2dd-43e247f90655", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "list(map(str,stream.tokens))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "89ba999d-781b-48c5-b383-b918b91229dd", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/vanguard/aleo/common.py b/vanguard/aleo/common.py index 6983600..4b7f7ff 100644 --- a/vanguard/aleo/common.py +++ b/vanguard/aleo/common.py @@ -1,278 +1,35 @@ -import argparse -import subprocess -import logging -import inspect -import shlex -import shutil -import json -import os -import re - +from io import StringIO from pathlib import Path from typing import List, Union -# ref (Aleo grammar): https://developer.aleo.org/aleo/grammar/ - -def run_command(cmd: Union[str, List[Union[str, Path]]], decode=True): - if isinstance(cmd, str): - logging.info(f" cmd: {cmd}") - proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) - elif isinstance(cmd, list): - logging.info(f" cmd: {shlex.join(map(str, cmd))}") - proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) - else: - raise Exception(f"unsupported command type, got: {cmd}") - - if proc.returncode != 0: - err_contents = proc.stdout.decode("utf-8") - raise Exception(f"command failed with message:\n{err_contents}") - - return proc.stdout.decode() if decode else proc.stdout +from antlr4 import FileStream, CommonTokenStream, Parser +from antlr4.Utils import escapeWhitespace +from antlr4.tree.Trees import Trees, Tree + +# ref: toStringTree method +# https://github.com/parrt/antlr4-python3/blob/master/src/antlr4/tree/Trees.py#L48 +@classmethod +def toJsonTree(cls, t: Tree, ruleNames: list=None, recog: Parser=None): + '''Get s-expression of the parse tree in json''' + if recog is not None: + ruleNames = recog.ruleNames + s = escapeWhitespace(cls.getNodeText(t, ruleNames), False) + if t.getChildCount() == 0: + return s + ret = [s] + for i in range(0, t.getChildCount()): + ret.append(cls.toJsonTree(t.getChild(i), ruleNames)) + return ret +# install class method +Trees.toJsonTree = toJsonTree + +from .parser.AleoLexer import AleoLexer +from .parser.AleoParser import AleoParser def aleo2json(path: Union[str, Path]): - cmd = ["aleo2json", path] - out = run_command(cmd) - return json.loads(out) - -def assert_node_field(node, field, val=None): - assert field in node.keys(), f"Can't find filed {field} in node" - if val is not None: - assert node[field] == val, f"Mismatch of {field} of node, expected: {val}, got: {node[field]}" - -def assert_range(value, range): - assert value in range, f"Value {value} is not in range {range}" - -def trim_inst(inst: str): - # remove space in "; " in array literals - # remove tailing semi-colon ";" - return inst.replace("; ", ";").strip(";") - -def parse_instance(v: str): - # parse register/constants - # returns a tuple (type, parsed_value) - # NOTE: some values are parsed but some are not, - # based on convenience of computation - - if v == "true": - return ("boolean", True) - elif v == "false": - return ("boolean", False) - elif v.startswith("r"): - # register - return ("register", v) - elif v.startswith("aleo1"): - # address constant - return ("address", v) - elif "[" in v and "]" in v: - # mapping access - r = re.match( r"^(.*?)\[(.*?)\]$", v ) - identifier = r.group(1) - operand = r.group(2) - return ("mapping", identifier, operand) - else: - ts = [ - "u128", "u64", "u32", "u16", "u8", - "i128", "i64", "i32", "i16", "i8", - "field", "group", "scalar" - ] - for p in ts: - if v.endswith(p): - return (p, int(v[:len(p)-1])) - raise NotImplementedError(f"Unsupported instance: {v}") - -def get_ifg_edges(prog, func, hash=False, call=False, inline=False): - """Get information flow graph edges. - Args: - - prog: - - func - - hash (default: False): whether to treat a hash function call directly as an edge - - call (default: False): whether to treat a call directly as an edge - - inline (default: False): whether to inline call invocations recursively to generate edges; - if `call` is True, this argument is then overridden and no inlining will take place. - Rets: A list of pairs of strings - """ - node = prog.functions[func] - assert_node_field(node, "instructions") - - edges = [] - # process instructions - for inst in node["instructions"] + node["outputs"]: - tokens = trim_inst(inst["str"]).split() - match tokens: - - case ["is.eq", o1, o2, "into", r]: - edges.append((o1, r)) - edges.append((o2, r)) - case ["is.neq", o1, o2, "into", r]: - edges.append((o1, r)) - edges.append((o2, r)) - - case ["assert.eq", o1, o2]: - edges.append((o1, o2)) - edges.append((o2, o1)) - case ["assert.neq", o1, o2]: - edges.append((o1, o2)) - edges.append((o2, o1)) - - case ["cast", o, "into", r, "as", d]: - edges.append((o, r)) - - case ["call", *ts]: - # manualy match the call component since there are two sequences of varying lengths - idx_into = tokens.index("into") - f = tokens[1] - os = tokens[2:idx_into] - rs = tokens[idx_into+1:] - if call: - for o in os: - for r in rs: - # overapproximated edges from every o to every r - edges.append((o, r)) - elif inline: - # TODO: add impl - raise NotImplementedError - else: - # no inline, no call, then no edge - pass - - case ["async", *ts]: - # FIXME: can't find official documentation for now, treated as call - # manualy match the call component since there are two sequences of varying lengths - idx_into = tokens.index("into") - f = tokens[1] - os = tokens[2:idx_into] - rs = tokens[idx_into+1:] - if call: - for o in os: - for r in rs: - # overapproximated edges from every o to every r - edges.append((o, r)) - elif inline: - # TODO: add impl - raise NotImplementedError - else: - # no inline, no call, then no edge - pass - - case [cop, o1, o2, "into", r, "as", t] if cop.startswith("commit"): - # no edge in commitment computation - pass - - case [hop, o1, "into", r, "as", t] if hop.startswith("hash"): - # no edge in hash computation - pass - - case [binop, o1, o2, "into", r]: - edges.append((o1, r)) - edges.append((o2, r)) - - case [unop, o, "into", r]: - edges.append((o, r)) - - case [terop, o1, o2, o3, "into", r]: - edges.append((o1, r)) - edges.append((o2, r)) - edges.append((o3, r)) - - case ["cast", *os, "into", dst, "as", typ]: - for o in os: - edges.append((o, dst)) - - case ["output", o, "as", typ]: - # no edge in output command - pass - - case _: - raise NotImplementedError(f"Unknown instruction pattern, got: {inst['str']}") - - return edges - -def get_dfg_edges(prog, func): - """Get data flow graph edges. - Args: - - prog: - - func: - Rets: A list of pairs of strings - """ - node = prog.functions[func] - assert_node_field(node, "instructions") - - edges = [] - # process instructions - for inst in node["instructions"]: - tokens = trim_inst(inst["str"]).split() - match tokens: - - case ["is.eq", o1, o2, "into", r]: - edges.append((o1, r)) - edges.append((o2, r)) - case ["is.neq", o1, o2, "into", r]: - edges.append((o1, r)) - edges.append((o2, r)) - - case ["assert.eq", o1, o2]: - edges.append((o1, o2)) - edges.append((o2, o1)) - case ["assert.neq", o1, o2]: - edges.append((o1, o2)) - edges.append((o2, o1)) - - case ["cast", o, "into", r, "as", d]: - edges.append((o, r)) - - case ["call", *ts]: - # manualy match the call component since there are two sequences of varying lengths - idx_into = tokens.index("into") - f = tokens[1] - os = tokens[2:idx_into] - rs = tokens[idx_into+1:] - # no inlining, just add edge from this level - for o in os: - for r in rs: - # overapproximated edges from every o to every r - edges.append((o, r)) - - case ["async", *ts]: - # FIXME: can't find official documentation for now, treated as call - # manualy match the call component since there are two sequences of varying lengths - idx_into = tokens.index("into") - f = tokens[1] - os = tokens[2:idx_into] - rs = tokens[idx_into+1:] - # no inlining, just add edge from this level - for o in os: - for r in rs: - # overapproximated edges from every o to every r - edges.append((o, r)) - - case [cop, o1, o2, "into", r, "as", t] if cop.startswith("commit"): - edges.append((o1, r)) - edges.append((o2, r)) - - case [hop, o1, "into", r, "as", t] if hop.startswith("hash"): - edges.append((o1, r)) - - case [binop, o1, o2, "into", r]: - edges.append((o1, r)) - edges.append((o2, r)) - - case [unop, o, "into", r]: - edges.append((o, r)) - - case [terop, o1, o2, o3, "into", r]: - edges.append((o1, r)) - edges.append((o2, r)) - edges.append((o3, r)) - - case ["cast", *os, "into", dst, "as", typ]: - for o in os: - edges.append((o, dst)) - - case ["output", o, "as", typ]: - # no edge in output command - pass - - case _: - raise NotImplementedError(f"Unknown instruction pattern, got: {inst['str']}") - - return edges \ No newline at end of file + input_stream = FileStream(path) + lexer = AleoLexer(input_stream) + stream = CommonTokenStream(lexer) + parser = AleoParser(stream) + tree = parser.start() + return Trees.toJsonTree(tree, None, parser) diff --git a/vanguard/aleo/detectors/__init__.py b/vanguard/aleo/detectors/__init__.py index e69de29..db7ea22 100644 --- a/vanguard/aleo/detectors/__init__.py +++ b/vanguard/aleo/detectors/__init__.py @@ -0,0 +1,4 @@ +from .divz import detector_divz +from .infoleak import detector_infoleak +from .rtcnst import detector_rtcnst +from .unused import detector_unused \ No newline at end of file diff --git a/vanguard/aleo/detectors/divrd.py b/vanguard/aleo/detectors/divrd.py deleted file mode 100644 index be24070..0000000 --- a/vanguard/aleo/detectors/divrd.py +++ /dev/null @@ -1,28 +0,0 @@ -import networkx as nx - -from ..grammar import AleoProgram - -def detector_divrd(prog: AleoProgram, func: str): - """Detect for division rounddown - Args: - - prog (AleoProgram): - - func (str): - Rets: (result, info) - """ - - lines = [] - # process output instructions - for inst in prog.functions[func]["instructions"]: - tokens = inst["str"].strip(";").split() - match tokens: - - case ["div", v0, v1, "into", r]: - # FIXME: improve precision - lines.append(inst["str"]) - - case _: - # fine for other cases - pass - - return (len(lines)>0, lines) - \ No newline at end of file diff --git a/vanguard/aleo/detectors/divz.py b/vanguard/aleo/detectors/divz.py index e124f6a..9182d5d 100644 --- a/vanguard/aleo/detectors/divz.py +++ b/vanguard/aleo/detectors/divz.py @@ -1,305 +1,317 @@ -import networkx as nx - +from typing import Union from enum import Enum +from collections import defaultdict -from ..grammar import AleoProgram -from ..common import parse_instance - -def detector_divz(prog: AleoProgram, func: str): - """Detect for division by zero - Args: - - prog (AleoProgram): - - func (str): - Rets: (result, info) - """ - - lines = [] - # process output instructions - for inst in prog.functions[func]["instructions"]: - tokens = inst["str"].strip(";").split() - match tokens: - - case ["div", v0, v1, "into", r]: - if v1.startswith("0u"): - lines.append(inst["str"]) - - case _: - # fine for other cases - pass - - return (len(lines)>0, lines) - -class Dom(Enum): - # abstract domain +from ..grammar import * +class AbsDom(Enum): NEG = -1 ZERO = 0 POS = 1 - FALSE = 100 TRUE = 101 -class Val: - # some pre-defined set - # NOTE: this is a normal class, so values don't get hased and are iterable - - # this is usually not used, use with caution - TOP = {Dom.NEG, Dom.ZERO, Dom.POS, Dom.FALSE, Dom.TRUE} - - ALLINT = {Dom.NEG, Dom.ZERO, Dom.POS} - NNINT = {Dom.ZERO, Dom.POS} # non-negative int - NPINT = {Dom.NEG, Dom.ZERO} # non-positive int - - ALLBOOL = {Dom.FALSE, Dom.TRUE} - - BOT = set() # exception status + def TOP(): return {AbsDom.NEG, AbsDom.ZERO, AbsDom.POS, AbsDom.FALSE, AbsDom.TRUE} + def ALLINT(): return {AbsDom.NEG, AbsDom.ZERO, AbsDom.POS} + def NNINT(): return {AbsDom.ZERO, AbsDom.POS} # non-negative int + def NPINT(): return {AbsDom.NEG, AbsDom.ZERO} # non-positive int + def ALLBOOL(): return {AbsDom.FALSE, AbsDom.TRUE} + def BOT(): return set() + +class AleoAbstractType(AleoType): + def __init__(self, **kwargs): + super().__init__(**kwargs) + def __str__(self): + return "$" + +class AleoAbstractLiteral(AleoLiteral): + + @staticmethod + def abs(node): + _type = AleoAbstractType() + match node: + case AleoAddressLiteral(): + return AleoAbstractLiteral(AbsDom.BOT(), _type) + case AleoBooleanLiteral(): + if node.value: + return AleoAbstractLiteral({AbsDom.TRUE}, _type) + else: + return AleoAbstractLiteral({AbsDom.FALSE}, _type) + case AleoFieldLiteral() | AleoUnsignedLiteral() | AleoSignedLiteral(): + if node.value == 0: + return AleoAbstractLiteral({AbsDom.ZERO}, _type) + elif node.value > 0: + return AleoAbstractLiteral({AbsDom.POS}, _type) + else: + return AleoAbstractLiteral({AbsDom.NEG}, _type) + case _: + raise NotImplementedError(f"Unsupported literal, got: {node}") + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) -def fabs(v): - if isinstance(v, bool): - # bool - if v == True: - return {Dom.TRUE} - else: - return {Dom.FALSE} - elif isinstance(v, int): - # integers - if v == 0: - return {Dom.ZERO} - elif v < 0: - return {Dom.NEG} - else: - return {Dom.POS} - elif isinstance(v, str): - # address - return Val.BOT - else: - raise NotImplementedError(f"Unsupported type for abstraction, got: {v}") + def __str__(self): + return f"{self.type}{self.value}" -def pget(mem, pid, env, path): - # fetch variable from environment - # if it's a literal, then convert to abstract value - # otherwise, fetch directly from program's mem or function's env - target = parse_instance(path) - match target[0]: - case "register": - return env[target[1]] - case "mapping": - id = target[1][0] - ac = target[1][1] - ac_0 = pget(mem, pid, env, ac) # recursive, as operand can also be a path - return mem[pid][id][ac_0] - case "u128" | "u64" | "u32" | "u16" | "u8" | \ - "i128" | "i64" | "i32" | "i16" | "i8" | \ - "field" | "group" | "scalar" | "bool" | \ - "address": - return fabs(target[1]) - case _: - raise NotImplementedError(f"Unsupported path type for pget, got: {target}") - -def pset(mem, pid, env, path, v): - # set value - target = parse_instance(path) - match target[0]: - case "register": - env[target[1]] = v - case "mapping": - id = target[1][0] - ac = target[1][1] - ac_0 = pget(mem, pid, env, ac) # recursive, as operand can also be a path - mem[pid][id][ac_0] = v - case _: - raise NotImplementedError(f"Unsupported path type for pset, got: {target}") - -def generate_absop(ltab): +def absop(ltab): # ltab: look-up table # construct function - def do(a, b): + def do(a: AleoAbstractLiteral, b: AleoAbstractLiteral): r = set() - for a0 in a: - for b0 in b: - r.update(ltab[a0][b0]) - return r + for a0 in a.value: + if a0 in ltab.keys(): + for b0 in b.value: + if b0 in ltab[a0].keys(): + r.update(ltab[a0][b0]) + return AleoAbstractLiteral(r, AleoAbstractType()) # return the function return do -class AbsOp: - # NOTE: let it throw an exception if abs value is not found, as Aleo should be type checked - # and it's usually the interpreter's issue when there's an exception - - ADD = generate_absop({ - Dom.NEG: { Dom.NEG: {Dom.NEG}, Dom.ZERO: {Dom.NEG}, Dom.POS: Val.ALLINT }, - Dom.ZERO: { Dom.NEG: {Dom.NEG}, Dom.ZERO: {Dom.ZERO}, Dom.POS: {Dom.POS} }, - Dom.POS: { Dom.NEG: Val.ALLINT, Dom.ZERO: {Dom.POS}, Dom.POS: {Dom.POS} }, - }) - - MUL = generate_absop({ - Dom.NEG: { Dom.NEG: {Dom.POS}, Dom.ZERO: {Dom.ZERO}, Dom.POS: {Dom.NEG} }, - Dom.ZERO: { Dom.NEG: {Dom.ZERO}, Dom.ZERO: {Dom.ZERO}, Dom.POS: {Dom.ZERO} }, - Dom.POS: { Dom.NEG: {Dom.NEG}, Dom.ZERO: {Dom.ZERO}, Dom.POS: {Dom.POS} }, - }) - - DIV = generate_absop({ - Dom.NEG: { Dom.NEG: {Dom.POS}, Dom.ZERO: set(), Dom.POS: {Dom.NEG} }, - Dom.ZERO: { Dom.NEG: {Dom.ZERO}, Dom.ZERO: set(), Dom.POS: {Dom.ZERO} }, - Dom.POS: { Dom.NEG: {Dom.NEG}, Dom.ZERO: set(), Dom.POS: {Dom.POS} }, - }) - - GTE = generate_absop({ - Dom.NEG: { Dom.NEG: Val.ALLBOOL, Dom.ZERO: {Dom.FALSE}, Dom.POS: {Dom.FALSE} }, - Dom.ZERO: { Dom.NEG: {Dom.TRUE}, Dom.ZERO: {Dom.TRUE}, Dom.POS: {Dom.FALSE} }, - Dom.POS: { Dom.NEG: {Dom.TRUE}, Dom.ZERO: {Dom.TRUE}, Dom.POS: Val.ALLBOOL }, - }) - - ISNEQ = generate_absop({ - Dom.NEG: { Dom.NEG: Val.ALLBOOL, Dom.ZERO: {Dom.TRUE}, Dom.POS: {Dom.TRUE} }, - Dom.ZERO: { Dom.NEG: {Dom.TRUE}, Dom.ZERO: {Dom.FALSE}, Dom.POS: {Dom.TRUE} }, - Dom.POS: { Dom.NEG: {Dom.TRUE}, Dom.ZERO: {Dom.TRUE}, Dom.POS: Val.ALLBOOL }, - Dom.FALSE:{ Dom.FALSE: {Dom.FALSE}, Dom.TRUE: {Dom.TRUE} }, - Dom.TRUE: { Dom.FALSE: {Dom.TRUE}, Dom.TRUE: {Dom.FALSE} }, - }) - - ISEQ = generate_absop({ - Dom.NEG: { Dom.NEG: Val.ALLBOOL, Dom.ZERO: {Dom.FALSE}, Dom.POS: {Dom.FALSE} }, - Dom.ZERO: { Dom.NEG: {Dom.FALSE}, Dom.ZERO: {Dom.TRUE}, Dom.POS: {Dom.FALSE} }, - Dom.POS: { Dom.NEG: {Dom.FALSE}, Dom.ZERO: {Dom.FALSE}, Dom.POS: Val.ALLBOOL }, - }) - -def detector_divz_new(prog: AleoProgram, func:str): +# load class attribute +AleoAbstractLiteral.ops = { + + # binary operators + AleoBinaryOp.ADD: absop({ + AbsDom.NEG: { AbsDom.NEG: {AbsDom.NEG}, AbsDom.ZERO: {AbsDom.NEG}, AbsDom.POS: AbsDom.ALLINT() }, + AbsDom.ZERO: { AbsDom.NEG: {AbsDom.NEG}, AbsDom.ZERO: {AbsDom.ZERO}, AbsDom.POS: {AbsDom.POS} }, + AbsDom.POS: { AbsDom.NEG: AbsDom.ALLINT(), AbsDom.ZERO: {AbsDom.POS}, AbsDom.POS: {AbsDom.POS} }, + }), + AleoBinaryOp.ADDW: absop({ + AbsDom.NEG: { AbsDom.NEG: {AbsDom.NEG}, AbsDom.ZERO: {AbsDom.NEG}, AbsDom.POS: AbsDom.ALLINT() }, + AbsDom.ZERO: { AbsDom.NEG: {AbsDom.NEG}, AbsDom.ZERO: {AbsDom.ZERO}, AbsDom.POS: {AbsDom.POS} }, + AbsDom.POS: { AbsDom.NEG: AbsDom.ALLINT(), AbsDom.ZERO: {AbsDom.POS}, AbsDom.POS: {AbsDom.POS} }, + }), + # AleoBinaryOp.SUB: lambda: 1/0, + # AleoBinaryOp.SUBW: lambda: 1/0, + AleoBinaryOp.MUL: absop({ + AbsDom.NEG: { AbsDom.NEG: {AbsDom.POS}, AbsDom.ZERO: {AbsDom.ZERO}, AbsDom.POS: {AbsDom.NEG} }, + AbsDom.ZERO: { AbsDom.NEG: {AbsDom.ZERO}, AbsDom.ZERO: {AbsDom.ZERO}, AbsDom.POS: {AbsDom.ZERO} }, + AbsDom.POS: { AbsDom.NEG: {AbsDom.NEG}, AbsDom.ZERO: {AbsDom.ZERO}, AbsDom.POS: {AbsDom.POS} }, + }), + AleoBinaryOp.MULW: absop({ + AbsDom.NEG: { AbsDom.NEG: {AbsDom.POS}, AbsDom.ZERO: {AbsDom.ZERO}, AbsDom.POS: {AbsDom.NEG} }, + AbsDom.ZERO: { AbsDom.NEG: {AbsDom.ZERO}, AbsDom.ZERO: {AbsDom.ZERO}, AbsDom.POS: {AbsDom.ZERO} }, + AbsDom.POS: { AbsDom.NEG: {AbsDom.NEG}, AbsDom.ZERO: {AbsDom.ZERO}, AbsDom.POS: {AbsDom.POS} }, + }), + AleoBinaryOp.DIV: absop({ + AbsDom.NEG: { AbsDom.NEG: {AbsDom.POS}, AbsDom.ZERO: set(), AbsDom.POS: {AbsDom.NEG} }, + AbsDom.ZERO: { AbsDom.NEG: {AbsDom.ZERO}, AbsDom.ZERO: set(), AbsDom.POS: {AbsDom.ZERO} }, + AbsDom.POS: { AbsDom.NEG: {AbsDom.NEG}, AbsDom.ZERO: set(), AbsDom.POS: {AbsDom.POS} }, + }), + AleoBinaryOp.DIVW: absop({ + AbsDom.NEG: { AbsDom.NEG: {AbsDom.POS}, AbsDom.ZERO: set(), AbsDom.POS: {AbsDom.NEG} }, + AbsDom.ZERO: { AbsDom.NEG: {AbsDom.ZERO}, AbsDom.ZERO: set(), AbsDom.POS: {AbsDom.ZERO} }, + AbsDom.POS: { AbsDom.NEG: {AbsDom.NEG}, AbsDom.ZERO: set(), AbsDom.POS: {AbsDom.POS} }, + }), + # AleoBinaryOp.REM: lambda: 1/0, + # AleoBinaryOp.REMW: lambda: 1/0, + # AleoBinaryOp.POW: lambda: 1/0, + # AleoBinaryOp.POWW: lambda: 1/0, + # AleoBinaryOp.SHL: lambda: 1/0, + # AleoBinaryOp.SHLW: lambda: 1/0, + # AleoBinaryOp.SHR: lambda: 1/0, + # AleoBinaryOp.SHRW: lambda: 1/0, + # AleoBinaryOp.MOD: lambda: 1/0, + # AleoBinaryOp.AND: lambda: 1/0, + # AleoBinaryOp.OR: lambda: 1/0, + # AleoBinaryOp.XOR: lambda: 1/0, + # AleoBinaryOp.NAND: lambda: 1/0, + # AleoBinaryOp.NOR: lambda: 1/0, + # AleoBinaryOp.GT: lambda: 1/0, + AleoBinaryOp.GTE: absop({ + AbsDom.NEG: { AbsDom.NEG: AbsDom.ALLBOOL(), AbsDom.ZERO: {AbsDom.FALSE}, AbsDom.POS: {AbsDom.FALSE} }, + AbsDom.ZERO: { AbsDom.NEG: {AbsDom.TRUE}, AbsDom.ZERO: {AbsDom.TRUE}, AbsDom.POS: {AbsDom.FALSE} }, + AbsDom.POS: { AbsDom.NEG: {AbsDom.TRUE}, AbsDom.ZERO: {AbsDom.TRUE}, AbsDom.POS: AbsDom.ALLBOOL() }, + }), + # AleoBinaryOp.LT: lambda: 1/0, + # AleoBinaryOp.LTE: lambda: 1/0, + + # is operators + AleoIsOp.NEQ: absop({ + AbsDom.NEG: { AbsDom.NEG: AbsDom.ALLBOOL(), AbsDom.ZERO: {AbsDom.TRUE}, AbsDom.POS: {AbsDom.TRUE} }, + AbsDom.ZERO: { AbsDom.NEG: {AbsDom.TRUE}, AbsDom.ZERO: {AbsDom.FALSE}, AbsDom.POS: {AbsDom.TRUE} }, + AbsDom.POS: { AbsDom.NEG: {AbsDom.TRUE}, AbsDom.ZERO: {AbsDom.TRUE}, AbsDom.POS: AbsDom.ALLBOOL() }, + AbsDom.FALSE:{ AbsDom.FALSE: {AbsDom.FALSE}, AbsDom.TRUE: {AbsDom.TRUE} }, + AbsDom.TRUE: { AbsDom.FALSE: {AbsDom.TRUE}, AbsDom.TRUE: {AbsDom.FALSE} }, + }), + AleoIsOp.EQ: absop({ + AbsDom.NEG: { AbsDom.NEG: AbsDom.ALLBOOL(), AbsDom.ZERO: {AbsDom.FALSE}, AbsDom.POS: {AbsDom.FALSE} }, + AbsDom.ZERO: { AbsDom.NEG: {AbsDom.FALSE}, AbsDom.ZERO: {AbsDom.TRUE}, AbsDom.POS: {AbsDom.FALSE} }, + AbsDom.POS: { AbsDom.NEG: {AbsDom.FALSE}, AbsDom.ZERO: {AbsDom.FALSE}, AbsDom.POS: AbsDom.ALLBOOL() }, + }), +} + +# abstract wrapper +def a(node): + match node: + # NOTE: match abstract literal first, before concrete literal + case AleoAbstractLiteral(): + return node + case AleoLiteral(): + return AleoAbstractLiteral.abs(node) + case _: + raise NotImplementedError(f"Can't wrap a non-literal, got: {node}") +def detector_divz(env: AleoEnvironment, pid: str, fid: str, readable=False): + # initialize + prog: AleoProgram = env.programs[pid] + func: AleoFunction = prog.functions[fid] + # store problematic instructions lines = [] - # memory/storage for storing program-wise structures, e.g., mapping - # needs a program name as key, separate between different programs - mem = {} - - def visitor(pid, f, inps): - # load inputs, purely positional - assert len(f["inputs"]) == len(inps), f"Numbers of argument mismatch calling {f['name']}, expected {len(f['inputs'])}, got {len(inps)}" - env = { - f"r{f['inputs'][i]['register']['value']}" : inps[i] - for i in range(len(f["inputs"])) - } - - # interpretation - for inst in f["instructions"]: - print(f"# [debug] executing: {inst["str"]}") - tokens = inst["str"].strip(";").split() - match tokens: - - # special abstract interpretation with detection - case [op, v0, v1, "into", r0] if op in ["div", "div.w"]: - # parse - pv0 = pget(mem, pid, env, v0) - pv1 = pget(mem, pid, env, v1) + # FIXME: get better naming for pid and fid + def visitor(pid, fid, inps: list, finalize=False): + + # determine block + pr = env.programs[pid] + fn = None + if fid in pr.functions.keys(): + if finalize: + fn = pr.functions[fid].finalize + else: + fn = pr.functions[fid] + else: + fn = pr.closures[fid] + assert not finalize, f"Closure {fid} doesn't have a finalize block" + + assert len(fn.inputs) == len(inps), \ + f"Argument lengths mismatch, expected: {len(fn.inputs)}, got:{len(inps)}" + # create local context + ctx = { fn.inputs[i][0] : inps[i] for i in range(len(fn.inputs))} + + # interpret + for inst in fn.instructions: + # print(f"# [debug] inst: {inst}") + match inst: + + case AleoBinary() | AleoIs(): + av0 = a(env.mget(pid, inst.operands[0], ctx=ctx)) + av1 = a(env.mget(pid, inst.operands[1], ctx=ctx)) # detect - if Dom.ZERO in pv1: - lines.append(inst["str"]) - # compute - cr0 = AbsOp.DIV(pv0, pv1) - # set - pset(mem, pid, env, r0, cr0) - - # regular abstract interpretation - case [op, v0, v1, "into", r0] if op in \ - {"add", "mul", "is.neq", "is.eq", "gte"}: - # parse - pv0 = pget(mem, pid, env, v0) - pv1 = pget(mem, pid, env, v1) + if inst.op in {AleoBinaryOp.DIV, AleoBinaryOp.DIVW}: + if AbsDom.ZERO in av1.value: + if readable: + lines.append(f"{inst}") + else: + lines.append(inst) # compute - OP = op.replace(".", "").upper() - cr0 = getattr(AbsOp, OP)(pv0, pv1) - # set - pset(mem, pid, env, r0, cr0) + ao = AleoAbstractLiteral.ops[inst.op](av0, av1) + env.mset(pid, inst.regacc, ao, ctx=ctx) - case ["ternary", v0, v1, v2, "into", r0]: - # parse - pv0 = pget(mem, pid, env, v0) - pv1 = pget(mem, pid, env, v1) - pv2 = pget(mem, pid, env, v2) + case AleoTernary(): + av0 = a(env.mget(pid, inst.operands[0], ctx=ctx)) + av1 = a(env.mget(pid, inst.operands[1], ctx=ctx)) + av2 = a(env.mget(pid, inst.operands[2], ctx=ctx)) # compute - cr0 = set() - if Dom.TRUE in pv0: - cr0.update(pv1) - if Dom.FALSE in pv0: - cr0.update(pv2) + ao = AleoAbstractLiteral(set(), AleoAbstractType()) + if AbsDom.TRUE in av0.value: + ao.value.update(av1.value) + if AbsDom.FALSE in av0.value: + ao.value.update(av2.value) # set - pset(mem, pid, env, r0, cr0) + env.mset(pid, inst.regacc, ao, ctx=ctx) - case ["assert.eq", v0, v1]: - # no env change, skip for simplicity + case AleoAssert(): + # no ctx change, skip pass - case ["call", *ts]: - # extract call components - idx_into = tokens.index("into") - fn = tokens[1] - vs = tokens[2:idx_into] - rs = tokens[idx_into+1:] + case AleoCall(): # collect parameters - params = [ pget(mem, pid, env, v) for v in vs ] + params = [ env.mget(pid, p, ctx=ctx) for p in inst.operands ] + # locate function + (_pid, _fid) = env.resolve_function(pid, inst.callee) # dispatch - outs = visitor(pid, prog.closures[fn], params) - # load outputs back to env - assert len(outs) == len(rs), f"Mismatch lengths of return, expected: {len(rs)}, got: {len(outs)}" - for r, o in zip(rs, outs): - pset(mem, pid, env, r, o) - - case ["async", fn, *vs, "into", r0]: - # async (Aleo) is finalize (Leo) - assert fn == f["name"], f"Call of async need to have the same name, expected: {f["name"]}, got: {fn}" - assert "finalize_logic" in f.keys(), f"Function {f["name"]} doesn't have a finalize block" + outs = visitor(_pid, _fid, params) + # update ctx + assert len(outs) == len(inst.regaccs), \ + f"Lengths of return mismatch, expected: {(len(inst.regaccs))}, got: {len(outs)}" + for r,o in zip(inst.regaccs, outs): + env.mset(pid, r, o, ctx=ctx) + + case AleoAsync(): + # NOTE: async in Aleo is finalize in Leo + assert inst.callee == fid, \ + f"Async id doesn't match function id, expected: {fid}, got: {inst.callee}" # collect parameters - params = [ pget(mem, pid, env, v) for v in vs ] + params = [ env.mget(pid, p, ctx=ctx) for p in inst.operands ] + # locate function + (_pid, _fid) = env.resolve_function(pid, inst.callee) # dispatch - outs = visitor(pid, f["finalize_logic"], params) - assert len(outs) == 1, f"Finalize must only return one single status, got: {len(outs)}" - # load outputs back to env - pset(mem, pid, env, r0, outs[0]) - - case ["set", v, "into", r]: + outs = visitor(_pid, _fid, params, finalize=True) + # update ctx + assert len(outs) == 1, \ + f"Lengths of return mismatch, expected: 1, got: {len(outs)}" + env.mset(pid, inst.regacc, outs[0], ctx=ctx) + + case AleoSet(): + _src = a(env.mget(pid, inst.src, ctx=ctx)) + # collect all possible values of mapping + _map = env.mget(pid, inst.id, ctx=None) # mapping, don't abstract + _vv = set([p.value for p in _map.values()]) | _src.value # merge existing + _ss = AleoAbstractLiteral(_vv, AleoAbstractType()) + # set mapping as defaultdict + env.mset(pid, inst.id, defaultdict(lambda: _ss), ctx=None) + + case AleoCast(): + avs = [ a(env.mget(pid, p, ctx=ctx)) for p in inst.operands ] + ao = None + # NOTE: dest is about type, not register, not value, just type + match inst.dest: + # identifier with modifier + case AleoIdentifier() | AleoLocator(): + # determine internal or external program id and id + _pid = pid if type(inst.dest) is AleoIdentifier else inst.dest.pid + _id = inst.dest if type(inst.dest) is AleoIdentifier else inst.dest.id + _pr = env.programs[_pid] + # NOTE: for locator, its current visibility overrrides + # the visibility of the location it refers to + if _id.visibility == AleoModifier.RECORD: + # record type specified + ao = _pr.records[_id].instantiate(avs) + elif _id.visibility == AleoModifier.DEFAULT: + # regular typing, first try struct, then record + if _id in _pr.structs.keys(): + ao = _pr.structs[_id].instantiate(avs) + elif _id in pr.records.keys(): + ao = _pr.records[_id].instantiate(avs) + else: + raise KeyError(f"Can't find struct/record, got: {inst.dest.id}") + else: + raise NotImplementedError(f"Unsupported identifier modifier in cast destination, got: {inst.dest}") + case AleoArrayType(): + assert len(inst.dest.dim) == 1, f"Only 1d array as cast destination is supported, got: {inst.dest.dim}" + assert len(avs) == inst.dest.dim[0], f"Array lengths mismatch, expected: {inst.dest.dim}, got: {len(avs)}" + ao = avs + case AleoLiteralType(): + # NOTE: this is actually value casting, not value packing as in other cases + # FIXME: add actual casting + assert len(avs) == 1, f"When casting to literal type, only one value is allowed, got: {avs}" + ao = avs[0] + case _: + raise NotImplementedError(f"Unsupported cast destination, got: {inst.dest}") # set - pset(mem, pid, env, v, r) + env.mset(pid, inst.regacc, ao, ctx=ctx) + case AleoRandom(): + # over-approximate + ao = AleoAbstractLiteral(AbsDom.ALLINT(), AleoAbstractType()) + env.mset(pid, inst.regacc, ao, ctx=ctx) + case _: - raise NotImplementedError(f"Unsupported instruction: {inst['str']}") + raise NotImplementedError(f"Unsupported instruction, got: {inst}") - # get returning registers and return - if f["type"] == "FunctionCore" or f["type"] == "ClosureCore": - # outs = [ - # env[f"r{p['operand']['value']['value']}"] - # for p in f["outputs"] - # ] - outs = [] - for p in f["outputs"]: - match p["operand"]["value"]["type"]: - case "Register": - outs.append(pget(mem, pid, env, f"r{p["operand"]["value"]["value"]}")) - case "Literal": - if p["operand"]["value"]["value"]["type"] == "Integer": - outs.append(int(p["operand"]["value"]["value"]["integer"])) - else: - raise NotImplementedError(f"Unsupported return literal type, got: {p["operand"]["value"]["value"]["type"]}") - case _: - raise NotImplementedError(f"Unsupported return type, got: {p["operand"]["value"]["type"]}") - return outs - elif f["type"] == "FinalizeCore": - # return all bool for safe - return [Val.ALLBOOL] + if isinstance(fn, AleoFinalize): + # finalize: no output, return all bool for safe + return [AleoAbstractLiteral(AbsDom.ALLBOOL(), AleoAbstractType())] else: - raise NotImplementedError(f"Unsupported visitor node type, got: {f["type"]}") - - # initialize program-wise structures: mapping - mem[prog.id] = { mvar: {} for mvar in prog.mappings.keys() } - - # call visitor - visitor( - prog.id, - prog.functions[func], - [ - Val.ALLINT # FIXME: determine values by type - for i in range(len(prog.functions[func]["inputs"])) - ] - ) - + # closure/function: return + return [ a(env.mget(pid, k, ctx=ctx)) for k,v in fn.outputs ] + + # FIXME: construct params according to types (could also be struct/record/mapping/etc.) + params = [ + AleoAbstractLiteral(AbsDom.TOP(), AleoAbstractType()) + for _ in range(len(func.inputs)) + ] + visitor(pid, fid, params) return (len(lines)>0, lines) \ No newline at end of file diff --git a/vanguard/aleo/detectors/infoleak.py b/vanguard/aleo/detectors/infoleak.py index 94a0905..b441731 100644 --- a/vanguard/aleo/detectors/infoleak.py +++ b/vanguard/aleo/detectors/infoleak.py @@ -1,31 +1,31 @@ import networkx as nx -from ..common import get_ifg_edges, trim_inst - -def detector_infoleak(prog, func): - """Detect for information leak - Args: - - prog: - - func: - Rets: (result, info) - """ - - edges = get_ifg_edges(prog, func, hash=False, call=True, inline=False) - # add special edge to account for direct return of input signal - for inst in prog.functions[func]["outputs"]: - tokens = trim_inst(inst["str"]).split() - match tokens: - case ["output", o, "as", t]: - edges.append((o,o)) - - prv_inps = prog.get_function_arguments(func, "private", "inputs") - pub_outs = prog.get_function_arguments(func, "public", "outputs") +from ..grammar import * +from ..graphs import get_dfg_edges + +def detector_infoleak(env: AleoEnvironment, pid: str, fid: str, readable=False): + # initialize + prog: AleoProgram = env.programs[pid] + func: AleoFunction = prog.functions[fid] + + edges = get_dfg_edges(env, pid, fid, hash=False) + # special edge a -> a so that direct returning of a variable is accounted + for k,v in func.inputs: + edges.append((k, k)) + + # DEBUG + # for p in edges: + # print(f"{p[0]} -> {p[1]}") + + prv_inps = [k for k,v in func.inputs if v.visibility in {AleoModifier.PRIVATE, AleoModifier.DEFAULT}] + pub_outs = [k for k,v in func.outputs if v.visibility==AleoModifier.PUBLIC] G = nx.DiGraph() G.add_edges_from(edges) paths = [] for sig_in in prv_inps: + # print(f"# [debug] sig_in: {sig_in}") if not G.has_node(sig_in): # signal is not in graph, meaning it's not used # since it's not used, it's not leaked @@ -33,7 +33,15 @@ def detector_infoleak(prog, func): continue for sig_out in pub_outs: + if not G.has_node(sig_out): + # output signal is not in graph, meaning it's not used + # meaning there's no leakage via this signal + continue + if nx.has_path(G, sig_in, sig_out): - paths.append((sig_in, sig_out)) - + if readable: + paths.append((f"{sig_in}", f"{sig_out}")) + else: + paths.append((sig_in, sig_out)) + return (len(paths)>0, paths) \ No newline at end of file diff --git a/vanguard/aleo/detectors/rtcnst.py b/vanguard/aleo/detectors/rtcnst.py index 6099662..6fe55b1 100644 --- a/vanguard/aleo/detectors/rtcnst.py +++ b/vanguard/aleo/detectors/rtcnst.py @@ -1,27 +1,17 @@ -import networkx as nx - -from ..grammar import AleoProgram - -def detector_rtcnst(prog: AleoProgram, func: str): - """Detect for returning of constant - Args: - - prog (AleoProgram): - - func (str): - Rets: (result, info) - """ +from ..grammar import * +from ..graphs import get_dfg_edges +def detector_rtcnst(env: AleoEnvironment, pid: str, fid: str, readable=False): + # initialize + prog: AleoProgram = env.programs[pid] + func: AleoFunction = prog.functions[fid] + cnsts = [] - # process output instructions - for inst in prog.functions[func]["outputs"]: - tokens = inst["str"].strip(";").split() - match tokens: + for k,v in func.outputs: + if isinstance(k, AleoLiteral): + if readable: + cnsts.append(f"{k}") + else: + cnsts.append(k) - case ["output", val, "as", typ] if not val.startswith("r"): - cnsts.append(val) - - case _: - # fine for other cases - pass - - return (len(cnsts)>0, cnsts) - \ No newline at end of file + return (len(cnsts)>0, cnsts) \ No newline at end of file diff --git a/vanguard/aleo/detectors/unused.py b/vanguard/aleo/detectors/unused.py index 6a5767e..f3ffb22 100644 --- a/vanguard/aleo/detectors/unused.py +++ b/vanguard/aleo/detectors/unused.py @@ -1,48 +1,46 @@ import networkx as nx -from ..grammar import AleoProgram -from ..common import get_dfg_edges - -def detector_unused(prog: AleoProgram, func: str): - """Detect for unused variable - Args: - - prog (AleoProgram): - - func (str): - Rets: (result, info) - """ - - edges = get_dfg_edges(prog, func) - # add special edge to account for direct return of input signal - for inst in prog.functions[func]["outputs"]: - tokens = inst["str"].strip(";").split() - match tokens: - case ["output", o, "as", t]: - edges.append((o,o)) - - prv_inps = prog.get_function_arguments(func, "private", "inputs") - pub_inps = prog.get_function_arguments(func, "public", "inputs") - prv_outs = prog.get_function_arguments(func, "private", "outputs") - pub_outs = prog.get_function_arguments(func, "public", "outputs") +from ..grammar import * +from ..graphs import get_dfg_edges + +def detector_unused(env: AleoEnvironment, pid: str, fid: str, readable=False): + # initialize + prog: AleoProgram = env.programs[pid] + func: AleoFunction = prog.functions[fid] + + edges = get_dfg_edges(env, pid, fid) + + # DEBUG + # for p in edges: + # print(f"{p[0]} -> {p[1]}") + + inps = [k for k,v in func.inputs] + outs = [k for k,v in func.outputs] G = nx.DiGraph() G.add_edges_from(edges) vars = [] - for sig_in in prv_inps+pub_inps: - + for sig_in in inps: + # print(f"# [debug] sig_in: {sig_in}") if not G.has_node(sig_in): # signal is not in graph, meaning it's not used - vars.append(sig_in) + if readable: + vars.append(f"{sig_in}") + else: + vars.append(sig_in) continue - - is_used = False - for sig_out in prv_outs+pub_outs: + used = False + for sig_out in outs: if nx.has_path(G, sig_in, sig_out): - is_used = True + used = True break - if not is_used: - vars.append(sig_in) - + if not used: + if readable: + vars.append(f"{sig_in}") + else: + vars.append(sig_in) + return (len(vars)>0, vars) \ No newline at end of file diff --git a/vanguard/aleo/grammar.py b/vanguard/aleo/grammar.py deleted file mode 100644 index e62772f..0000000 --- a/vanguard/aleo/grammar.py +++ /dev/null @@ -1,235 +0,0 @@ -from .common import assert_range, trim_inst - -class AleoProgram: - """A virtual machine that prepare Aleo program for future use and provides common functionalities - """ - - def __init__(self, json=None): - self.json = json - - # simplified json and functions to execute - self.sjson = None - - # program storage - self.initialized = False - self.id = None - self.network = None - self.identifiers = {} # id (str) -> type (str) - self.imports = {} - self.mappings = {} - self.structs = {} - self.records = {} - self.closures = {} - self.functions = {} - - if self.json is not None: - # load and initialize program - self.sjson = self.simplify_json(self.json, self.simplification_functions_1st) # 1st pass - self.sjson = self.simplify_json(self.sjson, self.simplification_functions_2nd) # 2nd pass - self.load_program(self.sjson) - - def assert_node_field(self, node, field, val=None): - assert field in node.keys(), f"Can't find filed {field} in node" - if val is not None: - assert node[field] == val, f"Mismatch of {field} of node, expected: {val}, got: {node[field]}" - - def assert_range(self, value, range): - assert value in range, f"Value {value} is not in range {range}" - - def simplify_json(self, node, func): - """Generate a simplified version of json for vm program loading via post-order traversal - Args: - - node: node to process - Rets: copy of modified node - """ - new_node = None - # post-order traversal - if isinstance(node, list): - new_node = [self.simplify_json(v, func) for v in node] - elif isinstance(node, dict): - new_node = { - k: self.simplify_json(v, func) - for k,v in node.items() - } - else: - new_node = node - # process self - return func(new_node) - - def simplification_functions_1st(self, node): - match node: - # simplify ProgramID - case { - "type": "ProgramCore", - "id": { - "type": "ProgramID", - "name": name, - "network": network, - }, - **rest, - }: - return { - "id": name, - "network": network, - **rest, - } - - # simplify ProgramDefinition - case { - "type": "ProgramDefinition", - "definition": type, - }: - return type - - # simplify ProgramID in imports - case { - "type": "Import", - "program_id": { - "type": "ProgramID", - "name": name, - "network": network, - } - }: - return { - "id": name, - "network": network, - } - - # simplify type name: Literal - case { - "type": "PlaintextType", - "vtype": "Literal", - "value": { - "type": "LiteralType", - "name": type, - } - }: - return type - - # simplify type name: Struct - case { - "type": "PlaintextType", - "vtype": "Struct", - "value": type, - }: - return type - - # default: no simplification - case _: - return node - - def simplification_functions_2nd(self, node): - match node: - # simplify mapping - case { - "type": "Mapping", - "name": name, - "key": {"type": "MapKey", "plaintext_type": kid}, - "value": {"type": "MapValue", "visibility": visibility, "plaintext_type": vid}, - }: - return { - "key": kid, - "value": vid, - "visibility": visibility, - } - - # simplify struct - case { - "type": "StructType", - "members": {**ms}, - **rest, - }: - return { - "members": {**ms} - } - - # simplify record - case { - "type": "RecordType", - "owner": owner, - "entries": entries, - **rest, - }: - return { - "owner": owner, - "entries": entries, - } - - # rename finalize `commands` to `instructions` - case { - "type": "FinalizeCore", - "commands": entries, - **rest, - }: - return { - "type": "FinalizeCore", - # directly extract the instruction part - "instructions": [ {**e["value"], **{"str":e["str"]}} for e in entries ], - **rest, - } - - # default: no simplification - case _: - return node - - def load_program(self, node): - """Load program from simplified json - Args: - - node: simplified json - """ - self.id = node["id"] - self.network = node["network"] - self.identifiers = node["identifiers"] - self.imports = node["imports"] - self.mappings = node["mappings"] - self.structs = node["structs"] - self.records = node["records"] - self.closures = node["closures"] - self.functions = node["functions"] - - self.initialized = True - - def get_function_arguments(self, func, vis, arg): - """Return a list of private/public inputs/outputs of a given function - Args: - - func: target function to analyze - - vis: private or public - - arg: input or output - """ - assert_range(func, self.functions.keys()) - assert_range(arg, set(["inputs", "outputs"])) - argkw = arg[:-1] # input/output - assert_range(vis, set(["private", "public"])) - - node = self.functions[func] - vars = [] - for inst in node[arg]: - tokens = trim_inst(inst["str"]).split() - match tokens: - - # visibility and status postfix - case [kw, r, "as", t] if kw == argkw and (t.endswith(".public") or t.endswith(".private") or t.endswith(".future")): - if t.endswith(f".{vis}"): - vars.append(r) - # for cases that end with ".future", it's used as execution status of the "finalize" function - # and this doesn't count as a regular output that can be queried in this function - - # record type - case [kw, r, "as", t] if kw == argkw: - if "/" in t: - # external type - # FIXME: ignored for now - pass - else: - ts = t.split(".") - if len(ts) == 2: - if self.records[ts[0]]["owner"] == vis: - vars.append(r) - else: - raise NotImplementedError(f"Unknown type, got: {t}") - - # others - case _: - raise NotImplementedError(f"Unknown input/output pattern, got: {inst['str']}") - - return vars \ No newline at end of file diff --git a/vanguard/aleo/grammar/__init__.py b/vanguard/aleo/grammar/__init__.py new file mode 100644 index 0000000..aa5599e --- /dev/null +++ b/vanguard/aleo/grammar/__init__.py @@ -0,0 +1,5 @@ +from .blocks import * +from .instructions import * +from .literals import * +from .types import * +from .misc import * \ No newline at end of file diff --git a/vanguard/aleo/grammar/blocks.py b/vanguard/aleo/grammar/blocks.py new file mode 100644 index 0000000..c144825 --- /dev/null +++ b/vanguard/aleo/grammar/blocks.py @@ -0,0 +1,457 @@ +from typing import Any, Union +from pathlib import Path + +from ..common import aleo2json + +from .instructions import * +from .literals import * +from .types import * +from .misc import * + +class AleoEnvironment(AleoNode): + def __init__(self, build_path, main_file: str="main.aleo"): + self.programs: dict[str, AleoProgram] = {} + self.main = None + self.load(build_path, main_file=main_file) + + # load the entire project + def load(self, build_path: Union[str, Path], main_file: str="main.aleo"): + path = build_path if isinstance(build_path, Path) else Path(build_path) + # look for main.aleo and deploy + # print(f"# [debug] deploy: {main_file}") + main_path = path / main_file + main_json = aleo2json(main_path) + self.main = self.deploy(main_json) + # look for imports and deploy + imports_path = path / "imports" + for fp_path in list(imports_path.glob("*.aleo")): + print(f"# [debug] deploy: {fp_path.name}") + fp_json = aleo2json(fp_path) + self.deploy(fp_json) + + # deploy a single Aleo program + def deploy(self, node: list) -> str: + assert node[0] == "start", f"Unsupported source of start, got: {node}" + p = AleoProgram.from_json(node[1]) + self.programs[p.id] = p + return p + + def resolve_function(self, pid, callee): + _pid = None + _fid = None + match callee: + case AleoIdentifier(): + _pid = pid + _fid = callee + case AleoLocator(): + _pid = callee.pid + _fid = callee.id + case _: + raise NotImplementedError(f"Unsupported callee, got: {callee}") + assert _pid in self.programs.keys(), f"Cannot locate program, got: {_pid}" + if _fid in self.programs[_pid].functions.keys() or _fid in self.programs[_pid].closures.keys(): + return (_pid, _fid) + else: + raise NotImplementedError(f"Cannot locate function/closure, got: {_fid}") + + def mget(self, pid: str, id: Union[AleoRegister, AleoRegisterAccess], ctx: dict=None): + match id: + + case AleoRegister() | AleoIdentifier(): + # flat + if ctx is None or id not in ctx.keys(): + return self.programs[pid].mem[id] + else: + return ctx[id] + + case AleoRegisterAccess(): + # potentially nested + # determine the base + base = None + if ctx is None or id.reg not in ctx.keys(): + # NOTE: check first layer, if not matched, proceed at ctx + base = self.programs[pid].mem[id.reg] + else: + base = ctx[id.reg] + # walk down the path + for p in id.accs: + match p: + case AleoAccessByField(): + base = base[f"{p.field}"] + case AleoAccessByIndex(): + base = base[p.index.value] + case _: + raise NotImplementedError(f"Unsupported accessor, got: {p}") + return base + + # if literal, directly resolve + case AleoLiteral(): + return id + + case _: + raise NotImplementedError(f"Unsupported type of id, got: {id} of type {type(id)}") + + + def mset(self, pid: str, id: Union[AleoRegister, AleoRegisterAccess], val: AleoLiteral, ctx: dict=None): + match id: + + case AleoRegister() | AleoIdentifier(): + # flat + if ctx is None or id not in ctx.keys(): + self.programs[pid].mem[id] = val + else: + ctx[id] = val + + case AleoRegisterAccess() if len(id.accs) == 0: + # no accessor, same as single register + if ctx is None or id not in ctx.keys(): + self.programs[pid].mem[id.reg] = val + else: + ctx[id.reg] = val + + case AleoRegisterAccess(): + # potentially nested + # determine the last but one base + lbobase = None + if ctx is None or id.reg not in ctx.keys(): + # NOTE: check first layer, if not matched, proceed at ctx + lbobase = self.programs[pid].mem[id.reg] + else: + lbobase = ctx[id.reg] + # walk down the path, with the last one left + for p in id.accs[:-1]: + match p: + case AleoAccessByField(): + lbobase = lbobase[f"{p.field}"] + case AleoAccessByIndex(): + lbobase = lbobase[p.index.value] + case _: + raise NotImplementedError(f"Unsupported accessor, got: {p}") + # set the last + lbobase[id.accs[-1]] = val + + case _: + raise NotImplementedError(f"Unsupported type of id, got: {id}") + +class AleoProgram(AleoNode): + """A virtual machine that prepare Aleo program for future use and provides common functionalities + """ + @staticmethod + def from_json(node): + _id = None + _imports = {} + _structs = {} + _records = {} + _mappings = {} + _functions = {} + _closures = {} + for p in node: + match p: + case "program" | ";": + pass + case ["program_id", *_]: + tmp0 = AleoProgramId.from_json(p) + _id = tmp0 + case ["ximport", *_]: + tmp0 = AleoImport.from_json(p) + _imports[tmp0.id] = tmp0 + case ["struct", *_]: + tmp0 = AleoStruct.from_json(p) + _structs[tmp0.id] = tmp0 + case ["record", *_]: + tmp0 = AleoRecord.from_json(p) + _records[tmp0.id] = tmp0 + case ["mapping", *_]: + tmp0 = AleoMapping.from_json(p) + _mappings[tmp0.id] = tmp0 + case ["function", *_]: + tmp0 = AleoFunction.from_json(p) + _functions[tmp0.id] = tmp0 + case ["closure", *_]: + tmp0 = AleoClosure.from_json(p) + _closures[tmp0.id] = tmp0 + case _: + raise NotImplementedError(f"Unsupported json component, got: {p}") + return AleoProgram(_id, _imports, _structs, _records, _mappings, _functions, _closures) + + def __init__(self, id, imports, structs, records, mappings, functions, closures, **kwargs): + super().__init__(**kwargs) + self.id = id + self.imports = imports + self.structs = structs + self.records = records + self.mappings = mappings + self.functions = functions + self.closures = closures + + # initialize memory + self.reset_memory() + # initialize mapping + for key in self.mappings.keys(): + self.mem[key] = {} + + def reset_memory(self): + self.mem = {} + + def __str__(self): + _imports = "\n".join([str(p) for p in self.imports.values()]) + _id = f"program {self.id};" + _structs = "\n\n".join([str(p) for p in self.structs.values()]) + _records = "\n\n".join([str(p) for p in self.records.values()]) + _mappings = "\n\n".join([str(p) for p in self.mappings.values()]) + _closures = "\n\n".join([str(p) for p in self.closures.values()]) + _functions = "\n\n".join([str(p) for p in self.functions.values()]) + _components = "\n\n".join(filter(None, [_imports, _id, _structs, _records, _mappings, _closures, _functions])) + return f"{_components}" + +class AleoImport(AleoNode): + @staticmethod + def from_json(node): + for p in node: + match p: + case "ximport" | "import" | ";": + pass + case ["program_id", *_]: + _id = AleoProgramId.from_json(p) + return AleoImport(_id) + case _: + raise NotImplementedError(f"Unsupported json component of import, got: {p}") + + def __init__(self, id, **kwargs): + super().__init__(**kwargs) + self.id = id + + def __str__(self): + return f"import {self.id};" + +class AleoStruct(AleoNode): + + @staticmethod + def from_json(node): + match node: + case ["struct", "struct", id, ":", *tuples]: + _id = AleoIdentifier.from_json(id) + _fields = {} + for p in tuples: + assert p[0] == "tuple", f"Unsupported struct member, got: {p}" + match p: + case ["tuple", name, "as", type, ";"]: + n = AleoIdentifier.from_json(name) + t = AleoPlaintextType.from_json(type) + _fields[n] = t + case _: + raise NotImplementedError(f"Unsupported json component of tuple, got: {p}") + return AleoStruct(_id, _fields) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, id, fields, **kwargs): + super().__init__(**kwargs) + self.id = id + self.fields = fields + + def __str__(self): + _iden = " "*self.iden + _id = f"struct {self.id}:" + _fields = "\n".join([f"{_iden}{k} as {v};" for k,v in self.fields.items()]) + return f"{_id}\n{_fields}" + + def instantiate(self, params: list): + _keys = list(self.fields.keys()) + return { _keys[i] : params[i] for i in range(len(_keys)) } + +class AleoMapping(AleoNode): + + @staticmethod + def from_json(node): + match node: + case ["mapping", "mapping", id, ":", key, val]: + _id = AleoIdentifier.from_json(id) + assert key[0] == "mapping_key" and key[3][0] == "mapping_type", f"Unsupported mapping key, got: {key}" + assert val[0] == "mapping_value" and val[3][0] == "mapping_type", f"Unsupported mapping value, got: {val}" + _ktype = AleoPlaintextType.from_json(key[3][1]) + _ktype.visibility = AleoModifier.from_json(key[3][2]) + _vtype = AleoPlaintextType.from_json(val[3][1]) + _vtype.visibility = AleoModifier.from_json(val[3][2]) + return AleoMapping(_id, _ktype, _vtype) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, id, ktype, vtype, **kwargs): + super().__init__(**kwargs) + self.id = id + self.ktype = ktype + self.vtype = vtype + + def __str__(self): + _iden = " "*self.iden + _id = f"mapping {self.id}:" + _ktype = f"{_iden}key as {self.ktype};" + _vtype = f"{_iden}value as {self.vtype};" + return f"{_id}\n{_ktype}\n{_vtype}" + +class AleoRecord(AleoNode): + + @staticmethod + def from_json(node): + match node: + case ["record", "record", id, ":", *entries]: + _id = AleoIdentifier.from_json(id) + _fields = {} + for p in entries: + assert p[0] == "entry" and p[3][0] == "entry_type", f"Unsupported entry, got: {p}" + name = AleoIdentifier.from_json(p[1]) + type = AleoPlaintextType.from_json(p[3][1]) + vis = AleoModifier.from_json(p[3][2]) + type.visibility = vis + _fields[name] = type + return AleoRecord(_id, _fields) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, id, fields, **kwargs): + super().__init__(**kwargs) + self.id = id + self.fields = fields + + def __str__(self): + _iden = " "*self.iden + _id = f"record {self.id}:" + _fields = "\n".join([f"{_iden}{k} as {v};" for k,v in self.fields.items()]) + return f"{_id}\n{_fields}" + + def instantiate(self, params: list): + _keys = list(self.fields.keys()) + return { _keys[i] : params[i] for i in range(len(_keys)) } + +class AleoFunction(AleoNode): + + @staticmethod + def from_json(node): + match node: + case ["function", "function", id, ":", *vs]: + # vs: input/output/instruction/finalize + _id = AleoIdentifier.from_json(id) + _instructions = [] + _inputs = [] + _outputs = [] + _finalize = None + for p in vs: + match p: + case ["instruction", *_]: + _instructions.append(AleoInstruction.from_json(p)) + case ["function_output", "output", operand, "as", vtype, ";"]: + key = AleoOperand.from_json(operand) + val = AleoValueType.from_json(vtype) + _outputs.append((key, val)) + case ["function_input", "input", reg, "as", vtype, ";"]: + key = AleoRegister.from_json(reg) + val = AleoValueType.from_json(vtype) + _inputs.append((key, val)) + case ["finalize", *_]: + _finalize = AleoFinalize.from_json(p) + case _: + raise NotImplementedError(f"Unsupported function component, got: {p}") + return AleoFunction(_id, _instructions, _inputs, _outputs, _finalize) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, id, instructions, inputs, outputs, finalize, **kwargs): + super().__init__(**kwargs) + self.id = id + self.instructions = instructions + self.inputs = inputs + self.outputs = outputs + self.finalize = finalize + + def __str__(self): + _iden = " "*self.iden + _id = f"function {self.id}:" + _inputs = "\n".join([f"{_iden}input {p[0]} as {p[1]};" for p in self.inputs]) + _outputs = "\n".join([f"{_iden}output {p[0]} as {p[1]};" for p in self.outputs]) + _instructions = "\n".join([f"{_iden}{p}" for p in self.instructions]) + _components = "\n".join(filter(None, [_id, _inputs, _instructions, _outputs])) + return f"{_components}" + +class AleoFinalize(AleoNode): + + @staticmethod + def from_json(node): + match node: + case ["finalize", "finalize", id, ":", *vs]: + # vs: input/instruction(command) + _id = AleoIdentifier.from_json(id) + _instructions = [] + _inputs = [] + for p in vs: + match p: + case ["command", *vs]: + _instructions.append(AleoCommand.from_json(p)) + case ["finalize_input", "input", reg, "as", ftype, ";"]: + key = AleoRegister.from_json(reg) + val = AleoFinalizeType.from_json(ftype) + _inputs.append((key, val)) + case _: + raise NotImplementedError(f"Unsupported finalize component, got: {p}") + return AleoFinalize(_id, _instructions, _inputs) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, id, instructions, inputs, **kwargs): + super().__init__(**kwargs) + self.id = id + self.instructions = instructions + self.inputs = inputs + + def __str__(self): + _iden = " "*self.iden + _id = f"finalize {self.id}:" + _inputs = "\n".join([f"{_iden}input {p[0]} as {p[1]};" for p in self.inputs]) + _instructions = "\n".join([f"{_iden}{p}" for p in self.instructions]) + _components = "\n".join(filter(None, [_id, _inputs, _instructions])) + return f"{_components}" + +class AleoClosure(AleoNode): + + @staticmethod + def from_json(node): + match node: + case ["closure", "closure", id, ":", *vs]: + # vs: input/output/instruction + _id = AleoIdentifier.from_json(id) + _instructions = [] + _inputs = [] + _outputs = [] + for p in vs: + match p: + case ["instruction", *_]: + _instructions.append(AleoInstruction.from_json(p)) + case ["closure_input", "input", reg, "as", rtype, ";"]: + key = AleoRegister.from_json(reg) + val = AleoRegisterType.from_json(rtype) + _inputs.append((key, val)) + case ["closure_output", "output", operand, "as", rtype, ";"]: + key = AleoOperand.from_json(operand) + val = AleoRegisterType.from_json(rtype) + _outputs.append((key, val)) + case _: + raise NotImplementedError(f"Unsupported closure component, got: {p}") + return AleoClosure(_id, _instructions, _inputs, _outputs) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, id, instructions, inputs, outputs, **kwargs): + super().__init__(**kwargs) + self.id = id + self.instructions = instructions + self.inputs = inputs + self.outputs = outputs + + def __str__(self): + _iden = " "*self.iden + _id = f"closure {self.id}:" + _inputs = "\n".join([f"{_iden}input {p[0]} as {p[1]};" for p in self.inputs]) + _outputs = "\n".join([f"{_iden}output {p[0]} as {p[1]};" for p in self.outputs]) + _instructions = "\n".join([f"{_iden}{p}" for p in self.instructions]) + _components = "\n".join(filter(None, [_id, _inputs, _outputs, _instructions])) + return f"{_components}" \ No newline at end of file diff --git a/vanguard/aleo/grammar/instructions.py b/vanguard/aleo/grammar/instructions.py new file mode 100644 index 0000000..6575328 --- /dev/null +++ b/vanguard/aleo/grammar/instructions.py @@ -0,0 +1,382 @@ +from typing import Any, Union + +from .misc import * +from .types import * + +class AleoCommand(AleoNode): + + @staticmethod + def from_json(node): + match node: + case ["command", ["instruction", *_]]: + return AleoInstruction.from_json(node[1]) + case ["command", ["set", *_]]: + return AleoSet.from_json(node[1]) + case ["command", ["random", *_]]: + return AleoRandom.from_json(node[1]) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + assert type(self) is not AleoCommand, "This class cannot be directly instantiated" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() + + +class AleoSet(AleoCommand): + + @staticmethod + def from_json(node): + match node: + case ["set", "set", operand0, "into", id, "[", operand1, "]", ";"]: + _src = AleoOperand.from_json(operand0) + _id = AleoIdentifier.from_json(id) + _tgt = AleoOperand.from_json(operand1) + return AleoSet(_src, _id, _tgt) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, src, id, tgt, **kwargs): + super().__init__(**kwargs) + self.src = src + self.id = id + self.tgt = tgt + + def __str__(self): + return f"set {self.src} into {self.id}[{self.tgt}];" + +class AleoRandom(AleoCommand): + + @staticmethod + def from_json(node): + match node: + case ["random", "rand.chacha", *operands, "into", regacc, "as", type, ";"]: + _operands = [AleoOperand.from_json(p) for p in operands] + _regacc = AleoRegisterAccess.from_json(regacc) + _type = None + match type: + case ["arithmetic_type", *_]: + _type = AleoArithmeticType.from_json(type) + case ["address_type", *_]: + _type = AleoAddressType.from_json(type) + case ["signature_type", *_]: + _type = AleoSignatureType.from_json(type) + case ["boolean_type", *_]: + _type = AleoBooleanType.from_json(type) + case _: + raise NotImplementedError(f"Unsupported type of random, got: {node}") + return AleoRandom(_operands, _regacc, _type) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, operands, regacc, type, **kwargs): + super().__init__(**kwargs) + self.operands = operands + self.regacc = regacc + self.type = type + + def __str__(self): + _operands = " ".join([str(p) for p in self.operands]) + return f"random.chacha {_operands} into {self.regacc} as {self.type};" + +class AleoInstruction(AleoCommand): + + @staticmethod + def from_json(inst): + match inst: + case ["instruction", ["cast", *_]] | ["instruction", ["cast.lossy", *_]]: + return AleoCast.from_json(inst[1]) + case ["instruction", ["unary", *_]]: + return AleoUnary.from_json(inst[1]) + case ["instruction", ["binary", *_]]: + return AleoBinary.from_json(inst[1]) + case ["instruction", ["is", *_]]: + return AleoIs.from_json(inst[1]) + case ["instruction", ["assert", *_]]: + return AleoAssert.from_json(inst[1]) + case ["instruction", ["call", *_]]: + return AleoCall.from_json(inst[1]) + case ["instruction", ["xasync", *_]]: + return AleoAsync.from_json(inst[1]) + case ["instruction", ["ternary", *_]]: + return AleoTernary.from_json(inst[1]) + case ["instruction", ["hash", *_]]: + return AleoHash.from_json(inst[1]) + case _: + raise NotImplementedError(f"Unsupported json component, got: {inst}") + + def __init__(self, **kwargs): + assert type(self) is not AleoInstruction, "This class cannot be directly instantiated" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() + +class AleoCast(AleoInstruction): + + @staticmethod + def from_json(node): + match node: + case ["cast", op, *operands, "into", regacc, "as", dest, ";"]: + _lossy = None + assert op[0] == "cast_op", f"Unsupported cast operator, got: {node}" + if op[1] == "cast": + _lossy = False + elif op[1] == "cast.lossy": + _lossy = True + else: + raise NotImplementedError(f"Unsupported cast operator, got: {node}") + _operands = [] + for p in operands: + _operands.append(AleoOperand.from_json(p)) + _regacc = AleoRegisterAccess.from_json(regacc) + _dest = AleoCastDestination.from_json(dest) + return AleoCast(_lossy, _operands, _regacc, _dest) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, lossy, operands, regacc, dest, **kwargs): + super().__init__(**kwargs) + self.lossy = lossy + self.operands = operands + self.regacc = regacc + self.dest = dest + + def __str__(self): + _operands = " ".join([str(p) for p in self.operands]) + if self.lossy: + return f"cast.lossy {_operands} into {self.regacc} as {self.dest};" + else: + return f"cast {_operands} into {self.regacc} as {self.dest};" + +class AleoUnary(AleoInstruction): + + @staticmethod + def from_json(node): + match node: + case ["unary", op, operand, "into", regacc, ";"]: + _op = AleoUnaryOp.from_json(op) + _operand = AleoOperand.from_json(operand) + _regacc = AleoRegisterAccess.from_json(regacc) + return AleoUnary(_op, _operand, _regacc) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, op, operand, regacc, **kwargs): + self.op = op + self.operand = operand + self.regacc = regacc + + def __str__(self): + return f"{self.op} {self.operand} into {self.regacc};" + + +class AleoBinary(AleoInstruction): + + @staticmethod + def from_json(node): + match node: + case ["binary", op, *operands, "into", regacc, ";"]: + assert len(operands) == 2, f"Unsupported number of operands, expected: 2, got: {len(operands)}" + _op = AleoBinaryOp.from_json(op) + _operands = [] + for p in operands: + _operands.append(AleoOperand.from_json(p)) + _regacc = AleoRegisterAccess.from_json(regacc) + return AleoBinary(_op, _operands, _regacc) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, op, operands, regacc, **kwargs): + super().__init__(**kwargs) + self.op = op + self.operands = operands + self.regacc = regacc + + def __str__(self): + _operands = " ".join([str(p) for p in self.operands]) + return f"{self.op} {_operands} into {self.regacc};" + +class AleoTernary(AleoInstruction): + + @staticmethod + def from_json(node): + match node: + case ["ternary", "ternary", *operands, "into", regacc, ";"]: + assert len(operands) == 3, f"Unsupported number or operands, expected: 3, got: {len(operands)}" + _operands = [AleoOperand.from_json(p) for p in operands] + _regacc = AleoRegisterAccess.from_json(regacc) + return AleoTernary(_operands, _regacc) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, operands, regacc, **kwargs): + super().__init__(**kwargs) + self.operands = operands + self.regacc = regacc + + def __str__(self): + _operands = " ".join([str(p) for p in self.operands]) + return f"ternary {_operands} into {self.regacc};" + +class AleoIs(AleoInstruction): + + @staticmethod + def from_json(node): + match node: + case ["is", op, *operands, "into", regacc, ";"]: + assert len(operands) == 2, f"Unsupported number of operands, expected: 2, got: {len(operands)}" + _op = AleoIsOp.from_json(op) + _operands = [] + for p in operands: + _operands.append(AleoOperand.from_json(p)) + _regacc = AleoRegisterAccess.from_json(regacc) + return AleoIs(_op, _operands, _regacc) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, op, operands, regacc, **kwargs): + super().__init__(**kwargs) + self.op = op + self.operands = operands + self.regacc = regacc + + def __str__(self): + _operands = " ".join([str(p) for p in self.operands]) + return f"{self.op} {_operands} into {self.regacc};" + +class AleoAssert(AleoInstruction): + + @staticmethod + def from_json(node): + match node: + case ["assert", op, *operands, ";"]: + _op = AleoAssertOp.from_json(op) + _operands = [AleoOperand.from_json(p) for p in operands] + return AleoAssert(_op, _operands) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, op, operands, **kwargs): + super().__init__(**kwargs) + self.op = op + self.operands = operands + + def __str__(self): + _operands = " ".join([str(p) for p in self.operands]) + return f"{self.op} {_operands};" + +class AleoCall(AleoInstruction): + + @staticmethod + def from_json(node): + match node: + # FIXME: there's another pattern without "into", add it when necessary + case ["call", "call", *vs, ";"] if "into" in node: + # extract call components + idx_into = vs.index("into") + callee = vs[0] + operands = vs[1:idx_into] + regaccs = vs[idx_into+1:] + _callee = None + if callee[0] == "locator": + _callee = AleoLocator.from_json(callee) + elif callee[0] == "identifier": + _callee = AleoIdentifier.from_json(callee) + else: + raise NotImplementedError(f"Unsupported callee of call, got: {node}") + _operands = [AleoOperand.from_json(p) for p in operands] + _regaccs = [AleoRegisterAccess.from_json(p) for p in regaccs] + return AleoCall(_callee, _operands, _regaccs) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, callee, operands, regaccs, **kwargs): + super().__init__(**kwargs) + self.callee = callee + self.operands = operands + self.regaccs = regaccs + + def __str__(self): + _operands = " ".join([str(p) for p in self.operands]) + _regaccs = " ".join([str(p) for p in self.regaccs]) + return f"call {self.callee} {_operands} into {_regaccs};" + +class AleoAsync(AleoInstruction): + + @staticmethod + def from_json(node): + match node: + case ["xasync", "async", callee, *operands, "into", regacc, ";"]: + _callee = AleoIdentifier.from_json(callee) + _operands = [AleoOperand.from_json(p) for p in operands] + _regacc = AleoRegisterAccess.from_json(regacc) + return AleoAsync(_callee, _operands, _regacc) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, callee, operands, regacc, **kwargs): + super().__init__(**kwargs) + self.callee = callee + self.operands = operands + self.regacc = regacc + + def __str__(self): + _operands = " ".join([str(p) for p in self.operands]) + return f"async {self.callee} {_operands} into {self.regacc};" + +class AleoHash(AleoInstruction): + + @staticmethod + def from_json(node): + match node: + case ["hash", ["hash1", *_]]: + return AleoHash1.from_json(node[1]) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + assert type(self) is not AleoInstruction, "This class cannot be directly instantiated" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() + +class AleoHash1(AleoHash): + + @staticmethod + def from_json(node): + match node: + case ["hash1", op, operand, "into", regacc, "as", type, ";"]: + _op = AleoHash1Op.from_json(op) + _operand = AleoOperand.from_json(operand) + _regacc = AleoRegisterAccess.from_json(regacc) + _type = None + match type: + case ["arithmetic_type", *_]: + _type = AleoArithmeticType.from_json(type) + case ["address_type", *_]: + _type = AleoAddressType.from_json(type) + case ["signature_type", *_]: + _type = AleoSignatureType.from_json(type) + case ["array_type", *_]: + _type = AleoArrayType.from_json(type) + case ["identifier", *_]: + _type = AleoIdentifier.from_json(type) + case _: + raise NotImplementedError(f"Unsupported hash type, got: {node}") + return AleoHash1(_op, _operand, _regacc, _type) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, op, operand, regacc, type, **kwargs): + super().__init__(**kwargs) + self.op = op + self.operand = operand + self.regacc = regacc + self.type = type + + def __str__(self): + return f"{self.op} {self.operand} into {self.regacc} as {self.type}" \ No newline at end of file diff --git a/vanguard/aleo/grammar/literals.py b/vanguard/aleo/grammar/literals.py new file mode 100644 index 0000000..b4a2349 --- /dev/null +++ b/vanguard/aleo/grammar/literals.py @@ -0,0 +1,181 @@ +from typing import Any, Union + +from .misc import * + +class AleoLiteral(AleoOperand): + + @staticmethod + def from_json(node): + match node: + case ["literal", ["boolean_literal", *_]]: + return AleoBooleanLiteral.from_json(node[1]) + case ["literal", ["arithmetic_literal", *_]]: + return AleoArithmeticLiteral.from_json(node[1]) + case ["literal", ["address_literal", *_]]: + return AleoAddressLiteral.from_json(node[1]) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, value, _type, **kwargs): + assert type(self) is not AleoLiteral, "This class cannot be directly instantiated" + super().__init__(**kwargs) + self.value = value + self.type = _type + + def __str__(self): + raise TypeError + +class AleoAddressLiteral(AleoLiteral): + + @staticmethod + def from_json(node): + match node: + case ["address_literal", addr]: + from .types import AleoAddressType + assert addr.startswith("aleo1"), f"Address prefixes mismatch, expected: aleo1, got: {addr}" + return AleoAddressLiteral(addr[5:], AleoAddressType()) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def __str__(self): + return f"{self.type}{self.value}" + +class AleoArithmeticLiteral(AleoLiteral): + + @staticmethod + def from_json(node): + match node: + case ["arithmetic_literal", ["integer_literal", *_]]: + return AleoIntegerLiteral.from_json(node[1]) + case ["arithmetic_literal", ["field_literal", *_]]: + return AleoFieldLiteral.from_json(node[1]) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, *args, **kwargs): + assert type(self) is not AleoArithmeticLiteral, "This class cannot be directly instantiated" + super().__init__(*args, **kwargs) + + def __str__(self): + raise TypeError() + +class AleoBooleanLiteral(AleoLiteral): + + @staticmethod + def from_json(node): + match node: + case ["boolean_literal", b]: + from .types import AleoBooleanType + if b == "true": + return AleoBooleanLiteral(True, AleoBooleanType()) + elif b == "false": + return AleoBooleanLiteral(False, AleoBooleanType()) + else: + raise NotImplementedError(f"Unsupported boolean lteral, got: {node}") + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def __str__(self): + return "true" if self.value else "false" + +class AleoIntegerLiteral(AleoArithmeticLiteral): + + @staticmethod + def from_json(node): + match node: + case ["integer_literal", ["unsigned_literal", *_]]: + return AleoUnsignedLiteral.from_json(node[1]) + case ["integer_literal", ["signed_literal", *_]]: + return AleoSignedLiteral.from_json(node[1]) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, *args, **kwargs): + assert type(self) is not AleoIntegerLiteral, "This class cannot be directly instantiated" + super().__init__(*args, **kwargs) + + def __str__(self): + raise TypeError() + +class AleoFieldLiteral(AleoArithmeticLiteral): + + @staticmethod + def from_json(node): + match node: + case ["field_literal", *digits, type]: + from .types import AleoFieldType + v = int("".join(digits)) + _type =AleoFieldType.from_json(type) + return AleoFieldLiteral(v, _type) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def __str__(self): + return f"{self.value}{self.type}" + +class AleoSignedLiteral(AleoIntegerLiteral): + + @staticmethod + def from_json(node): + match node: + case ["signed_literal", *digits, type]: + from .types import AleoSignedType + v = int("".join(digits)) + _type = AleoSignedType.from_json(type) + return AleoSignedLiteral(v, _type) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def __str__(self): + return f"{self.value}{self.type}" + +class AleoUnsignedLiteral(AleoIntegerLiteral): + + @staticmethod + def from_json(node): + match node: + case ["unsigned_literal", *digits, type]: + from .types import AleoUnsignedType + v = int("".join(digits)) + _type = AleoUnsignedType.from_json(type) + return AleoUnsignedLiteral(v, _type) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def __str__(self): + return f"{self.value}{self.type}" + +class AleoU32Literal: + """Special literal only for representing array, but this will instantiated to unsigned literal""" + + @staticmethod + def from_json(node): + match node: + case ["u32_literal", *digits, "u32"]: + from .types import AleoU32Type + v = int("".join(digits)) + return AleoUnsignedLiteral(v, AleoU32Type()) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + assert type(self) is not AleoU32Literal, "This terminal can't be directly initialized" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() \ No newline at end of file diff --git a/vanguard/aleo/grammar/misc.py b/vanguard/aleo/grammar/misc.py new file mode 100644 index 0000000..37da815 --- /dev/null +++ b/vanguard/aleo/grammar/misc.py @@ -0,0 +1,518 @@ +from typing import Any, Union +from enum import Enum + +# primitive type of all Aleo components +class AleoNode: + # FIXME: prevent direct initialization that is compatible with Enum child class + # NOTE: need both args and kwargs as child class also inherits Enum + def __init__(self, *args, **kwargs): + self.iden = 4 # indentation for str function + +class AleoProgramId(AleoNode): + + @staticmethod + def from_json(node): + match node: + case ["program_id", name, ".", domain]: + assert name[0] == "program_name", f"Unsupported program name, got: {name}" + assert domain[0] == "program_domain", f"Unsupported program domain, got: {domain}" + _name = AleoIdentifier.from_json(name[1]) + _domain = AleoIdentifier.from_json(domain[1]) + return AleoProgramId(_name, _domain) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, name, domain, **kwargs): + super().__init__(**kwargs) + self.name = name + self.domain = domain + + def __str__(self): + return f"{self.name}.{self.domain}" + + def __hash__(self): + return hash(self.__str__()) + + # NOTE: program id behaves like string but keeps its type + def __eq__(self, other): + if type(self) is type(other) or isinstance(other, str): + return str(self) == str(other) + else: + return False + +class AleoModifier(AleoNode, Enum): + + DEFAULT = -1 + PRIVATE = 0 + PUBLIC = 1 + CONSTANT = 2 + RECORD = 3 + FUTURE = 4 + + @staticmethod + def from_json(s): + match s: + case None: + return AleoModifier.DEFAULT + case ".private": + return AleoModifier.PRIVATE + case ".public": + return AleoModifier.PUBLIC + case ".constant": + return AleoModifier.CONSTANT + case ".record": + return AleoModifier.RECORD + case ".future": + return AleoModifier.FUTURE + case _: + raise NotImplementedError(f"Unsupported json component, got: {s}") + + def __str__(self): + match self.value: + case AleoModifier.DEFAULT.value: + return "" + case AleoModifier.PRIVATE.value: + return ".private" + case AleoModifier.PUBLIC.value: + return ".public" + case AleoModifier.CONSTANT.value: + return ".constant" + case AleoModifier.RECORD.value: + return ".record" + case AleoModifier.FUTURE.value: + return ".future" + case _: + raise NotImplementedError(f"Unsupported modifier, got: {self.value}") + +class AleoIdentifier(AleoNode): + + @staticmethod + def from_json(node): + match node: + case ["identifier", id]: + return AleoIdentifier(id) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, id, visibility=AleoModifier.DEFAULT, **kwargs): + super().__init__(**kwargs) + self.id = id + self.visibility = visibility + + def __str__(self): + return f"{self.id}{self.visibility}" + + # NOTE: when used as key, visibility does not hash + def __hash__(self): + return hash(f"{self.id}") + + # NOTE: identifier behaves like string but keeps its type + # NOTE: when used as key, visibility does not hash + def __eq__(self, other): + if type(self) is type(other): + return f"{self.id}" == f"{other.id}" + elif isinstance(other, str): + return f"{self.id}" == other + else: + return False + +class AleoRegister(AleoNode): + + @staticmethod + def from_json(node): + match node: + case ["register", id]: + return AleoRegister(int(id[1:])) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, idx, **kwargs): + super().__init__(**kwargs) + self.idx = idx + + def __str__(self): + return f"r{self.idx}" + + def __hash__(self): + return hash(self.__str__()) + + # NOTE: behaves like string but keeps its type + def __eq__(self, other): + if type(self) is type(other) or isinstance(other, str): + return str(self) == str(other) + elif isinstance(other, AleoRegisterAccess): + # NOTE: AleoRegister and AleoRegisterAccess can share key + return str(self) == str(other) + else: + return False + +class AleoRegisterAccessor(AleoNode): + + @staticmethod + def from_json(node): + match node: + case ["register_accessor", ["access_by_field", *_]]: + return AleoAccessByField.from_json(node[1]) + case ["register_accessor", ["access_by_index", *_]]: + return AleoAccessByIndex.from_json(node[1]) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + assert type(self) is not AleoRegisterAccessor, "This class cannot be directly instantiated" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() + +class AleoAccessByField(AleoRegisterAccessor): + + @staticmethod + def from_json(node): + match node: + case ["access_by_field", ".", id]: + _id = AleoIdentifier.from_json(id) + return AleoAccessByField(_id) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, field, **kwargs): + super().__init__(**kwargs) + self.field = field + + def __str__(self): + return f".{self.field}" + + def __hash__(self): + return hash(self.__str__()) + + # NOTE: behaves like string but keeps its type + def __eq__(self, other): + if type(self) is type(other) or isinstance(other, str): + return str(self) == str(other) + else: + return False + +class AleoAccessByIndex(AleoRegisterAccessor): + + @staticmethod + def from_json(node): + from .literals import AleoU32Literal + match node: + case ["access_by_index", "[", u32, "]"]: + _u32 = AleoU32Literal.from_json(u32) + return AleoAccessByIndex(_u32) + case ["access_by_index", "[", *digits, "]"]: + _u32 = AleoU32Literal.from_json(["u32_literal", None] + digits + ["u32"]) + return AleoAccessByIndex(_u32) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, index, **kwargs): + super().__init__(**kwargs) + self.index = index + + def __str__(self): + return f"[{self.index}]" + + def __hash__(self): + return hash(self.__str__()) + + # NOTE: behaves like string but keeps its type + def __eq__(self, other): + if type(self) is type(other) or isinstance(other, str): + return str(self) == str(other) + else: + return False + +class AleoRegisterAccess(AleoNode): + + @staticmethod + def from_json(node): + match node: + case ["register_access", register, *vs]: + # vs: register accessors + r = AleoRegister.from_json(register) + _accs = [AleoRegisterAccessor.from_json(p) for p in vs] + return AleoRegisterAccess(r, _accs) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, reg, accs, **kwargs): + super().__init__(**kwargs) + self.reg = reg + self.accs = accs + + def __str__(self): + return "".join([f"{self.reg}"] + [f"{p}" for p in self.accs]) + + def __hash__(self): + return hash(self.__str__()) + + # NOTE: behaves like string but keeps its type + def __eq__(self, other): + if type(self) is type(other) or isinstance(other, str): + return str(self) == str(other) + elif isinstance(other, AleoRegister): + # NOTE: AleoRegister and AleoRegisterAccess can share key + return str(self) == str(other) + else: + return False + + +class AleoOperand(AleoNode): + + @staticmethod + def from_json(node): + match node: + case ["operand", ["literal", *_]]: + from .literals import AleoLiteral + return AleoLiteral.from_json(node[1]) + case ["operand", ["register_access", *_]]: + return AleoRegisterAccess.from_json(node[1]) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + assert type(self) is not AleoOperand, "This class cannot be directly instantiated" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() + +class AleoCastDestination(AleoNode): + + @staticmethod + def from_json(node): + match node: + case ["cast_destination", dest] if isinstance(dest, str) and dest in {"group.x", "group.y"}: + return AleoDestinationGroup.from_json(dest) + case ["cast_destination", ["register_type", *_]]: + from .types import AleoRegisterType + return AleoRegisterType.from_json(node[1]) + case ["cast_destination", ["locator", *_]]: + return AleoLocator.from_json(node[1]) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + assert type(self) is not AleoCastDestination, "This class cannot be directly instantiated" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() + +class AleoDestinationGroup(AleoNode, Enum): + + X = 0 + Y = 1 + + @staticmethod + def from_json(s): + match s: + case "group.x": + return AleoDestinationGroup.X + case "group.y": + return AleoDestinationGroup.Y + case _: + raise NotImplementedError(f"Unsupported json component, got: {s}") + + def __str__(self): + match self.value: + case AleoDestinationGroup.X.value: + return "group.x" + case AleoDestinationGroup.Y.value: + return "group.y" + case _: + raise NotImplementedError(f"Unsupported destination group, got: {self.value}") + +class AleoUnaryOp(AleoNode, Enum): + + ABS = 0 + ABSW = 1 + DOUBLE = 2 + INV = 3 + NEG = 4 + NOT = 5 + SQUARE = 6 + SQRT = 7 + + @staticmethod + def from_json(s): + match s: + case ["unary_op", op]: + _s = op.replace(".", "").upper() + for p in AleoUnaryOp: + if _s == p.name: + return p + raise NotImplementedError(f"Unsupported unary op, got: {op}") + case _: + raise NotImplementedError(f"Unsupported json component, got: {s}") + + def __str__(self): + for p in AleoUnaryOp: + if self.value == p.value: + if p in {AleoUnaryOp.ABSW}: + return p.name[:-1].lower() + ".w" + else: + return p.name.lower() + raise NotImplementedError(f"Unsupported unary op, got: {self.value}") + +class AleoBinaryOp(AleoNode, Enum): + + ADD = 0 + ADDW = 1 + SUB = 2 + SUBW = 3 + MUL = 4 + MULW = 5 + DIV = 6 + DIVW = 7 + REM = 8 + REMW = 9 + POW = 10 + POWW = 11 + SHL = 12 + SHLW = 13 + SHR = 14 + SHRW = 15 + MOD = 16 + AND = 17 + OR = 18 + XOR = 19 + NAND = 20 + NOR = 21 + GT = 22 + GTE = 23 + LT = 24 + LTE = 25 + + @staticmethod + def from_json(s): + match s: + case ["binary_op", op]: + _s = op.replace(".", "").upper() + for p in AleoBinaryOp: + if _s == p.name: + return p + raise NotImplementedError(f"Unsupported binary op, got: {op}") + case _: + raise NotImplementedError(f"Unsupported json component, got: {s}") + + def __str__(self): + for p in AleoBinaryOp: + if self.value == p.value: + if p in {AleoBinaryOp.ADDW, AleoBinaryOp.SUBW, AleoBinaryOp.MULW, AleoBinaryOp.DIVW, + AleoBinaryOp.REMW, AleoBinaryOp.POWW, AleoBinaryOp.SHLW, AleoBinaryOp.SHRW}: + return p.name[:-1].lower() + ".w" + else: + return p.name.lower() + raise NotImplementedError(f"Unsupported binary op, got: {self.value}") + +class AleoIsOp(AleoNode, Enum): + + NEQ = 0 + EQ = 1 + + @staticmethod + def from_json(s): + match s: + case ["is_op", "is.eq"]: + return AleoIsOp.EQ + case ["is_op", "is.neq"]: + return AleoIsOp.NEQ + case _: + raise NotImplementedError(f"Unsupported json component, got: {s}") + + def __str__(self): + match self.value: + case AleoIsOp.NEQ.value: + return "is.neq" + case AleoIsOp.EQ.value: + return "is.eq" + case _: + raise NotImplementedError(f"Unsupported is op, got: {self.value}") + +class AleoAssertOp(AleoNode, Enum): + + NEQ = 0 + EQ = 1 + + @staticmethod + def from_json(s): + match s: + case ["assert_op", "assert.eq"]: + return AleoAssertOp.EQ + case ["assert_op", "assert.neq"]: + return AleoAssertOp.NEQ + case _: + raise NotImplementedError(f"Unsupported json component, got: {s}") + + def __str__(self): + match self.value: + case AleoAssertOp.NEQ.value: + return "assert.neq" + case AleoAssertOp.EQ.value: + return "assert.eq" + case _: + raise NotImplementedError(f"Unsupported assert op, got: {self.value}") + +class AleoLocator(AleoNode): + + @staticmethod + def from_json(node): + match node: + case ["locator", pid, "/", id]: + _pid = AleoProgramId.from_json(pid) + _id = AleoIdentifier.from_json(id) + return AleoLocator(_pid, _id) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, pid, id, visibility=AleoModifier.DEFAULT, **kwargs): + super().__init__(**kwargs) + self.pid = pid + self.id = id + self.visibility = visibility + + def __str__(self): + return f"{self.pid}/{self.id}{self.visibility}" + +class AleoHash1Op(AleoNode, Enum): + + BHP256 = 0 + BHP512 = 1 + BHP768 = 2 + BHP1024 = 3 + + PED64 = 4 + PED128 = 5 + + PSD2 = 6 + PSD4 = 7 + PSD8 = 8 + + KECCAK256 = 9 + KECCAK384 = 10 + KECCAK512 = 11 + + SHA3_256 = 12 + SHA3_384 = 13 + SHA3_512 = 14 + + + @staticmethod + def from_json(s): + match s: + case ["hash1_op", op]: + assert op.startswith("hash."), f"Hash op prefixes mismatch, expected: hash., got: {op}" + _s = op[5:].upper() + for p in AleoHash1Op: + if _s == p.name: + return p + raise NotImplementedError(f"Unsupported hash1 op, got: {op}") + case _: + raise NotImplementedError(f"Unsupported json component, got: {s}") + + def __str__(self): + return f"hash.{self.name.lower()}" \ No newline at end of file diff --git a/vanguard/aleo/grammar/types.py b/vanguard/aleo/grammar/types.py new file mode 100644 index 0000000..c3476a4 --- /dev/null +++ b/vanguard/aleo/grammar/types.py @@ -0,0 +1,380 @@ +from typing import Any, Union + +from .misc import * + +class AleoType(AleoNode): + + def __init__(self, visibility=AleoModifier.DEFAULT, **kwargs): + assert type(self) is not AleoType, "This class cannot be directly instantiated" + super().__init__(**kwargs) + self.visibility = visibility + + def __str__(self): + raise TypeError() + +class AleoRegisterType(AleoType): + + # NOTE: this contains visibility parsing, except for the plaintext type subtype + @staticmethod + def from_json(node): + match node: + case ["register_type", ["plaintext_type", *_]]: + return AleoPlaintextType.from_json(node[1]) + case ["register_type", ["identifier", *_], ".record"]: + _type = AleoIdentifier.from_json(node[1]) + _type.visibility = AleoModifier.from_json(".record") + return _type + case ["register_type", ["locator", *_], ".future"]: + _type = AleoLocator.from_json(node[1]) + _type.visibility = AleoModifier.from_json(".future") + return _type + case ["register_type", ["locator", *_], ".record"]: + _type = AleoLocator.from_json(node[1]) + _type.visibility = AleoModifier.from_json(".record") + return _type + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + assert type(self) is not AleoRegisterType, "This class cannot be directly instantiated" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() + +class AleoPlaintextType(AleoRegisterType): + + @staticmethod + def from_json(node): + match node: + case ["plaintext_type", ["literal_type", *_]]: + return AleoLiteralType.from_json(node[1]) + case ["plaintext_type", ["array_type", *_]]: + return AleoArrayType.from_json(node[1]) + case ["plaintext_type", ["identifier", *_]]: + return AleoIdentifier.from_json(node[1]) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + assert type(self) is not AleoPlaintextType, "This class cannot be directly instantiated" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() + +class AleoArrayType(AleoPlaintextType): + + @staticmethod + def from_json(node): + match node: + case ["array_type", "[", b, ";", u32, "]"]: + from .literals import AleoU32Literal + # b: base type + btype = AleoPlaintextType.from_json(b) + # if base type is a nested array type, unfold it + # directly use the integer after parsing, don't wrap + size = AleoU32Literal.from_json(u32).value + dim = btype.dim + (size,) if isinstance(btype, AleoArrayType) else (size,) + return AleoArrayType(btype, dim) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, btype, dim, **kwargs): + super().__init__(**kwargs) + self.btype = btype + self.dim = dim # directly stored in tuple + + def __str__(self): + # as dim is directly stored as tuple, add u32 postfix + s = f"[{self.btype};{self.dim[0]}u32]" + if len(self.dim) > 1: + for p in self.dim[1:]: + s = f"[{s};{p}u32]" + return s + +class AleoLiteralType(AleoPlaintextType): + + @staticmethod + def from_json(node): + match node: + case ["literal_type", ["arithmetic_type", *_]]: + return AleoArithmeticType.from_json(node[1]) + case ["literal_type", ["boolean_type", *_]]: + return AleoBooleanType.from_json(node[1]) + case ["literal_type", ["address_type", *_]]: + return AleoAddressType.from_json(node[1]) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + assert type(self) is not AleoLiteralType, "This class cannot be directly instantiated" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() + + +class AleoBooleanType(AleoLiteralType): + + @staticmethod + def from_json(node): + match node: + case ["boolean_type", "boolean"]: + return AleoBooleanType() + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + def __str__(self): + return "boolean" + +class AleoSignatureType(AleoLiteralType): + + @staticmethod + def from_json(node): + match node: + case ["signature_type", "signature"]: + return AleoSignatureType() + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + def __str__(self): + return "sign1" + +class AleoArithmeticType(AleoLiteralType): + + @staticmethod + def from_json(node): + match node: + case ["arithmetic_type", ["integer_type", *_]]: + return AleoIntegerType.from_json(node[1]) + case ["arithmetic_type", ["field_type", *_]]: + return AleoFieldType.from_json(node[1]) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + assert type(self) is not AleoArithmeticType, "This class cannot be directly instantiated" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() + +class AleoIntegerType(AleoArithmeticType): + + @staticmethod + def from_json(node): + match node: + case ["integer_type", ["unsigned_type", *_]]: + return AleoUnsignedType.from_json(node[1]) + case ["integer_type", ["signed_type", *_]]: + return AleoSignedType.from_json(node[1]) + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + assert type(self) is not AleoIntegerType, "This class cannot be directly instantiated" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() + +class AleoFieldType(AleoArithmeticType): + + @staticmethod + def from_json(node): + match node: + case ["field_type", "field"]: + return AleoFieldType() + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + def __str__(self): + return "field" + +class AleoSignedType(AleoIntegerType): + + @staticmethod + def from_json(node): + match node: + case ["signed_type", "i8"]: + return AleoI8Type() + case ["signed_type", "i16"]: + return AleoI16Type() + case ["signed_type", "i32"]: + return AleoI32Type() + case ["signed_type", "i64"]: + return AleoI64Type() + case ["signed_type", "i128"]: + return AleoI128Type() + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + assert type(self) is not AleoUnsignedType, "This class cannot be directly instantiated" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() + +class AleoI8Type(AleoSignatureType): + def __init__(self, **kwargs): + super().__init__(**kwargs) + def __str__(self): + return "i8" + +class AleoI16Type(AleoSignatureType): + def __init__(self, **kwargs): + super().__init__(**kwargs) + def __str__(self): + return "i16" + +class AleoI32Type(AleoSignatureType): + def __init__(self, **kwargs): + super().__init__(**kwargs) + def __str__(self): + return "i32" + +class AleoI64Type(AleoSignatureType): + def __init__(self, **kwargs): + super().__init__(**kwargs) + def __str__(self): + return "i64" + +class AleoI128Type(AleoSignatureType): + def __init__(self, **kwargs): + super().__init__(**kwargs) + def __str__(self): + return "i128" + +class AleoUnsignedType(AleoIntegerType): + + @staticmethod + def from_json(node): + match node: + case ["unsigned_type", "u8"]: + return AleoU8Type() + case ["unsigned_type", "u16"]: + return AleoU16Type() + case ["unsigned_type", "u32"]: + return AleoU32Type() + case ["unsigned_type", "u64"]: + return AleoU64Type() + case ["unsigned_type", "u128"]: + return AleoU128Type() + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + assert type(self) is not AleoUnsignedType, "This class cannot be directly instantiated" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() + +class AleoU8Type(AleoUnsignedType): + def __init__(self, **kwargs): + super().__init__(**kwargs) + def __str__(self): + return "u8" + +class AleoU16Type(AleoUnsignedType): + def __init__(self, **kwargs): + super().__init__(**kwargs) + def __str__(self): + return "u16" + +class AleoU32Type(AleoUnsignedType): + def __init__(self, **kwargs): + super().__init__(**kwargs) + def __str__(self): + return "u32" + +class AleoU64Type(AleoUnsignedType): + def __init__(self, **kwargs): + super().__init__(**kwargs) + def __str__(self): + return "u64" + +class AleoU128Type(AleoUnsignedType): + def __init__(self, **kwargs): + super().__init__(**kwargs) + def __str__(self): + return "u128" + +class AleoAddressType(AleoLiteralType): + + @staticmethod + def from_json(node): + match node: + case ["address_type", "address"]: + return AleoAddressType() + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + def __str__(self): + return "aleo1" + +class AleoValueType(AleoType): + + @staticmethod + def from_json(node): + # NOTE: this contains visibility parsing + match node: + case ["value_type", ["plaintext_type", *_], visibility]: + _type = AleoPlaintextType.from_json(node[1]) + _visibility = AleoModifier.from_json(visibility) + _type.visibility = _visibility + return _type + case ["value_type", ["locator", *_], modifier]: + _type = AleoLocator.from_json(node[1]) + _modifier = AleoModifier.from_json(modifier) + _type.visibility = _modifier + return _type + case ["value_type", ["identifier", *_], modifier]: + _type = AleoIdentifier.from_json(node[1]) + _modifier = AleoModifier.from_json(modifier) + _type.visibility = _modifier + return _type + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + assert type(self) is not AleoValueType, "This class cannot be directly instantiated" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() + +class AleoFinalizeType(AleoType): + + @staticmethod + def from_json(node): + # NOTE: this contains visibility parsing + match node: + case ["finalize_type", ["plaintext_type", *_], visibility]: + _type = AleoPlaintextType.from_json(node[1]) + _visibility = AleoModifier.from_json(visibility) + _type.visibility = _visibility + return _type + case _: + raise NotImplementedError(f"Unsupported json component, got: {node}") + + def __init__(self, **kwargs): + assert type(self) is not AleoFinalizeType, "This class cannot be directly instantiated" + super().__init__(**kwargs) + + def __str__(self): + raise TypeError() \ No newline at end of file diff --git a/vanguard/aleo/graphs.py b/vanguard/aleo/graphs.py new file mode 100644 index 0000000..83f8f09 --- /dev/null +++ b/vanguard/aleo/graphs.py @@ -0,0 +1,72 @@ +from .grammar import * + +def get_dfg_edges(env: AleoEnvironment, pid: str, fid: str, hash=True, call=False): + """Get a set of edges for data flow graph + Args: + - hash: whether or not to include edges from hash function + - call: whether or not to inline/expand internal/external call/async + """ + # initialize + prog: AleoProgram = env.programs[pid] + func: AleoFunction = prog.functions[fid] + edges = [] + # process instructions + for inst in func.instructions: + match inst: + + case AleoUnary(): + if not isinstance(inst.operand, AleoLiteral): + # only consider non-literal + edges.append((inst.operand, inst.regacc)) + + case AleoBinary(): + for p in inst.operands: + if not isinstance(p, AleoLiteral): + # only consider non-literal + edges.append((p, inst.regacc)) + + case AleoHash1(): + if hash: + if not isinstance(inst.operand, AleoLiteral): + # only consider non-literal + edges.append((inst.operand, inst.regacc)) + # else: do nothing + + case AleoAsync(): + if call: + # FIXME + raise NotImplementedError() + else: + # do not model + pass + + case AleoCall(): + if call: + # FIXME + raise NotImplementedError() + else: + # do not model + pass + + case AleoTernary(): + for p in inst.operands: + if not isinstance(p, AleoLiteral): + # only consider non-literal + edges.append((p, inst.regacc)) + + case AleoCast(): + for p in inst.operands: + if not isinstance(p, AleoLiteral): + # only consider non-literal + edges.append((p, inst.regacc)) + + case AleoIs(): + for p in inst.operands: + if not isinstance(p, AleoLiteral): + # only consider non-literal + edges.append((p, inst.regacc)) + + case _: + raise NotImplementedError(f"Unsupported instruction, got: {inst}, type: {type(inst)}") + + return edges \ No newline at end of file diff --git a/vanguard/aleo/parser/.antlr/AleoLexer.interp b/vanguard/aleo/parser/.antlr/AleoLexer.interp new file mode 100644 index 0000000..1894430 --- /dev/null +++ b/vanguard/aleo/parser/.antlr/AleoLexer.interp @@ -0,0 +1,442 @@ +token literal names: +null +'program' +';' +'import' +'mapping' +':' +'key' +'as' +'value' +'struct' +'record' +'closure' +'input' +'output' +'function' +'finalize' +'contains' +'[' +']' +'into' +'get' +'get.or_use' +'set' +'remove' +'rand.chacha' +'position' +'to' +'await' +'ternary' +'sign.verify' +'sign_verify' +'call' +'async' +'-' +'_' +'u32' +'true' +'false' +'u8' +'u16' +'u64' +'u128' +'i8' +'i16' +'i32' +'i64' +'i128' +'field' +'group' +'scalar' +'address' +'boolean' +'signature' +'.constant' +'.public' +'.private' +'.record' +'.future' +'.' +'group::GEN' +'self.signer' +'self.caller' +'block.height' +'/' +'group.x' +'group.y' +'abs' +'abs.w' +'double' +'inv' +'neg' +'not' +'square' +'sqrt' +'add' +'add.w' +'sub' +'sub.w' +'mul' +'mul.w' +'div' +'div.w' +'rem' +'rem.w' +'pow' +'pow.w' +'shl' +'shl.w' +'shr' +'shr.w' +'mod' +'and' +'or' +'xor' +'nand' +'nor' +'gt' +'gte' +'lt' +'lte' +'is.eq' +'is.neq' +'assert.eq' +'assert.neq' +'commit.bhp256' +'commit.bhp512' +'commit.bhp768' +'commit.bhp1024' +'commit.ped64' +'commit.ped128' +'hash.bhp256' +'hash.bhp512' +'hash.bhp768' +'hash.bhp1024' +'hash.ped64' +'hash.ped128' +'hash.psd2' +'hash.psd4' +'hash.psd8' +'hash.keccak256' +'hash.keccak384' +'hash.keccak512' +'hash.sha3_256' +'hash.sha3_384' +'hash.sha3_512' +'hash_many.psd2' +'hash_many.psd4' +'hash_many.psd8' +'cast.lossy' +'cast' +'branch.eq' +'branch.neq' +null +null +null +null +null +null +null +null + +token symbolic names: +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +ADDRESS_LITERAL +SIGNATURE_LITERAL +REGISTER +IDENTIFIER +DIGIT +WS +COMMENT +LINE_COMMENT + +rule names: +T__0 +T__1 +T__2 +T__3 +T__4 +T__5 +T__6 +T__7 +T__8 +T__9 +T__10 +T__11 +T__12 +T__13 +T__14 +T__15 +T__16 +T__17 +T__18 +T__19 +T__20 +T__21 +T__22 +T__23 +T__24 +T__25 +T__26 +T__27 +T__28 +T__29 +T__30 +T__31 +T__32 +T__33 +T__34 +T__35 +T__36 +T__37 +T__38 +T__39 +T__40 +T__41 +T__42 +T__43 +T__44 +T__45 +T__46 +T__47 +T__48 +T__49 +T__50 +T__51 +T__52 +T__53 +T__54 +T__55 +T__56 +T__57 +T__58 +T__59 +T__60 +T__61 +T__62 +T__63 +T__64 +T__65 +T__66 +T__67 +T__68 +T__69 +T__70 +T__71 +T__72 +T__73 +T__74 +T__75 +T__76 +T__77 +T__78 +T__79 +T__80 +T__81 +T__82 +T__83 +T__84 +T__85 +T__86 +T__87 +T__88 +T__89 +T__90 +T__91 +T__92 +T__93 +T__94 +T__95 +T__96 +T__97 +T__98 +T__99 +T__100 +T__101 +T__102 +T__103 +T__104 +T__105 +T__106 +T__107 +T__108 +T__109 +T__110 +T__111 +T__112 +T__113 +T__114 +T__115 +T__116 +T__117 +T__118 +T__119 +T__120 +T__121 +T__122 +T__123 +T__124 +T__125 +T__126 +T__127 +T__128 +T__129 +T__130 +ADDRESS_LITERAL +SIGNATURE_LITERAL +ADDRESS_OR_SIGNATURE_CHAR +REGISTER +IDENTIFIER +LETTER +LOWERCASE_LETTER +ADDRESS_OR_SIGNATURE_LOWERCASE_LETTER +OTHER_LOWERCASE_LETTER +UPPERCASE_LETTER +DIGIT +ADDRESS_OR_SIGNATURE_DIGIT +OTHER_DIGIT +WS +COMMENT +LINE_COMMENT + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 139, 1371, 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, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 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, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 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, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 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, 32, 1, 32, 1, 33, 1, 33, 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, 36, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 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, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 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, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 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, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 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, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 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, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 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, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 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, 1, 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, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 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, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 5, 131, 1273, 8, 131, 10, 131, 12, 131, 1276, 9, 131, 4, 131, 1278, 8, 131, 11, 131, 12, 131, 1279, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 5, 132, 1290, 8, 132, 10, 132, 12, 132, 1293, 9, 132, 4, 132, 1295, 8, 132, 11, 132, 12, 132, 1296, 1, 133, 1, 133, 3, 133, 1301, 8, 133, 1, 134, 1, 134, 4, 134, 1305, 8, 134, 11, 134, 12, 134, 1306, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 1313, 8, 135, 10, 135, 12, 135, 1316, 9, 135, 1, 136, 1, 136, 3, 136, 1320, 8, 136, 1, 137, 1, 137, 3, 137, 1324, 8, 137, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 3, 141, 1334, 8, 141, 1, 142, 1, 142, 1, 143, 1, 143, 1, 144, 4, 144, 1341, 8, 144, 11, 144, 12, 144, 1342, 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 5, 145, 1351, 8, 145, 10, 145, 12, 145, 1354, 9, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 5, 146, 1365, 8, 146, 10, 146, 12, 146, 1368, 9, 146, 1, 146, 1, 146, 1, 1352, 0, 147, 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, 0, 269, 134, 271, 135, 273, 0, 275, 0, 277, 0, 279, 0, 281, 0, 283, 136, 285, 0, 287, 0, 289, 137, 291, 138, 293, 139, 1, 0, 6, 4, 0, 97, 97, 99, 104, 106, 110, 112, 122, 3, 0, 98, 98, 105, 105, 111, 111, 1, 0, 65, 90, 2, 0, 48, 48, 50, 57, 3, 0, 9, 10, 12, 13, 32, 32, 2, 0, 10, 10, 13, 13, 1377, 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, 269, 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 283, 1, 0, 0, 0, 0, 289, 1, 0, 0, 0, 0, 291, 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, 1, 295, 1, 0, 0, 0, 3, 303, 1, 0, 0, 0, 5, 305, 1, 0, 0, 0, 7, 312, 1, 0, 0, 0, 9, 320, 1, 0, 0, 0, 11, 322, 1, 0, 0, 0, 13, 326, 1, 0, 0, 0, 15, 329, 1, 0, 0, 0, 17, 335, 1, 0, 0, 0, 19, 342, 1, 0, 0, 0, 21, 349, 1, 0, 0, 0, 23, 357, 1, 0, 0, 0, 25, 363, 1, 0, 0, 0, 27, 370, 1, 0, 0, 0, 29, 379, 1, 0, 0, 0, 31, 388, 1, 0, 0, 0, 33, 397, 1, 0, 0, 0, 35, 399, 1, 0, 0, 0, 37, 401, 1, 0, 0, 0, 39, 406, 1, 0, 0, 0, 41, 410, 1, 0, 0, 0, 43, 421, 1, 0, 0, 0, 45, 425, 1, 0, 0, 0, 47, 432, 1, 0, 0, 0, 49, 444, 1, 0, 0, 0, 51, 453, 1, 0, 0, 0, 53, 456, 1, 0, 0, 0, 55, 462, 1, 0, 0, 0, 57, 470, 1, 0, 0, 0, 59, 482, 1, 0, 0, 0, 61, 494, 1, 0, 0, 0, 63, 499, 1, 0, 0, 0, 65, 505, 1, 0, 0, 0, 67, 507, 1, 0, 0, 0, 69, 509, 1, 0, 0, 0, 71, 513, 1, 0, 0, 0, 73, 518, 1, 0, 0, 0, 75, 524, 1, 0, 0, 0, 77, 527, 1, 0, 0, 0, 79, 531, 1, 0, 0, 0, 81, 535, 1, 0, 0, 0, 83, 540, 1, 0, 0, 0, 85, 543, 1, 0, 0, 0, 87, 547, 1, 0, 0, 0, 89, 551, 1, 0, 0, 0, 91, 555, 1, 0, 0, 0, 93, 560, 1, 0, 0, 0, 95, 566, 1, 0, 0, 0, 97, 572, 1, 0, 0, 0, 99, 579, 1, 0, 0, 0, 101, 587, 1, 0, 0, 0, 103, 595, 1, 0, 0, 0, 105, 605, 1, 0, 0, 0, 107, 615, 1, 0, 0, 0, 109, 623, 1, 0, 0, 0, 111, 632, 1, 0, 0, 0, 113, 640, 1, 0, 0, 0, 115, 648, 1, 0, 0, 0, 117, 650, 1, 0, 0, 0, 119, 661, 1, 0, 0, 0, 121, 673, 1, 0, 0, 0, 123, 685, 1, 0, 0, 0, 125, 698, 1, 0, 0, 0, 127, 700, 1, 0, 0, 0, 129, 708, 1, 0, 0, 0, 131, 716, 1, 0, 0, 0, 133, 720, 1, 0, 0, 0, 135, 726, 1, 0, 0, 0, 137, 733, 1, 0, 0, 0, 139, 737, 1, 0, 0, 0, 141, 741, 1, 0, 0, 0, 143, 745, 1, 0, 0, 0, 145, 752, 1, 0, 0, 0, 147, 757, 1, 0, 0, 0, 149, 761, 1, 0, 0, 0, 151, 767, 1, 0, 0, 0, 153, 771, 1, 0, 0, 0, 155, 777, 1, 0, 0, 0, 157, 781, 1, 0, 0, 0, 159, 787, 1, 0, 0, 0, 161, 791, 1, 0, 0, 0, 163, 797, 1, 0, 0, 0, 165, 801, 1, 0, 0, 0, 167, 807, 1, 0, 0, 0, 169, 811, 1, 0, 0, 0, 171, 817, 1, 0, 0, 0, 173, 821, 1, 0, 0, 0, 175, 827, 1, 0, 0, 0, 177, 831, 1, 0, 0, 0, 179, 837, 1, 0, 0, 0, 181, 841, 1, 0, 0, 0, 183, 845, 1, 0, 0, 0, 185, 848, 1, 0, 0, 0, 187, 852, 1, 0, 0, 0, 189, 857, 1, 0, 0, 0, 191, 861, 1, 0, 0, 0, 193, 864, 1, 0, 0, 0, 195, 868, 1, 0, 0, 0, 197, 871, 1, 0, 0, 0, 199, 875, 1, 0, 0, 0, 201, 881, 1, 0, 0, 0, 203, 888, 1, 0, 0, 0, 205, 898, 1, 0, 0, 0, 207, 909, 1, 0, 0, 0, 209, 923, 1, 0, 0, 0, 211, 937, 1, 0, 0, 0, 213, 951, 1, 0, 0, 0, 215, 966, 1, 0, 0, 0, 217, 979, 1, 0, 0, 0, 219, 993, 1, 0, 0, 0, 221, 1005, 1, 0, 0, 0, 223, 1017, 1, 0, 0, 0, 225, 1029, 1, 0, 0, 0, 227, 1042, 1, 0, 0, 0, 229, 1053, 1, 0, 0, 0, 231, 1065, 1, 0, 0, 0, 233, 1075, 1, 0, 0, 0, 235, 1085, 1, 0, 0, 0, 237, 1095, 1, 0, 0, 0, 239, 1110, 1, 0, 0, 0, 241, 1125, 1, 0, 0, 0, 243, 1140, 1, 0, 0, 0, 245, 1154, 1, 0, 0, 0, 247, 1168, 1, 0, 0, 0, 249, 1182, 1, 0, 0, 0, 251, 1197, 1, 0, 0, 0, 253, 1212, 1, 0, 0, 0, 255, 1227, 1, 0, 0, 0, 257, 1238, 1, 0, 0, 0, 259, 1243, 1, 0, 0, 0, 261, 1253, 1, 0, 0, 0, 263, 1264, 1, 0, 0, 0, 265, 1281, 1, 0, 0, 0, 267, 1300, 1, 0, 0, 0, 269, 1302, 1, 0, 0, 0, 271, 1308, 1, 0, 0, 0, 273, 1319, 1, 0, 0, 0, 275, 1323, 1, 0, 0, 0, 277, 1325, 1, 0, 0, 0, 279, 1327, 1, 0, 0, 0, 281, 1329, 1, 0, 0, 0, 283, 1333, 1, 0, 0, 0, 285, 1335, 1, 0, 0, 0, 287, 1337, 1, 0, 0, 0, 289, 1340, 1, 0, 0, 0, 291, 1346, 1, 0, 0, 0, 293, 1360, 1, 0, 0, 0, 295, 296, 5, 112, 0, 0, 296, 297, 5, 114, 0, 0, 297, 298, 5, 111, 0, 0, 298, 299, 5, 103, 0, 0, 299, 300, 5, 114, 0, 0, 300, 301, 5, 97, 0, 0, 301, 302, 5, 109, 0, 0, 302, 2, 1, 0, 0, 0, 303, 304, 5, 59, 0, 0, 304, 4, 1, 0, 0, 0, 305, 306, 5, 105, 0, 0, 306, 307, 5, 109, 0, 0, 307, 308, 5, 112, 0, 0, 308, 309, 5, 111, 0, 0, 309, 310, 5, 114, 0, 0, 310, 311, 5, 116, 0, 0, 311, 6, 1, 0, 0, 0, 312, 313, 5, 109, 0, 0, 313, 314, 5, 97, 0, 0, 314, 315, 5, 112, 0, 0, 315, 316, 5, 112, 0, 0, 316, 317, 5, 105, 0, 0, 317, 318, 5, 110, 0, 0, 318, 319, 5, 103, 0, 0, 319, 8, 1, 0, 0, 0, 320, 321, 5, 58, 0, 0, 321, 10, 1, 0, 0, 0, 322, 323, 5, 107, 0, 0, 323, 324, 5, 101, 0, 0, 324, 325, 5, 121, 0, 0, 325, 12, 1, 0, 0, 0, 326, 327, 5, 97, 0, 0, 327, 328, 5, 115, 0, 0, 328, 14, 1, 0, 0, 0, 329, 330, 5, 118, 0, 0, 330, 331, 5, 97, 0, 0, 331, 332, 5, 108, 0, 0, 332, 333, 5, 117, 0, 0, 333, 334, 5, 101, 0, 0, 334, 16, 1, 0, 0, 0, 335, 336, 5, 115, 0, 0, 336, 337, 5, 116, 0, 0, 337, 338, 5, 114, 0, 0, 338, 339, 5, 117, 0, 0, 339, 340, 5, 99, 0, 0, 340, 341, 5, 116, 0, 0, 341, 18, 1, 0, 0, 0, 342, 343, 5, 114, 0, 0, 343, 344, 5, 101, 0, 0, 344, 345, 5, 99, 0, 0, 345, 346, 5, 111, 0, 0, 346, 347, 5, 114, 0, 0, 347, 348, 5, 100, 0, 0, 348, 20, 1, 0, 0, 0, 349, 350, 5, 99, 0, 0, 350, 351, 5, 108, 0, 0, 351, 352, 5, 111, 0, 0, 352, 353, 5, 115, 0, 0, 353, 354, 5, 117, 0, 0, 354, 355, 5, 114, 0, 0, 355, 356, 5, 101, 0, 0, 356, 22, 1, 0, 0, 0, 357, 358, 5, 105, 0, 0, 358, 359, 5, 110, 0, 0, 359, 360, 5, 112, 0, 0, 360, 361, 5, 117, 0, 0, 361, 362, 5, 116, 0, 0, 362, 24, 1, 0, 0, 0, 363, 364, 5, 111, 0, 0, 364, 365, 5, 117, 0, 0, 365, 366, 5, 116, 0, 0, 366, 367, 5, 112, 0, 0, 367, 368, 5, 117, 0, 0, 368, 369, 5, 116, 0, 0, 369, 26, 1, 0, 0, 0, 370, 371, 5, 102, 0, 0, 371, 372, 5, 117, 0, 0, 372, 373, 5, 110, 0, 0, 373, 374, 5, 99, 0, 0, 374, 375, 5, 116, 0, 0, 375, 376, 5, 105, 0, 0, 376, 377, 5, 111, 0, 0, 377, 378, 5, 110, 0, 0, 378, 28, 1, 0, 0, 0, 379, 380, 5, 102, 0, 0, 380, 381, 5, 105, 0, 0, 381, 382, 5, 110, 0, 0, 382, 383, 5, 97, 0, 0, 383, 384, 5, 108, 0, 0, 384, 385, 5, 105, 0, 0, 385, 386, 5, 122, 0, 0, 386, 387, 5, 101, 0, 0, 387, 30, 1, 0, 0, 0, 388, 389, 5, 99, 0, 0, 389, 390, 5, 111, 0, 0, 390, 391, 5, 110, 0, 0, 391, 392, 5, 116, 0, 0, 392, 393, 5, 97, 0, 0, 393, 394, 5, 105, 0, 0, 394, 395, 5, 110, 0, 0, 395, 396, 5, 115, 0, 0, 396, 32, 1, 0, 0, 0, 397, 398, 5, 91, 0, 0, 398, 34, 1, 0, 0, 0, 399, 400, 5, 93, 0, 0, 400, 36, 1, 0, 0, 0, 401, 402, 5, 105, 0, 0, 402, 403, 5, 110, 0, 0, 403, 404, 5, 116, 0, 0, 404, 405, 5, 111, 0, 0, 405, 38, 1, 0, 0, 0, 406, 407, 5, 103, 0, 0, 407, 408, 5, 101, 0, 0, 408, 409, 5, 116, 0, 0, 409, 40, 1, 0, 0, 0, 410, 411, 5, 103, 0, 0, 411, 412, 5, 101, 0, 0, 412, 413, 5, 116, 0, 0, 413, 414, 5, 46, 0, 0, 414, 415, 5, 111, 0, 0, 415, 416, 5, 114, 0, 0, 416, 417, 5, 95, 0, 0, 417, 418, 5, 117, 0, 0, 418, 419, 5, 115, 0, 0, 419, 420, 5, 101, 0, 0, 420, 42, 1, 0, 0, 0, 421, 422, 5, 115, 0, 0, 422, 423, 5, 101, 0, 0, 423, 424, 5, 116, 0, 0, 424, 44, 1, 0, 0, 0, 425, 426, 5, 114, 0, 0, 426, 427, 5, 101, 0, 0, 427, 428, 5, 109, 0, 0, 428, 429, 5, 111, 0, 0, 429, 430, 5, 118, 0, 0, 430, 431, 5, 101, 0, 0, 431, 46, 1, 0, 0, 0, 432, 433, 5, 114, 0, 0, 433, 434, 5, 97, 0, 0, 434, 435, 5, 110, 0, 0, 435, 436, 5, 100, 0, 0, 436, 437, 5, 46, 0, 0, 437, 438, 5, 99, 0, 0, 438, 439, 5, 104, 0, 0, 439, 440, 5, 97, 0, 0, 440, 441, 5, 99, 0, 0, 441, 442, 5, 104, 0, 0, 442, 443, 5, 97, 0, 0, 443, 48, 1, 0, 0, 0, 444, 445, 5, 112, 0, 0, 445, 446, 5, 111, 0, 0, 446, 447, 5, 115, 0, 0, 447, 448, 5, 105, 0, 0, 448, 449, 5, 116, 0, 0, 449, 450, 5, 105, 0, 0, 450, 451, 5, 111, 0, 0, 451, 452, 5, 110, 0, 0, 452, 50, 1, 0, 0, 0, 453, 454, 5, 116, 0, 0, 454, 455, 5, 111, 0, 0, 455, 52, 1, 0, 0, 0, 456, 457, 5, 97, 0, 0, 457, 458, 5, 119, 0, 0, 458, 459, 5, 97, 0, 0, 459, 460, 5, 105, 0, 0, 460, 461, 5, 116, 0, 0, 461, 54, 1, 0, 0, 0, 462, 463, 5, 116, 0, 0, 463, 464, 5, 101, 0, 0, 464, 465, 5, 114, 0, 0, 465, 466, 5, 110, 0, 0, 466, 467, 5, 97, 0, 0, 467, 468, 5, 114, 0, 0, 468, 469, 5, 121, 0, 0, 469, 56, 1, 0, 0, 0, 470, 471, 5, 115, 0, 0, 471, 472, 5, 105, 0, 0, 472, 473, 5, 103, 0, 0, 473, 474, 5, 110, 0, 0, 474, 475, 5, 46, 0, 0, 475, 476, 5, 118, 0, 0, 476, 477, 5, 101, 0, 0, 477, 478, 5, 114, 0, 0, 478, 479, 5, 105, 0, 0, 479, 480, 5, 102, 0, 0, 480, 481, 5, 121, 0, 0, 481, 58, 1, 0, 0, 0, 482, 483, 5, 115, 0, 0, 483, 484, 5, 105, 0, 0, 484, 485, 5, 103, 0, 0, 485, 486, 5, 110, 0, 0, 486, 487, 5, 95, 0, 0, 487, 488, 5, 118, 0, 0, 488, 489, 5, 101, 0, 0, 489, 490, 5, 114, 0, 0, 490, 491, 5, 105, 0, 0, 491, 492, 5, 102, 0, 0, 492, 493, 5, 121, 0, 0, 493, 60, 1, 0, 0, 0, 494, 495, 5, 99, 0, 0, 495, 496, 5, 97, 0, 0, 496, 497, 5, 108, 0, 0, 497, 498, 5, 108, 0, 0, 498, 62, 1, 0, 0, 0, 499, 500, 5, 97, 0, 0, 500, 501, 5, 115, 0, 0, 501, 502, 5, 121, 0, 0, 502, 503, 5, 110, 0, 0, 503, 504, 5, 99, 0, 0, 504, 64, 1, 0, 0, 0, 505, 506, 5, 45, 0, 0, 506, 66, 1, 0, 0, 0, 507, 508, 5, 95, 0, 0, 508, 68, 1, 0, 0, 0, 509, 510, 5, 117, 0, 0, 510, 511, 5, 51, 0, 0, 511, 512, 5, 50, 0, 0, 512, 70, 1, 0, 0, 0, 513, 514, 5, 116, 0, 0, 514, 515, 5, 114, 0, 0, 515, 516, 5, 117, 0, 0, 516, 517, 5, 101, 0, 0, 517, 72, 1, 0, 0, 0, 518, 519, 5, 102, 0, 0, 519, 520, 5, 97, 0, 0, 520, 521, 5, 108, 0, 0, 521, 522, 5, 115, 0, 0, 522, 523, 5, 101, 0, 0, 523, 74, 1, 0, 0, 0, 524, 525, 5, 117, 0, 0, 525, 526, 5, 56, 0, 0, 526, 76, 1, 0, 0, 0, 527, 528, 5, 117, 0, 0, 528, 529, 5, 49, 0, 0, 529, 530, 5, 54, 0, 0, 530, 78, 1, 0, 0, 0, 531, 532, 5, 117, 0, 0, 532, 533, 5, 54, 0, 0, 533, 534, 5, 52, 0, 0, 534, 80, 1, 0, 0, 0, 535, 536, 5, 117, 0, 0, 536, 537, 5, 49, 0, 0, 537, 538, 5, 50, 0, 0, 538, 539, 5, 56, 0, 0, 539, 82, 1, 0, 0, 0, 540, 541, 5, 105, 0, 0, 541, 542, 5, 56, 0, 0, 542, 84, 1, 0, 0, 0, 543, 544, 5, 105, 0, 0, 544, 545, 5, 49, 0, 0, 545, 546, 5, 54, 0, 0, 546, 86, 1, 0, 0, 0, 547, 548, 5, 105, 0, 0, 548, 549, 5, 51, 0, 0, 549, 550, 5, 50, 0, 0, 550, 88, 1, 0, 0, 0, 551, 552, 5, 105, 0, 0, 552, 553, 5, 54, 0, 0, 553, 554, 5, 52, 0, 0, 554, 90, 1, 0, 0, 0, 555, 556, 5, 105, 0, 0, 556, 557, 5, 49, 0, 0, 557, 558, 5, 50, 0, 0, 558, 559, 5, 56, 0, 0, 559, 92, 1, 0, 0, 0, 560, 561, 5, 102, 0, 0, 561, 562, 5, 105, 0, 0, 562, 563, 5, 101, 0, 0, 563, 564, 5, 108, 0, 0, 564, 565, 5, 100, 0, 0, 565, 94, 1, 0, 0, 0, 566, 567, 5, 103, 0, 0, 567, 568, 5, 114, 0, 0, 568, 569, 5, 111, 0, 0, 569, 570, 5, 117, 0, 0, 570, 571, 5, 112, 0, 0, 571, 96, 1, 0, 0, 0, 572, 573, 5, 115, 0, 0, 573, 574, 5, 99, 0, 0, 574, 575, 5, 97, 0, 0, 575, 576, 5, 108, 0, 0, 576, 577, 5, 97, 0, 0, 577, 578, 5, 114, 0, 0, 578, 98, 1, 0, 0, 0, 579, 580, 5, 97, 0, 0, 580, 581, 5, 100, 0, 0, 581, 582, 5, 100, 0, 0, 582, 583, 5, 114, 0, 0, 583, 584, 5, 101, 0, 0, 584, 585, 5, 115, 0, 0, 585, 586, 5, 115, 0, 0, 586, 100, 1, 0, 0, 0, 587, 588, 5, 98, 0, 0, 588, 589, 5, 111, 0, 0, 589, 590, 5, 111, 0, 0, 590, 591, 5, 108, 0, 0, 591, 592, 5, 101, 0, 0, 592, 593, 5, 97, 0, 0, 593, 594, 5, 110, 0, 0, 594, 102, 1, 0, 0, 0, 595, 596, 5, 115, 0, 0, 596, 597, 5, 105, 0, 0, 597, 598, 5, 103, 0, 0, 598, 599, 5, 110, 0, 0, 599, 600, 5, 97, 0, 0, 600, 601, 5, 116, 0, 0, 601, 602, 5, 117, 0, 0, 602, 603, 5, 114, 0, 0, 603, 604, 5, 101, 0, 0, 604, 104, 1, 0, 0, 0, 605, 606, 5, 46, 0, 0, 606, 607, 5, 99, 0, 0, 607, 608, 5, 111, 0, 0, 608, 609, 5, 110, 0, 0, 609, 610, 5, 115, 0, 0, 610, 611, 5, 116, 0, 0, 611, 612, 5, 97, 0, 0, 612, 613, 5, 110, 0, 0, 613, 614, 5, 116, 0, 0, 614, 106, 1, 0, 0, 0, 615, 616, 5, 46, 0, 0, 616, 617, 5, 112, 0, 0, 617, 618, 5, 117, 0, 0, 618, 619, 5, 98, 0, 0, 619, 620, 5, 108, 0, 0, 620, 621, 5, 105, 0, 0, 621, 622, 5, 99, 0, 0, 622, 108, 1, 0, 0, 0, 623, 624, 5, 46, 0, 0, 624, 625, 5, 112, 0, 0, 625, 626, 5, 114, 0, 0, 626, 627, 5, 105, 0, 0, 627, 628, 5, 118, 0, 0, 628, 629, 5, 97, 0, 0, 629, 630, 5, 116, 0, 0, 630, 631, 5, 101, 0, 0, 631, 110, 1, 0, 0, 0, 632, 633, 5, 46, 0, 0, 633, 634, 5, 114, 0, 0, 634, 635, 5, 101, 0, 0, 635, 636, 5, 99, 0, 0, 636, 637, 5, 111, 0, 0, 637, 638, 5, 114, 0, 0, 638, 639, 5, 100, 0, 0, 639, 112, 1, 0, 0, 0, 640, 641, 5, 46, 0, 0, 641, 642, 5, 102, 0, 0, 642, 643, 5, 117, 0, 0, 643, 644, 5, 116, 0, 0, 644, 645, 5, 117, 0, 0, 645, 646, 5, 114, 0, 0, 646, 647, 5, 101, 0, 0, 647, 114, 1, 0, 0, 0, 648, 649, 5, 46, 0, 0, 649, 116, 1, 0, 0, 0, 650, 651, 5, 103, 0, 0, 651, 652, 5, 114, 0, 0, 652, 653, 5, 111, 0, 0, 653, 654, 5, 117, 0, 0, 654, 655, 5, 112, 0, 0, 655, 656, 5, 58, 0, 0, 656, 657, 5, 58, 0, 0, 657, 658, 5, 71, 0, 0, 658, 659, 5, 69, 0, 0, 659, 660, 5, 78, 0, 0, 660, 118, 1, 0, 0, 0, 661, 662, 5, 115, 0, 0, 662, 663, 5, 101, 0, 0, 663, 664, 5, 108, 0, 0, 664, 665, 5, 102, 0, 0, 665, 666, 5, 46, 0, 0, 666, 667, 5, 115, 0, 0, 667, 668, 5, 105, 0, 0, 668, 669, 5, 103, 0, 0, 669, 670, 5, 110, 0, 0, 670, 671, 5, 101, 0, 0, 671, 672, 5, 114, 0, 0, 672, 120, 1, 0, 0, 0, 673, 674, 5, 115, 0, 0, 674, 675, 5, 101, 0, 0, 675, 676, 5, 108, 0, 0, 676, 677, 5, 102, 0, 0, 677, 678, 5, 46, 0, 0, 678, 679, 5, 99, 0, 0, 679, 680, 5, 97, 0, 0, 680, 681, 5, 108, 0, 0, 681, 682, 5, 108, 0, 0, 682, 683, 5, 101, 0, 0, 683, 684, 5, 114, 0, 0, 684, 122, 1, 0, 0, 0, 685, 686, 5, 98, 0, 0, 686, 687, 5, 108, 0, 0, 687, 688, 5, 111, 0, 0, 688, 689, 5, 99, 0, 0, 689, 690, 5, 107, 0, 0, 690, 691, 5, 46, 0, 0, 691, 692, 5, 104, 0, 0, 692, 693, 5, 101, 0, 0, 693, 694, 5, 105, 0, 0, 694, 695, 5, 103, 0, 0, 695, 696, 5, 104, 0, 0, 696, 697, 5, 116, 0, 0, 697, 124, 1, 0, 0, 0, 698, 699, 5, 47, 0, 0, 699, 126, 1, 0, 0, 0, 700, 701, 5, 103, 0, 0, 701, 702, 5, 114, 0, 0, 702, 703, 5, 111, 0, 0, 703, 704, 5, 117, 0, 0, 704, 705, 5, 112, 0, 0, 705, 706, 5, 46, 0, 0, 706, 707, 5, 120, 0, 0, 707, 128, 1, 0, 0, 0, 708, 709, 5, 103, 0, 0, 709, 710, 5, 114, 0, 0, 710, 711, 5, 111, 0, 0, 711, 712, 5, 117, 0, 0, 712, 713, 5, 112, 0, 0, 713, 714, 5, 46, 0, 0, 714, 715, 5, 121, 0, 0, 715, 130, 1, 0, 0, 0, 716, 717, 5, 97, 0, 0, 717, 718, 5, 98, 0, 0, 718, 719, 5, 115, 0, 0, 719, 132, 1, 0, 0, 0, 720, 721, 5, 97, 0, 0, 721, 722, 5, 98, 0, 0, 722, 723, 5, 115, 0, 0, 723, 724, 5, 46, 0, 0, 724, 725, 5, 119, 0, 0, 725, 134, 1, 0, 0, 0, 726, 727, 5, 100, 0, 0, 727, 728, 5, 111, 0, 0, 728, 729, 5, 117, 0, 0, 729, 730, 5, 98, 0, 0, 730, 731, 5, 108, 0, 0, 731, 732, 5, 101, 0, 0, 732, 136, 1, 0, 0, 0, 733, 734, 5, 105, 0, 0, 734, 735, 5, 110, 0, 0, 735, 736, 5, 118, 0, 0, 736, 138, 1, 0, 0, 0, 737, 738, 5, 110, 0, 0, 738, 739, 5, 101, 0, 0, 739, 740, 5, 103, 0, 0, 740, 140, 1, 0, 0, 0, 741, 742, 5, 110, 0, 0, 742, 743, 5, 111, 0, 0, 743, 744, 5, 116, 0, 0, 744, 142, 1, 0, 0, 0, 745, 746, 5, 115, 0, 0, 746, 747, 5, 113, 0, 0, 747, 748, 5, 117, 0, 0, 748, 749, 5, 97, 0, 0, 749, 750, 5, 114, 0, 0, 750, 751, 5, 101, 0, 0, 751, 144, 1, 0, 0, 0, 752, 753, 5, 115, 0, 0, 753, 754, 5, 113, 0, 0, 754, 755, 5, 114, 0, 0, 755, 756, 5, 116, 0, 0, 756, 146, 1, 0, 0, 0, 757, 758, 5, 97, 0, 0, 758, 759, 5, 100, 0, 0, 759, 760, 5, 100, 0, 0, 760, 148, 1, 0, 0, 0, 761, 762, 5, 97, 0, 0, 762, 763, 5, 100, 0, 0, 763, 764, 5, 100, 0, 0, 764, 765, 5, 46, 0, 0, 765, 766, 5, 119, 0, 0, 766, 150, 1, 0, 0, 0, 767, 768, 5, 115, 0, 0, 768, 769, 5, 117, 0, 0, 769, 770, 5, 98, 0, 0, 770, 152, 1, 0, 0, 0, 771, 772, 5, 115, 0, 0, 772, 773, 5, 117, 0, 0, 773, 774, 5, 98, 0, 0, 774, 775, 5, 46, 0, 0, 775, 776, 5, 119, 0, 0, 776, 154, 1, 0, 0, 0, 777, 778, 5, 109, 0, 0, 778, 779, 5, 117, 0, 0, 779, 780, 5, 108, 0, 0, 780, 156, 1, 0, 0, 0, 781, 782, 5, 109, 0, 0, 782, 783, 5, 117, 0, 0, 783, 784, 5, 108, 0, 0, 784, 785, 5, 46, 0, 0, 785, 786, 5, 119, 0, 0, 786, 158, 1, 0, 0, 0, 787, 788, 5, 100, 0, 0, 788, 789, 5, 105, 0, 0, 789, 790, 5, 118, 0, 0, 790, 160, 1, 0, 0, 0, 791, 792, 5, 100, 0, 0, 792, 793, 5, 105, 0, 0, 793, 794, 5, 118, 0, 0, 794, 795, 5, 46, 0, 0, 795, 796, 5, 119, 0, 0, 796, 162, 1, 0, 0, 0, 797, 798, 5, 114, 0, 0, 798, 799, 5, 101, 0, 0, 799, 800, 5, 109, 0, 0, 800, 164, 1, 0, 0, 0, 801, 802, 5, 114, 0, 0, 802, 803, 5, 101, 0, 0, 803, 804, 5, 109, 0, 0, 804, 805, 5, 46, 0, 0, 805, 806, 5, 119, 0, 0, 806, 166, 1, 0, 0, 0, 807, 808, 5, 112, 0, 0, 808, 809, 5, 111, 0, 0, 809, 810, 5, 119, 0, 0, 810, 168, 1, 0, 0, 0, 811, 812, 5, 112, 0, 0, 812, 813, 5, 111, 0, 0, 813, 814, 5, 119, 0, 0, 814, 815, 5, 46, 0, 0, 815, 816, 5, 119, 0, 0, 816, 170, 1, 0, 0, 0, 817, 818, 5, 115, 0, 0, 818, 819, 5, 104, 0, 0, 819, 820, 5, 108, 0, 0, 820, 172, 1, 0, 0, 0, 821, 822, 5, 115, 0, 0, 822, 823, 5, 104, 0, 0, 823, 824, 5, 108, 0, 0, 824, 825, 5, 46, 0, 0, 825, 826, 5, 119, 0, 0, 826, 174, 1, 0, 0, 0, 827, 828, 5, 115, 0, 0, 828, 829, 5, 104, 0, 0, 829, 830, 5, 114, 0, 0, 830, 176, 1, 0, 0, 0, 831, 832, 5, 115, 0, 0, 832, 833, 5, 104, 0, 0, 833, 834, 5, 114, 0, 0, 834, 835, 5, 46, 0, 0, 835, 836, 5, 119, 0, 0, 836, 178, 1, 0, 0, 0, 837, 838, 5, 109, 0, 0, 838, 839, 5, 111, 0, 0, 839, 840, 5, 100, 0, 0, 840, 180, 1, 0, 0, 0, 841, 842, 5, 97, 0, 0, 842, 843, 5, 110, 0, 0, 843, 844, 5, 100, 0, 0, 844, 182, 1, 0, 0, 0, 845, 846, 5, 111, 0, 0, 846, 847, 5, 114, 0, 0, 847, 184, 1, 0, 0, 0, 848, 849, 5, 120, 0, 0, 849, 850, 5, 111, 0, 0, 850, 851, 5, 114, 0, 0, 851, 186, 1, 0, 0, 0, 852, 853, 5, 110, 0, 0, 853, 854, 5, 97, 0, 0, 854, 855, 5, 110, 0, 0, 855, 856, 5, 100, 0, 0, 856, 188, 1, 0, 0, 0, 857, 858, 5, 110, 0, 0, 858, 859, 5, 111, 0, 0, 859, 860, 5, 114, 0, 0, 860, 190, 1, 0, 0, 0, 861, 862, 5, 103, 0, 0, 862, 863, 5, 116, 0, 0, 863, 192, 1, 0, 0, 0, 864, 865, 5, 103, 0, 0, 865, 866, 5, 116, 0, 0, 866, 867, 5, 101, 0, 0, 867, 194, 1, 0, 0, 0, 868, 869, 5, 108, 0, 0, 869, 870, 5, 116, 0, 0, 870, 196, 1, 0, 0, 0, 871, 872, 5, 108, 0, 0, 872, 873, 5, 116, 0, 0, 873, 874, 5, 101, 0, 0, 874, 198, 1, 0, 0, 0, 875, 876, 5, 105, 0, 0, 876, 877, 5, 115, 0, 0, 877, 878, 5, 46, 0, 0, 878, 879, 5, 101, 0, 0, 879, 880, 5, 113, 0, 0, 880, 200, 1, 0, 0, 0, 881, 882, 5, 105, 0, 0, 882, 883, 5, 115, 0, 0, 883, 884, 5, 46, 0, 0, 884, 885, 5, 110, 0, 0, 885, 886, 5, 101, 0, 0, 886, 887, 5, 113, 0, 0, 887, 202, 1, 0, 0, 0, 888, 889, 5, 97, 0, 0, 889, 890, 5, 115, 0, 0, 890, 891, 5, 115, 0, 0, 891, 892, 5, 101, 0, 0, 892, 893, 5, 114, 0, 0, 893, 894, 5, 116, 0, 0, 894, 895, 5, 46, 0, 0, 895, 896, 5, 101, 0, 0, 896, 897, 5, 113, 0, 0, 897, 204, 1, 0, 0, 0, 898, 899, 5, 97, 0, 0, 899, 900, 5, 115, 0, 0, 900, 901, 5, 115, 0, 0, 901, 902, 5, 101, 0, 0, 902, 903, 5, 114, 0, 0, 903, 904, 5, 116, 0, 0, 904, 905, 5, 46, 0, 0, 905, 906, 5, 110, 0, 0, 906, 907, 5, 101, 0, 0, 907, 908, 5, 113, 0, 0, 908, 206, 1, 0, 0, 0, 909, 910, 5, 99, 0, 0, 910, 911, 5, 111, 0, 0, 911, 912, 5, 109, 0, 0, 912, 913, 5, 109, 0, 0, 913, 914, 5, 105, 0, 0, 914, 915, 5, 116, 0, 0, 915, 916, 5, 46, 0, 0, 916, 917, 5, 98, 0, 0, 917, 918, 5, 104, 0, 0, 918, 919, 5, 112, 0, 0, 919, 920, 5, 50, 0, 0, 920, 921, 5, 53, 0, 0, 921, 922, 5, 54, 0, 0, 922, 208, 1, 0, 0, 0, 923, 924, 5, 99, 0, 0, 924, 925, 5, 111, 0, 0, 925, 926, 5, 109, 0, 0, 926, 927, 5, 109, 0, 0, 927, 928, 5, 105, 0, 0, 928, 929, 5, 116, 0, 0, 929, 930, 5, 46, 0, 0, 930, 931, 5, 98, 0, 0, 931, 932, 5, 104, 0, 0, 932, 933, 5, 112, 0, 0, 933, 934, 5, 53, 0, 0, 934, 935, 5, 49, 0, 0, 935, 936, 5, 50, 0, 0, 936, 210, 1, 0, 0, 0, 937, 938, 5, 99, 0, 0, 938, 939, 5, 111, 0, 0, 939, 940, 5, 109, 0, 0, 940, 941, 5, 109, 0, 0, 941, 942, 5, 105, 0, 0, 942, 943, 5, 116, 0, 0, 943, 944, 5, 46, 0, 0, 944, 945, 5, 98, 0, 0, 945, 946, 5, 104, 0, 0, 946, 947, 5, 112, 0, 0, 947, 948, 5, 55, 0, 0, 948, 949, 5, 54, 0, 0, 949, 950, 5, 56, 0, 0, 950, 212, 1, 0, 0, 0, 951, 952, 5, 99, 0, 0, 952, 953, 5, 111, 0, 0, 953, 954, 5, 109, 0, 0, 954, 955, 5, 109, 0, 0, 955, 956, 5, 105, 0, 0, 956, 957, 5, 116, 0, 0, 957, 958, 5, 46, 0, 0, 958, 959, 5, 98, 0, 0, 959, 960, 5, 104, 0, 0, 960, 961, 5, 112, 0, 0, 961, 962, 5, 49, 0, 0, 962, 963, 5, 48, 0, 0, 963, 964, 5, 50, 0, 0, 964, 965, 5, 52, 0, 0, 965, 214, 1, 0, 0, 0, 966, 967, 5, 99, 0, 0, 967, 968, 5, 111, 0, 0, 968, 969, 5, 109, 0, 0, 969, 970, 5, 109, 0, 0, 970, 971, 5, 105, 0, 0, 971, 972, 5, 116, 0, 0, 972, 973, 5, 46, 0, 0, 973, 974, 5, 112, 0, 0, 974, 975, 5, 101, 0, 0, 975, 976, 5, 100, 0, 0, 976, 977, 5, 54, 0, 0, 977, 978, 5, 52, 0, 0, 978, 216, 1, 0, 0, 0, 979, 980, 5, 99, 0, 0, 980, 981, 5, 111, 0, 0, 981, 982, 5, 109, 0, 0, 982, 983, 5, 109, 0, 0, 983, 984, 5, 105, 0, 0, 984, 985, 5, 116, 0, 0, 985, 986, 5, 46, 0, 0, 986, 987, 5, 112, 0, 0, 987, 988, 5, 101, 0, 0, 988, 989, 5, 100, 0, 0, 989, 990, 5, 49, 0, 0, 990, 991, 5, 50, 0, 0, 991, 992, 5, 56, 0, 0, 992, 218, 1, 0, 0, 0, 993, 994, 5, 104, 0, 0, 994, 995, 5, 97, 0, 0, 995, 996, 5, 115, 0, 0, 996, 997, 5, 104, 0, 0, 997, 998, 5, 46, 0, 0, 998, 999, 5, 98, 0, 0, 999, 1000, 5, 104, 0, 0, 1000, 1001, 5, 112, 0, 0, 1001, 1002, 5, 50, 0, 0, 1002, 1003, 5, 53, 0, 0, 1003, 1004, 5, 54, 0, 0, 1004, 220, 1, 0, 0, 0, 1005, 1006, 5, 104, 0, 0, 1006, 1007, 5, 97, 0, 0, 1007, 1008, 5, 115, 0, 0, 1008, 1009, 5, 104, 0, 0, 1009, 1010, 5, 46, 0, 0, 1010, 1011, 5, 98, 0, 0, 1011, 1012, 5, 104, 0, 0, 1012, 1013, 5, 112, 0, 0, 1013, 1014, 5, 53, 0, 0, 1014, 1015, 5, 49, 0, 0, 1015, 1016, 5, 50, 0, 0, 1016, 222, 1, 0, 0, 0, 1017, 1018, 5, 104, 0, 0, 1018, 1019, 5, 97, 0, 0, 1019, 1020, 5, 115, 0, 0, 1020, 1021, 5, 104, 0, 0, 1021, 1022, 5, 46, 0, 0, 1022, 1023, 5, 98, 0, 0, 1023, 1024, 5, 104, 0, 0, 1024, 1025, 5, 112, 0, 0, 1025, 1026, 5, 55, 0, 0, 1026, 1027, 5, 54, 0, 0, 1027, 1028, 5, 56, 0, 0, 1028, 224, 1, 0, 0, 0, 1029, 1030, 5, 104, 0, 0, 1030, 1031, 5, 97, 0, 0, 1031, 1032, 5, 115, 0, 0, 1032, 1033, 5, 104, 0, 0, 1033, 1034, 5, 46, 0, 0, 1034, 1035, 5, 98, 0, 0, 1035, 1036, 5, 104, 0, 0, 1036, 1037, 5, 112, 0, 0, 1037, 1038, 5, 49, 0, 0, 1038, 1039, 5, 48, 0, 0, 1039, 1040, 5, 50, 0, 0, 1040, 1041, 5, 52, 0, 0, 1041, 226, 1, 0, 0, 0, 1042, 1043, 5, 104, 0, 0, 1043, 1044, 5, 97, 0, 0, 1044, 1045, 5, 115, 0, 0, 1045, 1046, 5, 104, 0, 0, 1046, 1047, 5, 46, 0, 0, 1047, 1048, 5, 112, 0, 0, 1048, 1049, 5, 101, 0, 0, 1049, 1050, 5, 100, 0, 0, 1050, 1051, 5, 54, 0, 0, 1051, 1052, 5, 52, 0, 0, 1052, 228, 1, 0, 0, 0, 1053, 1054, 5, 104, 0, 0, 1054, 1055, 5, 97, 0, 0, 1055, 1056, 5, 115, 0, 0, 1056, 1057, 5, 104, 0, 0, 1057, 1058, 5, 46, 0, 0, 1058, 1059, 5, 112, 0, 0, 1059, 1060, 5, 101, 0, 0, 1060, 1061, 5, 100, 0, 0, 1061, 1062, 5, 49, 0, 0, 1062, 1063, 5, 50, 0, 0, 1063, 1064, 5, 56, 0, 0, 1064, 230, 1, 0, 0, 0, 1065, 1066, 5, 104, 0, 0, 1066, 1067, 5, 97, 0, 0, 1067, 1068, 5, 115, 0, 0, 1068, 1069, 5, 104, 0, 0, 1069, 1070, 5, 46, 0, 0, 1070, 1071, 5, 112, 0, 0, 1071, 1072, 5, 115, 0, 0, 1072, 1073, 5, 100, 0, 0, 1073, 1074, 5, 50, 0, 0, 1074, 232, 1, 0, 0, 0, 1075, 1076, 5, 104, 0, 0, 1076, 1077, 5, 97, 0, 0, 1077, 1078, 5, 115, 0, 0, 1078, 1079, 5, 104, 0, 0, 1079, 1080, 5, 46, 0, 0, 1080, 1081, 5, 112, 0, 0, 1081, 1082, 5, 115, 0, 0, 1082, 1083, 5, 100, 0, 0, 1083, 1084, 5, 52, 0, 0, 1084, 234, 1, 0, 0, 0, 1085, 1086, 5, 104, 0, 0, 1086, 1087, 5, 97, 0, 0, 1087, 1088, 5, 115, 0, 0, 1088, 1089, 5, 104, 0, 0, 1089, 1090, 5, 46, 0, 0, 1090, 1091, 5, 112, 0, 0, 1091, 1092, 5, 115, 0, 0, 1092, 1093, 5, 100, 0, 0, 1093, 1094, 5, 56, 0, 0, 1094, 236, 1, 0, 0, 0, 1095, 1096, 5, 104, 0, 0, 1096, 1097, 5, 97, 0, 0, 1097, 1098, 5, 115, 0, 0, 1098, 1099, 5, 104, 0, 0, 1099, 1100, 5, 46, 0, 0, 1100, 1101, 5, 107, 0, 0, 1101, 1102, 5, 101, 0, 0, 1102, 1103, 5, 99, 0, 0, 1103, 1104, 5, 99, 0, 0, 1104, 1105, 5, 97, 0, 0, 1105, 1106, 5, 107, 0, 0, 1106, 1107, 5, 50, 0, 0, 1107, 1108, 5, 53, 0, 0, 1108, 1109, 5, 54, 0, 0, 1109, 238, 1, 0, 0, 0, 1110, 1111, 5, 104, 0, 0, 1111, 1112, 5, 97, 0, 0, 1112, 1113, 5, 115, 0, 0, 1113, 1114, 5, 104, 0, 0, 1114, 1115, 5, 46, 0, 0, 1115, 1116, 5, 107, 0, 0, 1116, 1117, 5, 101, 0, 0, 1117, 1118, 5, 99, 0, 0, 1118, 1119, 5, 99, 0, 0, 1119, 1120, 5, 97, 0, 0, 1120, 1121, 5, 107, 0, 0, 1121, 1122, 5, 51, 0, 0, 1122, 1123, 5, 56, 0, 0, 1123, 1124, 5, 52, 0, 0, 1124, 240, 1, 0, 0, 0, 1125, 1126, 5, 104, 0, 0, 1126, 1127, 5, 97, 0, 0, 1127, 1128, 5, 115, 0, 0, 1128, 1129, 5, 104, 0, 0, 1129, 1130, 5, 46, 0, 0, 1130, 1131, 5, 107, 0, 0, 1131, 1132, 5, 101, 0, 0, 1132, 1133, 5, 99, 0, 0, 1133, 1134, 5, 99, 0, 0, 1134, 1135, 5, 97, 0, 0, 1135, 1136, 5, 107, 0, 0, 1136, 1137, 5, 53, 0, 0, 1137, 1138, 5, 49, 0, 0, 1138, 1139, 5, 50, 0, 0, 1139, 242, 1, 0, 0, 0, 1140, 1141, 5, 104, 0, 0, 1141, 1142, 5, 97, 0, 0, 1142, 1143, 5, 115, 0, 0, 1143, 1144, 5, 104, 0, 0, 1144, 1145, 5, 46, 0, 0, 1145, 1146, 5, 115, 0, 0, 1146, 1147, 5, 104, 0, 0, 1147, 1148, 5, 97, 0, 0, 1148, 1149, 5, 51, 0, 0, 1149, 1150, 5, 95, 0, 0, 1150, 1151, 5, 50, 0, 0, 1151, 1152, 5, 53, 0, 0, 1152, 1153, 5, 54, 0, 0, 1153, 244, 1, 0, 0, 0, 1154, 1155, 5, 104, 0, 0, 1155, 1156, 5, 97, 0, 0, 1156, 1157, 5, 115, 0, 0, 1157, 1158, 5, 104, 0, 0, 1158, 1159, 5, 46, 0, 0, 1159, 1160, 5, 115, 0, 0, 1160, 1161, 5, 104, 0, 0, 1161, 1162, 5, 97, 0, 0, 1162, 1163, 5, 51, 0, 0, 1163, 1164, 5, 95, 0, 0, 1164, 1165, 5, 51, 0, 0, 1165, 1166, 5, 56, 0, 0, 1166, 1167, 5, 52, 0, 0, 1167, 246, 1, 0, 0, 0, 1168, 1169, 5, 104, 0, 0, 1169, 1170, 5, 97, 0, 0, 1170, 1171, 5, 115, 0, 0, 1171, 1172, 5, 104, 0, 0, 1172, 1173, 5, 46, 0, 0, 1173, 1174, 5, 115, 0, 0, 1174, 1175, 5, 104, 0, 0, 1175, 1176, 5, 97, 0, 0, 1176, 1177, 5, 51, 0, 0, 1177, 1178, 5, 95, 0, 0, 1178, 1179, 5, 53, 0, 0, 1179, 1180, 5, 49, 0, 0, 1180, 1181, 5, 50, 0, 0, 1181, 248, 1, 0, 0, 0, 1182, 1183, 5, 104, 0, 0, 1183, 1184, 5, 97, 0, 0, 1184, 1185, 5, 115, 0, 0, 1185, 1186, 5, 104, 0, 0, 1186, 1187, 5, 95, 0, 0, 1187, 1188, 5, 109, 0, 0, 1188, 1189, 5, 97, 0, 0, 1189, 1190, 5, 110, 0, 0, 1190, 1191, 5, 121, 0, 0, 1191, 1192, 5, 46, 0, 0, 1192, 1193, 5, 112, 0, 0, 1193, 1194, 5, 115, 0, 0, 1194, 1195, 5, 100, 0, 0, 1195, 1196, 5, 50, 0, 0, 1196, 250, 1, 0, 0, 0, 1197, 1198, 5, 104, 0, 0, 1198, 1199, 5, 97, 0, 0, 1199, 1200, 5, 115, 0, 0, 1200, 1201, 5, 104, 0, 0, 1201, 1202, 5, 95, 0, 0, 1202, 1203, 5, 109, 0, 0, 1203, 1204, 5, 97, 0, 0, 1204, 1205, 5, 110, 0, 0, 1205, 1206, 5, 121, 0, 0, 1206, 1207, 5, 46, 0, 0, 1207, 1208, 5, 112, 0, 0, 1208, 1209, 5, 115, 0, 0, 1209, 1210, 5, 100, 0, 0, 1210, 1211, 5, 52, 0, 0, 1211, 252, 1, 0, 0, 0, 1212, 1213, 5, 104, 0, 0, 1213, 1214, 5, 97, 0, 0, 1214, 1215, 5, 115, 0, 0, 1215, 1216, 5, 104, 0, 0, 1216, 1217, 5, 95, 0, 0, 1217, 1218, 5, 109, 0, 0, 1218, 1219, 5, 97, 0, 0, 1219, 1220, 5, 110, 0, 0, 1220, 1221, 5, 121, 0, 0, 1221, 1222, 5, 46, 0, 0, 1222, 1223, 5, 112, 0, 0, 1223, 1224, 5, 115, 0, 0, 1224, 1225, 5, 100, 0, 0, 1225, 1226, 5, 56, 0, 0, 1226, 254, 1, 0, 0, 0, 1227, 1228, 5, 99, 0, 0, 1228, 1229, 5, 97, 0, 0, 1229, 1230, 5, 115, 0, 0, 1230, 1231, 5, 116, 0, 0, 1231, 1232, 5, 46, 0, 0, 1232, 1233, 5, 108, 0, 0, 1233, 1234, 5, 111, 0, 0, 1234, 1235, 5, 115, 0, 0, 1235, 1236, 5, 115, 0, 0, 1236, 1237, 5, 121, 0, 0, 1237, 256, 1, 0, 0, 0, 1238, 1239, 5, 99, 0, 0, 1239, 1240, 5, 97, 0, 0, 1240, 1241, 5, 115, 0, 0, 1241, 1242, 5, 116, 0, 0, 1242, 258, 1, 0, 0, 0, 1243, 1244, 5, 98, 0, 0, 1244, 1245, 5, 114, 0, 0, 1245, 1246, 5, 97, 0, 0, 1246, 1247, 5, 110, 0, 0, 1247, 1248, 5, 99, 0, 0, 1248, 1249, 5, 104, 0, 0, 1249, 1250, 5, 46, 0, 0, 1250, 1251, 5, 101, 0, 0, 1251, 1252, 5, 113, 0, 0, 1252, 260, 1, 0, 0, 0, 1253, 1254, 5, 98, 0, 0, 1254, 1255, 5, 114, 0, 0, 1255, 1256, 5, 97, 0, 0, 1256, 1257, 5, 110, 0, 0, 1257, 1258, 5, 99, 0, 0, 1258, 1259, 5, 104, 0, 0, 1259, 1260, 5, 46, 0, 0, 1260, 1261, 5, 110, 0, 0, 1261, 1262, 5, 101, 0, 0, 1262, 1263, 5, 113, 0, 0, 1263, 262, 1, 0, 0, 0, 1264, 1265, 5, 97, 0, 0, 1265, 1266, 5, 108, 0, 0, 1266, 1267, 5, 101, 0, 0, 1267, 1268, 5, 111, 0, 0, 1268, 1269, 5, 49, 0, 0, 1269, 1277, 1, 0, 0, 0, 1270, 1274, 3, 267, 133, 0, 1271, 1273, 5, 95, 0, 0, 1272, 1271, 1, 0, 0, 0, 1273, 1276, 1, 0, 0, 0, 1274, 1272, 1, 0, 0, 0, 1274, 1275, 1, 0, 0, 0, 1275, 1278, 1, 0, 0, 0, 1276, 1274, 1, 0, 0, 0, 1277, 1270, 1, 0, 0, 0, 1278, 1279, 1, 0, 0, 0, 1279, 1277, 1, 0, 0, 0, 1279, 1280, 1, 0, 0, 0, 1280, 264, 1, 0, 0, 0, 1281, 1282, 5, 115, 0, 0, 1282, 1283, 5, 105, 0, 0, 1283, 1284, 5, 103, 0, 0, 1284, 1285, 5, 110, 0, 0, 1285, 1286, 5, 49, 0, 0, 1286, 1294, 1, 0, 0, 0, 1287, 1291, 3, 267, 133, 0, 1288, 1290, 5, 95, 0, 0, 1289, 1288, 1, 0, 0, 0, 1290, 1293, 1, 0, 0, 0, 1291, 1289, 1, 0, 0, 0, 1291, 1292, 1, 0, 0, 0, 1292, 1295, 1, 0, 0, 0, 1293, 1291, 1, 0, 0, 0, 1294, 1287, 1, 0, 0, 0, 1295, 1296, 1, 0, 0, 0, 1296, 1294, 1, 0, 0, 0, 1296, 1297, 1, 0, 0, 0, 1297, 266, 1, 0, 0, 0, 1298, 1301, 3, 277, 138, 0, 1299, 1301, 3, 285, 142, 0, 1300, 1298, 1, 0, 0, 0, 1300, 1299, 1, 0, 0, 0, 1301, 268, 1, 0, 0, 0, 1302, 1304, 5, 114, 0, 0, 1303, 1305, 3, 283, 141, 0, 1304, 1303, 1, 0, 0, 0, 1305, 1306, 1, 0, 0, 0, 1306, 1304, 1, 0, 0, 0, 1306, 1307, 1, 0, 0, 0, 1307, 270, 1, 0, 0, 0, 1308, 1314, 3, 273, 136, 0, 1309, 1313, 3, 273, 136, 0, 1310, 1313, 3, 283, 141, 0, 1311, 1313, 5, 95, 0, 0, 1312, 1309, 1, 0, 0, 0, 1312, 1310, 1, 0, 0, 0, 1312, 1311, 1, 0, 0, 0, 1313, 1316, 1, 0, 0, 0, 1314, 1312, 1, 0, 0, 0, 1314, 1315, 1, 0, 0, 0, 1315, 272, 1, 0, 0, 0, 1316, 1314, 1, 0, 0, 0, 1317, 1320, 3, 275, 137, 0, 1318, 1320, 3, 281, 140, 0, 1319, 1317, 1, 0, 0, 0, 1319, 1318, 1, 0, 0, 0, 1320, 274, 1, 0, 0, 0, 1321, 1324, 3, 277, 138, 0, 1322, 1324, 3, 279, 139, 0, 1323, 1321, 1, 0, 0, 0, 1323, 1322, 1, 0, 0, 0, 1324, 276, 1, 0, 0, 0, 1325, 1326, 7, 0, 0, 0, 1326, 278, 1, 0, 0, 0, 1327, 1328, 7, 1, 0, 0, 1328, 280, 1, 0, 0, 0, 1329, 1330, 7, 2, 0, 0, 1330, 282, 1, 0, 0, 0, 1331, 1334, 3, 285, 142, 0, 1332, 1334, 3, 287, 143, 0, 1333, 1331, 1, 0, 0, 0, 1333, 1332, 1, 0, 0, 0, 1334, 284, 1, 0, 0, 0, 1335, 1336, 7, 3, 0, 0, 1336, 286, 1, 0, 0, 0, 1337, 1338, 5, 49, 0, 0, 1338, 288, 1, 0, 0, 0, 1339, 1341, 7, 4, 0, 0, 1340, 1339, 1, 0, 0, 0, 1341, 1342, 1, 0, 0, 0, 1342, 1340, 1, 0, 0, 0, 1342, 1343, 1, 0, 0, 0, 1343, 1344, 1, 0, 0, 0, 1344, 1345, 6, 144, 0, 0, 1345, 290, 1, 0, 0, 0, 1346, 1347, 5, 47, 0, 0, 1347, 1348, 5, 42, 0, 0, 1348, 1352, 1, 0, 0, 0, 1349, 1351, 9, 0, 0, 0, 1350, 1349, 1, 0, 0, 0, 1351, 1354, 1, 0, 0, 0, 1352, 1353, 1, 0, 0, 0, 1352, 1350, 1, 0, 0, 0, 1353, 1355, 1, 0, 0, 0, 1354, 1352, 1, 0, 0, 0, 1355, 1356, 5, 42, 0, 0, 1356, 1357, 5, 47, 0, 0, 1357, 1358, 1, 0, 0, 0, 1358, 1359, 6, 145, 1, 0, 1359, 292, 1, 0, 0, 0, 1360, 1361, 5, 47, 0, 0, 1361, 1362, 5, 47, 0, 0, 1362, 1366, 1, 0, 0, 0, 1363, 1365, 8, 5, 0, 0, 1364, 1363, 1, 0, 0, 0, 1365, 1368, 1, 0, 0, 0, 1366, 1364, 1, 0, 0, 0, 1366, 1367, 1, 0, 0, 0, 1367, 1369, 1, 0, 0, 0, 1368, 1366, 1, 0, 0, 0, 1369, 1370, 6, 146, 1, 0, 1370, 294, 1, 0, 0, 0, 15, 0, 1274, 1279, 1291, 1296, 1300, 1306, 1312, 1314, 1319, 1323, 1333, 1342, 1352, 1366, 2, 6, 0, 0, 0, 1, 0] \ No newline at end of file diff --git a/vanguard/aleo/parser/.antlr/AleoLexer.java b/vanguard/aleo/parser/.antlr/AleoLexer.java new file mode 100644 index 0000000..760a4ea --- /dev/null +++ b/vanguard/aleo/parser/.antlr/AleoLexer.java @@ -0,0 +1,986 @@ +// Generated from /Users/joseph/Desktop/UCSB/24winter/vanguard-aleo/vanguard/aleo/parser/aleo.g4 by ANTLR 4.13.1 +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.*; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) +public class AleoLexer extends Lexer { + static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, + T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, + T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, + T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31, + T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38, + T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, T__44=45, + T__45=46, T__46=47, T__47=48, T__48=49, T__49=50, T__50=51, T__51=52, + T__52=53, T__53=54, T__54=55, T__55=56, T__56=57, T__57=58, T__58=59, + T__59=60, T__60=61, T__61=62, T__62=63, T__63=64, T__64=65, T__65=66, + T__66=67, T__67=68, T__68=69, T__69=70, T__70=71, T__71=72, T__72=73, + T__73=74, T__74=75, T__75=76, T__76=77, T__77=78, T__78=79, T__79=80, + T__80=81, T__81=82, T__82=83, T__83=84, T__84=85, T__85=86, T__86=87, + T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, T__92=93, T__93=94, + T__94=95, T__95=96, T__96=97, T__97=98, T__98=99, T__99=100, T__100=101, + T__101=102, T__102=103, T__103=104, T__104=105, T__105=106, T__106=107, + T__107=108, T__108=109, T__109=110, T__110=111, T__111=112, T__112=113, + T__113=114, T__114=115, T__115=116, T__116=117, T__117=118, T__118=119, + T__119=120, T__120=121, T__121=122, T__122=123, T__123=124, T__124=125, + T__125=126, T__126=127, T__127=128, T__128=129, T__129=130, T__130=131, + ADDRESS_LITERAL=132, SIGNATURE_LITERAL=133, REGISTER=134, IDENTIFIER=135, + DIGIT=136, WS=137, COMMENT=138, LINE_COMMENT=139; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }; + + public static String[] modeNames = { + "DEFAULT_MODE" + }; + + private static String[] makeRuleNames() { + return new String[] { + "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", "T__7", "T__8", + "T__9", "T__10", "T__11", "T__12", "T__13", "T__14", "T__15", "T__16", + "T__17", "T__18", "T__19", "T__20", "T__21", "T__22", "T__23", "T__24", + "T__25", "T__26", "T__27", "T__28", "T__29", "T__30", "T__31", "T__32", + "T__33", "T__34", "T__35", "T__36", "T__37", "T__38", "T__39", "T__40", + "T__41", "T__42", "T__43", "T__44", "T__45", "T__46", "T__47", "T__48", + "T__49", "T__50", "T__51", "T__52", "T__53", "T__54", "T__55", "T__56", + "T__57", "T__58", "T__59", "T__60", "T__61", "T__62", "T__63", "T__64", + "T__65", "T__66", "T__67", "T__68", "T__69", "T__70", "T__71", "T__72", + "T__73", "T__74", "T__75", "T__76", "T__77", "T__78", "T__79", "T__80", + "T__81", "T__82", "T__83", "T__84", "T__85", "T__86", "T__87", "T__88", + "T__89", "T__90", "T__91", "T__92", "T__93", "T__94", "T__95", "T__96", + "T__97", "T__98", "T__99", "T__100", "T__101", "T__102", "T__103", "T__104", + "T__105", "T__106", "T__107", "T__108", "T__109", "T__110", "T__111", + "T__112", "T__113", "T__114", "T__115", "T__116", "T__117", "T__118", + "T__119", "T__120", "T__121", "T__122", "T__123", "T__124", "T__125", + "T__126", "T__127", "T__128", "T__129", "T__130", "ADDRESS_LITERAL", + "SIGNATURE_LITERAL", "ADDRESS_OR_SIGNATURE_CHAR", "REGISTER", "IDENTIFIER", + "LETTER", "LOWERCASE_LETTER", "ADDRESS_OR_SIGNATURE_LOWERCASE_LETTER", + "OTHER_LOWERCASE_LETTER", "UPPERCASE_LETTER", "DIGIT", "ADDRESS_OR_SIGNATURE_DIGIT", + "OTHER_DIGIT", "WS", "COMMENT", "LINE_COMMENT" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, "'program'", "';'", "'import'", "'mapping'", "':'", "'key'", "'as'", + "'value'", "'struct'", "'record'", "'closure'", "'input'", "'output'", + "'function'", "'finalize'", "'contains'", "'['", "']'", "'into'", "'get'", + "'get.or_use'", "'set'", "'remove'", "'rand.chacha'", "'position'", "'to'", + "'await'", "'ternary'", "'sign.verify'", "'sign_verify'", "'call'", "'async'", + "'-'", "'_'", "'u32'", "'true'", "'false'", "'u8'", "'u16'", "'u64'", + "'u128'", "'i8'", "'i16'", "'i32'", "'i64'", "'i128'", "'field'", "'group'", + "'scalar'", "'address'", "'boolean'", "'signature'", "'.constant'", "'.public'", + "'.private'", "'.record'", "'.future'", "'.'", "'group::GEN'", "'self.signer'", + "'self.caller'", "'block.height'", "'/'", "'group.x'", "'group.y'", "'abs'", + "'abs.w'", "'double'", "'inv'", "'neg'", "'not'", "'square'", "'sqrt'", + "'add'", "'add.w'", "'sub'", "'sub.w'", "'mul'", "'mul.w'", "'div'", + "'div.w'", "'rem'", "'rem.w'", "'pow'", "'pow.w'", "'shl'", "'shl.w'", + "'shr'", "'shr.w'", "'mod'", "'and'", "'or'", "'xor'", "'nand'", "'nor'", + "'gt'", "'gte'", "'lt'", "'lte'", "'is.eq'", "'is.neq'", "'assert.eq'", + "'assert.neq'", "'commit.bhp256'", "'commit.bhp512'", "'commit.bhp768'", + "'commit.bhp1024'", "'commit.ped64'", "'commit.ped128'", "'hash.bhp256'", + "'hash.bhp512'", "'hash.bhp768'", "'hash.bhp1024'", "'hash.ped64'", "'hash.ped128'", + "'hash.psd2'", "'hash.psd4'", "'hash.psd8'", "'hash.keccak256'", "'hash.keccak384'", + "'hash.keccak512'", "'hash.sha3_256'", "'hash.sha3_384'", "'hash.sha3_512'", + "'hash_many.psd2'", "'hash_many.psd4'", "'hash_many.psd8'", "'cast.lossy'", + "'cast'", "'branch.eq'", "'branch.neq'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + "ADDRESS_LITERAL", "SIGNATURE_LITERAL", "REGISTER", "IDENTIFIER", "DIGIT", + "WS", "COMMENT", "LINE_COMMENT" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + + public AleoLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "aleo.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getChannelNames() { return channelNames; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + public static final String _serializedATN = + "\u0004\u0000\u008b\u055b\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002"+ + "\u0001\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002"+ + "\u0004\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002"+ + "\u0007\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002"+ + "\u000b\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e"+ + "\u0002\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011"+ + "\u0002\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014"+ + "\u0002\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017"+ + "\u0002\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a"+ + "\u0002\u001b\u0007\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d"+ + "\u0002\u001e\u0007\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!"+ + "\u0007!\u0002\"\u0007\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002"+ + "&\u0007&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002"+ + "+\u0007+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u0002"+ + "0\u00070\u00021\u00071\u00022\u00072\u00023\u00073\u00024\u00074\u0002"+ + "5\u00075\u00026\u00076\u00027\u00077\u00028\u00078\u00029\u00079\u0002"+ + ":\u0007:\u0002;\u0007;\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002"+ + "?\u0007?\u0002@\u0007@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002"+ + "D\u0007D\u0002E\u0007E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002"+ + "I\u0007I\u0002J\u0007J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002"+ + "N\u0007N\u0002O\u0007O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002"+ + "S\u0007S\u0002T\u0007T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002"+ + "X\u0007X\u0002Y\u0007Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002"+ + "]\u0007]\u0002^\u0007^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002"+ + "b\u0007b\u0002c\u0007c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002"+ + "g\u0007g\u0002h\u0007h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002"+ + "l\u0007l\u0002m\u0007m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002"+ + "q\u0007q\u0002r\u0007r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002"+ + "v\u0007v\u0002w\u0007w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002"+ + "{\u0007{\u0002|\u0007|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f"+ + "\u0002\u0080\u0007\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082"+ + "\u0002\u0083\u0007\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085"+ + "\u0002\u0086\u0007\u0086\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088"+ + "\u0002\u0089\u0007\u0089\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b"+ + "\u0002\u008c\u0007\u008c\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e"+ + "\u0002\u008f\u0007\u008f\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091"+ + "\u0002\u0092\u0007\u0092\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000"+ + "\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001"+ + "\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+ + "\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003"+ + "\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0004\u0001\u0004\u0001\u0005"+ + "\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006\u0001\u0006"+ + "\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+ + "\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\t\u0001"+ + "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\n\u0001\n\u0001\n\u0001"+ + "\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\u000b\u0001\u000b\u0001\u000b"+ + "\u0001\u000b\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0001"+ + "\f\u0001\f\u0001\f\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+ + "\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+ + "\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000f\u0001"+ + "\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001"+ + "\u000f\u0001\u000f\u0001\u0010\u0001\u0010\u0001\u0011\u0001\u0011\u0001"+ + "\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0013\u0001"+ + "\u0013\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+ + "\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+ + "\u0014\u0001\u0014\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001"+ + "\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001"+ + "\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+ + "\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+ + "\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001"+ + "\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001"+ + "\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+ + "\u001a\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001"+ + "\u001b\u0001\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0001"+ + "\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001"+ + "\u001c\u0001\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+ + "\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+ + "\u001d\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0001"+ + "\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001"+ + "\u001f\u0001\u001f\u0001 \u0001 \u0001!\u0001!\u0001\"\u0001\"\u0001\""+ + "\u0001\"\u0001#\u0001#\u0001#\u0001#\u0001#\u0001$\u0001$\u0001$\u0001"+ + "$\u0001$\u0001$\u0001%\u0001%\u0001%\u0001&\u0001&\u0001&\u0001&\u0001"+ + "\'\u0001\'\u0001\'\u0001\'\u0001(\u0001(\u0001(\u0001(\u0001(\u0001)\u0001"+ + ")\u0001)\u0001*\u0001*\u0001*\u0001*\u0001+\u0001+\u0001+\u0001+\u0001"+ + ",\u0001,\u0001,\u0001,\u0001-\u0001-\u0001-\u0001-\u0001-\u0001.\u0001"+ + ".\u0001.\u0001.\u0001.\u0001.\u0001/\u0001/\u0001/\u0001/\u0001/\u0001"+ + "/\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u00011\u00011\u0001"+ + "1\u00011\u00011\u00011\u00011\u00011\u00012\u00012\u00012\u00012\u0001"+ + "2\u00012\u00012\u00012\u00013\u00013\u00013\u00013\u00013\u00013\u0001"+ + "3\u00013\u00013\u00013\u00014\u00014\u00014\u00014\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00015\u00015\u00015\u00015\u00015\u00015\u0001"+ + "5\u00015\u00016\u00016\u00016\u00016\u00016\u00016\u00016\u00016\u0001"+ + "6\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u00018\u0001"+ + "8\u00018\u00018\u00018\u00018\u00018\u00018\u00019\u00019\u0001:\u0001"+ + ":\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001"+ + ";\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001"+ + ";\u0001;\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001"+ + "<\u0001<\u0001<\u0001<\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001"+ + "=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001>\u0001>\u0001?\u0001"+ + "?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001@\u0001@\u0001@\u0001"+ + "@\u0001@\u0001@\u0001@\u0001@\u0001A\u0001A\u0001A\u0001A\u0001B\u0001"+ + "B\u0001B\u0001B\u0001B\u0001B\u0001C\u0001C\u0001C\u0001C\u0001C\u0001"+ + "C\u0001C\u0001D\u0001D\u0001D\u0001D\u0001E\u0001E\u0001E\u0001E\u0001"+ + "F\u0001F\u0001F\u0001F\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001"+ + "G\u0001H\u0001H\u0001H\u0001H\u0001H\u0001I\u0001I\u0001I\u0001I\u0001"+ + "J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001K\u0001K\u0001K\u0001K\u0001"+ + "L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001M\u0001M\u0001M\u0001M\u0001"+ + "N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001O\u0001O\u0001O\u0001O\u0001"+ + "P\u0001P\u0001P\u0001P\u0001P\u0001P\u0001Q\u0001Q\u0001Q\u0001Q\u0001"+ + "R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001S\u0001S\u0001S\u0001S\u0001"+ + "T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001U\u0001U\u0001U\u0001U\u0001"+ + "V\u0001V\u0001V\u0001V\u0001V\u0001V\u0001W\u0001W\u0001W\u0001W\u0001"+ + "X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001Y\u0001Y\u0001Y\u0001Y\u0001"+ + "Z\u0001Z\u0001Z\u0001Z\u0001[\u0001[\u0001[\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001]\u0001]\u0001]\u0001]\u0001]\u0001^\u0001^\u0001^\u0001^\u0001"+ + "_\u0001_\u0001_\u0001`\u0001`\u0001`\u0001`\u0001a\u0001a\u0001a\u0001"+ + "b\u0001b\u0001b\u0001b\u0001c\u0001c\u0001c\u0001c\u0001c\u0001c\u0001"+ + "d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001e\u0001e\u0001e\u0001"+ + "e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001f\u0001f\u0001f\u0001"+ + "f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001g\u0001g\u0001"+ + "g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001g\u0001"+ + "g\u0001g\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001"+ + "h\u0001h\u0001h\u0001h\u0001h\u0001h\u0001i\u0001i\u0001i\u0001i\u0001"+ + "i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+ + "j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001"+ + "j\u0001j\u0001j\u0001j\u0001j\u0001k\u0001k\u0001k\u0001k\u0001k\u0001"+ + "k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001l\u0001l\u0001"+ + "l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001"+ + "l\u0001l\u0001m\u0001m\u0001m\u0001m\u0001m\u0001m\u0001m\u0001m\u0001"+ + "m\u0001m\u0001m\u0001m\u0001n\u0001n\u0001n\u0001n\u0001n\u0001n\u0001"+ + "n\u0001n\u0001n\u0001n\u0001n\u0001n\u0001o\u0001o\u0001o\u0001o\u0001"+ + "o\u0001o\u0001o\u0001o\u0001o\u0001o\u0001o\u0001o\u0001p\u0001p\u0001"+ + "p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001"+ + "p\u0001q\u0001q\u0001q\u0001q\u0001q\u0001q\u0001q\u0001q\u0001q\u0001"+ + "q\u0001q\u0001r\u0001r\u0001r\u0001r\u0001r\u0001r\u0001r\u0001r\u0001"+ + "r\u0001r\u0001r\u0001r\u0001s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001"+ + "s\u0001s\u0001s\u0001s\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001"+ + "t\u0001t\u0001t\u0001t\u0001u\u0001u\u0001u\u0001u\u0001u\u0001u\u0001"+ + "u\u0001u\u0001u\u0001u\u0001v\u0001v\u0001v\u0001v\u0001v\u0001v\u0001"+ + "v\u0001v\u0001v\u0001v\u0001v\u0001v\u0001v\u0001v\u0001v\u0001w\u0001"+ + "w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001"+ + "w\u0001w\u0001w\u0001w\u0001x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001"+ + "x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001y\u0001"+ + "y\u0001y\u0001y\u0001y\u0001y\u0001y\u0001y\u0001y\u0001y\u0001y\u0001"+ + "y\u0001y\u0001y\u0001z\u0001z\u0001z\u0001z\u0001z\u0001z\u0001z\u0001"+ + "z\u0001z\u0001z\u0001z\u0001z\u0001z\u0001z\u0001{\u0001{\u0001{\u0001"+ + "{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001"+ + "{\u0001|\u0001|\u0001|\u0001|\u0001|\u0001|\u0001|\u0001|\u0001|\u0001"+ + "|\u0001|\u0001|\u0001|\u0001|\u0001|\u0001}\u0001}\u0001}\u0001}\u0001"+ + "}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001"+ + "}\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001"+ + "~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001\u007f\u0001\u007f\u0001\u007f"+ + "\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f"+ + "\u0001\u007f\u0001\u007f\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0080"+ + "\u0001\u0080\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081"+ + "\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0082"+ + "\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082"+ + "\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0083\u0001\u0083"+ + "\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083"+ + "\u0005\u0083\u04f9\b\u0083\n\u0083\f\u0083\u04fc\t\u0083\u0004\u0083\u04fe"+ + "\b\u0083\u000b\u0083\f\u0083\u04ff\u0001\u0084\u0001\u0084\u0001\u0084"+ + "\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0005\u0084"+ + "\u050a\b\u0084\n\u0084\f\u0084\u050d\t\u0084\u0004\u0084\u050f\b\u0084"+ + "\u000b\u0084\f\u0084\u0510\u0001\u0085\u0001\u0085\u0003\u0085\u0515\b"+ + "\u0085\u0001\u0086\u0001\u0086\u0004\u0086\u0519\b\u0086\u000b\u0086\f"+ + "\u0086\u051a\u0001\u0087\u0001\u0087\u0001\u0087\u0001\u0087\u0005\u0087"+ + "\u0521\b\u0087\n\u0087\f\u0087\u0524\t\u0087\u0001\u0088\u0001\u0088\u0003"+ + "\u0088\u0528\b\u0088\u0001\u0089\u0001\u0089\u0003\u0089\u052c\b\u0089"+ + "\u0001\u008a\u0001\u008a\u0001\u008b\u0001\u008b\u0001\u008c\u0001\u008c"+ + "\u0001\u008d\u0001\u008d\u0003\u008d\u0536\b\u008d\u0001\u008e\u0001\u008e"+ + "\u0001\u008f\u0001\u008f\u0001\u0090\u0004\u0090\u053d\b\u0090\u000b\u0090"+ + "\f\u0090\u053e\u0001\u0090\u0001\u0090\u0001\u0091\u0001\u0091\u0001\u0091"+ + "\u0001\u0091\u0005\u0091\u0547\b\u0091\n\u0091\f\u0091\u054a\t\u0091\u0001"+ + "\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0092\u0001"+ + "\u0092\u0001\u0092\u0001\u0092\u0005\u0092\u0555\b\u0092\n\u0092\f\u0092"+ + "\u0558\t\u0092\u0001\u0092\u0001\u0092\u0001\u0548\u0000\u0093\u0001\u0001"+ + "\u0003\u0002\u0005\u0003\u0007\u0004\t\u0005\u000b\u0006\r\u0007\u000f"+ + "\b\u0011\t\u0013\n\u0015\u000b\u0017\f\u0019\r\u001b\u000e\u001d\u000f"+ + "\u001f\u0010!\u0011#\u0012%\u0013\'\u0014)\u0015+\u0016-\u0017/\u0018"+ + "1\u00193\u001a5\u001b7\u001c9\u001d;\u001e=\u001f? A!C\"E#G$I%K&M\'O("+ + "Q)S*U+W,Y-[.]/_0a1c2e3g4i5k6m7o8q9s:u;w}?\u007f@\u0081A\u0083B\u0085"+ + "C\u0087D\u0089E\u008bF\u008dG\u008fH\u0091I\u0093J\u0095K\u0097L\u0099"+ + "M\u009bN\u009dO\u009fP\u00a1Q\u00a3R\u00a5S\u00a7T\u00a9U\u00abV\u00ad"+ + "W\u00afX\u00b1Y\u00b3Z\u00b5[\u00b7\\\u00b9]\u00bb^\u00bd_\u00bf`\u00c1"+ + "a\u00c3b\u00c5c\u00c7d\u00c9e\u00cbf\u00cdg\u00cfh\u00d1i\u00d3j\u00d5"+ + "k\u00d7l\u00d9m\u00dbn\u00ddo\u00dfp\u00e1q\u00e3r\u00e5s\u00e7t\u00e9"+ + "u\u00ebv\u00edw\u00efx\u00f1y\u00f3z\u00f5{\u00f7|\u00f9}\u00fb~\u00fd"+ + "\u007f\u00ff\u0080\u0101\u0081\u0103\u0082\u0105\u0083\u0107\u0084\u0109"+ + "\u0085\u010b\u0000\u010d\u0086\u010f\u0087\u0111\u0000\u0113\u0000\u0115"+ + "\u0000\u0117\u0000\u0119\u0000\u011b\u0088\u011d\u0000\u011f\u0000\u0121"+ + "\u0089\u0123\u008a\u0125\u008b\u0001\u0000\u0006\u0004\u0000aachjnpz\u0003"+ + "\u0000bbiioo\u0001\u0000AZ\u0002\u00000029\u0003\u0000\t\n\f\r \u0002"+ + "\u0000\n\n\r\r\u0561\u0000\u0001\u0001\u0000\u0000\u0000\u0000\u0003\u0001"+ + "\u0000\u0000\u0000\u0000\u0005\u0001\u0000\u0000\u0000\u0000\u0007\u0001"+ + "\u0000\u0000\u0000\u0000\t\u0001\u0000\u0000\u0000\u0000\u000b\u0001\u0000"+ + "\u0000\u0000\u0000\r\u0001\u0000\u0000\u0000\u0000\u000f\u0001\u0000\u0000"+ + "\u0000\u0000\u0011\u0001\u0000\u0000\u0000\u0000\u0013\u0001\u0000\u0000"+ + "\u0000\u0000\u0015\u0001\u0000\u0000\u0000\u0000\u0017\u0001\u0000\u0000"+ + "\u0000\u0000\u0019\u0001\u0000\u0000\u0000\u0000\u001b\u0001\u0000\u0000"+ + "\u0000\u0000\u001d\u0001\u0000\u0000\u0000\u0000\u001f\u0001\u0000\u0000"+ + "\u0000\u0000!\u0001\u0000\u0000\u0000\u0000#\u0001\u0000\u0000\u0000\u0000"+ + "%\u0001\u0000\u0000\u0000\u0000\'\u0001\u0000\u0000\u0000\u0000)\u0001"+ + "\u0000\u0000\u0000\u0000+\u0001\u0000\u0000\u0000\u0000-\u0001\u0000\u0000"+ + "\u0000\u0000/\u0001\u0000\u0000\u0000\u00001\u0001\u0000\u0000\u0000\u0000"+ + "3\u0001\u0000\u0000\u0000\u00005\u0001\u0000\u0000\u0000\u00007\u0001"+ + "\u0000\u0000\u0000\u00009\u0001\u0000\u0000\u0000\u0000;\u0001\u0000\u0000"+ + "\u0000\u0000=\u0001\u0000\u0000\u0000\u0000?\u0001\u0000\u0000\u0000\u0000"+ + "A\u0001\u0000\u0000\u0000\u0000C\u0001\u0000\u0000\u0000\u0000E\u0001"+ + "\u0000\u0000\u0000\u0000G\u0001\u0000\u0000\u0000\u0000I\u0001\u0000\u0000"+ + "\u0000\u0000K\u0001\u0000\u0000\u0000\u0000M\u0001\u0000\u0000\u0000\u0000"+ + "O\u0001\u0000\u0000\u0000\u0000Q\u0001\u0000\u0000\u0000\u0000S\u0001"+ + "\u0000\u0000\u0000\u0000U\u0001\u0000\u0000\u0000\u0000W\u0001\u0000\u0000"+ + "\u0000\u0000Y\u0001\u0000\u0000\u0000\u0000[\u0001\u0000\u0000\u0000\u0000"+ + "]\u0001\u0000\u0000\u0000\u0000_\u0001\u0000\u0000\u0000\u0000a\u0001"+ + "\u0000\u0000\u0000\u0000c\u0001\u0000\u0000\u0000\u0000e\u0001\u0000\u0000"+ + "\u0000\u0000g\u0001\u0000\u0000\u0000\u0000i\u0001\u0000\u0000\u0000\u0000"+ + "k\u0001\u0000\u0000\u0000\u0000m\u0001\u0000\u0000\u0000\u0000o\u0001"+ + "\u0000\u0000\u0000\u0000q\u0001\u0000\u0000\u0000\u0000s\u0001\u0000\u0000"+ + "\u0000\u0000u\u0001\u0000\u0000\u0000\u0000w\u0001\u0000\u0000\u0000\u0000"+ + "y\u0001\u0000\u0000\u0000\u0000{\u0001\u0000\u0000\u0000\u0000}\u0001"+ + "\u0000\u0000\u0000\u0000\u007f\u0001\u0000\u0000\u0000\u0000\u0081\u0001"+ + "\u0000\u0000\u0000\u0000\u0083\u0001\u0000\u0000\u0000\u0000\u0085\u0001"+ + "\u0000\u0000\u0000\u0000\u0087\u0001\u0000\u0000\u0000\u0000\u0089\u0001"+ + "\u0000\u0000\u0000\u0000\u008b\u0001\u0000\u0000\u0000\u0000\u008d\u0001"+ + "\u0000\u0000\u0000\u0000\u008f\u0001\u0000\u0000\u0000\u0000\u0091\u0001"+ + "\u0000\u0000\u0000\u0000\u0093\u0001\u0000\u0000\u0000\u0000\u0095\u0001"+ + "\u0000\u0000\u0000\u0000\u0097\u0001\u0000\u0000\u0000\u0000\u0099\u0001"+ + "\u0000\u0000\u0000\u0000\u009b\u0001\u0000\u0000\u0000\u0000\u009d\u0001"+ + "\u0000\u0000\u0000\u0000\u009f\u0001\u0000\u0000\u0000\u0000\u00a1\u0001"+ + "\u0000\u0000\u0000\u0000\u00a3\u0001\u0000\u0000\u0000\u0000\u00a5\u0001"+ + "\u0000\u0000\u0000\u0000\u00a7\u0001\u0000\u0000\u0000\u0000\u00a9\u0001"+ + "\u0000\u0000\u0000\u0000\u00ab\u0001\u0000\u0000\u0000\u0000\u00ad\u0001"+ + "\u0000\u0000\u0000\u0000\u00af\u0001\u0000\u0000\u0000\u0000\u00b1\u0001"+ + "\u0000\u0000\u0000\u0000\u00b3\u0001\u0000\u0000\u0000\u0000\u00b5\u0001"+ + "\u0000\u0000\u0000\u0000\u00b7\u0001\u0000\u0000\u0000\u0000\u00b9\u0001"+ + "\u0000\u0000\u0000\u0000\u00bb\u0001\u0000\u0000\u0000\u0000\u00bd\u0001"+ + "\u0000\u0000\u0000\u0000\u00bf\u0001\u0000\u0000\u0000\u0000\u00c1\u0001"+ + "\u0000\u0000\u0000\u0000\u00c3\u0001\u0000\u0000\u0000\u0000\u00c5\u0001"+ + "\u0000\u0000\u0000\u0000\u00c7\u0001\u0000\u0000\u0000\u0000\u00c9\u0001"+ + "\u0000\u0000\u0000\u0000\u00cb\u0001\u0000\u0000\u0000\u0000\u00cd\u0001"+ + "\u0000\u0000\u0000\u0000\u00cf\u0001\u0000\u0000\u0000\u0000\u00d1\u0001"+ + "\u0000\u0000\u0000\u0000\u00d3\u0001\u0000\u0000\u0000\u0000\u00d5\u0001"+ + "\u0000\u0000\u0000\u0000\u00d7\u0001\u0000\u0000\u0000\u0000\u00d9\u0001"+ + "\u0000\u0000\u0000\u0000\u00db\u0001\u0000\u0000\u0000\u0000\u00dd\u0001"+ + "\u0000\u0000\u0000\u0000\u00df\u0001\u0000\u0000\u0000\u0000\u00e1\u0001"+ + "\u0000\u0000\u0000\u0000\u00e3\u0001\u0000\u0000\u0000\u0000\u00e5\u0001"+ + "\u0000\u0000\u0000\u0000\u00e7\u0001\u0000\u0000\u0000\u0000\u00e9\u0001"+ + "\u0000\u0000\u0000\u0000\u00eb\u0001\u0000\u0000\u0000\u0000\u00ed\u0001"+ + "\u0000\u0000\u0000\u0000\u00ef\u0001\u0000\u0000\u0000\u0000\u00f1\u0001"+ + "\u0000\u0000\u0000\u0000\u00f3\u0001\u0000\u0000\u0000\u0000\u00f5\u0001"+ + "\u0000\u0000\u0000\u0000\u00f7\u0001\u0000\u0000\u0000\u0000\u00f9\u0001"+ + "\u0000\u0000\u0000\u0000\u00fb\u0001\u0000\u0000\u0000\u0000\u00fd\u0001"+ + "\u0000\u0000\u0000\u0000\u00ff\u0001\u0000\u0000\u0000\u0000\u0101\u0001"+ + "\u0000\u0000\u0000\u0000\u0103\u0001\u0000\u0000\u0000\u0000\u0105\u0001"+ + "\u0000\u0000\u0000\u0000\u0107\u0001\u0000\u0000\u0000\u0000\u0109\u0001"+ + "\u0000\u0000\u0000\u0000\u010d\u0001\u0000\u0000\u0000\u0000\u010f\u0001"+ + "\u0000\u0000\u0000\u0000\u011b\u0001\u0000\u0000\u0000\u0000\u0121\u0001"+ + "\u0000\u0000\u0000\u0000\u0123\u0001\u0000\u0000\u0000\u0000\u0125\u0001"+ + "\u0000\u0000\u0000\u0001\u0127\u0001\u0000\u0000\u0000\u0003\u012f\u0001"+ + "\u0000\u0000\u0000\u0005\u0131\u0001\u0000\u0000\u0000\u0007\u0138\u0001"+ + "\u0000\u0000\u0000\t\u0140\u0001\u0000\u0000\u0000\u000b\u0142\u0001\u0000"+ + "\u0000\u0000\r\u0146\u0001\u0000\u0000\u0000\u000f\u0149\u0001\u0000\u0000"+ + "\u0000\u0011\u014f\u0001\u0000\u0000\u0000\u0013\u0156\u0001\u0000\u0000"+ + "\u0000\u0015\u015d\u0001\u0000\u0000\u0000\u0017\u0165\u0001\u0000\u0000"+ + "\u0000\u0019\u016b\u0001\u0000\u0000\u0000\u001b\u0172\u0001\u0000\u0000"+ + "\u0000\u001d\u017b\u0001\u0000\u0000\u0000\u001f\u0184\u0001\u0000\u0000"+ + "\u0000!\u018d\u0001\u0000\u0000\u0000#\u018f\u0001\u0000\u0000\u0000%"+ + "\u0191\u0001\u0000\u0000\u0000\'\u0196\u0001\u0000\u0000\u0000)\u019a"+ + "\u0001\u0000\u0000\u0000+\u01a5\u0001\u0000\u0000\u0000-\u01a9\u0001\u0000"+ + "\u0000\u0000/\u01b0\u0001\u0000\u0000\u00001\u01bc\u0001\u0000\u0000\u0000"+ + "3\u01c5\u0001\u0000\u0000\u00005\u01c8\u0001\u0000\u0000\u00007\u01ce"+ + "\u0001\u0000\u0000\u00009\u01d6\u0001\u0000\u0000\u0000;\u01e2\u0001\u0000"+ + "\u0000\u0000=\u01ee\u0001\u0000\u0000\u0000?\u01f3\u0001\u0000\u0000\u0000"+ + "A\u01f9\u0001\u0000\u0000\u0000C\u01fb\u0001\u0000\u0000\u0000E\u01fd"+ + "\u0001\u0000\u0000\u0000G\u0201\u0001\u0000\u0000\u0000I\u0206\u0001\u0000"+ + "\u0000\u0000K\u020c\u0001\u0000\u0000\u0000M\u020f\u0001\u0000\u0000\u0000"+ + "O\u0213\u0001\u0000\u0000\u0000Q\u0217\u0001\u0000\u0000\u0000S\u021c"+ + "\u0001\u0000\u0000\u0000U\u021f\u0001\u0000\u0000\u0000W\u0223\u0001\u0000"+ + "\u0000\u0000Y\u0227\u0001\u0000\u0000\u0000[\u022b\u0001\u0000\u0000\u0000"+ + "]\u0230\u0001\u0000\u0000\u0000_\u0236\u0001\u0000\u0000\u0000a\u023c"+ + "\u0001\u0000\u0000\u0000c\u0243\u0001\u0000\u0000\u0000e\u024b\u0001\u0000"+ + "\u0000\u0000g\u0253\u0001\u0000\u0000\u0000i\u025d\u0001\u0000\u0000\u0000"+ + "k\u0267\u0001\u0000\u0000\u0000m\u026f\u0001\u0000\u0000\u0000o\u0278"+ + "\u0001\u0000\u0000\u0000q\u0280\u0001\u0000\u0000\u0000s\u0288\u0001\u0000"+ + "\u0000\u0000u\u028a\u0001\u0000\u0000\u0000w\u0295\u0001\u0000\u0000\u0000"+ + "y\u02a1\u0001\u0000\u0000\u0000{\u02ad\u0001\u0000\u0000\u0000}\u02ba"+ + "\u0001\u0000\u0000\u0000\u007f\u02bc\u0001\u0000\u0000\u0000\u0081\u02c4"+ + "\u0001\u0000\u0000\u0000\u0083\u02cc\u0001\u0000\u0000\u0000\u0085\u02d0"+ + "\u0001\u0000\u0000\u0000\u0087\u02d6\u0001\u0000\u0000\u0000\u0089\u02dd"+ + "\u0001\u0000\u0000\u0000\u008b\u02e1\u0001\u0000\u0000\u0000\u008d\u02e5"+ + "\u0001\u0000\u0000\u0000\u008f\u02e9\u0001\u0000\u0000\u0000\u0091\u02f0"+ + "\u0001\u0000\u0000\u0000\u0093\u02f5\u0001\u0000\u0000\u0000\u0095\u02f9"+ + "\u0001\u0000\u0000\u0000\u0097\u02ff\u0001\u0000\u0000\u0000\u0099\u0303"+ + "\u0001\u0000\u0000\u0000\u009b\u0309\u0001\u0000\u0000\u0000\u009d\u030d"+ + "\u0001\u0000\u0000\u0000\u009f\u0313\u0001\u0000\u0000\u0000\u00a1\u0317"+ + "\u0001\u0000\u0000\u0000\u00a3\u031d\u0001\u0000\u0000\u0000\u00a5\u0321"+ + "\u0001\u0000\u0000\u0000\u00a7\u0327\u0001\u0000\u0000\u0000\u00a9\u032b"+ + "\u0001\u0000\u0000\u0000\u00ab\u0331\u0001\u0000\u0000\u0000\u00ad\u0335"+ + "\u0001\u0000\u0000\u0000\u00af\u033b\u0001\u0000\u0000\u0000\u00b1\u033f"+ + "\u0001\u0000\u0000\u0000\u00b3\u0345\u0001\u0000\u0000\u0000\u00b5\u0349"+ + "\u0001\u0000\u0000\u0000\u00b7\u034d\u0001\u0000\u0000\u0000\u00b9\u0350"+ + "\u0001\u0000\u0000\u0000\u00bb\u0354\u0001\u0000\u0000\u0000\u00bd\u0359"+ + "\u0001\u0000\u0000\u0000\u00bf\u035d\u0001\u0000\u0000\u0000\u00c1\u0360"+ + "\u0001\u0000\u0000\u0000\u00c3\u0364\u0001\u0000\u0000\u0000\u00c5\u0367"+ + "\u0001\u0000\u0000\u0000\u00c7\u036b\u0001\u0000\u0000\u0000\u00c9\u0371"+ + "\u0001\u0000\u0000\u0000\u00cb\u0378\u0001\u0000\u0000\u0000\u00cd\u0382"+ + "\u0001\u0000\u0000\u0000\u00cf\u038d\u0001\u0000\u0000\u0000\u00d1\u039b"+ + "\u0001\u0000\u0000\u0000\u00d3\u03a9\u0001\u0000\u0000\u0000\u00d5\u03b7"+ + "\u0001\u0000\u0000\u0000\u00d7\u03c6\u0001\u0000\u0000\u0000\u00d9\u03d3"+ + "\u0001\u0000\u0000\u0000\u00db\u03e1\u0001\u0000\u0000\u0000\u00dd\u03ed"+ + "\u0001\u0000\u0000\u0000\u00df\u03f9\u0001\u0000\u0000\u0000\u00e1\u0405"+ + "\u0001\u0000\u0000\u0000\u00e3\u0412\u0001\u0000\u0000\u0000\u00e5\u041d"+ + "\u0001\u0000\u0000\u0000\u00e7\u0429\u0001\u0000\u0000\u0000\u00e9\u0433"+ + "\u0001\u0000\u0000\u0000\u00eb\u043d\u0001\u0000\u0000\u0000\u00ed\u0447"+ + "\u0001\u0000\u0000\u0000\u00ef\u0456\u0001\u0000\u0000\u0000\u00f1\u0465"+ + "\u0001\u0000\u0000\u0000\u00f3\u0474\u0001\u0000\u0000\u0000\u00f5\u0482"+ + "\u0001\u0000\u0000\u0000\u00f7\u0490\u0001\u0000\u0000\u0000\u00f9\u049e"+ + "\u0001\u0000\u0000\u0000\u00fb\u04ad\u0001\u0000\u0000\u0000\u00fd\u04bc"+ + "\u0001\u0000\u0000\u0000\u00ff\u04cb\u0001\u0000\u0000\u0000\u0101\u04d6"+ + "\u0001\u0000\u0000\u0000\u0103\u04db\u0001\u0000\u0000\u0000\u0105\u04e5"+ + "\u0001\u0000\u0000\u0000\u0107\u04f0\u0001\u0000\u0000\u0000\u0109\u0501"+ + "\u0001\u0000\u0000\u0000\u010b\u0514\u0001\u0000\u0000\u0000\u010d\u0516"+ + "\u0001\u0000\u0000\u0000\u010f\u051c\u0001\u0000\u0000\u0000\u0111\u0527"+ + "\u0001\u0000\u0000\u0000\u0113\u052b\u0001\u0000\u0000\u0000\u0115\u052d"+ + "\u0001\u0000\u0000\u0000\u0117\u052f\u0001\u0000\u0000\u0000\u0119\u0531"+ + "\u0001\u0000\u0000\u0000\u011b\u0535\u0001\u0000\u0000\u0000\u011d\u0537"+ + "\u0001\u0000\u0000\u0000\u011f\u0539\u0001\u0000\u0000\u0000\u0121\u053c"+ + "\u0001\u0000\u0000\u0000\u0123\u0542\u0001\u0000\u0000\u0000\u0125\u0550"+ + "\u0001\u0000\u0000\u0000\u0127\u0128\u0005p\u0000\u0000\u0128\u0129\u0005"+ + "r\u0000\u0000\u0129\u012a\u0005o\u0000\u0000\u012a\u012b\u0005g\u0000"+ + "\u0000\u012b\u012c\u0005r\u0000\u0000\u012c\u012d\u0005a\u0000\u0000\u012d"+ + "\u012e\u0005m\u0000\u0000\u012e\u0002\u0001\u0000\u0000\u0000\u012f\u0130"+ + "\u0005;\u0000\u0000\u0130\u0004\u0001\u0000\u0000\u0000\u0131\u0132\u0005"+ + "i\u0000\u0000\u0132\u0133\u0005m\u0000\u0000\u0133\u0134\u0005p\u0000"+ + "\u0000\u0134\u0135\u0005o\u0000\u0000\u0135\u0136\u0005r\u0000\u0000\u0136"+ + "\u0137\u0005t\u0000\u0000\u0137\u0006\u0001\u0000\u0000\u0000\u0138\u0139"+ + "\u0005m\u0000\u0000\u0139\u013a\u0005a\u0000\u0000\u013a\u013b\u0005p"+ + "\u0000\u0000\u013b\u013c\u0005p\u0000\u0000\u013c\u013d\u0005i\u0000\u0000"+ + "\u013d\u013e\u0005n\u0000\u0000\u013e\u013f\u0005g\u0000\u0000\u013f\b"+ + "\u0001\u0000\u0000\u0000\u0140\u0141\u0005:\u0000\u0000\u0141\n\u0001"+ + "\u0000\u0000\u0000\u0142\u0143\u0005k\u0000\u0000\u0143\u0144\u0005e\u0000"+ + "\u0000\u0144\u0145\u0005y\u0000\u0000\u0145\f\u0001\u0000\u0000\u0000"+ + "\u0146\u0147\u0005a\u0000\u0000\u0147\u0148\u0005s\u0000\u0000\u0148\u000e"+ + "\u0001\u0000\u0000\u0000\u0149\u014a\u0005v\u0000\u0000\u014a\u014b\u0005"+ + "a\u0000\u0000\u014b\u014c\u0005l\u0000\u0000\u014c\u014d\u0005u\u0000"+ + "\u0000\u014d\u014e\u0005e\u0000\u0000\u014e\u0010\u0001\u0000\u0000\u0000"+ + "\u014f\u0150\u0005s\u0000\u0000\u0150\u0151\u0005t\u0000\u0000\u0151\u0152"+ + "\u0005r\u0000\u0000\u0152\u0153\u0005u\u0000\u0000\u0153\u0154\u0005c"+ + "\u0000\u0000\u0154\u0155\u0005t\u0000\u0000\u0155\u0012\u0001\u0000\u0000"+ + "\u0000\u0156\u0157\u0005r\u0000\u0000\u0157\u0158\u0005e\u0000\u0000\u0158"+ + "\u0159\u0005c\u0000\u0000\u0159\u015a\u0005o\u0000\u0000\u015a\u015b\u0005"+ + "r\u0000\u0000\u015b\u015c\u0005d\u0000\u0000\u015c\u0014\u0001\u0000\u0000"+ + "\u0000\u015d\u015e\u0005c\u0000\u0000\u015e\u015f\u0005l\u0000\u0000\u015f"+ + "\u0160\u0005o\u0000\u0000\u0160\u0161\u0005s\u0000\u0000\u0161\u0162\u0005"+ + "u\u0000\u0000\u0162\u0163\u0005r\u0000\u0000\u0163\u0164\u0005e\u0000"+ + "\u0000\u0164\u0016\u0001\u0000\u0000\u0000\u0165\u0166\u0005i\u0000\u0000"+ + "\u0166\u0167\u0005n\u0000\u0000\u0167\u0168\u0005p\u0000\u0000\u0168\u0169"+ + "\u0005u\u0000\u0000\u0169\u016a\u0005t\u0000\u0000\u016a\u0018\u0001\u0000"+ + "\u0000\u0000\u016b\u016c\u0005o\u0000\u0000\u016c\u016d\u0005u\u0000\u0000"+ + "\u016d\u016e\u0005t\u0000\u0000\u016e\u016f\u0005p\u0000\u0000\u016f\u0170"+ + "\u0005u\u0000\u0000\u0170\u0171\u0005t\u0000\u0000\u0171\u001a\u0001\u0000"+ + "\u0000\u0000\u0172\u0173\u0005f\u0000\u0000\u0173\u0174\u0005u\u0000\u0000"+ + "\u0174\u0175\u0005n\u0000\u0000\u0175\u0176\u0005c\u0000\u0000\u0176\u0177"+ + "\u0005t\u0000\u0000\u0177\u0178\u0005i\u0000\u0000\u0178\u0179\u0005o"+ + "\u0000\u0000\u0179\u017a\u0005n\u0000\u0000\u017a\u001c\u0001\u0000\u0000"+ + "\u0000\u017b\u017c\u0005f\u0000\u0000\u017c\u017d\u0005i\u0000\u0000\u017d"+ + "\u017e\u0005n\u0000\u0000\u017e\u017f\u0005a\u0000\u0000\u017f\u0180\u0005"+ + "l\u0000\u0000\u0180\u0181\u0005i\u0000\u0000\u0181\u0182\u0005z\u0000"+ + "\u0000\u0182\u0183\u0005e\u0000\u0000\u0183\u001e\u0001\u0000\u0000\u0000"+ + "\u0184\u0185\u0005c\u0000\u0000\u0185\u0186\u0005o\u0000\u0000\u0186\u0187"+ + "\u0005n\u0000\u0000\u0187\u0188\u0005t\u0000\u0000\u0188\u0189\u0005a"+ + "\u0000\u0000\u0189\u018a\u0005i\u0000\u0000\u018a\u018b\u0005n\u0000\u0000"+ + "\u018b\u018c\u0005s\u0000\u0000\u018c \u0001\u0000\u0000\u0000\u018d\u018e"+ + "\u0005[\u0000\u0000\u018e\"\u0001\u0000\u0000\u0000\u018f\u0190\u0005"+ + "]\u0000\u0000\u0190$\u0001\u0000\u0000\u0000\u0191\u0192\u0005i\u0000"+ + "\u0000\u0192\u0193\u0005n\u0000\u0000\u0193\u0194\u0005t\u0000\u0000\u0194"+ + "\u0195\u0005o\u0000\u0000\u0195&\u0001\u0000\u0000\u0000\u0196\u0197\u0005"+ + "g\u0000\u0000\u0197\u0198\u0005e\u0000\u0000\u0198\u0199\u0005t\u0000"+ + "\u0000\u0199(\u0001\u0000\u0000\u0000\u019a\u019b\u0005g\u0000\u0000\u019b"+ + "\u019c\u0005e\u0000\u0000\u019c\u019d\u0005t\u0000\u0000\u019d\u019e\u0005"+ + ".\u0000\u0000\u019e\u019f\u0005o\u0000\u0000\u019f\u01a0\u0005r\u0000"+ + "\u0000\u01a0\u01a1\u0005_\u0000\u0000\u01a1\u01a2\u0005u\u0000\u0000\u01a2"+ + "\u01a3\u0005s\u0000\u0000\u01a3\u01a4\u0005e\u0000\u0000\u01a4*\u0001"+ + "\u0000\u0000\u0000\u01a5\u01a6\u0005s\u0000\u0000\u01a6\u01a7\u0005e\u0000"+ + "\u0000\u01a7\u01a8\u0005t\u0000\u0000\u01a8,\u0001\u0000\u0000\u0000\u01a9"+ + "\u01aa\u0005r\u0000\u0000\u01aa\u01ab\u0005e\u0000\u0000\u01ab\u01ac\u0005"+ + "m\u0000\u0000\u01ac\u01ad\u0005o\u0000\u0000\u01ad\u01ae\u0005v\u0000"+ + "\u0000\u01ae\u01af\u0005e\u0000\u0000\u01af.\u0001\u0000\u0000\u0000\u01b0"+ + "\u01b1\u0005r\u0000\u0000\u01b1\u01b2\u0005a\u0000\u0000\u01b2\u01b3\u0005"+ + "n\u0000\u0000\u01b3\u01b4\u0005d\u0000\u0000\u01b4\u01b5\u0005.\u0000"+ + "\u0000\u01b5\u01b6\u0005c\u0000\u0000\u01b6\u01b7\u0005h\u0000\u0000\u01b7"+ + "\u01b8\u0005a\u0000\u0000\u01b8\u01b9\u0005c\u0000\u0000\u01b9\u01ba\u0005"+ + "h\u0000\u0000\u01ba\u01bb\u0005a\u0000\u0000\u01bb0\u0001\u0000\u0000"+ + "\u0000\u01bc\u01bd\u0005p\u0000\u0000\u01bd\u01be\u0005o\u0000\u0000\u01be"+ + "\u01bf\u0005s\u0000\u0000\u01bf\u01c0\u0005i\u0000\u0000\u01c0\u01c1\u0005"+ + "t\u0000\u0000\u01c1\u01c2\u0005i\u0000\u0000\u01c2\u01c3\u0005o\u0000"+ + "\u0000\u01c3\u01c4\u0005n\u0000\u0000\u01c42\u0001\u0000\u0000\u0000\u01c5"+ + "\u01c6\u0005t\u0000\u0000\u01c6\u01c7\u0005o\u0000\u0000\u01c74\u0001"+ + "\u0000\u0000\u0000\u01c8\u01c9\u0005a\u0000\u0000\u01c9\u01ca\u0005w\u0000"+ + "\u0000\u01ca\u01cb\u0005a\u0000\u0000\u01cb\u01cc\u0005i\u0000\u0000\u01cc"+ + "\u01cd\u0005t\u0000\u0000\u01cd6\u0001\u0000\u0000\u0000\u01ce\u01cf\u0005"+ + "t\u0000\u0000\u01cf\u01d0\u0005e\u0000\u0000\u01d0\u01d1\u0005r\u0000"+ + "\u0000\u01d1\u01d2\u0005n\u0000\u0000\u01d2\u01d3\u0005a\u0000\u0000\u01d3"+ + "\u01d4\u0005r\u0000\u0000\u01d4\u01d5\u0005y\u0000\u0000\u01d58\u0001"+ + "\u0000\u0000\u0000\u01d6\u01d7\u0005s\u0000\u0000\u01d7\u01d8\u0005i\u0000"+ + "\u0000\u01d8\u01d9\u0005g\u0000\u0000\u01d9\u01da\u0005n\u0000\u0000\u01da"+ + "\u01db\u0005.\u0000\u0000\u01db\u01dc\u0005v\u0000\u0000\u01dc\u01dd\u0005"+ + "e\u0000\u0000\u01dd\u01de\u0005r\u0000\u0000\u01de\u01df\u0005i\u0000"+ + "\u0000\u01df\u01e0\u0005f\u0000\u0000\u01e0\u01e1\u0005y\u0000\u0000\u01e1"+ + ":\u0001\u0000\u0000\u0000\u01e2\u01e3\u0005s\u0000\u0000\u01e3\u01e4\u0005"+ + "i\u0000\u0000\u01e4\u01e5\u0005g\u0000\u0000\u01e5\u01e6\u0005n\u0000"+ + "\u0000\u01e6\u01e7\u0005_\u0000\u0000\u01e7\u01e8\u0005v\u0000\u0000\u01e8"+ + "\u01e9\u0005e\u0000\u0000\u01e9\u01ea\u0005r\u0000\u0000\u01ea\u01eb\u0005"+ + "i\u0000\u0000\u01eb\u01ec\u0005f\u0000\u0000\u01ec\u01ed\u0005y\u0000"+ + "\u0000\u01ed<\u0001\u0000\u0000\u0000\u01ee\u01ef\u0005c\u0000\u0000\u01ef"+ + "\u01f0\u0005a\u0000\u0000\u01f0\u01f1\u0005l\u0000\u0000\u01f1\u01f2\u0005"+ + "l\u0000\u0000\u01f2>\u0001\u0000\u0000\u0000\u01f3\u01f4\u0005a\u0000"+ + "\u0000\u01f4\u01f5\u0005s\u0000\u0000\u01f5\u01f6\u0005y\u0000\u0000\u01f6"+ + "\u01f7\u0005n\u0000\u0000\u01f7\u01f8\u0005c\u0000\u0000\u01f8@\u0001"+ + "\u0000\u0000\u0000\u01f9\u01fa\u0005-\u0000\u0000\u01faB\u0001\u0000\u0000"+ + "\u0000\u01fb\u01fc\u0005_\u0000\u0000\u01fcD\u0001\u0000\u0000\u0000\u01fd"+ + "\u01fe\u0005u\u0000\u0000\u01fe\u01ff\u00053\u0000\u0000\u01ff\u0200\u0005"+ + "2\u0000\u0000\u0200F\u0001\u0000\u0000\u0000\u0201\u0202\u0005t\u0000"+ + "\u0000\u0202\u0203\u0005r\u0000\u0000\u0203\u0204\u0005u\u0000\u0000\u0204"+ + "\u0205\u0005e\u0000\u0000\u0205H\u0001\u0000\u0000\u0000\u0206\u0207\u0005"+ + "f\u0000\u0000\u0207\u0208\u0005a\u0000\u0000\u0208\u0209\u0005l\u0000"+ + "\u0000\u0209\u020a\u0005s\u0000\u0000\u020a\u020b\u0005e\u0000\u0000\u020b"+ + "J\u0001\u0000\u0000\u0000\u020c\u020d\u0005u\u0000\u0000\u020d\u020e\u0005"+ + "8\u0000\u0000\u020eL\u0001\u0000\u0000\u0000\u020f\u0210\u0005u\u0000"+ + "\u0000\u0210\u0211\u00051\u0000\u0000\u0211\u0212\u00056\u0000\u0000\u0212"+ + "N\u0001\u0000\u0000\u0000\u0213\u0214\u0005u\u0000\u0000\u0214\u0215\u0005"+ + "6\u0000\u0000\u0215\u0216\u00054\u0000\u0000\u0216P\u0001\u0000\u0000"+ + "\u0000\u0217\u0218\u0005u\u0000\u0000\u0218\u0219\u00051\u0000\u0000\u0219"+ + "\u021a\u00052\u0000\u0000\u021a\u021b\u00058\u0000\u0000\u021bR\u0001"+ + "\u0000\u0000\u0000\u021c\u021d\u0005i\u0000\u0000\u021d\u021e\u00058\u0000"+ + "\u0000\u021eT\u0001\u0000\u0000\u0000\u021f\u0220\u0005i\u0000\u0000\u0220"+ + "\u0221\u00051\u0000\u0000\u0221\u0222\u00056\u0000\u0000\u0222V\u0001"+ + "\u0000\u0000\u0000\u0223\u0224\u0005i\u0000\u0000\u0224\u0225\u00053\u0000"+ + "\u0000\u0225\u0226\u00052\u0000\u0000\u0226X\u0001\u0000\u0000\u0000\u0227"+ + "\u0228\u0005i\u0000\u0000\u0228\u0229\u00056\u0000\u0000\u0229\u022a\u0005"+ + "4\u0000\u0000\u022aZ\u0001\u0000\u0000\u0000\u022b\u022c\u0005i\u0000"+ + "\u0000\u022c\u022d\u00051\u0000\u0000\u022d\u022e\u00052\u0000\u0000\u022e"+ + "\u022f\u00058\u0000\u0000\u022f\\\u0001\u0000\u0000\u0000\u0230\u0231"+ + "\u0005f\u0000\u0000\u0231\u0232\u0005i\u0000\u0000\u0232\u0233\u0005e"+ + "\u0000\u0000\u0233\u0234\u0005l\u0000\u0000\u0234\u0235\u0005d\u0000\u0000"+ + "\u0235^\u0001\u0000\u0000\u0000\u0236\u0237\u0005g\u0000\u0000\u0237\u0238"+ + "\u0005r\u0000\u0000\u0238\u0239\u0005o\u0000\u0000\u0239\u023a\u0005u"+ + "\u0000\u0000\u023a\u023b\u0005p\u0000\u0000\u023b`\u0001\u0000\u0000\u0000"+ + "\u023c\u023d\u0005s\u0000\u0000\u023d\u023e\u0005c\u0000\u0000\u023e\u023f"+ + "\u0005a\u0000\u0000\u023f\u0240\u0005l\u0000\u0000\u0240\u0241\u0005a"+ + "\u0000\u0000\u0241\u0242\u0005r\u0000\u0000\u0242b\u0001\u0000\u0000\u0000"+ + "\u0243\u0244\u0005a\u0000\u0000\u0244\u0245\u0005d\u0000\u0000\u0245\u0246"+ + "\u0005d\u0000\u0000\u0246\u0247\u0005r\u0000\u0000\u0247\u0248\u0005e"+ + "\u0000\u0000\u0248\u0249\u0005s\u0000\u0000\u0249\u024a\u0005s\u0000\u0000"+ + "\u024ad\u0001\u0000\u0000\u0000\u024b\u024c\u0005b\u0000\u0000\u024c\u024d"+ + "\u0005o\u0000\u0000\u024d\u024e\u0005o\u0000\u0000\u024e\u024f\u0005l"+ + "\u0000\u0000\u024f\u0250\u0005e\u0000\u0000\u0250\u0251\u0005a\u0000\u0000"+ + "\u0251\u0252\u0005n\u0000\u0000\u0252f\u0001\u0000\u0000\u0000\u0253\u0254"+ + "\u0005s\u0000\u0000\u0254\u0255\u0005i\u0000\u0000\u0255\u0256\u0005g"+ + "\u0000\u0000\u0256\u0257\u0005n\u0000\u0000\u0257\u0258\u0005a\u0000\u0000"+ + "\u0258\u0259\u0005t\u0000\u0000\u0259\u025a\u0005u\u0000\u0000\u025a\u025b"+ + "\u0005r\u0000\u0000\u025b\u025c\u0005e\u0000\u0000\u025ch\u0001\u0000"+ + "\u0000\u0000\u025d\u025e\u0005.\u0000\u0000\u025e\u025f\u0005c\u0000\u0000"+ + "\u025f\u0260\u0005o\u0000\u0000\u0260\u0261\u0005n\u0000\u0000\u0261\u0262"+ + "\u0005s\u0000\u0000\u0262\u0263\u0005t\u0000\u0000\u0263\u0264\u0005a"+ + "\u0000\u0000\u0264\u0265\u0005n\u0000\u0000\u0265\u0266\u0005t\u0000\u0000"+ + "\u0266j\u0001\u0000\u0000\u0000\u0267\u0268\u0005.\u0000\u0000\u0268\u0269"+ + "\u0005p\u0000\u0000\u0269\u026a\u0005u\u0000\u0000\u026a\u026b\u0005b"+ + "\u0000\u0000\u026b\u026c\u0005l\u0000\u0000\u026c\u026d\u0005i\u0000\u0000"+ + "\u026d\u026e\u0005c\u0000\u0000\u026el\u0001\u0000\u0000\u0000\u026f\u0270"+ + "\u0005.\u0000\u0000\u0270\u0271\u0005p\u0000\u0000\u0271\u0272\u0005r"+ + "\u0000\u0000\u0272\u0273\u0005i\u0000\u0000\u0273\u0274\u0005v\u0000\u0000"+ + "\u0274\u0275\u0005a\u0000\u0000\u0275\u0276\u0005t\u0000\u0000\u0276\u0277"+ + "\u0005e\u0000\u0000\u0277n\u0001\u0000\u0000\u0000\u0278\u0279\u0005."+ + "\u0000\u0000\u0279\u027a\u0005r\u0000\u0000\u027a\u027b\u0005e\u0000\u0000"+ + "\u027b\u027c\u0005c\u0000\u0000\u027c\u027d\u0005o\u0000\u0000\u027d\u027e"+ + "\u0005r\u0000\u0000\u027e\u027f\u0005d\u0000\u0000\u027fp\u0001\u0000"+ + "\u0000\u0000\u0280\u0281\u0005.\u0000\u0000\u0281\u0282\u0005f\u0000\u0000"+ + "\u0282\u0283\u0005u\u0000\u0000\u0283\u0284\u0005t\u0000\u0000\u0284\u0285"+ + "\u0005u\u0000\u0000\u0285\u0286\u0005r\u0000\u0000\u0286\u0287\u0005e"+ + "\u0000\u0000\u0287r\u0001\u0000\u0000\u0000\u0288\u0289\u0005.\u0000\u0000"+ + "\u0289t\u0001\u0000\u0000\u0000\u028a\u028b\u0005g\u0000\u0000\u028b\u028c"+ + "\u0005r\u0000\u0000\u028c\u028d\u0005o\u0000\u0000\u028d\u028e\u0005u"+ + "\u0000\u0000\u028e\u028f\u0005p\u0000\u0000\u028f\u0290\u0005:\u0000\u0000"+ + "\u0290\u0291\u0005:\u0000\u0000\u0291\u0292\u0005G\u0000\u0000\u0292\u0293"+ + "\u0005E\u0000\u0000\u0293\u0294\u0005N\u0000\u0000\u0294v\u0001\u0000"+ + "\u0000\u0000\u0295\u0296\u0005s\u0000\u0000\u0296\u0297\u0005e\u0000\u0000"+ + "\u0297\u0298\u0005l\u0000\u0000\u0298\u0299\u0005f\u0000\u0000\u0299\u029a"+ + "\u0005.\u0000\u0000\u029a\u029b\u0005s\u0000\u0000\u029b\u029c\u0005i"+ + "\u0000\u0000\u029c\u029d\u0005g\u0000\u0000\u029d\u029e\u0005n\u0000\u0000"+ + "\u029e\u029f\u0005e\u0000\u0000\u029f\u02a0\u0005r\u0000\u0000\u02a0x"+ + "\u0001\u0000\u0000\u0000\u02a1\u02a2\u0005s\u0000\u0000\u02a2\u02a3\u0005"+ + "e\u0000\u0000\u02a3\u02a4\u0005l\u0000\u0000\u02a4\u02a5\u0005f\u0000"+ + "\u0000\u02a5\u02a6\u0005.\u0000\u0000\u02a6\u02a7\u0005c\u0000\u0000\u02a7"+ + "\u02a8\u0005a\u0000\u0000\u02a8\u02a9\u0005l\u0000\u0000\u02a9\u02aa\u0005"+ + "l\u0000\u0000\u02aa\u02ab\u0005e\u0000\u0000\u02ab\u02ac\u0005r\u0000"+ + "\u0000\u02acz\u0001\u0000\u0000\u0000\u02ad\u02ae\u0005b\u0000\u0000\u02ae"+ + "\u02af\u0005l\u0000\u0000\u02af\u02b0\u0005o\u0000\u0000\u02b0\u02b1\u0005"+ + "c\u0000\u0000\u02b1\u02b2\u0005k\u0000\u0000\u02b2\u02b3\u0005.\u0000"+ + "\u0000\u02b3\u02b4\u0005h\u0000\u0000\u02b4\u02b5\u0005e\u0000\u0000\u02b5"+ + "\u02b6\u0005i\u0000\u0000\u02b6\u02b7\u0005g\u0000\u0000\u02b7\u02b8\u0005"+ + "h\u0000\u0000\u02b8\u02b9\u0005t\u0000\u0000\u02b9|\u0001\u0000\u0000"+ + "\u0000\u02ba\u02bb\u0005/\u0000\u0000\u02bb~\u0001\u0000\u0000\u0000\u02bc"+ + "\u02bd\u0005g\u0000\u0000\u02bd\u02be\u0005r\u0000\u0000\u02be\u02bf\u0005"+ + "o\u0000\u0000\u02bf\u02c0\u0005u\u0000\u0000\u02c0\u02c1\u0005p\u0000"+ + "\u0000\u02c1\u02c2\u0005.\u0000\u0000\u02c2\u02c3\u0005x\u0000\u0000\u02c3"+ + "\u0080\u0001\u0000\u0000\u0000\u02c4\u02c5\u0005g\u0000\u0000\u02c5\u02c6"+ + "\u0005r\u0000\u0000\u02c6\u02c7\u0005o\u0000\u0000\u02c7\u02c8\u0005u"+ + "\u0000\u0000\u02c8\u02c9\u0005p\u0000\u0000\u02c9\u02ca\u0005.\u0000\u0000"+ + "\u02ca\u02cb\u0005y\u0000\u0000\u02cb\u0082\u0001\u0000\u0000\u0000\u02cc"+ + "\u02cd\u0005a\u0000\u0000\u02cd\u02ce\u0005b\u0000\u0000\u02ce\u02cf\u0005"+ + "s\u0000\u0000\u02cf\u0084\u0001\u0000\u0000\u0000\u02d0\u02d1\u0005a\u0000"+ + "\u0000\u02d1\u02d2\u0005b\u0000\u0000\u02d2\u02d3\u0005s\u0000\u0000\u02d3"+ + "\u02d4\u0005.\u0000\u0000\u02d4\u02d5\u0005w\u0000\u0000\u02d5\u0086\u0001"+ + "\u0000\u0000\u0000\u02d6\u02d7\u0005d\u0000\u0000\u02d7\u02d8\u0005o\u0000"+ + "\u0000\u02d8\u02d9\u0005u\u0000\u0000\u02d9\u02da\u0005b\u0000\u0000\u02da"+ + "\u02db\u0005l\u0000\u0000\u02db\u02dc\u0005e\u0000\u0000\u02dc\u0088\u0001"+ + "\u0000\u0000\u0000\u02dd\u02de\u0005i\u0000\u0000\u02de\u02df\u0005n\u0000"+ + "\u0000\u02df\u02e0\u0005v\u0000\u0000\u02e0\u008a\u0001\u0000\u0000\u0000"+ + "\u02e1\u02e2\u0005n\u0000\u0000\u02e2\u02e3\u0005e\u0000\u0000\u02e3\u02e4"+ + "\u0005g\u0000\u0000\u02e4\u008c\u0001\u0000\u0000\u0000\u02e5\u02e6\u0005"+ + "n\u0000\u0000\u02e6\u02e7\u0005o\u0000\u0000\u02e7\u02e8\u0005t\u0000"+ + "\u0000\u02e8\u008e\u0001\u0000\u0000\u0000\u02e9\u02ea\u0005s\u0000\u0000"+ + "\u02ea\u02eb\u0005q\u0000\u0000\u02eb\u02ec\u0005u\u0000\u0000\u02ec\u02ed"+ + "\u0005a\u0000\u0000\u02ed\u02ee\u0005r\u0000\u0000\u02ee\u02ef\u0005e"+ + "\u0000\u0000\u02ef\u0090\u0001\u0000\u0000\u0000\u02f0\u02f1\u0005s\u0000"+ + "\u0000\u02f1\u02f2\u0005q\u0000\u0000\u02f2\u02f3\u0005r\u0000\u0000\u02f3"+ + "\u02f4\u0005t\u0000\u0000\u02f4\u0092\u0001\u0000\u0000\u0000\u02f5\u02f6"+ + "\u0005a\u0000\u0000\u02f6\u02f7\u0005d\u0000\u0000\u02f7\u02f8\u0005d"+ + "\u0000\u0000\u02f8\u0094\u0001\u0000\u0000\u0000\u02f9\u02fa\u0005a\u0000"+ + "\u0000\u02fa\u02fb\u0005d\u0000\u0000\u02fb\u02fc\u0005d\u0000\u0000\u02fc"+ + "\u02fd\u0005.\u0000\u0000\u02fd\u02fe\u0005w\u0000\u0000\u02fe\u0096\u0001"+ + "\u0000\u0000\u0000\u02ff\u0300\u0005s\u0000\u0000\u0300\u0301\u0005u\u0000"+ + "\u0000\u0301\u0302\u0005b\u0000\u0000\u0302\u0098\u0001\u0000\u0000\u0000"+ + "\u0303\u0304\u0005s\u0000\u0000\u0304\u0305\u0005u\u0000\u0000\u0305\u0306"+ + "\u0005b\u0000\u0000\u0306\u0307\u0005.\u0000\u0000\u0307\u0308\u0005w"+ + "\u0000\u0000\u0308\u009a\u0001\u0000\u0000\u0000\u0309\u030a\u0005m\u0000"+ + "\u0000\u030a\u030b\u0005u\u0000\u0000\u030b\u030c\u0005l\u0000\u0000\u030c"+ + "\u009c\u0001\u0000\u0000\u0000\u030d\u030e\u0005m\u0000\u0000\u030e\u030f"+ + "\u0005u\u0000\u0000\u030f\u0310\u0005l\u0000\u0000\u0310\u0311\u0005."+ + "\u0000\u0000\u0311\u0312\u0005w\u0000\u0000\u0312\u009e\u0001\u0000\u0000"+ + "\u0000\u0313\u0314\u0005d\u0000\u0000\u0314\u0315\u0005i\u0000\u0000\u0315"+ + "\u0316\u0005v\u0000\u0000\u0316\u00a0\u0001\u0000\u0000\u0000\u0317\u0318"+ + "\u0005d\u0000\u0000\u0318\u0319\u0005i\u0000\u0000\u0319\u031a\u0005v"+ + "\u0000\u0000\u031a\u031b\u0005.\u0000\u0000\u031b\u031c\u0005w\u0000\u0000"+ + "\u031c\u00a2\u0001\u0000\u0000\u0000\u031d\u031e\u0005r\u0000\u0000\u031e"+ + "\u031f\u0005e\u0000\u0000\u031f\u0320\u0005m\u0000\u0000\u0320\u00a4\u0001"+ + "\u0000\u0000\u0000\u0321\u0322\u0005r\u0000\u0000\u0322\u0323\u0005e\u0000"+ + "\u0000\u0323\u0324\u0005m\u0000\u0000\u0324\u0325\u0005.\u0000\u0000\u0325"+ + "\u0326\u0005w\u0000\u0000\u0326\u00a6\u0001\u0000\u0000\u0000\u0327\u0328"+ + "\u0005p\u0000\u0000\u0328\u0329\u0005o\u0000\u0000\u0329\u032a\u0005w"+ + "\u0000\u0000\u032a\u00a8\u0001\u0000\u0000\u0000\u032b\u032c\u0005p\u0000"+ + "\u0000\u032c\u032d\u0005o\u0000\u0000\u032d\u032e\u0005w\u0000\u0000\u032e"+ + "\u032f\u0005.\u0000\u0000\u032f\u0330\u0005w\u0000\u0000\u0330\u00aa\u0001"+ + "\u0000\u0000\u0000\u0331\u0332\u0005s\u0000\u0000\u0332\u0333\u0005h\u0000"+ + "\u0000\u0333\u0334\u0005l\u0000\u0000\u0334\u00ac\u0001\u0000\u0000\u0000"+ + "\u0335\u0336\u0005s\u0000\u0000\u0336\u0337\u0005h\u0000\u0000\u0337\u0338"+ + "\u0005l\u0000\u0000\u0338\u0339\u0005.\u0000\u0000\u0339\u033a\u0005w"+ + "\u0000\u0000\u033a\u00ae\u0001\u0000\u0000\u0000\u033b\u033c\u0005s\u0000"+ + "\u0000\u033c\u033d\u0005h\u0000\u0000\u033d\u033e\u0005r\u0000\u0000\u033e"+ + "\u00b0\u0001\u0000\u0000\u0000\u033f\u0340\u0005s\u0000\u0000\u0340\u0341"+ + "\u0005h\u0000\u0000\u0341\u0342\u0005r\u0000\u0000\u0342\u0343\u0005."+ + "\u0000\u0000\u0343\u0344\u0005w\u0000\u0000\u0344\u00b2\u0001\u0000\u0000"+ + "\u0000\u0345\u0346\u0005m\u0000\u0000\u0346\u0347\u0005o\u0000\u0000\u0347"+ + "\u0348\u0005d\u0000\u0000\u0348\u00b4\u0001\u0000\u0000\u0000\u0349\u034a"+ + "\u0005a\u0000\u0000\u034a\u034b\u0005n\u0000\u0000\u034b\u034c\u0005d"+ + "\u0000\u0000\u034c\u00b6\u0001\u0000\u0000\u0000\u034d\u034e\u0005o\u0000"+ + "\u0000\u034e\u034f\u0005r\u0000\u0000\u034f\u00b8\u0001\u0000\u0000\u0000"+ + "\u0350\u0351\u0005x\u0000\u0000\u0351\u0352\u0005o\u0000\u0000\u0352\u0353"+ + "\u0005r\u0000\u0000\u0353\u00ba\u0001\u0000\u0000\u0000\u0354\u0355\u0005"+ + "n\u0000\u0000\u0355\u0356\u0005a\u0000\u0000\u0356\u0357\u0005n\u0000"+ + "\u0000\u0357\u0358\u0005d\u0000\u0000\u0358\u00bc\u0001\u0000\u0000\u0000"+ + "\u0359\u035a\u0005n\u0000\u0000\u035a\u035b\u0005o\u0000\u0000\u035b\u035c"+ + "\u0005r\u0000\u0000\u035c\u00be\u0001\u0000\u0000\u0000\u035d\u035e\u0005"+ + "g\u0000\u0000\u035e\u035f\u0005t\u0000\u0000\u035f\u00c0\u0001\u0000\u0000"+ + "\u0000\u0360\u0361\u0005g\u0000\u0000\u0361\u0362\u0005t\u0000\u0000\u0362"+ + "\u0363\u0005e\u0000\u0000\u0363\u00c2\u0001\u0000\u0000\u0000\u0364\u0365"+ + "\u0005l\u0000\u0000\u0365\u0366\u0005t\u0000\u0000\u0366\u00c4\u0001\u0000"+ + "\u0000\u0000\u0367\u0368\u0005l\u0000\u0000\u0368\u0369\u0005t\u0000\u0000"+ + "\u0369\u036a\u0005e\u0000\u0000\u036a\u00c6\u0001\u0000\u0000\u0000\u036b"+ + "\u036c\u0005i\u0000\u0000\u036c\u036d\u0005s\u0000\u0000\u036d\u036e\u0005"+ + ".\u0000\u0000\u036e\u036f\u0005e\u0000\u0000\u036f\u0370\u0005q\u0000"+ + "\u0000\u0370\u00c8\u0001\u0000\u0000\u0000\u0371\u0372\u0005i\u0000\u0000"+ + "\u0372\u0373\u0005s\u0000\u0000\u0373\u0374\u0005.\u0000\u0000\u0374\u0375"+ + "\u0005n\u0000\u0000\u0375\u0376\u0005e\u0000\u0000\u0376\u0377\u0005q"+ + "\u0000\u0000\u0377\u00ca\u0001\u0000\u0000\u0000\u0378\u0379\u0005a\u0000"+ + "\u0000\u0379\u037a\u0005s\u0000\u0000\u037a\u037b\u0005s\u0000\u0000\u037b"+ + "\u037c\u0005e\u0000\u0000\u037c\u037d\u0005r\u0000\u0000\u037d\u037e\u0005"+ + "t\u0000\u0000\u037e\u037f\u0005.\u0000\u0000\u037f\u0380\u0005e\u0000"+ + "\u0000\u0380\u0381\u0005q\u0000\u0000\u0381\u00cc\u0001\u0000\u0000\u0000"+ + "\u0382\u0383\u0005a\u0000\u0000\u0383\u0384\u0005s\u0000\u0000\u0384\u0385"+ + "\u0005s\u0000\u0000\u0385\u0386\u0005e\u0000\u0000\u0386\u0387\u0005r"+ + "\u0000\u0000\u0387\u0388\u0005t\u0000\u0000\u0388\u0389\u0005.\u0000\u0000"+ + "\u0389\u038a\u0005n\u0000\u0000\u038a\u038b\u0005e\u0000\u0000\u038b\u038c"+ + "\u0005q\u0000\u0000\u038c\u00ce\u0001\u0000\u0000\u0000\u038d\u038e\u0005"+ + "c\u0000\u0000\u038e\u038f\u0005o\u0000\u0000\u038f\u0390\u0005m\u0000"+ + "\u0000\u0390\u0391\u0005m\u0000\u0000\u0391\u0392\u0005i\u0000\u0000\u0392"+ + "\u0393\u0005t\u0000\u0000\u0393\u0394\u0005.\u0000\u0000\u0394\u0395\u0005"+ + "b\u0000\u0000\u0395\u0396\u0005h\u0000\u0000\u0396\u0397\u0005p\u0000"+ + "\u0000\u0397\u0398\u00052\u0000\u0000\u0398\u0399\u00055\u0000\u0000\u0399"+ + "\u039a\u00056\u0000\u0000\u039a\u00d0\u0001\u0000\u0000\u0000\u039b\u039c"+ + "\u0005c\u0000\u0000\u039c\u039d\u0005o\u0000\u0000\u039d\u039e\u0005m"+ + "\u0000\u0000\u039e\u039f\u0005m\u0000\u0000\u039f\u03a0\u0005i\u0000\u0000"+ + "\u03a0\u03a1\u0005t\u0000\u0000\u03a1\u03a2\u0005.\u0000\u0000\u03a2\u03a3"+ + "\u0005b\u0000\u0000\u03a3\u03a4\u0005h\u0000\u0000\u03a4\u03a5\u0005p"+ + "\u0000\u0000\u03a5\u03a6\u00055\u0000\u0000\u03a6\u03a7\u00051\u0000\u0000"+ + "\u03a7\u03a8\u00052\u0000\u0000\u03a8\u00d2\u0001\u0000\u0000\u0000\u03a9"+ + "\u03aa\u0005c\u0000\u0000\u03aa\u03ab\u0005o\u0000\u0000\u03ab\u03ac\u0005"+ + "m\u0000\u0000\u03ac\u03ad\u0005m\u0000\u0000\u03ad\u03ae\u0005i\u0000"+ + "\u0000\u03ae\u03af\u0005t\u0000\u0000\u03af\u03b0\u0005.\u0000\u0000\u03b0"+ + "\u03b1\u0005b\u0000\u0000\u03b1\u03b2\u0005h\u0000\u0000\u03b2\u03b3\u0005"+ + "p\u0000\u0000\u03b3\u03b4\u00057\u0000\u0000\u03b4\u03b5\u00056\u0000"+ + "\u0000\u03b5\u03b6\u00058\u0000\u0000\u03b6\u00d4\u0001\u0000\u0000\u0000"+ + "\u03b7\u03b8\u0005c\u0000\u0000\u03b8\u03b9\u0005o\u0000\u0000\u03b9\u03ba"+ + "\u0005m\u0000\u0000\u03ba\u03bb\u0005m\u0000\u0000\u03bb\u03bc\u0005i"+ + "\u0000\u0000\u03bc\u03bd\u0005t\u0000\u0000\u03bd\u03be\u0005.\u0000\u0000"+ + "\u03be\u03bf\u0005b\u0000\u0000\u03bf\u03c0\u0005h\u0000\u0000\u03c0\u03c1"+ + "\u0005p\u0000\u0000\u03c1\u03c2\u00051\u0000\u0000\u03c2\u03c3\u00050"+ + "\u0000\u0000\u03c3\u03c4\u00052\u0000\u0000\u03c4\u03c5\u00054\u0000\u0000"+ + "\u03c5\u00d6\u0001\u0000\u0000\u0000\u03c6\u03c7\u0005c\u0000\u0000\u03c7"+ + "\u03c8\u0005o\u0000\u0000\u03c8\u03c9\u0005m\u0000\u0000\u03c9\u03ca\u0005"+ + "m\u0000\u0000\u03ca\u03cb\u0005i\u0000\u0000\u03cb\u03cc\u0005t\u0000"+ + "\u0000\u03cc\u03cd\u0005.\u0000\u0000\u03cd\u03ce\u0005p\u0000\u0000\u03ce"+ + "\u03cf\u0005e\u0000\u0000\u03cf\u03d0\u0005d\u0000\u0000\u03d0\u03d1\u0005"+ + "6\u0000\u0000\u03d1\u03d2\u00054\u0000\u0000\u03d2\u00d8\u0001\u0000\u0000"+ + "\u0000\u03d3\u03d4\u0005c\u0000\u0000\u03d4\u03d5\u0005o\u0000\u0000\u03d5"+ + "\u03d6\u0005m\u0000\u0000\u03d6\u03d7\u0005m\u0000\u0000\u03d7\u03d8\u0005"+ + "i\u0000\u0000\u03d8\u03d9\u0005t\u0000\u0000\u03d9\u03da\u0005.\u0000"+ + "\u0000\u03da\u03db\u0005p\u0000\u0000\u03db\u03dc\u0005e\u0000\u0000\u03dc"+ + "\u03dd\u0005d\u0000\u0000\u03dd\u03de\u00051\u0000\u0000\u03de\u03df\u0005"+ + "2\u0000\u0000\u03df\u03e0\u00058\u0000\u0000\u03e0\u00da\u0001\u0000\u0000"+ + "\u0000\u03e1\u03e2\u0005h\u0000\u0000\u03e2\u03e3\u0005a\u0000\u0000\u03e3"+ + "\u03e4\u0005s\u0000\u0000\u03e4\u03e5\u0005h\u0000\u0000\u03e5\u03e6\u0005"+ + ".\u0000\u0000\u03e6\u03e7\u0005b\u0000\u0000\u03e7\u03e8\u0005h\u0000"+ + "\u0000\u03e8\u03e9\u0005p\u0000\u0000\u03e9\u03ea\u00052\u0000\u0000\u03ea"+ + "\u03eb\u00055\u0000\u0000\u03eb\u03ec\u00056\u0000\u0000\u03ec\u00dc\u0001"+ + "\u0000\u0000\u0000\u03ed\u03ee\u0005h\u0000\u0000\u03ee\u03ef\u0005a\u0000"+ + "\u0000\u03ef\u03f0\u0005s\u0000\u0000\u03f0\u03f1\u0005h\u0000\u0000\u03f1"+ + "\u03f2\u0005.\u0000\u0000\u03f2\u03f3\u0005b\u0000\u0000\u03f3\u03f4\u0005"+ + "h\u0000\u0000\u03f4\u03f5\u0005p\u0000\u0000\u03f5\u03f6\u00055\u0000"+ + "\u0000\u03f6\u03f7\u00051\u0000\u0000\u03f7\u03f8\u00052\u0000\u0000\u03f8"+ + "\u00de\u0001\u0000\u0000\u0000\u03f9\u03fa\u0005h\u0000\u0000\u03fa\u03fb"+ + "\u0005a\u0000\u0000\u03fb\u03fc\u0005s\u0000\u0000\u03fc\u03fd\u0005h"+ + "\u0000\u0000\u03fd\u03fe\u0005.\u0000\u0000\u03fe\u03ff\u0005b\u0000\u0000"+ + "\u03ff\u0400\u0005h\u0000\u0000\u0400\u0401\u0005p\u0000\u0000\u0401\u0402"+ + "\u00057\u0000\u0000\u0402\u0403\u00056\u0000\u0000\u0403\u0404\u00058"+ + "\u0000\u0000\u0404\u00e0\u0001\u0000\u0000\u0000\u0405\u0406\u0005h\u0000"+ + "\u0000\u0406\u0407\u0005a\u0000\u0000\u0407\u0408\u0005s\u0000\u0000\u0408"+ + "\u0409\u0005h\u0000\u0000\u0409\u040a\u0005.\u0000\u0000\u040a\u040b\u0005"+ + "b\u0000\u0000\u040b\u040c\u0005h\u0000\u0000\u040c\u040d\u0005p\u0000"+ + "\u0000\u040d\u040e\u00051\u0000\u0000\u040e\u040f\u00050\u0000\u0000\u040f"+ + "\u0410\u00052\u0000\u0000\u0410\u0411\u00054\u0000\u0000\u0411\u00e2\u0001"+ + "\u0000\u0000\u0000\u0412\u0413\u0005h\u0000\u0000\u0413\u0414\u0005a\u0000"+ + "\u0000\u0414\u0415\u0005s\u0000\u0000\u0415\u0416\u0005h\u0000\u0000\u0416"+ + "\u0417\u0005.\u0000\u0000\u0417\u0418\u0005p\u0000\u0000\u0418\u0419\u0005"+ + "e\u0000\u0000\u0419\u041a\u0005d\u0000\u0000\u041a\u041b\u00056\u0000"+ + "\u0000\u041b\u041c\u00054\u0000\u0000\u041c\u00e4\u0001\u0000\u0000\u0000"+ + "\u041d\u041e\u0005h\u0000\u0000\u041e\u041f\u0005a\u0000\u0000\u041f\u0420"+ + "\u0005s\u0000\u0000\u0420\u0421\u0005h\u0000\u0000\u0421\u0422\u0005."+ + "\u0000\u0000\u0422\u0423\u0005p\u0000\u0000\u0423\u0424\u0005e\u0000\u0000"+ + "\u0424\u0425\u0005d\u0000\u0000\u0425\u0426\u00051\u0000\u0000\u0426\u0427"+ + "\u00052\u0000\u0000\u0427\u0428\u00058\u0000\u0000\u0428\u00e6\u0001\u0000"+ + "\u0000\u0000\u0429\u042a\u0005h\u0000\u0000\u042a\u042b\u0005a\u0000\u0000"+ + "\u042b\u042c\u0005s\u0000\u0000\u042c\u042d\u0005h\u0000\u0000\u042d\u042e"+ + "\u0005.\u0000\u0000\u042e\u042f\u0005p\u0000\u0000\u042f\u0430\u0005s"+ + "\u0000\u0000\u0430\u0431\u0005d\u0000\u0000\u0431\u0432\u00052\u0000\u0000"+ + "\u0432\u00e8\u0001\u0000\u0000\u0000\u0433\u0434\u0005h\u0000\u0000\u0434"+ + "\u0435\u0005a\u0000\u0000\u0435\u0436\u0005s\u0000\u0000\u0436\u0437\u0005"+ + "h\u0000\u0000\u0437\u0438\u0005.\u0000\u0000\u0438\u0439\u0005p\u0000"+ + "\u0000\u0439\u043a\u0005s\u0000\u0000\u043a\u043b\u0005d\u0000\u0000\u043b"+ + "\u043c\u00054\u0000\u0000\u043c\u00ea\u0001\u0000\u0000\u0000\u043d\u043e"+ + "\u0005h\u0000\u0000\u043e\u043f\u0005a\u0000\u0000\u043f\u0440\u0005s"+ + "\u0000\u0000\u0440\u0441\u0005h\u0000\u0000\u0441\u0442\u0005.\u0000\u0000"+ + "\u0442\u0443\u0005p\u0000\u0000\u0443\u0444\u0005s\u0000\u0000\u0444\u0445"+ + "\u0005d\u0000\u0000\u0445\u0446\u00058\u0000\u0000\u0446\u00ec\u0001\u0000"+ + "\u0000\u0000\u0447\u0448\u0005h\u0000\u0000\u0448\u0449\u0005a\u0000\u0000"+ + "\u0449\u044a\u0005s\u0000\u0000\u044a\u044b\u0005h\u0000\u0000\u044b\u044c"+ + "\u0005.\u0000\u0000\u044c\u044d\u0005k\u0000\u0000\u044d\u044e\u0005e"+ + "\u0000\u0000\u044e\u044f\u0005c\u0000\u0000\u044f\u0450\u0005c\u0000\u0000"+ + "\u0450\u0451\u0005a\u0000\u0000\u0451\u0452\u0005k\u0000\u0000\u0452\u0453"+ + "\u00052\u0000\u0000\u0453\u0454\u00055\u0000\u0000\u0454\u0455\u00056"+ + "\u0000\u0000\u0455\u00ee\u0001\u0000\u0000\u0000\u0456\u0457\u0005h\u0000"+ + "\u0000\u0457\u0458\u0005a\u0000\u0000\u0458\u0459\u0005s\u0000\u0000\u0459"+ + "\u045a\u0005h\u0000\u0000\u045a\u045b\u0005.\u0000\u0000\u045b\u045c\u0005"+ + "k\u0000\u0000\u045c\u045d\u0005e\u0000\u0000\u045d\u045e\u0005c\u0000"+ + "\u0000\u045e\u045f\u0005c\u0000\u0000\u045f\u0460\u0005a\u0000\u0000\u0460"+ + "\u0461\u0005k\u0000\u0000\u0461\u0462\u00053\u0000\u0000\u0462\u0463\u0005"+ + "8\u0000\u0000\u0463\u0464\u00054\u0000\u0000\u0464\u00f0\u0001\u0000\u0000"+ + "\u0000\u0465\u0466\u0005h\u0000\u0000\u0466\u0467\u0005a\u0000\u0000\u0467"+ + "\u0468\u0005s\u0000\u0000\u0468\u0469\u0005h\u0000\u0000\u0469\u046a\u0005"+ + ".\u0000\u0000\u046a\u046b\u0005k\u0000\u0000\u046b\u046c\u0005e\u0000"+ + "\u0000\u046c\u046d\u0005c\u0000\u0000\u046d\u046e\u0005c\u0000\u0000\u046e"+ + "\u046f\u0005a\u0000\u0000\u046f\u0470\u0005k\u0000\u0000\u0470\u0471\u0005"+ + "5\u0000\u0000\u0471\u0472\u00051\u0000\u0000\u0472\u0473\u00052\u0000"+ + "\u0000\u0473\u00f2\u0001\u0000\u0000\u0000\u0474\u0475\u0005h\u0000\u0000"+ + "\u0475\u0476\u0005a\u0000\u0000\u0476\u0477\u0005s\u0000\u0000\u0477\u0478"+ + "\u0005h\u0000\u0000\u0478\u0479\u0005.\u0000\u0000\u0479\u047a\u0005s"+ + "\u0000\u0000\u047a\u047b\u0005h\u0000\u0000\u047b\u047c\u0005a\u0000\u0000"+ + "\u047c\u047d\u00053\u0000\u0000\u047d\u047e\u0005_\u0000\u0000\u047e\u047f"+ + "\u00052\u0000\u0000\u047f\u0480\u00055\u0000\u0000\u0480\u0481\u00056"+ + "\u0000\u0000\u0481\u00f4\u0001\u0000\u0000\u0000\u0482\u0483\u0005h\u0000"+ + "\u0000\u0483\u0484\u0005a\u0000\u0000\u0484\u0485\u0005s\u0000\u0000\u0485"+ + "\u0486\u0005h\u0000\u0000\u0486\u0487\u0005.\u0000\u0000\u0487\u0488\u0005"+ + "s\u0000\u0000\u0488\u0489\u0005h\u0000\u0000\u0489\u048a\u0005a\u0000"+ + "\u0000\u048a\u048b\u00053\u0000\u0000\u048b\u048c\u0005_\u0000\u0000\u048c"+ + "\u048d\u00053\u0000\u0000\u048d\u048e\u00058\u0000\u0000\u048e\u048f\u0005"+ + "4\u0000\u0000\u048f\u00f6\u0001\u0000\u0000\u0000\u0490\u0491\u0005h\u0000"+ + "\u0000\u0491\u0492\u0005a\u0000\u0000\u0492\u0493\u0005s\u0000\u0000\u0493"+ + "\u0494\u0005h\u0000\u0000\u0494\u0495\u0005.\u0000\u0000\u0495\u0496\u0005"+ + "s\u0000\u0000\u0496\u0497\u0005h\u0000\u0000\u0497\u0498\u0005a\u0000"+ + "\u0000\u0498\u0499\u00053\u0000\u0000\u0499\u049a\u0005_\u0000\u0000\u049a"+ + "\u049b\u00055\u0000\u0000\u049b\u049c\u00051\u0000\u0000\u049c\u049d\u0005"+ + "2\u0000\u0000\u049d\u00f8\u0001\u0000\u0000\u0000\u049e\u049f\u0005h\u0000"+ + "\u0000\u049f\u04a0\u0005a\u0000\u0000\u04a0\u04a1\u0005s\u0000\u0000\u04a1"+ + "\u04a2\u0005h\u0000\u0000\u04a2\u04a3\u0005_\u0000\u0000\u04a3\u04a4\u0005"+ + "m\u0000\u0000\u04a4\u04a5\u0005a\u0000\u0000\u04a5\u04a6\u0005n\u0000"+ + "\u0000\u04a6\u04a7\u0005y\u0000\u0000\u04a7\u04a8\u0005.\u0000\u0000\u04a8"+ + "\u04a9\u0005p\u0000\u0000\u04a9\u04aa\u0005s\u0000\u0000\u04aa\u04ab\u0005"+ + "d\u0000\u0000\u04ab\u04ac\u00052\u0000\u0000\u04ac\u00fa\u0001\u0000\u0000"+ + "\u0000\u04ad\u04ae\u0005h\u0000\u0000\u04ae\u04af\u0005a\u0000\u0000\u04af"+ + "\u04b0\u0005s\u0000\u0000\u04b0\u04b1\u0005h\u0000\u0000\u04b1\u04b2\u0005"+ + "_\u0000\u0000\u04b2\u04b3\u0005m\u0000\u0000\u04b3\u04b4\u0005a\u0000"+ + "\u0000\u04b4\u04b5\u0005n\u0000\u0000\u04b5\u04b6\u0005y\u0000\u0000\u04b6"+ + "\u04b7\u0005.\u0000\u0000\u04b7\u04b8\u0005p\u0000\u0000\u04b8\u04b9\u0005"+ + "s\u0000\u0000\u04b9\u04ba\u0005d\u0000\u0000\u04ba\u04bb\u00054\u0000"+ + "\u0000\u04bb\u00fc\u0001\u0000\u0000\u0000\u04bc\u04bd\u0005h\u0000\u0000"+ + "\u04bd\u04be\u0005a\u0000\u0000\u04be\u04bf\u0005s\u0000\u0000\u04bf\u04c0"+ + "\u0005h\u0000\u0000\u04c0\u04c1\u0005_\u0000\u0000\u04c1\u04c2\u0005m"+ + "\u0000\u0000\u04c2\u04c3\u0005a\u0000\u0000\u04c3\u04c4\u0005n\u0000\u0000"+ + "\u04c4\u04c5\u0005y\u0000\u0000\u04c5\u04c6\u0005.\u0000\u0000\u04c6\u04c7"+ + "\u0005p\u0000\u0000\u04c7\u04c8\u0005s\u0000\u0000\u04c8\u04c9\u0005d"+ + "\u0000\u0000\u04c9\u04ca\u00058\u0000\u0000\u04ca\u00fe\u0001\u0000\u0000"+ + "\u0000\u04cb\u04cc\u0005c\u0000\u0000\u04cc\u04cd\u0005a\u0000\u0000\u04cd"+ + "\u04ce\u0005s\u0000\u0000\u04ce\u04cf\u0005t\u0000\u0000\u04cf\u04d0\u0005"+ + ".\u0000\u0000\u04d0\u04d1\u0005l\u0000\u0000\u04d1\u04d2\u0005o\u0000"+ + "\u0000\u04d2\u04d3\u0005s\u0000\u0000\u04d3\u04d4\u0005s\u0000\u0000\u04d4"+ + "\u04d5\u0005y\u0000\u0000\u04d5\u0100\u0001\u0000\u0000\u0000\u04d6\u04d7"+ + "\u0005c\u0000\u0000\u04d7\u04d8\u0005a\u0000\u0000\u04d8\u04d9\u0005s"+ + "\u0000\u0000\u04d9\u04da\u0005t\u0000\u0000\u04da\u0102\u0001\u0000\u0000"+ + "\u0000\u04db\u04dc\u0005b\u0000\u0000\u04dc\u04dd\u0005r\u0000\u0000\u04dd"+ + "\u04de\u0005a\u0000\u0000\u04de\u04df\u0005n\u0000\u0000\u04df\u04e0\u0005"+ + "c\u0000\u0000\u04e0\u04e1\u0005h\u0000\u0000\u04e1\u04e2\u0005.\u0000"+ + "\u0000\u04e2\u04e3\u0005e\u0000\u0000\u04e3\u04e4\u0005q\u0000\u0000\u04e4"+ + "\u0104\u0001\u0000\u0000\u0000\u04e5\u04e6\u0005b\u0000\u0000\u04e6\u04e7"+ + "\u0005r\u0000\u0000\u04e7\u04e8\u0005a\u0000\u0000\u04e8\u04e9\u0005n"+ + "\u0000\u0000\u04e9\u04ea\u0005c\u0000\u0000\u04ea\u04eb\u0005h\u0000\u0000"+ + "\u04eb\u04ec\u0005.\u0000\u0000\u04ec\u04ed\u0005n\u0000\u0000\u04ed\u04ee"+ + "\u0005e\u0000\u0000\u04ee\u04ef\u0005q\u0000\u0000\u04ef\u0106\u0001\u0000"+ + "\u0000\u0000\u04f0\u04f1\u0005a\u0000\u0000\u04f1\u04f2\u0005l\u0000\u0000"+ + "\u04f2\u04f3\u0005e\u0000\u0000\u04f3\u04f4\u0005o\u0000\u0000\u04f4\u04f5"+ + "\u00051\u0000\u0000\u04f5\u04fd\u0001\u0000\u0000\u0000\u04f6\u04fa\u0003"+ + "\u010b\u0085\u0000\u04f7\u04f9\u0005_\u0000\u0000\u04f8\u04f7\u0001\u0000"+ + "\u0000\u0000\u04f9\u04fc\u0001\u0000\u0000\u0000\u04fa\u04f8\u0001\u0000"+ + "\u0000\u0000\u04fa\u04fb\u0001\u0000\u0000\u0000\u04fb\u04fe\u0001\u0000"+ + "\u0000\u0000\u04fc\u04fa\u0001\u0000\u0000\u0000\u04fd\u04f6\u0001\u0000"+ + "\u0000\u0000\u04fe\u04ff\u0001\u0000\u0000\u0000\u04ff\u04fd\u0001\u0000"+ + "\u0000\u0000\u04ff\u0500\u0001\u0000\u0000\u0000\u0500\u0108\u0001\u0000"+ + "\u0000\u0000\u0501\u0502\u0005s\u0000\u0000\u0502\u0503\u0005i\u0000\u0000"+ + "\u0503\u0504\u0005g\u0000\u0000\u0504\u0505\u0005n\u0000\u0000\u0505\u0506"+ + "\u00051\u0000\u0000\u0506\u050e\u0001\u0000\u0000\u0000\u0507\u050b\u0003"+ + "\u010b\u0085\u0000\u0508\u050a\u0005_\u0000\u0000\u0509\u0508\u0001\u0000"+ + "\u0000\u0000\u050a\u050d\u0001\u0000\u0000\u0000\u050b\u0509\u0001\u0000"+ + "\u0000\u0000\u050b\u050c\u0001\u0000\u0000\u0000\u050c\u050f\u0001\u0000"+ + "\u0000\u0000\u050d\u050b\u0001\u0000\u0000\u0000\u050e\u0507\u0001\u0000"+ + "\u0000\u0000\u050f\u0510\u0001\u0000\u0000\u0000\u0510\u050e\u0001\u0000"+ + "\u0000\u0000\u0510\u0511\u0001\u0000\u0000\u0000\u0511\u010a\u0001\u0000"+ + "\u0000\u0000\u0512\u0515\u0003\u0115\u008a\u0000\u0513\u0515\u0003\u011d"+ + "\u008e\u0000\u0514\u0512\u0001\u0000\u0000\u0000\u0514\u0513\u0001\u0000"+ + "\u0000\u0000\u0515\u010c\u0001\u0000\u0000\u0000\u0516\u0518\u0005r\u0000"+ + "\u0000\u0517\u0519\u0003\u011b\u008d\u0000\u0518\u0517\u0001\u0000\u0000"+ + "\u0000\u0519\u051a\u0001\u0000\u0000\u0000\u051a\u0518\u0001\u0000\u0000"+ + "\u0000\u051a\u051b\u0001\u0000\u0000\u0000\u051b\u010e\u0001\u0000\u0000"+ + "\u0000\u051c\u0522\u0003\u0111\u0088\u0000\u051d\u0521\u0003\u0111\u0088"+ + "\u0000\u051e\u0521\u0003\u011b\u008d\u0000\u051f\u0521\u0005_\u0000\u0000"+ + "\u0520\u051d\u0001\u0000\u0000\u0000\u0520\u051e\u0001\u0000\u0000\u0000"+ + "\u0520\u051f\u0001\u0000\u0000\u0000\u0521\u0524\u0001\u0000\u0000\u0000"+ + "\u0522\u0520\u0001\u0000\u0000\u0000\u0522\u0523\u0001\u0000\u0000\u0000"+ + "\u0523\u0110\u0001\u0000\u0000\u0000\u0524\u0522\u0001\u0000\u0000\u0000"+ + "\u0525\u0528\u0003\u0113\u0089\u0000\u0526\u0528\u0003\u0119\u008c\u0000"+ + "\u0527\u0525\u0001\u0000\u0000\u0000\u0527\u0526\u0001\u0000\u0000\u0000"+ + "\u0528\u0112\u0001\u0000\u0000\u0000\u0529\u052c\u0003\u0115\u008a\u0000"+ + "\u052a\u052c\u0003\u0117\u008b\u0000\u052b\u0529\u0001\u0000\u0000\u0000"+ + "\u052b\u052a\u0001\u0000\u0000\u0000\u052c\u0114\u0001\u0000\u0000\u0000"+ + "\u052d\u052e\u0007\u0000\u0000\u0000\u052e\u0116\u0001\u0000\u0000\u0000"+ + "\u052f\u0530\u0007\u0001\u0000\u0000\u0530\u0118\u0001\u0000\u0000\u0000"+ + "\u0531\u0532\u0007\u0002\u0000\u0000\u0532\u011a\u0001\u0000\u0000\u0000"+ + "\u0533\u0536\u0003\u011d\u008e\u0000\u0534\u0536\u0003\u011f\u008f\u0000"+ + "\u0535\u0533\u0001\u0000\u0000\u0000\u0535\u0534\u0001\u0000\u0000\u0000"+ + "\u0536\u011c\u0001\u0000\u0000\u0000\u0537\u0538\u0007\u0003\u0000\u0000"+ + "\u0538\u011e\u0001\u0000\u0000\u0000\u0539\u053a\u00051\u0000\u0000\u053a"+ + "\u0120\u0001\u0000\u0000\u0000\u053b\u053d\u0007\u0004\u0000\u0000\u053c"+ + "\u053b\u0001\u0000\u0000\u0000\u053d\u053e\u0001\u0000\u0000\u0000\u053e"+ + "\u053c\u0001\u0000\u0000\u0000\u053e\u053f\u0001\u0000\u0000\u0000\u053f"+ + "\u0540\u0001\u0000\u0000\u0000\u0540\u0541\u0006\u0090\u0000\u0000\u0541"+ + "\u0122\u0001\u0000\u0000\u0000\u0542\u0543\u0005/\u0000\u0000\u0543\u0544"+ + "\u0005*\u0000\u0000\u0544\u0548\u0001\u0000\u0000\u0000\u0545\u0547\t"+ + "\u0000\u0000\u0000\u0546\u0545\u0001\u0000\u0000\u0000\u0547\u054a\u0001"+ + "\u0000\u0000\u0000\u0548\u0549\u0001\u0000\u0000\u0000\u0548\u0546\u0001"+ + "\u0000\u0000\u0000\u0549\u054b\u0001\u0000\u0000\u0000\u054a\u0548\u0001"+ + "\u0000\u0000\u0000\u054b\u054c\u0005*\u0000\u0000\u054c\u054d\u0005/\u0000"+ + "\u0000\u054d\u054e\u0001\u0000\u0000\u0000\u054e\u054f\u0006\u0091\u0001"+ + "\u0000\u054f\u0124\u0001\u0000\u0000\u0000\u0550\u0551\u0005/\u0000\u0000"+ + "\u0551\u0552\u0005/\u0000\u0000\u0552\u0556\u0001\u0000\u0000\u0000\u0553"+ + "\u0555\b\u0005\u0000\u0000\u0554\u0553\u0001\u0000\u0000\u0000\u0555\u0558"+ + "\u0001\u0000\u0000\u0000\u0556\u0554\u0001\u0000\u0000\u0000\u0556\u0557"+ + "\u0001\u0000\u0000\u0000\u0557\u0559\u0001\u0000\u0000\u0000\u0558\u0556"+ + "\u0001\u0000\u0000\u0000\u0559\u055a\u0006\u0092\u0001\u0000\u055a\u0126"+ + "\u0001\u0000\u0000\u0000\u000f\u0000\u04fa\u04ff\u050b\u0510\u0514\u051a"+ + "\u0520\u0522\u0527\u052b\u0535\u053e\u0548\u0556\u0002\u0006\u0000\u0000"+ + "\u0000\u0001\u0000"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/vanguard/aleo/parser/.antlr/AleoLexer.tokens b/vanguard/aleo/parser/.antlr/AleoLexer.tokens new file mode 100644 index 0000000..89e7efa --- /dev/null +++ b/vanguard/aleo/parser/.antlr/AleoLexer.tokens @@ -0,0 +1,270 @@ +T__0=1 +T__1=2 +T__2=3 +T__3=4 +T__4=5 +T__5=6 +T__6=7 +T__7=8 +T__8=9 +T__9=10 +T__10=11 +T__11=12 +T__12=13 +T__13=14 +T__14=15 +T__15=16 +T__16=17 +T__17=18 +T__18=19 +T__19=20 +T__20=21 +T__21=22 +T__22=23 +T__23=24 +T__24=25 +T__25=26 +T__26=27 +T__27=28 +T__28=29 +T__29=30 +T__30=31 +T__31=32 +T__32=33 +T__33=34 +T__34=35 +T__35=36 +T__36=37 +T__37=38 +T__38=39 +T__39=40 +T__40=41 +T__41=42 +T__42=43 +T__43=44 +T__44=45 +T__45=46 +T__46=47 +T__47=48 +T__48=49 +T__49=50 +T__50=51 +T__51=52 +T__52=53 +T__53=54 +T__54=55 +T__55=56 +T__56=57 +T__57=58 +T__58=59 +T__59=60 +T__60=61 +T__61=62 +T__62=63 +T__63=64 +T__64=65 +T__65=66 +T__66=67 +T__67=68 +T__68=69 +T__69=70 +T__70=71 +T__71=72 +T__72=73 +T__73=74 +T__74=75 +T__75=76 +T__76=77 +T__77=78 +T__78=79 +T__79=80 +T__80=81 +T__81=82 +T__82=83 +T__83=84 +T__84=85 +T__85=86 +T__86=87 +T__87=88 +T__88=89 +T__89=90 +T__90=91 +T__91=92 +T__92=93 +T__93=94 +T__94=95 +T__95=96 +T__96=97 +T__97=98 +T__98=99 +T__99=100 +T__100=101 +T__101=102 +T__102=103 +T__103=104 +T__104=105 +T__105=106 +T__106=107 +T__107=108 +T__108=109 +T__109=110 +T__110=111 +T__111=112 +T__112=113 +T__113=114 +T__114=115 +T__115=116 +T__116=117 +T__117=118 +T__118=119 +T__119=120 +T__120=121 +T__121=122 +T__122=123 +T__123=124 +T__124=125 +T__125=126 +T__126=127 +T__127=128 +T__128=129 +T__129=130 +T__130=131 +ADDRESS_LITERAL=132 +SIGNATURE_LITERAL=133 +REGISTER=134 +IDENTIFIER=135 +DIGIT=136 +WS=137 +COMMENT=138 +LINE_COMMENT=139 +'program'=1 +';'=2 +'import'=3 +'mapping'=4 +':'=5 +'key'=6 +'as'=7 +'value'=8 +'struct'=9 +'record'=10 +'closure'=11 +'input'=12 +'output'=13 +'function'=14 +'finalize'=15 +'contains'=16 +'['=17 +']'=18 +'into'=19 +'get'=20 +'get.or_use'=21 +'set'=22 +'remove'=23 +'rand.chacha'=24 +'position'=25 +'to'=26 +'await'=27 +'ternary'=28 +'sign.verify'=29 +'sign_verify'=30 +'call'=31 +'async'=32 +'-'=33 +'_'=34 +'u32'=35 +'true'=36 +'false'=37 +'u8'=38 +'u16'=39 +'u64'=40 +'u128'=41 +'i8'=42 +'i16'=43 +'i32'=44 +'i64'=45 +'i128'=46 +'field'=47 +'group'=48 +'scalar'=49 +'address'=50 +'boolean'=51 +'signature'=52 +'.constant'=53 +'.public'=54 +'.private'=55 +'.record'=56 +'.future'=57 +'.'=58 +'group::GEN'=59 +'self.signer'=60 +'self.caller'=61 +'block.height'=62 +'/'=63 +'group.x'=64 +'group.y'=65 +'abs'=66 +'abs.w'=67 +'double'=68 +'inv'=69 +'neg'=70 +'not'=71 +'square'=72 +'sqrt'=73 +'add'=74 +'add.w'=75 +'sub'=76 +'sub.w'=77 +'mul'=78 +'mul.w'=79 +'div'=80 +'div.w'=81 +'rem'=82 +'rem.w'=83 +'pow'=84 +'pow.w'=85 +'shl'=86 +'shl.w'=87 +'shr'=88 +'shr.w'=89 +'mod'=90 +'and'=91 +'or'=92 +'xor'=93 +'nand'=94 +'nor'=95 +'gt'=96 +'gte'=97 +'lt'=98 +'lte'=99 +'is.eq'=100 +'is.neq'=101 +'assert.eq'=102 +'assert.neq'=103 +'commit.bhp256'=104 +'commit.bhp512'=105 +'commit.bhp768'=106 +'commit.bhp1024'=107 +'commit.ped64'=108 +'commit.ped128'=109 +'hash.bhp256'=110 +'hash.bhp512'=111 +'hash.bhp768'=112 +'hash.bhp1024'=113 +'hash.ped64'=114 +'hash.ped128'=115 +'hash.psd2'=116 +'hash.psd4'=117 +'hash.psd8'=118 +'hash.keccak256'=119 +'hash.keccak384'=120 +'hash.keccak512'=121 +'hash.sha3_256'=122 +'hash.sha3_384'=123 +'hash.sha3_512'=124 +'hash_many.psd2'=125 +'hash_many.psd4'=126 +'hash_many.psd8'=127 +'cast.lossy'=128 +'cast'=129 +'branch.eq'=130 +'branch.neq'=131 diff --git a/vanguard/aleo/parser/.antlr/Solidity.interp b/vanguard/aleo/parser/.antlr/Solidity.interp new file mode 100644 index 0000000..bda522b --- /dev/null +++ b/vanguard/aleo/parser/.antlr/Solidity.interp @@ -0,0 +1,355 @@ +token literal names: +null +'pragma' +';' +'^' +'~' +'>=' +'>' +'<' +'<=' +'=' +'import' +'as' +'*' +'from' +'{' +',' +'}' +'abstract' +'contract' +'interface' +'library' +'is' +'(' +')' +'override' +'using' +'for' +'struct' +'modifier' +'function' +'returns' +'event' +'enum' +'[' +']' +'.' +'mapping' +'=>' +'memory' +'storage' +'calldata' +'if' +'else' +'try' +'catch' +'while' +'assembly' +'do' +'return' +'throw' +'emit' +'var' +'address' +'bool' +'string' +'byte' +'++' +'--' +'new' +':' +'+' +'-' +'after' +'delete' +'!' +'**' +'/' +'%' +'<<' +'>>' +'&' +'|' +'==' +'!=' +'&&' +'||' +'?' +'|=' +'^=' +'&=' +'<<=' +'>>=' +'+=' +'-=' +'*=' +'/=' +'%=' +'let' +':=' +'=:' +'switch' +'case' +'default' +null +null +null +null +null +null +null +null +null +null +null +'anonymous' +'break' +'constant' +'immutable' +'continue' +'leave' +'external' +'indexed' +'internal' +'payable' +'private' +'public' +'virtual' +'pure' +'type' +'view' +'constructor' +'fallback' +'receive' +null +null +null +null +null +null + +token symbolic names: +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +Int +Uint +Byte +Fixed +Ufixed +BooleanLiteral +DecimalNumber +HexNumber +NumberUnit +HexLiteralFragment +ReservedKeyword +AnonymousKeyword +BreakKeyword +ConstantKeyword +ImmutableKeyword +ContinueKeyword +LeaveKeyword +ExternalKeyword +IndexedKeyword +InternalKeyword +PayableKeyword +PrivateKeyword +PublicKeyword +VirtualKeyword +PureKeyword +TypeKeyword +ViewKeyword +ConstructorKeyword +FallbackKeyword +ReceiveKeyword +Identifier +StringLiteralFragment +VersionLiteral +WS +COMMENT +LINE_COMMENT + +rule names: +sourceUnit +pragmaDirective +pragmaName +pragmaValue +version +versionConstraint +versionOperator +importDirective +importDeclaration +contractDefinition +inheritanceSpecifier +contractPart +stateVariableDeclaration +overrideSpecifier +usingForDeclaration +structDefinition +modifierDefinition +functionDefinition +functionDescriptor +returnParameters +modifierList +modifierInvocation +eventDefinition +enumDefinition +enumValue +parameterList +parameter +eventParameterList +eventParameter +variableDeclaration +typeName +userDefinedTypeName +mapping +functionTypeName +storageLocation +stateMutability +block +statement +expressionStatement +ifStatement +tryStatement +catchClause +whileStatement +forStatement +simpleStatement +inlineAssemblyStatement +doWhileStatement +continueStatement +breakStatement +returnStatement +throwStatement +emitStatement +variableDeclarationStatement +variableDeclarationList +identifierList +elementaryTypeName +expression +primaryExpression +expressionList +nameValueList +nameValue +functionCallArguments +functionCall +tupleExpression +typeNameExpression +assemblyItem +assemblyBlock +assemblyExpression +assemblyCall +assemblyLocalDefinition +assemblyAssignment +assemblyIdentifierList +assemblyStackAssignment +labelDefinition +assemblySwitch +assemblyCase +assemblyFunctionDefinition +assemblyFunctionReturns +assemblyFor +assemblyIf +assemblyLiteral +assemblyTypedVariableList +assemblyType +subAssembly +numberLiteral +identifier +hexLiteral +stringLiteral + + +atn: +[4, 1, 128, 1057, 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, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 182, 8, 0, 10, 0, 12, 0, 185, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 3, 3, 198, 8, 3, 1, 4, 1, 4, 3, 4, 202, 8, 4, 1, 5, 3, 5, 205, 8, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 215, 8, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 221, 8, 7, 1, 7, 1, 7, 3, 7, 225, 8, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 5, 7, 235, 8, 7, 10, 7, 12, 7, 238, 9, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 245, 8, 7, 1, 8, 1, 8, 1, 8, 3, 8, 250, 8, 8, 1, 9, 3, 9, 253, 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 5, 9, 261, 8, 9, 10, 9, 12, 9, 264, 9, 9, 3, 9, 266, 8, 9, 1, 9, 1, 9, 5, 9, 270, 8, 9, 10, 9, 12, 9, 273, 9, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 3, 10, 280, 8, 10, 1, 10, 3, 10, 283, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 292, 8, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 5, 12, 301, 8, 12, 10, 12, 12, 12, 304, 9, 12, 1, 12, 1, 12, 1, 12, 3, 12, 309, 8, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 5, 13, 318, 8, 13, 10, 13, 12, 13, 321, 9, 13, 1, 13, 1, 13, 3, 13, 325, 8, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 332, 8, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 344, 8, 15, 10, 15, 12, 15, 347, 9, 15, 3, 15, 349, 8, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 3, 16, 356, 8, 16, 1, 16, 1, 16, 5, 16, 360, 8, 16, 10, 16, 12, 16, 363, 9, 16, 1, 16, 1, 16, 3, 16, 367, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 373, 8, 17, 1, 17, 1, 17, 3, 17, 377, 8, 17, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 383, 8, 18, 1, 18, 1, 18, 1, 18, 3, 18, 388, 8, 18, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 5, 20, 401, 8, 20, 10, 20, 12, 20, 404, 9, 20, 1, 21, 1, 21, 1, 21, 3, 21, 409, 8, 21, 1, 21, 3, 21, 412, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 418, 8, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 426, 8, 23, 1, 23, 1, 23, 5, 23, 430, 8, 23, 10, 23, 12, 23, 433, 9, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 5, 25, 443, 8, 25, 10, 25, 12, 25, 446, 9, 25, 3, 25, 448, 8, 25, 1, 25, 1, 25, 1, 26, 1, 26, 3, 26, 454, 8, 26, 1, 26, 3, 26, 457, 8, 26, 1, 27, 1, 27, 1, 27, 1, 27, 5, 27, 463, 8, 27, 10, 27, 12, 27, 466, 9, 27, 3, 27, 468, 8, 27, 1, 27, 1, 27, 1, 28, 1, 28, 3, 28, 474, 8, 28, 1, 28, 3, 28, 477, 8, 28, 1, 29, 1, 29, 3, 29, 481, 8, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 3, 30, 490, 8, 30, 1, 30, 1, 30, 1, 30, 3, 30, 495, 8, 30, 1, 30, 5, 30, 498, 8, 30, 10, 30, 12, 30, 501, 9, 30, 1, 31, 1, 31, 1, 31, 5, 31, 506, 8, 31, 10, 31, 12, 31, 509, 9, 31, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 515, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 525, 8, 33, 1, 34, 1, 34, 1, 35, 1, 35, 1, 36, 1, 36, 5, 36, 533, 8, 36, 10, 36, 12, 36, 536, 9, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 553, 8, 37, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 565, 8, 39, 1, 40, 1, 40, 1, 40, 3, 40, 570, 8, 40, 1, 40, 1, 40, 4, 40, 574, 8, 40, 11, 40, 12, 40, 575, 1, 41, 1, 41, 3, 41, 580, 8, 41, 1, 41, 3, 41, 583, 8, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 3, 43, 597, 8, 43, 1, 43, 1, 43, 3, 43, 601, 8, 43, 1, 43, 3, 43, 604, 8, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 3, 44, 611, 8, 44, 1, 45, 1, 45, 3, 45, 615, 8, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 3, 49, 635, 8, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 653, 8, 52, 1, 52, 1, 52, 3, 52, 657, 8, 52, 1, 52, 1, 52, 1, 53, 3, 53, 662, 8, 53, 1, 53, 1, 53, 3, 53, 666, 8, 53, 5, 53, 668, 8, 53, 10, 53, 12, 53, 671, 9, 53, 1, 54, 1, 54, 3, 54, 675, 8, 54, 1, 54, 5, 54, 678, 8, 54, 10, 54, 12, 54, 681, 9, 54, 1, 54, 3, 54, 684, 8, 54, 1, 54, 1, 54, 1, 55, 1, 55, 3, 55, 690, 8, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 701, 8, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 726, 8, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 775, 8, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 781, 8, 56, 1, 56, 1, 56, 3, 56, 785, 8, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 5, 56, 801, 8, 56, 10, 56, 12, 56, 804, 9, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 813, 8, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 820, 8, 57, 3, 57, 822, 8, 57, 1, 58, 1, 58, 1, 58, 5, 58, 827, 8, 58, 10, 58, 12, 58, 830, 9, 58, 1, 59, 1, 59, 1, 59, 5, 59, 835, 8, 59, 10, 59, 12, 59, 838, 9, 59, 1, 59, 3, 59, 841, 8, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 3, 61, 849, 8, 61, 1, 61, 1, 61, 3, 61, 853, 8, 61, 3, 61, 855, 8, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 3, 63, 864, 8, 63, 1, 63, 1, 63, 3, 63, 868, 8, 63, 5, 63, 870, 8, 63, 10, 63, 12, 63, 873, 9, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 5, 63, 880, 8, 63, 10, 63, 12, 63, 883, 9, 63, 3, 63, 885, 8, 63, 1, 63, 3, 63, 888, 8, 63, 1, 64, 1, 64, 3, 64, 892, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 912, 8, 65, 1, 66, 1, 66, 5, 66, 916, 8, 66, 10, 66, 12, 66, 919, 9, 66, 1, 66, 1, 66, 1, 67, 1, 67, 3, 67, 925, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 931, 8, 68, 1, 68, 1, 68, 3, 68, 935, 8, 68, 1, 68, 1, 68, 5, 68, 939, 8, 68, 10, 68, 12, 68, 942, 9, 68, 1, 68, 3, 68, 945, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 951, 8, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 5, 71, 960, 8, 71, 10, 71, 12, 71, 963, 9, 71, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 5, 74, 974, 8, 74, 10, 74, 12, 74, 977, 9, 74, 1, 75, 1, 75, 1, 75, 3, 75, 982, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 988, 8, 75, 1, 76, 1, 76, 1, 76, 1, 76, 3, 76, 994, 8, 76, 1, 76, 1, 76, 3, 76, 998, 8, 76, 1, 76, 1, 76, 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, 80, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 1021, 8, 80, 1, 80, 3, 80, 1024, 8, 80, 1, 81, 1, 81, 3, 81, 1028, 8, 81, 1, 81, 1, 81, 3, 81, 1032, 8, 81, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 3, 84, 1043, 8, 84, 1, 85, 1, 85, 1, 86, 4, 86, 1048, 8, 86, 11, 86, 12, 86, 1049, 1, 87, 4, 87, 1053, 8, 87, 11, 87, 12, 87, 1054, 1, 87, 0, 2, 60, 112, 88, 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, 0, 14, 1, 0, 3, 9, 1, 0, 18, 20, 1, 0, 38, 40, 4, 0, 106, 106, 113, 113, 117, 117, 119, 119, 1, 0, 56, 57, 1, 0, 60, 61, 1, 0, 62, 63, 2, 0, 12, 12, 66, 67, 1, 0, 68, 69, 1, 0, 5, 8, 1, 0, 72, 73, 2, 0, 9, 9, 77, 86, 1, 0, 99, 100, 4, 0, 13, 13, 40, 40, 52, 52, 123, 123, 1186, 0, 183, 1, 0, 0, 0, 2, 188, 1, 0, 0, 0, 4, 193, 1, 0, 0, 0, 6, 197, 1, 0, 0, 0, 8, 199, 1, 0, 0, 0, 10, 204, 1, 0, 0, 0, 12, 208, 1, 0, 0, 0, 14, 244, 1, 0, 0, 0, 16, 246, 1, 0, 0, 0, 18, 252, 1, 0, 0, 0, 20, 276, 1, 0, 0, 0, 22, 291, 1, 0, 0, 0, 24, 293, 1, 0, 0, 0, 26, 312, 1, 0, 0, 0, 28, 326, 1, 0, 0, 0, 30, 335, 1, 0, 0, 0, 32, 352, 1, 0, 0, 0, 34, 368, 1, 0, 0, 0, 36, 387, 1, 0, 0, 0, 38, 389, 1, 0, 0, 0, 40, 402, 1, 0, 0, 0, 42, 405, 1, 0, 0, 0, 44, 413, 1, 0, 0, 0, 46, 421, 1, 0, 0, 0, 48, 436, 1, 0, 0, 0, 50, 438, 1, 0, 0, 0, 52, 451, 1, 0, 0, 0, 54, 458, 1, 0, 0, 0, 56, 471, 1, 0, 0, 0, 58, 478, 1, 0, 0, 0, 60, 489, 1, 0, 0, 0, 62, 502, 1, 0, 0, 0, 64, 510, 1, 0, 0, 0, 66, 520, 1, 0, 0, 0, 68, 526, 1, 0, 0, 0, 70, 528, 1, 0, 0, 0, 72, 530, 1, 0, 0, 0, 74, 552, 1, 0, 0, 0, 76, 554, 1, 0, 0, 0, 78, 557, 1, 0, 0, 0, 80, 566, 1, 0, 0, 0, 82, 577, 1, 0, 0, 0, 84, 586, 1, 0, 0, 0, 86, 592, 1, 0, 0, 0, 88, 610, 1, 0, 0, 0, 90, 612, 1, 0, 0, 0, 92, 618, 1, 0, 0, 0, 94, 626, 1, 0, 0, 0, 96, 629, 1, 0, 0, 0, 98, 632, 1, 0, 0, 0, 100, 638, 1, 0, 0, 0, 102, 641, 1, 0, 0, 0, 104, 652, 1, 0, 0, 0, 106, 661, 1, 0, 0, 0, 108, 672, 1, 0, 0, 0, 110, 700, 1, 0, 0, 0, 112, 725, 1, 0, 0, 0, 114, 821, 1, 0, 0, 0, 116, 823, 1, 0, 0, 0, 118, 831, 1, 0, 0, 0, 120, 842, 1, 0, 0, 0, 122, 854, 1, 0, 0, 0, 124, 856, 1, 0, 0, 0, 126, 887, 1, 0, 0, 0, 128, 891, 1, 0, 0, 0, 130, 911, 1, 0, 0, 0, 132, 913, 1, 0, 0, 0, 134, 924, 1, 0, 0, 0, 136, 930, 1, 0, 0, 0, 138, 946, 1, 0, 0, 0, 140, 952, 1, 0, 0, 0, 142, 956, 1, 0, 0, 0, 144, 964, 1, 0, 0, 0, 146, 967, 1, 0, 0, 0, 148, 970, 1, 0, 0, 0, 150, 987, 1, 0, 0, 0, 152, 989, 1, 0, 0, 0, 154, 1001, 1, 0, 0, 0, 156, 1005, 1, 0, 0, 0, 158, 1011, 1, 0, 0, 0, 160, 1020, 1, 0, 0, 0, 162, 1025, 1, 0, 0, 0, 164, 1033, 1, 0, 0, 0, 166, 1036, 1, 0, 0, 0, 168, 1040, 1, 0, 0, 0, 170, 1044, 1, 0, 0, 0, 172, 1047, 1, 0, 0, 0, 174, 1052, 1, 0, 0, 0, 176, 182, 3, 2, 1, 0, 177, 182, 3, 14, 7, 0, 178, 182, 3, 30, 15, 0, 179, 182, 3, 46, 23, 0, 180, 182, 3, 18, 9, 0, 181, 176, 1, 0, 0, 0, 181, 177, 1, 0, 0, 0, 181, 178, 1, 0, 0, 0, 181, 179, 1, 0, 0, 0, 181, 180, 1, 0, 0, 0, 182, 185, 1, 0, 0, 0, 183, 181, 1, 0, 0, 0, 183, 184, 1, 0, 0, 0, 184, 186, 1, 0, 0, 0, 185, 183, 1, 0, 0, 0, 186, 187, 5, 0, 0, 1, 187, 1, 1, 0, 0, 0, 188, 189, 5, 1, 0, 0, 189, 190, 3, 4, 2, 0, 190, 191, 3, 6, 3, 0, 191, 192, 5, 2, 0, 0, 192, 3, 1, 0, 0, 0, 193, 194, 3, 170, 85, 0, 194, 5, 1, 0, 0, 0, 195, 198, 3, 8, 4, 0, 196, 198, 3, 112, 56, 0, 197, 195, 1, 0, 0, 0, 197, 196, 1, 0, 0, 0, 198, 7, 1, 0, 0, 0, 199, 201, 3, 10, 5, 0, 200, 202, 3, 10, 5, 0, 201, 200, 1, 0, 0, 0, 201, 202, 1, 0, 0, 0, 202, 9, 1, 0, 0, 0, 203, 205, 3, 12, 6, 0, 204, 203, 1, 0, 0, 0, 204, 205, 1, 0, 0, 0, 205, 206, 1, 0, 0, 0, 206, 207, 5, 125, 0, 0, 207, 11, 1, 0, 0, 0, 208, 209, 7, 0, 0, 0, 209, 13, 1, 0, 0, 0, 210, 211, 5, 10, 0, 0, 211, 214, 5, 124, 0, 0, 212, 213, 5, 11, 0, 0, 213, 215, 3, 170, 85, 0, 214, 212, 1, 0, 0, 0, 214, 215, 1, 0, 0, 0, 215, 216, 1, 0, 0, 0, 216, 245, 5, 2, 0, 0, 217, 220, 5, 10, 0, 0, 218, 221, 5, 12, 0, 0, 219, 221, 3, 170, 85, 0, 220, 218, 1, 0, 0, 0, 220, 219, 1, 0, 0, 0, 221, 224, 1, 0, 0, 0, 222, 223, 5, 11, 0, 0, 223, 225, 3, 170, 85, 0, 224, 222, 1, 0, 0, 0, 224, 225, 1, 0, 0, 0, 225, 226, 1, 0, 0, 0, 226, 227, 5, 13, 0, 0, 227, 228, 5, 124, 0, 0, 228, 245, 5, 2, 0, 0, 229, 230, 5, 10, 0, 0, 230, 231, 5, 14, 0, 0, 231, 236, 3, 16, 8, 0, 232, 233, 5, 15, 0, 0, 233, 235, 3, 16, 8, 0, 234, 232, 1, 0, 0, 0, 235, 238, 1, 0, 0, 0, 236, 234, 1, 0, 0, 0, 236, 237, 1, 0, 0, 0, 237, 239, 1, 0, 0, 0, 238, 236, 1, 0, 0, 0, 239, 240, 5, 16, 0, 0, 240, 241, 5, 13, 0, 0, 241, 242, 5, 124, 0, 0, 242, 243, 5, 2, 0, 0, 243, 245, 1, 0, 0, 0, 244, 210, 1, 0, 0, 0, 244, 217, 1, 0, 0, 0, 244, 229, 1, 0, 0, 0, 245, 15, 1, 0, 0, 0, 246, 249, 3, 170, 85, 0, 247, 248, 5, 11, 0, 0, 248, 250, 3, 170, 85, 0, 249, 247, 1, 0, 0, 0, 249, 250, 1, 0, 0, 0, 250, 17, 1, 0, 0, 0, 251, 253, 5, 17, 0, 0, 252, 251, 1, 0, 0, 0, 252, 253, 1, 0, 0, 0, 253, 254, 1, 0, 0, 0, 254, 255, 7, 1, 0, 0, 255, 265, 3, 170, 85, 0, 256, 257, 5, 21, 0, 0, 257, 262, 3, 20, 10, 0, 258, 259, 5, 15, 0, 0, 259, 261, 3, 20, 10, 0, 260, 258, 1, 0, 0, 0, 261, 264, 1, 0, 0, 0, 262, 260, 1, 0, 0, 0, 262, 263, 1, 0, 0, 0, 263, 266, 1, 0, 0, 0, 264, 262, 1, 0, 0, 0, 265, 256, 1, 0, 0, 0, 265, 266, 1, 0, 0, 0, 266, 267, 1, 0, 0, 0, 267, 271, 5, 14, 0, 0, 268, 270, 3, 22, 11, 0, 269, 268, 1, 0, 0, 0, 270, 273, 1, 0, 0, 0, 271, 269, 1, 0, 0, 0, 271, 272, 1, 0, 0, 0, 272, 274, 1, 0, 0, 0, 273, 271, 1, 0, 0, 0, 274, 275, 5, 16, 0, 0, 275, 19, 1, 0, 0, 0, 276, 282, 3, 62, 31, 0, 277, 279, 5, 22, 0, 0, 278, 280, 3, 116, 58, 0, 279, 278, 1, 0, 0, 0, 279, 280, 1, 0, 0, 0, 280, 281, 1, 0, 0, 0, 281, 283, 5, 23, 0, 0, 282, 277, 1, 0, 0, 0, 282, 283, 1, 0, 0, 0, 283, 21, 1, 0, 0, 0, 284, 292, 3, 24, 12, 0, 285, 292, 3, 28, 14, 0, 286, 292, 3, 30, 15, 0, 287, 292, 3, 32, 16, 0, 288, 292, 3, 34, 17, 0, 289, 292, 3, 44, 22, 0, 290, 292, 3, 46, 23, 0, 291, 284, 1, 0, 0, 0, 291, 285, 1, 0, 0, 0, 291, 286, 1, 0, 0, 0, 291, 287, 1, 0, 0, 0, 291, 288, 1, 0, 0, 0, 291, 289, 1, 0, 0, 0, 291, 290, 1, 0, 0, 0, 292, 23, 1, 0, 0, 0, 293, 302, 3, 60, 30, 0, 294, 301, 5, 115, 0, 0, 295, 301, 5, 112, 0, 0, 296, 301, 5, 114, 0, 0, 297, 301, 5, 106, 0, 0, 298, 301, 5, 107, 0, 0, 299, 301, 3, 26, 13, 0, 300, 294, 1, 0, 0, 0, 300, 295, 1, 0, 0, 0, 300, 296, 1, 0, 0, 0, 300, 297, 1, 0, 0, 0, 300, 298, 1, 0, 0, 0, 300, 299, 1, 0, 0, 0, 301, 304, 1, 0, 0, 0, 302, 300, 1, 0, 0, 0, 302, 303, 1, 0, 0, 0, 303, 305, 1, 0, 0, 0, 304, 302, 1, 0, 0, 0, 305, 308, 3, 170, 85, 0, 306, 307, 5, 9, 0, 0, 307, 309, 3, 112, 56, 0, 308, 306, 1, 0, 0, 0, 308, 309, 1, 0, 0, 0, 309, 310, 1, 0, 0, 0, 310, 311, 5, 2, 0, 0, 311, 25, 1, 0, 0, 0, 312, 324, 5, 24, 0, 0, 313, 314, 5, 22, 0, 0, 314, 319, 3, 62, 31, 0, 315, 316, 5, 15, 0, 0, 316, 318, 3, 62, 31, 0, 317, 315, 1, 0, 0, 0, 318, 321, 1, 0, 0, 0, 319, 317, 1, 0, 0, 0, 319, 320, 1, 0, 0, 0, 320, 322, 1, 0, 0, 0, 321, 319, 1, 0, 0, 0, 322, 323, 5, 23, 0, 0, 323, 325, 1, 0, 0, 0, 324, 313, 1, 0, 0, 0, 324, 325, 1, 0, 0, 0, 325, 27, 1, 0, 0, 0, 326, 327, 5, 25, 0, 0, 327, 328, 3, 170, 85, 0, 328, 331, 5, 26, 0, 0, 329, 332, 5, 12, 0, 0, 330, 332, 3, 60, 30, 0, 331, 329, 1, 0, 0, 0, 331, 330, 1, 0, 0, 0, 332, 333, 1, 0, 0, 0, 333, 334, 5, 2, 0, 0, 334, 29, 1, 0, 0, 0, 335, 336, 5, 27, 0, 0, 336, 337, 3, 170, 85, 0, 337, 348, 5, 14, 0, 0, 338, 339, 3, 58, 29, 0, 339, 345, 5, 2, 0, 0, 340, 341, 3, 58, 29, 0, 341, 342, 5, 2, 0, 0, 342, 344, 1, 0, 0, 0, 343, 340, 1, 0, 0, 0, 344, 347, 1, 0, 0, 0, 345, 343, 1, 0, 0, 0, 345, 346, 1, 0, 0, 0, 346, 349, 1, 0, 0, 0, 347, 345, 1, 0, 0, 0, 348, 338, 1, 0, 0, 0, 348, 349, 1, 0, 0, 0, 349, 350, 1, 0, 0, 0, 350, 351, 5, 16, 0, 0, 351, 31, 1, 0, 0, 0, 352, 353, 5, 28, 0, 0, 353, 355, 3, 170, 85, 0, 354, 356, 3, 50, 25, 0, 355, 354, 1, 0, 0, 0, 355, 356, 1, 0, 0, 0, 356, 361, 1, 0, 0, 0, 357, 360, 5, 116, 0, 0, 358, 360, 3, 26, 13, 0, 359, 357, 1, 0, 0, 0, 359, 358, 1, 0, 0, 0, 360, 363, 1, 0, 0, 0, 361, 359, 1, 0, 0, 0, 361, 362, 1, 0, 0, 0, 362, 366, 1, 0, 0, 0, 363, 361, 1, 0, 0, 0, 364, 367, 5, 2, 0, 0, 365, 367, 3, 72, 36, 0, 366, 364, 1, 0, 0, 0, 366, 365, 1, 0, 0, 0, 367, 33, 1, 0, 0, 0, 368, 369, 3, 36, 18, 0, 369, 370, 3, 50, 25, 0, 370, 372, 3, 40, 20, 0, 371, 373, 3, 38, 19, 0, 372, 371, 1, 0, 0, 0, 372, 373, 1, 0, 0, 0, 373, 376, 1, 0, 0, 0, 374, 377, 5, 2, 0, 0, 375, 377, 3, 72, 36, 0, 376, 374, 1, 0, 0, 0, 376, 375, 1, 0, 0, 0, 377, 35, 1, 0, 0, 0, 378, 382, 5, 29, 0, 0, 379, 383, 3, 170, 85, 0, 380, 383, 5, 122, 0, 0, 381, 383, 5, 121, 0, 0, 382, 379, 1, 0, 0, 0, 382, 380, 1, 0, 0, 0, 382, 381, 1, 0, 0, 0, 382, 383, 1, 0, 0, 0, 383, 388, 1, 0, 0, 0, 384, 388, 5, 120, 0, 0, 385, 388, 5, 121, 0, 0, 386, 388, 5, 122, 0, 0, 387, 378, 1, 0, 0, 0, 387, 384, 1, 0, 0, 0, 387, 385, 1, 0, 0, 0, 387, 386, 1, 0, 0, 0, 388, 37, 1, 0, 0, 0, 389, 390, 5, 30, 0, 0, 390, 391, 3, 50, 25, 0, 391, 39, 1, 0, 0, 0, 392, 401, 3, 42, 21, 0, 393, 401, 3, 70, 35, 0, 394, 401, 5, 110, 0, 0, 395, 401, 5, 115, 0, 0, 396, 401, 5, 112, 0, 0, 397, 401, 5, 114, 0, 0, 398, 401, 5, 116, 0, 0, 399, 401, 3, 26, 13, 0, 400, 392, 1, 0, 0, 0, 400, 393, 1, 0, 0, 0, 400, 394, 1, 0, 0, 0, 400, 395, 1, 0, 0, 0, 400, 396, 1, 0, 0, 0, 400, 397, 1, 0, 0, 0, 400, 398, 1, 0, 0, 0, 400, 399, 1, 0, 0, 0, 401, 404, 1, 0, 0, 0, 402, 400, 1, 0, 0, 0, 402, 403, 1, 0, 0, 0, 403, 41, 1, 0, 0, 0, 404, 402, 1, 0, 0, 0, 405, 411, 3, 170, 85, 0, 406, 408, 5, 22, 0, 0, 407, 409, 3, 116, 58, 0, 408, 407, 1, 0, 0, 0, 408, 409, 1, 0, 0, 0, 409, 410, 1, 0, 0, 0, 410, 412, 5, 23, 0, 0, 411, 406, 1, 0, 0, 0, 411, 412, 1, 0, 0, 0, 412, 43, 1, 0, 0, 0, 413, 414, 5, 31, 0, 0, 414, 415, 3, 170, 85, 0, 415, 417, 3, 54, 27, 0, 416, 418, 5, 104, 0, 0, 417, 416, 1, 0, 0, 0, 417, 418, 1, 0, 0, 0, 418, 419, 1, 0, 0, 0, 419, 420, 5, 2, 0, 0, 420, 45, 1, 0, 0, 0, 421, 422, 5, 32, 0, 0, 422, 423, 3, 170, 85, 0, 423, 425, 5, 14, 0, 0, 424, 426, 3, 48, 24, 0, 425, 424, 1, 0, 0, 0, 425, 426, 1, 0, 0, 0, 426, 431, 1, 0, 0, 0, 427, 428, 5, 15, 0, 0, 428, 430, 3, 48, 24, 0, 429, 427, 1, 0, 0, 0, 430, 433, 1, 0, 0, 0, 431, 429, 1, 0, 0, 0, 431, 432, 1, 0, 0, 0, 432, 434, 1, 0, 0, 0, 433, 431, 1, 0, 0, 0, 434, 435, 5, 16, 0, 0, 435, 47, 1, 0, 0, 0, 436, 437, 3, 170, 85, 0, 437, 49, 1, 0, 0, 0, 438, 447, 5, 22, 0, 0, 439, 444, 3, 52, 26, 0, 440, 441, 5, 15, 0, 0, 441, 443, 3, 52, 26, 0, 442, 440, 1, 0, 0, 0, 443, 446, 1, 0, 0, 0, 444, 442, 1, 0, 0, 0, 444, 445, 1, 0, 0, 0, 445, 448, 1, 0, 0, 0, 446, 444, 1, 0, 0, 0, 447, 439, 1, 0, 0, 0, 447, 448, 1, 0, 0, 0, 448, 449, 1, 0, 0, 0, 449, 450, 5, 23, 0, 0, 450, 51, 1, 0, 0, 0, 451, 453, 3, 60, 30, 0, 452, 454, 3, 68, 34, 0, 453, 452, 1, 0, 0, 0, 453, 454, 1, 0, 0, 0, 454, 456, 1, 0, 0, 0, 455, 457, 3, 170, 85, 0, 456, 455, 1, 0, 0, 0, 456, 457, 1, 0, 0, 0, 457, 53, 1, 0, 0, 0, 458, 467, 5, 22, 0, 0, 459, 464, 3, 56, 28, 0, 460, 461, 5, 15, 0, 0, 461, 463, 3, 56, 28, 0, 462, 460, 1, 0, 0, 0, 463, 466, 1, 0, 0, 0, 464, 462, 1, 0, 0, 0, 464, 465, 1, 0, 0, 0, 465, 468, 1, 0, 0, 0, 466, 464, 1, 0, 0, 0, 467, 459, 1, 0, 0, 0, 467, 468, 1, 0, 0, 0, 468, 469, 1, 0, 0, 0, 469, 470, 5, 23, 0, 0, 470, 55, 1, 0, 0, 0, 471, 473, 3, 60, 30, 0, 472, 474, 5, 111, 0, 0, 473, 472, 1, 0, 0, 0, 473, 474, 1, 0, 0, 0, 474, 476, 1, 0, 0, 0, 475, 477, 3, 170, 85, 0, 476, 475, 1, 0, 0, 0, 476, 477, 1, 0, 0, 0, 477, 57, 1, 0, 0, 0, 478, 480, 3, 60, 30, 0, 479, 481, 3, 68, 34, 0, 480, 479, 1, 0, 0, 0, 480, 481, 1, 0, 0, 0, 481, 482, 1, 0, 0, 0, 482, 483, 3, 170, 85, 0, 483, 59, 1, 0, 0, 0, 484, 485, 6, 30, -1, 0, 485, 490, 3, 110, 55, 0, 486, 490, 3, 62, 31, 0, 487, 490, 3, 64, 32, 0, 488, 490, 3, 66, 33, 0, 489, 484, 1, 0, 0, 0, 489, 486, 1, 0, 0, 0, 489, 487, 1, 0, 0, 0, 489, 488, 1, 0, 0, 0, 490, 499, 1, 0, 0, 0, 491, 492, 10, 2, 0, 0, 492, 494, 5, 33, 0, 0, 493, 495, 3, 112, 56, 0, 494, 493, 1, 0, 0, 0, 494, 495, 1, 0, 0, 0, 495, 496, 1, 0, 0, 0, 496, 498, 5, 34, 0, 0, 497, 491, 1, 0, 0, 0, 498, 501, 1, 0, 0, 0, 499, 497, 1, 0, 0, 0, 499, 500, 1, 0, 0, 0, 500, 61, 1, 0, 0, 0, 501, 499, 1, 0, 0, 0, 502, 507, 3, 170, 85, 0, 503, 504, 5, 35, 0, 0, 504, 506, 3, 170, 85, 0, 505, 503, 1, 0, 0, 0, 506, 509, 1, 0, 0, 0, 507, 505, 1, 0, 0, 0, 507, 508, 1, 0, 0, 0, 508, 63, 1, 0, 0, 0, 509, 507, 1, 0, 0, 0, 510, 511, 5, 36, 0, 0, 511, 514, 5, 22, 0, 0, 512, 515, 3, 110, 55, 0, 513, 515, 3, 62, 31, 0, 514, 512, 1, 0, 0, 0, 514, 513, 1, 0, 0, 0, 515, 516, 1, 0, 0, 0, 516, 517, 5, 37, 0, 0, 517, 518, 3, 60, 30, 0, 518, 519, 5, 23, 0, 0, 519, 65, 1, 0, 0, 0, 520, 521, 5, 29, 0, 0, 521, 522, 3, 50, 25, 0, 522, 524, 3, 40, 20, 0, 523, 525, 3, 38, 19, 0, 524, 523, 1, 0, 0, 0, 524, 525, 1, 0, 0, 0, 525, 67, 1, 0, 0, 0, 526, 527, 7, 2, 0, 0, 527, 69, 1, 0, 0, 0, 528, 529, 7, 3, 0, 0, 529, 71, 1, 0, 0, 0, 530, 534, 5, 14, 0, 0, 531, 533, 3, 74, 37, 0, 532, 531, 1, 0, 0, 0, 533, 536, 1, 0, 0, 0, 534, 532, 1, 0, 0, 0, 534, 535, 1, 0, 0, 0, 535, 537, 1, 0, 0, 0, 536, 534, 1, 0, 0, 0, 537, 538, 5, 16, 0, 0, 538, 73, 1, 0, 0, 0, 539, 553, 3, 78, 39, 0, 540, 553, 3, 80, 40, 0, 541, 553, 3, 84, 42, 0, 542, 553, 3, 86, 43, 0, 543, 553, 3, 72, 36, 0, 544, 553, 3, 90, 45, 0, 545, 553, 3, 92, 46, 0, 546, 553, 3, 94, 47, 0, 547, 553, 3, 96, 48, 0, 548, 553, 3, 98, 49, 0, 549, 553, 3, 100, 50, 0, 550, 553, 3, 102, 51, 0, 551, 553, 3, 88, 44, 0, 552, 539, 1, 0, 0, 0, 552, 540, 1, 0, 0, 0, 552, 541, 1, 0, 0, 0, 552, 542, 1, 0, 0, 0, 552, 543, 1, 0, 0, 0, 552, 544, 1, 0, 0, 0, 552, 545, 1, 0, 0, 0, 552, 546, 1, 0, 0, 0, 552, 547, 1, 0, 0, 0, 552, 548, 1, 0, 0, 0, 552, 549, 1, 0, 0, 0, 552, 550, 1, 0, 0, 0, 552, 551, 1, 0, 0, 0, 553, 75, 1, 0, 0, 0, 554, 555, 3, 112, 56, 0, 555, 556, 5, 2, 0, 0, 556, 77, 1, 0, 0, 0, 557, 558, 5, 41, 0, 0, 558, 559, 5, 22, 0, 0, 559, 560, 3, 112, 56, 0, 560, 561, 5, 23, 0, 0, 561, 564, 3, 74, 37, 0, 562, 563, 5, 42, 0, 0, 563, 565, 3, 74, 37, 0, 564, 562, 1, 0, 0, 0, 564, 565, 1, 0, 0, 0, 565, 79, 1, 0, 0, 0, 566, 567, 5, 43, 0, 0, 567, 569, 3, 112, 56, 0, 568, 570, 3, 38, 19, 0, 569, 568, 1, 0, 0, 0, 569, 570, 1, 0, 0, 0, 570, 571, 1, 0, 0, 0, 571, 573, 3, 72, 36, 0, 572, 574, 3, 82, 41, 0, 573, 572, 1, 0, 0, 0, 574, 575, 1, 0, 0, 0, 575, 573, 1, 0, 0, 0, 575, 576, 1, 0, 0, 0, 576, 81, 1, 0, 0, 0, 577, 582, 5, 44, 0, 0, 578, 580, 3, 170, 85, 0, 579, 578, 1, 0, 0, 0, 579, 580, 1, 0, 0, 0, 580, 581, 1, 0, 0, 0, 581, 583, 3, 50, 25, 0, 582, 579, 1, 0, 0, 0, 582, 583, 1, 0, 0, 0, 583, 584, 1, 0, 0, 0, 584, 585, 3, 72, 36, 0, 585, 83, 1, 0, 0, 0, 586, 587, 5, 45, 0, 0, 587, 588, 5, 22, 0, 0, 588, 589, 3, 112, 56, 0, 589, 590, 5, 23, 0, 0, 590, 591, 3, 74, 37, 0, 591, 85, 1, 0, 0, 0, 592, 593, 5, 26, 0, 0, 593, 596, 5, 22, 0, 0, 594, 597, 3, 88, 44, 0, 595, 597, 5, 2, 0, 0, 596, 594, 1, 0, 0, 0, 596, 595, 1, 0, 0, 0, 597, 600, 1, 0, 0, 0, 598, 601, 3, 76, 38, 0, 599, 601, 5, 2, 0, 0, 600, 598, 1, 0, 0, 0, 600, 599, 1, 0, 0, 0, 601, 603, 1, 0, 0, 0, 602, 604, 3, 112, 56, 0, 603, 602, 1, 0, 0, 0, 603, 604, 1, 0, 0, 0, 604, 605, 1, 0, 0, 0, 605, 606, 5, 23, 0, 0, 606, 607, 3, 74, 37, 0, 607, 87, 1, 0, 0, 0, 608, 611, 3, 104, 52, 0, 609, 611, 3, 76, 38, 0, 610, 608, 1, 0, 0, 0, 610, 609, 1, 0, 0, 0, 611, 89, 1, 0, 0, 0, 612, 614, 5, 46, 0, 0, 613, 615, 5, 124, 0, 0, 614, 613, 1, 0, 0, 0, 614, 615, 1, 0, 0, 0, 615, 616, 1, 0, 0, 0, 616, 617, 3, 132, 66, 0, 617, 91, 1, 0, 0, 0, 618, 619, 5, 47, 0, 0, 619, 620, 3, 74, 37, 0, 620, 621, 5, 45, 0, 0, 621, 622, 5, 22, 0, 0, 622, 623, 3, 112, 56, 0, 623, 624, 5, 23, 0, 0, 624, 625, 5, 2, 0, 0, 625, 93, 1, 0, 0, 0, 626, 627, 5, 108, 0, 0, 627, 628, 5, 2, 0, 0, 628, 95, 1, 0, 0, 0, 629, 630, 5, 105, 0, 0, 630, 631, 5, 2, 0, 0, 631, 97, 1, 0, 0, 0, 632, 634, 5, 48, 0, 0, 633, 635, 3, 112, 56, 0, 634, 633, 1, 0, 0, 0, 634, 635, 1, 0, 0, 0, 635, 636, 1, 0, 0, 0, 636, 637, 5, 2, 0, 0, 637, 99, 1, 0, 0, 0, 638, 639, 5, 49, 0, 0, 639, 640, 5, 2, 0, 0, 640, 101, 1, 0, 0, 0, 641, 642, 5, 50, 0, 0, 642, 643, 3, 124, 62, 0, 643, 644, 5, 2, 0, 0, 644, 103, 1, 0, 0, 0, 645, 646, 5, 51, 0, 0, 646, 653, 3, 108, 54, 0, 647, 653, 3, 58, 29, 0, 648, 649, 5, 22, 0, 0, 649, 650, 3, 106, 53, 0, 650, 651, 5, 23, 0, 0, 651, 653, 1, 0, 0, 0, 652, 645, 1, 0, 0, 0, 652, 647, 1, 0, 0, 0, 652, 648, 1, 0, 0, 0, 653, 656, 1, 0, 0, 0, 654, 655, 5, 9, 0, 0, 655, 657, 3, 112, 56, 0, 656, 654, 1, 0, 0, 0, 656, 657, 1, 0, 0, 0, 657, 658, 1, 0, 0, 0, 658, 659, 5, 2, 0, 0, 659, 105, 1, 0, 0, 0, 660, 662, 3, 58, 29, 0, 661, 660, 1, 0, 0, 0, 661, 662, 1, 0, 0, 0, 662, 669, 1, 0, 0, 0, 663, 665, 5, 15, 0, 0, 664, 666, 3, 58, 29, 0, 665, 664, 1, 0, 0, 0, 665, 666, 1, 0, 0, 0, 666, 668, 1, 0, 0, 0, 667, 663, 1, 0, 0, 0, 668, 671, 1, 0, 0, 0, 669, 667, 1, 0, 0, 0, 669, 670, 1, 0, 0, 0, 670, 107, 1, 0, 0, 0, 671, 669, 1, 0, 0, 0, 672, 679, 5, 22, 0, 0, 673, 675, 3, 170, 85, 0, 674, 673, 1, 0, 0, 0, 674, 675, 1, 0, 0, 0, 675, 676, 1, 0, 0, 0, 676, 678, 5, 15, 0, 0, 677, 674, 1, 0, 0, 0, 678, 681, 1, 0, 0, 0, 679, 677, 1, 0, 0, 0, 679, 680, 1, 0, 0, 0, 680, 683, 1, 0, 0, 0, 681, 679, 1, 0, 0, 0, 682, 684, 3, 170, 85, 0, 683, 682, 1, 0, 0, 0, 683, 684, 1, 0, 0, 0, 684, 685, 1, 0, 0, 0, 685, 686, 5, 23, 0, 0, 686, 109, 1, 0, 0, 0, 687, 689, 5, 52, 0, 0, 688, 690, 5, 113, 0, 0, 689, 688, 1, 0, 0, 0, 689, 690, 1, 0, 0, 0, 690, 701, 1, 0, 0, 0, 691, 701, 5, 53, 0, 0, 692, 701, 5, 54, 0, 0, 693, 701, 5, 51, 0, 0, 694, 701, 5, 93, 0, 0, 695, 701, 5, 94, 0, 0, 696, 701, 5, 55, 0, 0, 697, 701, 5, 95, 0, 0, 698, 701, 5, 96, 0, 0, 699, 701, 5, 97, 0, 0, 700, 687, 1, 0, 0, 0, 700, 691, 1, 0, 0, 0, 700, 692, 1, 0, 0, 0, 700, 693, 1, 0, 0, 0, 700, 694, 1, 0, 0, 0, 700, 695, 1, 0, 0, 0, 700, 696, 1, 0, 0, 0, 700, 697, 1, 0, 0, 0, 700, 698, 1, 0, 0, 0, 700, 699, 1, 0, 0, 0, 701, 111, 1, 0, 0, 0, 702, 703, 6, 56, -1, 0, 703, 704, 5, 58, 0, 0, 704, 726, 3, 60, 30, 0, 705, 706, 5, 113, 0, 0, 706, 707, 5, 22, 0, 0, 707, 708, 3, 112, 56, 0, 708, 709, 5, 23, 0, 0, 709, 726, 1, 0, 0, 0, 710, 711, 5, 22, 0, 0, 711, 712, 3, 112, 56, 0, 712, 713, 5, 23, 0, 0, 713, 726, 1, 0, 0, 0, 714, 715, 7, 4, 0, 0, 715, 726, 3, 112, 56, 19, 716, 717, 7, 5, 0, 0, 717, 726, 3, 112, 56, 18, 718, 719, 7, 6, 0, 0, 719, 726, 3, 112, 56, 17, 720, 721, 5, 64, 0, 0, 721, 726, 3, 112, 56, 16, 722, 723, 5, 4, 0, 0, 723, 726, 3, 112, 56, 15, 724, 726, 3, 114, 57, 0, 725, 702, 1, 0, 0, 0, 725, 705, 1, 0, 0, 0, 725, 710, 1, 0, 0, 0, 725, 714, 1, 0, 0, 0, 725, 716, 1, 0, 0, 0, 725, 718, 1, 0, 0, 0, 725, 720, 1, 0, 0, 0, 725, 722, 1, 0, 0, 0, 725, 724, 1, 0, 0, 0, 726, 802, 1, 0, 0, 0, 727, 728, 10, 14, 0, 0, 728, 729, 5, 65, 0, 0, 729, 801, 3, 112, 56, 15, 730, 731, 10, 13, 0, 0, 731, 732, 7, 7, 0, 0, 732, 801, 3, 112, 56, 14, 733, 734, 10, 12, 0, 0, 734, 735, 7, 5, 0, 0, 735, 801, 3, 112, 56, 13, 736, 737, 10, 11, 0, 0, 737, 738, 7, 8, 0, 0, 738, 801, 3, 112, 56, 12, 739, 740, 10, 10, 0, 0, 740, 741, 5, 70, 0, 0, 741, 801, 3, 112, 56, 11, 742, 743, 10, 9, 0, 0, 743, 744, 5, 3, 0, 0, 744, 801, 3, 112, 56, 10, 745, 746, 10, 8, 0, 0, 746, 747, 5, 71, 0, 0, 747, 801, 3, 112, 56, 9, 748, 749, 10, 7, 0, 0, 749, 750, 7, 9, 0, 0, 750, 801, 3, 112, 56, 8, 751, 752, 10, 6, 0, 0, 752, 753, 7, 10, 0, 0, 753, 801, 3, 112, 56, 7, 754, 755, 10, 5, 0, 0, 755, 756, 5, 74, 0, 0, 756, 801, 3, 112, 56, 6, 757, 758, 10, 4, 0, 0, 758, 759, 5, 75, 0, 0, 759, 801, 3, 112, 56, 5, 760, 761, 10, 3, 0, 0, 761, 762, 5, 76, 0, 0, 762, 763, 3, 112, 56, 0, 763, 764, 5, 59, 0, 0, 764, 765, 3, 112, 56, 4, 765, 801, 1, 0, 0, 0, 766, 767, 10, 2, 0, 0, 767, 768, 7, 11, 0, 0, 768, 801, 3, 112, 56, 3, 769, 770, 10, 28, 0, 0, 770, 801, 7, 4, 0, 0, 771, 772, 10, 26, 0, 0, 772, 774, 5, 33, 0, 0, 773, 775, 3, 112, 56, 0, 774, 773, 1, 0, 0, 0, 774, 775, 1, 0, 0, 0, 775, 776, 1, 0, 0, 0, 776, 801, 5, 34, 0, 0, 777, 778, 10, 25, 0, 0, 778, 780, 5, 33, 0, 0, 779, 781, 3, 112, 56, 0, 780, 779, 1, 0, 0, 0, 780, 781, 1, 0, 0, 0, 781, 782, 1, 0, 0, 0, 782, 784, 5, 59, 0, 0, 783, 785, 3, 112, 56, 0, 784, 783, 1, 0, 0, 0, 784, 785, 1, 0, 0, 0, 785, 786, 1, 0, 0, 0, 786, 801, 5, 34, 0, 0, 787, 788, 10, 24, 0, 0, 788, 789, 5, 35, 0, 0, 789, 801, 3, 170, 85, 0, 790, 791, 10, 23, 0, 0, 791, 792, 5, 14, 0, 0, 792, 793, 3, 118, 59, 0, 793, 794, 5, 16, 0, 0, 794, 801, 1, 0, 0, 0, 795, 796, 10, 22, 0, 0, 796, 797, 5, 22, 0, 0, 797, 798, 3, 122, 61, 0, 798, 799, 5, 23, 0, 0, 799, 801, 1, 0, 0, 0, 800, 727, 1, 0, 0, 0, 800, 730, 1, 0, 0, 0, 800, 733, 1, 0, 0, 0, 800, 736, 1, 0, 0, 0, 800, 739, 1, 0, 0, 0, 800, 742, 1, 0, 0, 0, 800, 745, 1, 0, 0, 0, 800, 748, 1, 0, 0, 0, 800, 751, 1, 0, 0, 0, 800, 754, 1, 0, 0, 0, 800, 757, 1, 0, 0, 0, 800, 760, 1, 0, 0, 0, 800, 766, 1, 0, 0, 0, 800, 769, 1, 0, 0, 0, 800, 771, 1, 0, 0, 0, 800, 777, 1, 0, 0, 0, 800, 787, 1, 0, 0, 0, 800, 790, 1, 0, 0, 0, 800, 795, 1, 0, 0, 0, 801, 804, 1, 0, 0, 0, 802, 800, 1, 0, 0, 0, 802, 803, 1, 0, 0, 0, 803, 113, 1, 0, 0, 0, 804, 802, 1, 0, 0, 0, 805, 822, 5, 98, 0, 0, 806, 822, 3, 168, 84, 0, 807, 822, 3, 172, 86, 0, 808, 822, 3, 174, 87, 0, 809, 812, 3, 170, 85, 0, 810, 811, 5, 33, 0, 0, 811, 813, 5, 34, 0, 0, 812, 810, 1, 0, 0, 0, 812, 813, 1, 0, 0, 0, 813, 822, 1, 0, 0, 0, 814, 822, 5, 118, 0, 0, 815, 822, 3, 126, 63, 0, 816, 819, 3, 128, 64, 0, 817, 818, 5, 33, 0, 0, 818, 820, 5, 34, 0, 0, 819, 817, 1, 0, 0, 0, 819, 820, 1, 0, 0, 0, 820, 822, 1, 0, 0, 0, 821, 805, 1, 0, 0, 0, 821, 806, 1, 0, 0, 0, 821, 807, 1, 0, 0, 0, 821, 808, 1, 0, 0, 0, 821, 809, 1, 0, 0, 0, 821, 814, 1, 0, 0, 0, 821, 815, 1, 0, 0, 0, 821, 816, 1, 0, 0, 0, 822, 115, 1, 0, 0, 0, 823, 828, 3, 112, 56, 0, 824, 825, 5, 15, 0, 0, 825, 827, 3, 112, 56, 0, 826, 824, 1, 0, 0, 0, 827, 830, 1, 0, 0, 0, 828, 826, 1, 0, 0, 0, 828, 829, 1, 0, 0, 0, 829, 117, 1, 0, 0, 0, 830, 828, 1, 0, 0, 0, 831, 836, 3, 120, 60, 0, 832, 833, 5, 15, 0, 0, 833, 835, 3, 120, 60, 0, 834, 832, 1, 0, 0, 0, 835, 838, 1, 0, 0, 0, 836, 834, 1, 0, 0, 0, 836, 837, 1, 0, 0, 0, 837, 840, 1, 0, 0, 0, 838, 836, 1, 0, 0, 0, 839, 841, 5, 15, 0, 0, 840, 839, 1, 0, 0, 0, 840, 841, 1, 0, 0, 0, 841, 119, 1, 0, 0, 0, 842, 843, 3, 170, 85, 0, 843, 844, 5, 59, 0, 0, 844, 845, 3, 112, 56, 0, 845, 121, 1, 0, 0, 0, 846, 848, 5, 14, 0, 0, 847, 849, 3, 118, 59, 0, 848, 847, 1, 0, 0, 0, 848, 849, 1, 0, 0, 0, 849, 850, 1, 0, 0, 0, 850, 855, 5, 16, 0, 0, 851, 853, 3, 116, 58, 0, 852, 851, 1, 0, 0, 0, 852, 853, 1, 0, 0, 0, 853, 855, 1, 0, 0, 0, 854, 846, 1, 0, 0, 0, 854, 852, 1, 0, 0, 0, 855, 123, 1, 0, 0, 0, 856, 857, 3, 112, 56, 0, 857, 858, 5, 22, 0, 0, 858, 859, 3, 122, 61, 0, 859, 860, 5, 23, 0, 0, 860, 125, 1, 0, 0, 0, 861, 863, 5, 22, 0, 0, 862, 864, 3, 112, 56, 0, 863, 862, 1, 0, 0, 0, 863, 864, 1, 0, 0, 0, 864, 871, 1, 0, 0, 0, 865, 867, 5, 15, 0, 0, 866, 868, 3, 112, 56, 0, 867, 866, 1, 0, 0, 0, 867, 868, 1, 0, 0, 0, 868, 870, 1, 0, 0, 0, 869, 865, 1, 0, 0, 0, 870, 873, 1, 0, 0, 0, 871, 869, 1, 0, 0, 0, 871, 872, 1, 0, 0, 0, 872, 874, 1, 0, 0, 0, 873, 871, 1, 0, 0, 0, 874, 888, 5, 23, 0, 0, 875, 884, 5, 33, 0, 0, 876, 881, 3, 112, 56, 0, 877, 878, 5, 15, 0, 0, 878, 880, 3, 112, 56, 0, 879, 877, 1, 0, 0, 0, 880, 883, 1, 0, 0, 0, 881, 879, 1, 0, 0, 0, 881, 882, 1, 0, 0, 0, 882, 885, 1, 0, 0, 0, 883, 881, 1, 0, 0, 0, 884, 876, 1, 0, 0, 0, 884, 885, 1, 0, 0, 0, 885, 886, 1, 0, 0, 0, 886, 888, 5, 34, 0, 0, 887, 861, 1, 0, 0, 0, 887, 875, 1, 0, 0, 0, 888, 127, 1, 0, 0, 0, 889, 892, 3, 110, 55, 0, 890, 892, 3, 62, 31, 0, 891, 889, 1, 0, 0, 0, 891, 890, 1, 0, 0, 0, 892, 129, 1, 0, 0, 0, 893, 912, 3, 170, 85, 0, 894, 912, 3, 132, 66, 0, 895, 912, 3, 134, 67, 0, 896, 912, 3, 138, 69, 0, 897, 912, 3, 140, 70, 0, 898, 912, 3, 144, 72, 0, 899, 912, 3, 146, 73, 0, 900, 912, 3, 148, 74, 0, 901, 912, 3, 152, 76, 0, 902, 912, 3, 156, 78, 0, 903, 912, 3, 158, 79, 0, 904, 912, 5, 105, 0, 0, 905, 912, 5, 108, 0, 0, 906, 912, 5, 109, 0, 0, 907, 912, 3, 166, 83, 0, 908, 912, 3, 168, 84, 0, 909, 912, 3, 174, 87, 0, 910, 912, 3, 172, 86, 0, 911, 893, 1, 0, 0, 0, 911, 894, 1, 0, 0, 0, 911, 895, 1, 0, 0, 0, 911, 896, 1, 0, 0, 0, 911, 897, 1, 0, 0, 0, 911, 898, 1, 0, 0, 0, 911, 899, 1, 0, 0, 0, 911, 900, 1, 0, 0, 0, 911, 901, 1, 0, 0, 0, 911, 902, 1, 0, 0, 0, 911, 903, 1, 0, 0, 0, 911, 904, 1, 0, 0, 0, 911, 905, 1, 0, 0, 0, 911, 906, 1, 0, 0, 0, 911, 907, 1, 0, 0, 0, 911, 908, 1, 0, 0, 0, 911, 909, 1, 0, 0, 0, 911, 910, 1, 0, 0, 0, 912, 131, 1, 0, 0, 0, 913, 917, 5, 14, 0, 0, 914, 916, 3, 130, 65, 0, 915, 914, 1, 0, 0, 0, 916, 919, 1, 0, 0, 0, 917, 915, 1, 0, 0, 0, 917, 918, 1, 0, 0, 0, 918, 920, 1, 0, 0, 0, 919, 917, 1, 0, 0, 0, 920, 921, 5, 16, 0, 0, 921, 133, 1, 0, 0, 0, 922, 925, 3, 136, 68, 0, 923, 925, 3, 160, 80, 0, 924, 922, 1, 0, 0, 0, 924, 923, 1, 0, 0, 0, 925, 135, 1, 0, 0, 0, 926, 931, 5, 48, 0, 0, 927, 931, 5, 52, 0, 0, 928, 931, 5, 55, 0, 0, 929, 931, 3, 170, 85, 0, 930, 926, 1, 0, 0, 0, 930, 927, 1, 0, 0, 0, 930, 928, 1, 0, 0, 0, 930, 929, 1, 0, 0, 0, 931, 944, 1, 0, 0, 0, 932, 934, 5, 22, 0, 0, 933, 935, 3, 134, 67, 0, 934, 933, 1, 0, 0, 0, 934, 935, 1, 0, 0, 0, 935, 940, 1, 0, 0, 0, 936, 937, 5, 15, 0, 0, 937, 939, 3, 134, 67, 0, 938, 936, 1, 0, 0, 0, 939, 942, 1, 0, 0, 0, 940, 938, 1, 0, 0, 0, 940, 941, 1, 0, 0, 0, 941, 943, 1, 0, 0, 0, 942, 940, 1, 0, 0, 0, 943, 945, 5, 23, 0, 0, 944, 932, 1, 0, 0, 0, 944, 945, 1, 0, 0, 0, 945, 137, 1, 0, 0, 0, 946, 947, 5, 87, 0, 0, 947, 950, 3, 142, 71, 0, 948, 949, 5, 88, 0, 0, 949, 951, 3, 134, 67, 0, 950, 948, 1, 0, 0, 0, 950, 951, 1, 0, 0, 0, 951, 139, 1, 0, 0, 0, 952, 953, 3, 142, 71, 0, 953, 954, 5, 88, 0, 0, 954, 955, 3, 134, 67, 0, 955, 141, 1, 0, 0, 0, 956, 961, 3, 170, 85, 0, 957, 958, 5, 15, 0, 0, 958, 960, 3, 170, 85, 0, 959, 957, 1, 0, 0, 0, 960, 963, 1, 0, 0, 0, 961, 959, 1, 0, 0, 0, 961, 962, 1, 0, 0, 0, 962, 143, 1, 0, 0, 0, 963, 961, 1, 0, 0, 0, 964, 965, 5, 89, 0, 0, 965, 966, 3, 170, 85, 0, 966, 145, 1, 0, 0, 0, 967, 968, 3, 170, 85, 0, 968, 969, 5, 59, 0, 0, 969, 147, 1, 0, 0, 0, 970, 971, 5, 90, 0, 0, 971, 975, 3, 134, 67, 0, 972, 974, 3, 150, 75, 0, 973, 972, 1, 0, 0, 0, 974, 977, 1, 0, 0, 0, 975, 973, 1, 0, 0, 0, 975, 976, 1, 0, 0, 0, 976, 149, 1, 0, 0, 0, 977, 975, 1, 0, 0, 0, 978, 979, 5, 91, 0, 0, 979, 981, 3, 160, 80, 0, 980, 982, 3, 164, 82, 0, 981, 980, 1, 0, 0, 0, 981, 982, 1, 0, 0, 0, 982, 983, 1, 0, 0, 0, 983, 984, 3, 132, 66, 0, 984, 988, 1, 0, 0, 0, 985, 986, 5, 92, 0, 0, 986, 988, 3, 132, 66, 0, 987, 978, 1, 0, 0, 0, 987, 985, 1, 0, 0, 0, 988, 151, 1, 0, 0, 0, 989, 990, 5, 29, 0, 0, 990, 991, 3, 170, 85, 0, 991, 993, 5, 22, 0, 0, 992, 994, 3, 162, 81, 0, 993, 992, 1, 0, 0, 0, 993, 994, 1, 0, 0, 0, 994, 995, 1, 0, 0, 0, 995, 997, 5, 23, 0, 0, 996, 998, 3, 154, 77, 0, 997, 996, 1, 0, 0, 0, 997, 998, 1, 0, 0, 0, 998, 999, 1, 0, 0, 0, 999, 1000, 3, 132, 66, 0, 1000, 153, 1, 0, 0, 0, 1001, 1002, 5, 61, 0, 0, 1002, 1003, 5, 6, 0, 0, 1003, 1004, 3, 162, 81, 0, 1004, 155, 1, 0, 0, 0, 1005, 1006, 5, 26, 0, 0, 1006, 1007, 3, 132, 66, 0, 1007, 1008, 3, 134, 67, 0, 1008, 1009, 3, 132, 66, 0, 1009, 1010, 3, 132, 66, 0, 1010, 157, 1, 0, 0, 0, 1011, 1012, 5, 41, 0, 0, 1012, 1013, 3, 134, 67, 0, 1013, 1014, 3, 132, 66, 0, 1014, 159, 1, 0, 0, 0, 1015, 1021, 3, 174, 87, 0, 1016, 1021, 5, 99, 0, 0, 1017, 1021, 5, 100, 0, 0, 1018, 1021, 3, 172, 86, 0, 1019, 1021, 5, 98, 0, 0, 1020, 1015, 1, 0, 0, 0, 1020, 1016, 1, 0, 0, 0, 1020, 1017, 1, 0, 0, 0, 1020, 1018, 1, 0, 0, 0, 1020, 1019, 1, 0, 0, 0, 1021, 1023, 1, 0, 0, 0, 1022, 1024, 3, 164, 82, 0, 1023, 1022, 1, 0, 0, 0, 1023, 1024, 1, 0, 0, 0, 1024, 161, 1, 0, 0, 0, 1025, 1027, 3, 170, 85, 0, 1026, 1028, 3, 164, 82, 0, 1027, 1026, 1, 0, 0, 0, 1027, 1028, 1, 0, 0, 0, 1028, 1031, 1, 0, 0, 0, 1029, 1030, 5, 15, 0, 0, 1030, 1032, 3, 162, 81, 0, 1031, 1029, 1, 0, 0, 0, 1031, 1032, 1, 0, 0, 0, 1032, 163, 1, 0, 0, 0, 1033, 1034, 5, 59, 0, 0, 1034, 1035, 3, 170, 85, 0, 1035, 165, 1, 0, 0, 0, 1036, 1037, 5, 46, 0, 0, 1037, 1038, 3, 170, 85, 0, 1038, 1039, 3, 132, 66, 0, 1039, 167, 1, 0, 0, 0, 1040, 1042, 7, 12, 0, 0, 1041, 1043, 5, 101, 0, 0, 1042, 1041, 1, 0, 0, 0, 1042, 1043, 1, 0, 0, 0, 1043, 169, 1, 0, 0, 0, 1044, 1045, 7, 13, 0, 0, 1045, 171, 1, 0, 0, 0, 1046, 1048, 5, 102, 0, 0, 1047, 1046, 1, 0, 0, 0, 1048, 1049, 1, 0, 0, 0, 1049, 1047, 1, 0, 0, 0, 1049, 1050, 1, 0, 0, 0, 1050, 173, 1, 0, 0, 0, 1051, 1053, 5, 124, 0, 0, 1052, 1051, 1, 0, 0, 0, 1053, 1054, 1, 0, 0, 0, 1054, 1052, 1, 0, 0, 0, 1054, 1055, 1, 0, 0, 0, 1055, 175, 1, 0, 0, 0, 122, 181, 183, 197, 201, 204, 214, 220, 224, 236, 244, 249, 252, 262, 265, 271, 279, 282, 291, 300, 302, 308, 319, 324, 331, 345, 348, 355, 359, 361, 366, 372, 376, 382, 387, 400, 402, 408, 411, 417, 425, 431, 444, 447, 453, 456, 464, 467, 473, 476, 480, 489, 494, 499, 507, 514, 524, 534, 552, 564, 569, 575, 579, 582, 596, 600, 603, 610, 614, 634, 652, 656, 661, 665, 669, 674, 679, 683, 689, 700, 725, 774, 780, 784, 800, 802, 812, 819, 821, 828, 836, 840, 848, 852, 854, 863, 867, 871, 881, 884, 887, 891, 911, 917, 924, 930, 934, 940, 944, 950, 961, 975, 981, 987, 993, 997, 1020, 1023, 1027, 1031, 1042, 1049, 1054] \ No newline at end of file diff --git a/vanguard/aleo/parser/.antlr/Solidity.tokens b/vanguard/aleo/parser/.antlr/Solidity.tokens new file mode 100644 index 0000000..ffcbd26 --- /dev/null +++ b/vanguard/aleo/parser/.antlr/Solidity.tokens @@ -0,0 +1,239 @@ +T__0=1 +T__1=2 +T__2=3 +T__3=4 +T__4=5 +T__5=6 +T__6=7 +T__7=8 +T__8=9 +T__9=10 +T__10=11 +T__11=12 +T__12=13 +T__13=14 +T__14=15 +T__15=16 +T__16=17 +T__17=18 +T__18=19 +T__19=20 +T__20=21 +T__21=22 +T__22=23 +T__23=24 +T__24=25 +T__25=26 +T__26=27 +T__27=28 +T__28=29 +T__29=30 +T__30=31 +T__31=32 +T__32=33 +T__33=34 +T__34=35 +T__35=36 +T__36=37 +T__37=38 +T__38=39 +T__39=40 +T__40=41 +T__41=42 +T__42=43 +T__43=44 +T__44=45 +T__45=46 +T__46=47 +T__47=48 +T__48=49 +T__49=50 +T__50=51 +T__51=52 +T__52=53 +T__53=54 +T__54=55 +T__55=56 +T__56=57 +T__57=58 +T__58=59 +T__59=60 +T__60=61 +T__61=62 +T__62=63 +T__63=64 +T__64=65 +T__65=66 +T__66=67 +T__67=68 +T__68=69 +T__69=70 +T__70=71 +T__71=72 +T__72=73 +T__73=74 +T__74=75 +T__75=76 +T__76=77 +T__77=78 +T__78=79 +T__79=80 +T__80=81 +T__81=82 +T__82=83 +T__83=84 +T__84=85 +T__85=86 +T__86=87 +T__87=88 +T__88=89 +T__89=90 +T__90=91 +T__91=92 +Int=93 +Uint=94 +Byte=95 +Fixed=96 +Ufixed=97 +BooleanLiteral=98 +DecimalNumber=99 +HexNumber=100 +NumberUnit=101 +HexLiteralFragment=102 +ReservedKeyword=103 +AnonymousKeyword=104 +BreakKeyword=105 +ConstantKeyword=106 +ImmutableKeyword=107 +ContinueKeyword=108 +LeaveKeyword=109 +ExternalKeyword=110 +IndexedKeyword=111 +InternalKeyword=112 +PayableKeyword=113 +PrivateKeyword=114 +PublicKeyword=115 +VirtualKeyword=116 +PureKeyword=117 +TypeKeyword=118 +ViewKeyword=119 +ConstructorKeyword=120 +FallbackKeyword=121 +ReceiveKeyword=122 +Identifier=123 +StringLiteralFragment=124 +VersionLiteral=125 +WS=126 +COMMENT=127 +LINE_COMMENT=128 +'pragma'=1 +';'=2 +'^'=3 +'~'=4 +'>='=5 +'>'=6 +'<'=7 +'<='=8 +'='=9 +'import'=10 +'as'=11 +'*'=12 +'from'=13 +'{'=14 +','=15 +'}'=16 +'abstract'=17 +'contract'=18 +'interface'=19 +'library'=20 +'is'=21 +'('=22 +')'=23 +'override'=24 +'using'=25 +'for'=26 +'struct'=27 +'modifier'=28 +'function'=29 +'returns'=30 +'event'=31 +'enum'=32 +'['=33 +']'=34 +'.'=35 +'mapping'=36 +'=>'=37 +'memory'=38 +'storage'=39 +'calldata'=40 +'if'=41 +'else'=42 +'try'=43 +'catch'=44 +'while'=45 +'assembly'=46 +'do'=47 +'return'=48 +'throw'=49 +'emit'=50 +'var'=51 +'address'=52 +'bool'=53 +'string'=54 +'byte'=55 +'++'=56 +'--'=57 +'new'=58 +':'=59 +'+'=60 +'-'=61 +'after'=62 +'delete'=63 +'!'=64 +'**'=65 +'/'=66 +'%'=67 +'<<'=68 +'>>'=69 +'&'=70 +'|'=71 +'=='=72 +'!='=73 +'&&'=74 +'||'=75 +'?'=76 +'|='=77 +'^='=78 +'&='=79 +'<<='=80 +'>>='=81 +'+='=82 +'-='=83 +'*='=84 +'/='=85 +'%='=86 +'let'=87 +':='=88 +'=:'=89 +'switch'=90 +'case'=91 +'default'=92 +'anonymous'=104 +'break'=105 +'constant'=106 +'immutable'=107 +'continue'=108 +'leave'=109 +'external'=110 +'indexed'=111 +'internal'=112 +'payable'=113 +'private'=114 +'public'=115 +'virtual'=116 +'pure'=117 +'type'=118 +'view'=119 +'constructor'=120 +'fallback'=121 +'receive'=122 diff --git a/vanguard/aleo/parser/.antlr/SolidityLexer.interp b/vanguard/aleo/parser/.antlr/SolidityLexer.interp new file mode 100644 index 0000000..4ad93f0 --- /dev/null +++ b/vanguard/aleo/parser/.antlr/SolidityLexer.interp @@ -0,0 +1,409 @@ +token literal names: +null +'pragma' +';' +'^' +'~' +'>=' +'>' +'<' +'<=' +'=' +'import' +'as' +'*' +'from' +'{' +',' +'}' +'abstract' +'contract' +'interface' +'library' +'is' +'(' +')' +'override' +'using' +'for' +'struct' +'modifier' +'function' +'returns' +'event' +'enum' +'[' +']' +'.' +'mapping' +'=>' +'memory' +'storage' +'calldata' +'if' +'else' +'try' +'catch' +'while' +'assembly' +'do' +'return' +'throw' +'emit' +'var' +'address' +'bool' +'string' +'byte' +'++' +'--' +'new' +':' +'+' +'-' +'after' +'delete' +'!' +'**' +'/' +'%' +'<<' +'>>' +'&' +'|' +'==' +'!=' +'&&' +'||' +'?' +'|=' +'^=' +'&=' +'<<=' +'>>=' +'+=' +'-=' +'*=' +'/=' +'%=' +'let' +':=' +'=:' +'switch' +'case' +'default' +null +null +null +null +null +null +null +null +null +null +null +'anonymous' +'break' +'constant' +'immutable' +'continue' +'leave' +'external' +'indexed' +'internal' +'payable' +'private' +'public' +'virtual' +'pure' +'type' +'view' +'constructor' +'fallback' +'receive' +null +null +null +null +null +null + +token symbolic names: +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +Int +Uint +Byte +Fixed +Ufixed +BooleanLiteral +DecimalNumber +HexNumber +NumberUnit +HexLiteralFragment +ReservedKeyword +AnonymousKeyword +BreakKeyword +ConstantKeyword +ImmutableKeyword +ContinueKeyword +LeaveKeyword +ExternalKeyword +IndexedKeyword +InternalKeyword +PayableKeyword +PrivateKeyword +PublicKeyword +VirtualKeyword +PureKeyword +TypeKeyword +ViewKeyword +ConstructorKeyword +FallbackKeyword +ReceiveKeyword +Identifier +StringLiteralFragment +VersionLiteral +WS +COMMENT +LINE_COMMENT + +rule names: +T__0 +T__1 +T__2 +T__3 +T__4 +T__5 +T__6 +T__7 +T__8 +T__9 +T__10 +T__11 +T__12 +T__13 +T__14 +T__15 +T__16 +T__17 +T__18 +T__19 +T__20 +T__21 +T__22 +T__23 +T__24 +T__25 +T__26 +T__27 +T__28 +T__29 +T__30 +T__31 +T__32 +T__33 +T__34 +T__35 +T__36 +T__37 +T__38 +T__39 +T__40 +T__41 +T__42 +T__43 +T__44 +T__45 +T__46 +T__47 +T__48 +T__49 +T__50 +T__51 +T__52 +T__53 +T__54 +T__55 +T__56 +T__57 +T__58 +T__59 +T__60 +T__61 +T__62 +T__63 +T__64 +T__65 +T__66 +T__67 +T__68 +T__69 +T__70 +T__71 +T__72 +T__73 +T__74 +T__75 +T__76 +T__77 +T__78 +T__79 +T__80 +T__81 +T__82 +T__83 +T__84 +T__85 +T__86 +T__87 +T__88 +T__89 +T__90 +T__91 +Int +Uint +Byte +Fixed +Ufixed +BooleanLiteral +DecimalNumber +DecimalDigits +HexNumber +HexDigits +NumberUnit +HexLiteralFragment +HexPair +HexCharacter +ReservedKeyword +AnonymousKeyword +BreakKeyword +ConstantKeyword +ImmutableKeyword +ContinueKeyword +LeaveKeyword +ExternalKeyword +IndexedKeyword +InternalKeyword +PayableKeyword +PrivateKeyword +PublicKeyword +VirtualKeyword +PureKeyword +TypeKeyword +ViewKeyword +ConstructorKeyword +FallbackKeyword +ReceiveKeyword +Identifier +IdentifierStart +IdentifierPart +StringLiteralFragment +DoubleQuotedStringCharacter +SingleQuotedStringCharacter +VersionLiteral +WS +COMMENT +LINE_COMMENT + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 128, 1788, 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, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 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, 28, 1, 28, 1, 28, 1, 28, 1, 29, 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, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 33, 1, 33, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 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, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 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, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 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, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 59, 1, 59, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 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, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 858, 8, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 3, 93, 1075, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 3, 94, 1297, 8, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 4, 95, 1311, 8, 95, 11, 95, 12, 95, 1312, 1, 95, 1, 95, 4, 95, 1317, 8, 95, 11, 95, 12, 95, 1318, 3, 95, 1321, 8, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 4, 96, 1337, 8, 96, 11, 96, 12, 96, 1338, 1, 96, 1, 96, 4, 96, 1343, 8, 96, 11, 96, 12, 96, 1344, 3, 96, 1347, 8, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 1358, 8, 97, 1, 98, 1, 98, 3, 98, 1362, 8, 98, 1, 98, 1, 98, 3, 98, 1366, 8, 98, 1, 98, 1, 98, 3, 98, 1370, 8, 98, 1, 98, 3, 98, 1373, 8, 98, 1, 99, 1, 99, 3, 99, 1377, 8, 99, 1, 99, 5, 99, 1380, 8, 99, 10, 99, 12, 99, 1383, 9, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 3, 101, 1391, 8, 101, 1, 101, 5, 101, 1394, 8, 101, 10, 101, 12, 101, 1397, 9, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 1451, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 1459, 8, 103, 1, 103, 1, 103, 1, 103, 3, 103, 1464, 8, 103, 1, 103, 3, 103, 1467, 8, 103, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 1546, 8, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 5, 126, 1701, 8, 126, 10, 126, 12, 126, 1704, 9, 126, 1, 127, 1, 127, 1, 128, 1, 128, 1, 129, 1, 129, 5, 129, 1712, 8, 129, 10, 129, 12, 129, 1715, 9, 129, 1, 129, 1, 129, 1, 129, 5, 129, 1720, 8, 129, 10, 129, 12, 129, 1723, 9, 129, 1, 129, 3, 129, 1726, 8, 129, 1, 130, 1, 130, 1, 130, 3, 130, 1731, 8, 130, 1, 131, 1, 131, 1, 131, 3, 131, 1736, 8, 131, 1, 132, 4, 132, 1739, 8, 132, 11, 132, 12, 132, 1740, 1, 132, 1, 132, 4, 132, 1745, 8, 132, 11, 132, 12, 132, 1746, 1, 132, 1, 132, 4, 132, 1751, 8, 132, 11, 132, 12, 132, 1752, 3, 132, 1755, 8, 132, 1, 133, 4, 133, 1758, 8, 133, 11, 133, 12, 133, 1759, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 134, 5, 134, 1768, 8, 134, 10, 134, 12, 134, 1771, 9, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 1782, 8, 135, 10, 135, 12, 135, 1785, 9, 135, 1, 135, 1, 135, 1, 1769, 0, 136, 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, 0, 201, 100, 203, 0, 205, 101, 207, 102, 209, 0, 211, 0, 213, 103, 215, 104, 217, 105, 219, 106, 221, 107, 223, 108, 225, 109, 227, 110, 229, 111, 231, 112, 233, 113, 235, 114, 237, 115, 239, 116, 241, 117, 243, 118, 245, 119, 247, 120, 249, 121, 251, 122, 253, 123, 255, 0, 257, 0, 259, 124, 261, 0, 263, 0, 265, 125, 267, 126, 269, 127, 271, 128, 1, 0, 10, 1, 0, 48, 57, 2, 0, 69, 69, 101, 101, 2, 0, 88, 88, 120, 120, 3, 0, 48, 57, 65, 70, 97, 102, 4, 0, 36, 36, 65, 90, 95, 95, 97, 122, 5, 0, 36, 36, 48, 57, 65, 90, 95, 95, 97, 122, 4, 0, 10, 10, 13, 13, 34, 34, 92, 92, 4, 0, 10, 10, 13, 13, 39, 39, 92, 92, 3, 0, 9, 10, 12, 13, 32, 32, 2, 0, 10, 10, 13, 13, 1928, 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, 201, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 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, 259, 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, 1, 273, 1, 0, 0, 0, 3, 280, 1, 0, 0, 0, 5, 282, 1, 0, 0, 0, 7, 284, 1, 0, 0, 0, 9, 286, 1, 0, 0, 0, 11, 289, 1, 0, 0, 0, 13, 291, 1, 0, 0, 0, 15, 293, 1, 0, 0, 0, 17, 296, 1, 0, 0, 0, 19, 298, 1, 0, 0, 0, 21, 305, 1, 0, 0, 0, 23, 308, 1, 0, 0, 0, 25, 310, 1, 0, 0, 0, 27, 315, 1, 0, 0, 0, 29, 317, 1, 0, 0, 0, 31, 319, 1, 0, 0, 0, 33, 321, 1, 0, 0, 0, 35, 330, 1, 0, 0, 0, 37, 339, 1, 0, 0, 0, 39, 349, 1, 0, 0, 0, 41, 357, 1, 0, 0, 0, 43, 360, 1, 0, 0, 0, 45, 362, 1, 0, 0, 0, 47, 364, 1, 0, 0, 0, 49, 373, 1, 0, 0, 0, 51, 379, 1, 0, 0, 0, 53, 383, 1, 0, 0, 0, 55, 390, 1, 0, 0, 0, 57, 399, 1, 0, 0, 0, 59, 408, 1, 0, 0, 0, 61, 416, 1, 0, 0, 0, 63, 422, 1, 0, 0, 0, 65, 427, 1, 0, 0, 0, 67, 429, 1, 0, 0, 0, 69, 431, 1, 0, 0, 0, 71, 433, 1, 0, 0, 0, 73, 441, 1, 0, 0, 0, 75, 444, 1, 0, 0, 0, 77, 451, 1, 0, 0, 0, 79, 459, 1, 0, 0, 0, 81, 468, 1, 0, 0, 0, 83, 471, 1, 0, 0, 0, 85, 476, 1, 0, 0, 0, 87, 480, 1, 0, 0, 0, 89, 486, 1, 0, 0, 0, 91, 492, 1, 0, 0, 0, 93, 501, 1, 0, 0, 0, 95, 504, 1, 0, 0, 0, 97, 511, 1, 0, 0, 0, 99, 517, 1, 0, 0, 0, 101, 522, 1, 0, 0, 0, 103, 526, 1, 0, 0, 0, 105, 534, 1, 0, 0, 0, 107, 539, 1, 0, 0, 0, 109, 546, 1, 0, 0, 0, 111, 551, 1, 0, 0, 0, 113, 554, 1, 0, 0, 0, 115, 557, 1, 0, 0, 0, 117, 561, 1, 0, 0, 0, 119, 563, 1, 0, 0, 0, 121, 565, 1, 0, 0, 0, 123, 567, 1, 0, 0, 0, 125, 573, 1, 0, 0, 0, 127, 580, 1, 0, 0, 0, 129, 582, 1, 0, 0, 0, 131, 585, 1, 0, 0, 0, 133, 587, 1, 0, 0, 0, 135, 589, 1, 0, 0, 0, 137, 592, 1, 0, 0, 0, 139, 595, 1, 0, 0, 0, 141, 597, 1, 0, 0, 0, 143, 599, 1, 0, 0, 0, 145, 602, 1, 0, 0, 0, 147, 605, 1, 0, 0, 0, 149, 608, 1, 0, 0, 0, 151, 611, 1, 0, 0, 0, 153, 613, 1, 0, 0, 0, 155, 616, 1, 0, 0, 0, 157, 619, 1, 0, 0, 0, 159, 622, 1, 0, 0, 0, 161, 626, 1, 0, 0, 0, 163, 630, 1, 0, 0, 0, 165, 633, 1, 0, 0, 0, 167, 636, 1, 0, 0, 0, 169, 639, 1, 0, 0, 0, 171, 642, 1, 0, 0, 0, 173, 645, 1, 0, 0, 0, 175, 649, 1, 0, 0, 0, 177, 652, 1, 0, 0, 0, 179, 655, 1, 0, 0, 0, 181, 662, 1, 0, 0, 0, 183, 667, 1, 0, 0, 0, 185, 857, 1, 0, 0, 0, 187, 1074, 1, 0, 0, 0, 189, 1296, 1, 0, 0, 0, 191, 1320, 1, 0, 0, 0, 193, 1346, 1, 0, 0, 0, 195, 1357, 1, 0, 0, 0, 197, 1365, 1, 0, 0, 0, 199, 1374, 1, 0, 0, 0, 201, 1384, 1, 0, 0, 0, 203, 1388, 1, 0, 0, 0, 205, 1450, 1, 0, 0, 0, 207, 1452, 1, 0, 0, 0, 209, 1468, 1, 0, 0, 0, 211, 1471, 1, 0, 0, 0, 213, 1545, 1, 0, 0, 0, 215, 1547, 1, 0, 0, 0, 217, 1557, 1, 0, 0, 0, 219, 1563, 1, 0, 0, 0, 221, 1572, 1, 0, 0, 0, 223, 1582, 1, 0, 0, 0, 225, 1591, 1, 0, 0, 0, 227, 1597, 1, 0, 0, 0, 229, 1606, 1, 0, 0, 0, 231, 1614, 1, 0, 0, 0, 233, 1623, 1, 0, 0, 0, 235, 1631, 1, 0, 0, 0, 237, 1639, 1, 0, 0, 0, 239, 1646, 1, 0, 0, 0, 241, 1654, 1, 0, 0, 0, 243, 1659, 1, 0, 0, 0, 245, 1664, 1, 0, 0, 0, 247, 1669, 1, 0, 0, 0, 249, 1681, 1, 0, 0, 0, 251, 1690, 1, 0, 0, 0, 253, 1698, 1, 0, 0, 0, 255, 1705, 1, 0, 0, 0, 257, 1707, 1, 0, 0, 0, 259, 1725, 1, 0, 0, 0, 261, 1730, 1, 0, 0, 0, 263, 1735, 1, 0, 0, 0, 265, 1738, 1, 0, 0, 0, 267, 1757, 1, 0, 0, 0, 269, 1763, 1, 0, 0, 0, 271, 1777, 1, 0, 0, 0, 273, 274, 5, 112, 0, 0, 274, 275, 5, 114, 0, 0, 275, 276, 5, 97, 0, 0, 276, 277, 5, 103, 0, 0, 277, 278, 5, 109, 0, 0, 278, 279, 5, 97, 0, 0, 279, 2, 1, 0, 0, 0, 280, 281, 5, 59, 0, 0, 281, 4, 1, 0, 0, 0, 282, 283, 5, 94, 0, 0, 283, 6, 1, 0, 0, 0, 284, 285, 5, 126, 0, 0, 285, 8, 1, 0, 0, 0, 286, 287, 5, 62, 0, 0, 287, 288, 5, 61, 0, 0, 288, 10, 1, 0, 0, 0, 289, 290, 5, 62, 0, 0, 290, 12, 1, 0, 0, 0, 291, 292, 5, 60, 0, 0, 292, 14, 1, 0, 0, 0, 293, 294, 5, 60, 0, 0, 294, 295, 5, 61, 0, 0, 295, 16, 1, 0, 0, 0, 296, 297, 5, 61, 0, 0, 297, 18, 1, 0, 0, 0, 298, 299, 5, 105, 0, 0, 299, 300, 5, 109, 0, 0, 300, 301, 5, 112, 0, 0, 301, 302, 5, 111, 0, 0, 302, 303, 5, 114, 0, 0, 303, 304, 5, 116, 0, 0, 304, 20, 1, 0, 0, 0, 305, 306, 5, 97, 0, 0, 306, 307, 5, 115, 0, 0, 307, 22, 1, 0, 0, 0, 308, 309, 5, 42, 0, 0, 309, 24, 1, 0, 0, 0, 310, 311, 5, 102, 0, 0, 311, 312, 5, 114, 0, 0, 312, 313, 5, 111, 0, 0, 313, 314, 5, 109, 0, 0, 314, 26, 1, 0, 0, 0, 315, 316, 5, 123, 0, 0, 316, 28, 1, 0, 0, 0, 317, 318, 5, 44, 0, 0, 318, 30, 1, 0, 0, 0, 319, 320, 5, 125, 0, 0, 320, 32, 1, 0, 0, 0, 321, 322, 5, 97, 0, 0, 322, 323, 5, 98, 0, 0, 323, 324, 5, 115, 0, 0, 324, 325, 5, 116, 0, 0, 325, 326, 5, 114, 0, 0, 326, 327, 5, 97, 0, 0, 327, 328, 5, 99, 0, 0, 328, 329, 5, 116, 0, 0, 329, 34, 1, 0, 0, 0, 330, 331, 5, 99, 0, 0, 331, 332, 5, 111, 0, 0, 332, 333, 5, 110, 0, 0, 333, 334, 5, 116, 0, 0, 334, 335, 5, 114, 0, 0, 335, 336, 5, 97, 0, 0, 336, 337, 5, 99, 0, 0, 337, 338, 5, 116, 0, 0, 338, 36, 1, 0, 0, 0, 339, 340, 5, 105, 0, 0, 340, 341, 5, 110, 0, 0, 341, 342, 5, 116, 0, 0, 342, 343, 5, 101, 0, 0, 343, 344, 5, 114, 0, 0, 344, 345, 5, 102, 0, 0, 345, 346, 5, 97, 0, 0, 346, 347, 5, 99, 0, 0, 347, 348, 5, 101, 0, 0, 348, 38, 1, 0, 0, 0, 349, 350, 5, 108, 0, 0, 350, 351, 5, 105, 0, 0, 351, 352, 5, 98, 0, 0, 352, 353, 5, 114, 0, 0, 353, 354, 5, 97, 0, 0, 354, 355, 5, 114, 0, 0, 355, 356, 5, 121, 0, 0, 356, 40, 1, 0, 0, 0, 357, 358, 5, 105, 0, 0, 358, 359, 5, 115, 0, 0, 359, 42, 1, 0, 0, 0, 360, 361, 5, 40, 0, 0, 361, 44, 1, 0, 0, 0, 362, 363, 5, 41, 0, 0, 363, 46, 1, 0, 0, 0, 364, 365, 5, 111, 0, 0, 365, 366, 5, 118, 0, 0, 366, 367, 5, 101, 0, 0, 367, 368, 5, 114, 0, 0, 368, 369, 5, 114, 0, 0, 369, 370, 5, 105, 0, 0, 370, 371, 5, 100, 0, 0, 371, 372, 5, 101, 0, 0, 372, 48, 1, 0, 0, 0, 373, 374, 5, 117, 0, 0, 374, 375, 5, 115, 0, 0, 375, 376, 5, 105, 0, 0, 376, 377, 5, 110, 0, 0, 377, 378, 5, 103, 0, 0, 378, 50, 1, 0, 0, 0, 379, 380, 5, 102, 0, 0, 380, 381, 5, 111, 0, 0, 381, 382, 5, 114, 0, 0, 382, 52, 1, 0, 0, 0, 383, 384, 5, 115, 0, 0, 384, 385, 5, 116, 0, 0, 385, 386, 5, 114, 0, 0, 386, 387, 5, 117, 0, 0, 387, 388, 5, 99, 0, 0, 388, 389, 5, 116, 0, 0, 389, 54, 1, 0, 0, 0, 390, 391, 5, 109, 0, 0, 391, 392, 5, 111, 0, 0, 392, 393, 5, 100, 0, 0, 393, 394, 5, 105, 0, 0, 394, 395, 5, 102, 0, 0, 395, 396, 5, 105, 0, 0, 396, 397, 5, 101, 0, 0, 397, 398, 5, 114, 0, 0, 398, 56, 1, 0, 0, 0, 399, 400, 5, 102, 0, 0, 400, 401, 5, 117, 0, 0, 401, 402, 5, 110, 0, 0, 402, 403, 5, 99, 0, 0, 403, 404, 5, 116, 0, 0, 404, 405, 5, 105, 0, 0, 405, 406, 5, 111, 0, 0, 406, 407, 5, 110, 0, 0, 407, 58, 1, 0, 0, 0, 408, 409, 5, 114, 0, 0, 409, 410, 5, 101, 0, 0, 410, 411, 5, 116, 0, 0, 411, 412, 5, 117, 0, 0, 412, 413, 5, 114, 0, 0, 413, 414, 5, 110, 0, 0, 414, 415, 5, 115, 0, 0, 415, 60, 1, 0, 0, 0, 416, 417, 5, 101, 0, 0, 417, 418, 5, 118, 0, 0, 418, 419, 5, 101, 0, 0, 419, 420, 5, 110, 0, 0, 420, 421, 5, 116, 0, 0, 421, 62, 1, 0, 0, 0, 422, 423, 5, 101, 0, 0, 423, 424, 5, 110, 0, 0, 424, 425, 5, 117, 0, 0, 425, 426, 5, 109, 0, 0, 426, 64, 1, 0, 0, 0, 427, 428, 5, 91, 0, 0, 428, 66, 1, 0, 0, 0, 429, 430, 5, 93, 0, 0, 430, 68, 1, 0, 0, 0, 431, 432, 5, 46, 0, 0, 432, 70, 1, 0, 0, 0, 433, 434, 5, 109, 0, 0, 434, 435, 5, 97, 0, 0, 435, 436, 5, 112, 0, 0, 436, 437, 5, 112, 0, 0, 437, 438, 5, 105, 0, 0, 438, 439, 5, 110, 0, 0, 439, 440, 5, 103, 0, 0, 440, 72, 1, 0, 0, 0, 441, 442, 5, 61, 0, 0, 442, 443, 5, 62, 0, 0, 443, 74, 1, 0, 0, 0, 444, 445, 5, 109, 0, 0, 445, 446, 5, 101, 0, 0, 446, 447, 5, 109, 0, 0, 447, 448, 5, 111, 0, 0, 448, 449, 5, 114, 0, 0, 449, 450, 5, 121, 0, 0, 450, 76, 1, 0, 0, 0, 451, 452, 5, 115, 0, 0, 452, 453, 5, 116, 0, 0, 453, 454, 5, 111, 0, 0, 454, 455, 5, 114, 0, 0, 455, 456, 5, 97, 0, 0, 456, 457, 5, 103, 0, 0, 457, 458, 5, 101, 0, 0, 458, 78, 1, 0, 0, 0, 459, 460, 5, 99, 0, 0, 460, 461, 5, 97, 0, 0, 461, 462, 5, 108, 0, 0, 462, 463, 5, 108, 0, 0, 463, 464, 5, 100, 0, 0, 464, 465, 5, 97, 0, 0, 465, 466, 5, 116, 0, 0, 466, 467, 5, 97, 0, 0, 467, 80, 1, 0, 0, 0, 468, 469, 5, 105, 0, 0, 469, 470, 5, 102, 0, 0, 470, 82, 1, 0, 0, 0, 471, 472, 5, 101, 0, 0, 472, 473, 5, 108, 0, 0, 473, 474, 5, 115, 0, 0, 474, 475, 5, 101, 0, 0, 475, 84, 1, 0, 0, 0, 476, 477, 5, 116, 0, 0, 477, 478, 5, 114, 0, 0, 478, 479, 5, 121, 0, 0, 479, 86, 1, 0, 0, 0, 480, 481, 5, 99, 0, 0, 481, 482, 5, 97, 0, 0, 482, 483, 5, 116, 0, 0, 483, 484, 5, 99, 0, 0, 484, 485, 5, 104, 0, 0, 485, 88, 1, 0, 0, 0, 486, 487, 5, 119, 0, 0, 487, 488, 5, 104, 0, 0, 488, 489, 5, 105, 0, 0, 489, 490, 5, 108, 0, 0, 490, 491, 5, 101, 0, 0, 491, 90, 1, 0, 0, 0, 492, 493, 5, 97, 0, 0, 493, 494, 5, 115, 0, 0, 494, 495, 5, 115, 0, 0, 495, 496, 5, 101, 0, 0, 496, 497, 5, 109, 0, 0, 497, 498, 5, 98, 0, 0, 498, 499, 5, 108, 0, 0, 499, 500, 5, 121, 0, 0, 500, 92, 1, 0, 0, 0, 501, 502, 5, 100, 0, 0, 502, 503, 5, 111, 0, 0, 503, 94, 1, 0, 0, 0, 504, 505, 5, 114, 0, 0, 505, 506, 5, 101, 0, 0, 506, 507, 5, 116, 0, 0, 507, 508, 5, 117, 0, 0, 508, 509, 5, 114, 0, 0, 509, 510, 5, 110, 0, 0, 510, 96, 1, 0, 0, 0, 511, 512, 5, 116, 0, 0, 512, 513, 5, 104, 0, 0, 513, 514, 5, 114, 0, 0, 514, 515, 5, 111, 0, 0, 515, 516, 5, 119, 0, 0, 516, 98, 1, 0, 0, 0, 517, 518, 5, 101, 0, 0, 518, 519, 5, 109, 0, 0, 519, 520, 5, 105, 0, 0, 520, 521, 5, 116, 0, 0, 521, 100, 1, 0, 0, 0, 522, 523, 5, 118, 0, 0, 523, 524, 5, 97, 0, 0, 524, 525, 5, 114, 0, 0, 525, 102, 1, 0, 0, 0, 526, 527, 5, 97, 0, 0, 527, 528, 5, 100, 0, 0, 528, 529, 5, 100, 0, 0, 529, 530, 5, 114, 0, 0, 530, 531, 5, 101, 0, 0, 531, 532, 5, 115, 0, 0, 532, 533, 5, 115, 0, 0, 533, 104, 1, 0, 0, 0, 534, 535, 5, 98, 0, 0, 535, 536, 5, 111, 0, 0, 536, 537, 5, 111, 0, 0, 537, 538, 5, 108, 0, 0, 538, 106, 1, 0, 0, 0, 539, 540, 5, 115, 0, 0, 540, 541, 5, 116, 0, 0, 541, 542, 5, 114, 0, 0, 542, 543, 5, 105, 0, 0, 543, 544, 5, 110, 0, 0, 544, 545, 5, 103, 0, 0, 545, 108, 1, 0, 0, 0, 546, 547, 5, 98, 0, 0, 547, 548, 5, 121, 0, 0, 548, 549, 5, 116, 0, 0, 549, 550, 5, 101, 0, 0, 550, 110, 1, 0, 0, 0, 551, 552, 5, 43, 0, 0, 552, 553, 5, 43, 0, 0, 553, 112, 1, 0, 0, 0, 554, 555, 5, 45, 0, 0, 555, 556, 5, 45, 0, 0, 556, 114, 1, 0, 0, 0, 557, 558, 5, 110, 0, 0, 558, 559, 5, 101, 0, 0, 559, 560, 5, 119, 0, 0, 560, 116, 1, 0, 0, 0, 561, 562, 5, 58, 0, 0, 562, 118, 1, 0, 0, 0, 563, 564, 5, 43, 0, 0, 564, 120, 1, 0, 0, 0, 565, 566, 5, 45, 0, 0, 566, 122, 1, 0, 0, 0, 567, 568, 5, 97, 0, 0, 568, 569, 5, 102, 0, 0, 569, 570, 5, 116, 0, 0, 570, 571, 5, 101, 0, 0, 571, 572, 5, 114, 0, 0, 572, 124, 1, 0, 0, 0, 573, 574, 5, 100, 0, 0, 574, 575, 5, 101, 0, 0, 575, 576, 5, 108, 0, 0, 576, 577, 5, 101, 0, 0, 577, 578, 5, 116, 0, 0, 578, 579, 5, 101, 0, 0, 579, 126, 1, 0, 0, 0, 580, 581, 5, 33, 0, 0, 581, 128, 1, 0, 0, 0, 582, 583, 5, 42, 0, 0, 583, 584, 5, 42, 0, 0, 584, 130, 1, 0, 0, 0, 585, 586, 5, 47, 0, 0, 586, 132, 1, 0, 0, 0, 587, 588, 5, 37, 0, 0, 588, 134, 1, 0, 0, 0, 589, 590, 5, 60, 0, 0, 590, 591, 5, 60, 0, 0, 591, 136, 1, 0, 0, 0, 592, 593, 5, 62, 0, 0, 593, 594, 5, 62, 0, 0, 594, 138, 1, 0, 0, 0, 595, 596, 5, 38, 0, 0, 596, 140, 1, 0, 0, 0, 597, 598, 5, 124, 0, 0, 598, 142, 1, 0, 0, 0, 599, 600, 5, 61, 0, 0, 600, 601, 5, 61, 0, 0, 601, 144, 1, 0, 0, 0, 602, 603, 5, 33, 0, 0, 603, 604, 5, 61, 0, 0, 604, 146, 1, 0, 0, 0, 605, 606, 5, 38, 0, 0, 606, 607, 5, 38, 0, 0, 607, 148, 1, 0, 0, 0, 608, 609, 5, 124, 0, 0, 609, 610, 5, 124, 0, 0, 610, 150, 1, 0, 0, 0, 611, 612, 5, 63, 0, 0, 612, 152, 1, 0, 0, 0, 613, 614, 5, 124, 0, 0, 614, 615, 5, 61, 0, 0, 615, 154, 1, 0, 0, 0, 616, 617, 5, 94, 0, 0, 617, 618, 5, 61, 0, 0, 618, 156, 1, 0, 0, 0, 619, 620, 5, 38, 0, 0, 620, 621, 5, 61, 0, 0, 621, 158, 1, 0, 0, 0, 622, 623, 5, 60, 0, 0, 623, 624, 5, 60, 0, 0, 624, 625, 5, 61, 0, 0, 625, 160, 1, 0, 0, 0, 626, 627, 5, 62, 0, 0, 627, 628, 5, 62, 0, 0, 628, 629, 5, 61, 0, 0, 629, 162, 1, 0, 0, 0, 630, 631, 5, 43, 0, 0, 631, 632, 5, 61, 0, 0, 632, 164, 1, 0, 0, 0, 633, 634, 5, 45, 0, 0, 634, 635, 5, 61, 0, 0, 635, 166, 1, 0, 0, 0, 636, 637, 5, 42, 0, 0, 637, 638, 5, 61, 0, 0, 638, 168, 1, 0, 0, 0, 639, 640, 5, 47, 0, 0, 640, 641, 5, 61, 0, 0, 641, 170, 1, 0, 0, 0, 642, 643, 5, 37, 0, 0, 643, 644, 5, 61, 0, 0, 644, 172, 1, 0, 0, 0, 645, 646, 5, 108, 0, 0, 646, 647, 5, 101, 0, 0, 647, 648, 5, 116, 0, 0, 648, 174, 1, 0, 0, 0, 649, 650, 5, 58, 0, 0, 650, 651, 5, 61, 0, 0, 651, 176, 1, 0, 0, 0, 652, 653, 5, 61, 0, 0, 653, 654, 5, 58, 0, 0, 654, 178, 1, 0, 0, 0, 655, 656, 5, 115, 0, 0, 656, 657, 5, 119, 0, 0, 657, 658, 5, 105, 0, 0, 658, 659, 5, 116, 0, 0, 659, 660, 5, 99, 0, 0, 660, 661, 5, 104, 0, 0, 661, 180, 1, 0, 0, 0, 662, 663, 5, 99, 0, 0, 663, 664, 5, 97, 0, 0, 664, 665, 5, 115, 0, 0, 665, 666, 5, 101, 0, 0, 666, 182, 1, 0, 0, 0, 667, 668, 5, 100, 0, 0, 668, 669, 5, 101, 0, 0, 669, 670, 5, 102, 0, 0, 670, 671, 5, 97, 0, 0, 671, 672, 5, 117, 0, 0, 672, 673, 5, 108, 0, 0, 673, 674, 5, 116, 0, 0, 674, 184, 1, 0, 0, 0, 675, 676, 5, 105, 0, 0, 676, 677, 5, 110, 0, 0, 677, 858, 5, 116, 0, 0, 678, 679, 5, 105, 0, 0, 679, 680, 5, 110, 0, 0, 680, 681, 5, 116, 0, 0, 681, 858, 5, 56, 0, 0, 682, 683, 5, 105, 0, 0, 683, 684, 5, 110, 0, 0, 684, 685, 5, 116, 0, 0, 685, 686, 5, 49, 0, 0, 686, 858, 5, 54, 0, 0, 687, 688, 5, 105, 0, 0, 688, 689, 5, 110, 0, 0, 689, 690, 5, 116, 0, 0, 690, 691, 5, 50, 0, 0, 691, 858, 5, 52, 0, 0, 692, 693, 5, 105, 0, 0, 693, 694, 5, 110, 0, 0, 694, 695, 5, 116, 0, 0, 695, 696, 5, 51, 0, 0, 696, 858, 5, 50, 0, 0, 697, 698, 5, 105, 0, 0, 698, 699, 5, 110, 0, 0, 699, 700, 5, 116, 0, 0, 700, 701, 5, 52, 0, 0, 701, 858, 5, 48, 0, 0, 702, 703, 5, 105, 0, 0, 703, 704, 5, 110, 0, 0, 704, 705, 5, 116, 0, 0, 705, 706, 5, 52, 0, 0, 706, 858, 5, 56, 0, 0, 707, 708, 5, 105, 0, 0, 708, 709, 5, 110, 0, 0, 709, 710, 5, 116, 0, 0, 710, 711, 5, 53, 0, 0, 711, 858, 5, 54, 0, 0, 712, 713, 5, 105, 0, 0, 713, 714, 5, 110, 0, 0, 714, 715, 5, 116, 0, 0, 715, 716, 5, 54, 0, 0, 716, 858, 5, 52, 0, 0, 717, 718, 5, 105, 0, 0, 718, 719, 5, 110, 0, 0, 719, 720, 5, 116, 0, 0, 720, 721, 5, 55, 0, 0, 721, 858, 5, 50, 0, 0, 722, 723, 5, 105, 0, 0, 723, 724, 5, 110, 0, 0, 724, 725, 5, 116, 0, 0, 725, 726, 5, 56, 0, 0, 726, 858, 5, 48, 0, 0, 727, 728, 5, 105, 0, 0, 728, 729, 5, 110, 0, 0, 729, 730, 5, 116, 0, 0, 730, 731, 5, 56, 0, 0, 731, 858, 5, 56, 0, 0, 732, 733, 5, 105, 0, 0, 733, 734, 5, 110, 0, 0, 734, 735, 5, 116, 0, 0, 735, 736, 5, 57, 0, 0, 736, 858, 5, 54, 0, 0, 737, 738, 5, 105, 0, 0, 738, 739, 5, 110, 0, 0, 739, 740, 5, 116, 0, 0, 740, 741, 5, 49, 0, 0, 741, 742, 5, 48, 0, 0, 742, 858, 5, 52, 0, 0, 743, 744, 5, 105, 0, 0, 744, 745, 5, 110, 0, 0, 745, 746, 5, 116, 0, 0, 746, 747, 5, 49, 0, 0, 747, 748, 5, 49, 0, 0, 748, 858, 5, 50, 0, 0, 749, 750, 5, 105, 0, 0, 750, 751, 5, 110, 0, 0, 751, 752, 5, 116, 0, 0, 752, 753, 5, 49, 0, 0, 753, 754, 5, 50, 0, 0, 754, 858, 5, 48, 0, 0, 755, 756, 5, 105, 0, 0, 756, 757, 5, 110, 0, 0, 757, 758, 5, 116, 0, 0, 758, 759, 5, 49, 0, 0, 759, 760, 5, 50, 0, 0, 760, 858, 5, 56, 0, 0, 761, 762, 5, 105, 0, 0, 762, 763, 5, 110, 0, 0, 763, 764, 5, 116, 0, 0, 764, 765, 5, 49, 0, 0, 765, 766, 5, 51, 0, 0, 766, 858, 5, 54, 0, 0, 767, 768, 5, 105, 0, 0, 768, 769, 5, 110, 0, 0, 769, 770, 5, 116, 0, 0, 770, 771, 5, 49, 0, 0, 771, 772, 5, 52, 0, 0, 772, 858, 5, 52, 0, 0, 773, 774, 5, 105, 0, 0, 774, 775, 5, 110, 0, 0, 775, 776, 5, 116, 0, 0, 776, 777, 5, 49, 0, 0, 777, 778, 5, 53, 0, 0, 778, 858, 5, 50, 0, 0, 779, 780, 5, 105, 0, 0, 780, 781, 5, 110, 0, 0, 781, 782, 5, 116, 0, 0, 782, 783, 5, 49, 0, 0, 783, 784, 5, 54, 0, 0, 784, 858, 5, 48, 0, 0, 785, 786, 5, 105, 0, 0, 786, 787, 5, 110, 0, 0, 787, 788, 5, 116, 0, 0, 788, 789, 5, 49, 0, 0, 789, 790, 5, 54, 0, 0, 790, 858, 5, 56, 0, 0, 791, 792, 5, 105, 0, 0, 792, 793, 5, 110, 0, 0, 793, 794, 5, 116, 0, 0, 794, 795, 5, 49, 0, 0, 795, 796, 5, 55, 0, 0, 796, 858, 5, 54, 0, 0, 797, 798, 5, 105, 0, 0, 798, 799, 5, 110, 0, 0, 799, 800, 5, 116, 0, 0, 800, 801, 5, 49, 0, 0, 801, 802, 5, 56, 0, 0, 802, 858, 5, 52, 0, 0, 803, 804, 5, 105, 0, 0, 804, 805, 5, 110, 0, 0, 805, 806, 5, 116, 0, 0, 806, 807, 5, 49, 0, 0, 807, 808, 5, 57, 0, 0, 808, 858, 5, 50, 0, 0, 809, 810, 5, 105, 0, 0, 810, 811, 5, 110, 0, 0, 811, 812, 5, 116, 0, 0, 812, 813, 5, 50, 0, 0, 813, 814, 5, 48, 0, 0, 814, 858, 5, 48, 0, 0, 815, 816, 5, 105, 0, 0, 816, 817, 5, 110, 0, 0, 817, 818, 5, 116, 0, 0, 818, 819, 5, 50, 0, 0, 819, 820, 5, 48, 0, 0, 820, 858, 5, 56, 0, 0, 821, 822, 5, 105, 0, 0, 822, 823, 5, 110, 0, 0, 823, 824, 5, 116, 0, 0, 824, 825, 5, 50, 0, 0, 825, 826, 5, 49, 0, 0, 826, 858, 5, 54, 0, 0, 827, 828, 5, 105, 0, 0, 828, 829, 5, 110, 0, 0, 829, 830, 5, 116, 0, 0, 830, 831, 5, 50, 0, 0, 831, 832, 5, 50, 0, 0, 832, 858, 5, 52, 0, 0, 833, 834, 5, 105, 0, 0, 834, 835, 5, 110, 0, 0, 835, 836, 5, 116, 0, 0, 836, 837, 5, 50, 0, 0, 837, 838, 5, 51, 0, 0, 838, 858, 5, 50, 0, 0, 839, 840, 5, 105, 0, 0, 840, 841, 5, 110, 0, 0, 841, 842, 5, 116, 0, 0, 842, 843, 5, 50, 0, 0, 843, 844, 5, 52, 0, 0, 844, 858, 5, 48, 0, 0, 845, 846, 5, 105, 0, 0, 846, 847, 5, 110, 0, 0, 847, 848, 5, 116, 0, 0, 848, 849, 5, 50, 0, 0, 849, 850, 5, 52, 0, 0, 850, 858, 5, 56, 0, 0, 851, 852, 5, 105, 0, 0, 852, 853, 5, 110, 0, 0, 853, 854, 5, 116, 0, 0, 854, 855, 5, 50, 0, 0, 855, 856, 5, 53, 0, 0, 856, 858, 5, 54, 0, 0, 857, 675, 1, 0, 0, 0, 857, 678, 1, 0, 0, 0, 857, 682, 1, 0, 0, 0, 857, 687, 1, 0, 0, 0, 857, 692, 1, 0, 0, 0, 857, 697, 1, 0, 0, 0, 857, 702, 1, 0, 0, 0, 857, 707, 1, 0, 0, 0, 857, 712, 1, 0, 0, 0, 857, 717, 1, 0, 0, 0, 857, 722, 1, 0, 0, 0, 857, 727, 1, 0, 0, 0, 857, 732, 1, 0, 0, 0, 857, 737, 1, 0, 0, 0, 857, 743, 1, 0, 0, 0, 857, 749, 1, 0, 0, 0, 857, 755, 1, 0, 0, 0, 857, 761, 1, 0, 0, 0, 857, 767, 1, 0, 0, 0, 857, 773, 1, 0, 0, 0, 857, 779, 1, 0, 0, 0, 857, 785, 1, 0, 0, 0, 857, 791, 1, 0, 0, 0, 857, 797, 1, 0, 0, 0, 857, 803, 1, 0, 0, 0, 857, 809, 1, 0, 0, 0, 857, 815, 1, 0, 0, 0, 857, 821, 1, 0, 0, 0, 857, 827, 1, 0, 0, 0, 857, 833, 1, 0, 0, 0, 857, 839, 1, 0, 0, 0, 857, 845, 1, 0, 0, 0, 857, 851, 1, 0, 0, 0, 858, 186, 1, 0, 0, 0, 859, 860, 5, 117, 0, 0, 860, 861, 5, 105, 0, 0, 861, 862, 5, 110, 0, 0, 862, 1075, 5, 116, 0, 0, 863, 864, 5, 117, 0, 0, 864, 865, 5, 105, 0, 0, 865, 866, 5, 110, 0, 0, 866, 867, 5, 116, 0, 0, 867, 1075, 5, 56, 0, 0, 868, 869, 5, 117, 0, 0, 869, 870, 5, 105, 0, 0, 870, 871, 5, 110, 0, 0, 871, 872, 5, 116, 0, 0, 872, 873, 5, 49, 0, 0, 873, 1075, 5, 54, 0, 0, 874, 875, 5, 117, 0, 0, 875, 876, 5, 105, 0, 0, 876, 877, 5, 110, 0, 0, 877, 878, 5, 116, 0, 0, 878, 879, 5, 50, 0, 0, 879, 1075, 5, 52, 0, 0, 880, 881, 5, 117, 0, 0, 881, 882, 5, 105, 0, 0, 882, 883, 5, 110, 0, 0, 883, 884, 5, 116, 0, 0, 884, 885, 5, 51, 0, 0, 885, 1075, 5, 50, 0, 0, 886, 887, 5, 117, 0, 0, 887, 888, 5, 105, 0, 0, 888, 889, 5, 110, 0, 0, 889, 890, 5, 116, 0, 0, 890, 891, 5, 52, 0, 0, 891, 1075, 5, 48, 0, 0, 892, 893, 5, 117, 0, 0, 893, 894, 5, 105, 0, 0, 894, 895, 5, 110, 0, 0, 895, 896, 5, 116, 0, 0, 896, 897, 5, 52, 0, 0, 897, 1075, 5, 56, 0, 0, 898, 899, 5, 117, 0, 0, 899, 900, 5, 105, 0, 0, 900, 901, 5, 110, 0, 0, 901, 902, 5, 116, 0, 0, 902, 903, 5, 53, 0, 0, 903, 1075, 5, 54, 0, 0, 904, 905, 5, 117, 0, 0, 905, 906, 5, 105, 0, 0, 906, 907, 5, 110, 0, 0, 907, 908, 5, 116, 0, 0, 908, 909, 5, 54, 0, 0, 909, 1075, 5, 52, 0, 0, 910, 911, 5, 117, 0, 0, 911, 912, 5, 105, 0, 0, 912, 913, 5, 110, 0, 0, 913, 914, 5, 116, 0, 0, 914, 915, 5, 55, 0, 0, 915, 1075, 5, 50, 0, 0, 916, 917, 5, 117, 0, 0, 917, 918, 5, 105, 0, 0, 918, 919, 5, 110, 0, 0, 919, 920, 5, 116, 0, 0, 920, 921, 5, 56, 0, 0, 921, 1075, 5, 48, 0, 0, 922, 923, 5, 117, 0, 0, 923, 924, 5, 105, 0, 0, 924, 925, 5, 110, 0, 0, 925, 926, 5, 116, 0, 0, 926, 927, 5, 56, 0, 0, 927, 1075, 5, 56, 0, 0, 928, 929, 5, 117, 0, 0, 929, 930, 5, 105, 0, 0, 930, 931, 5, 110, 0, 0, 931, 932, 5, 116, 0, 0, 932, 933, 5, 57, 0, 0, 933, 1075, 5, 54, 0, 0, 934, 935, 5, 117, 0, 0, 935, 936, 5, 105, 0, 0, 936, 937, 5, 110, 0, 0, 937, 938, 5, 116, 0, 0, 938, 939, 5, 49, 0, 0, 939, 940, 5, 48, 0, 0, 940, 1075, 5, 52, 0, 0, 941, 942, 5, 117, 0, 0, 942, 943, 5, 105, 0, 0, 943, 944, 5, 110, 0, 0, 944, 945, 5, 116, 0, 0, 945, 946, 5, 49, 0, 0, 946, 947, 5, 49, 0, 0, 947, 1075, 5, 50, 0, 0, 948, 949, 5, 117, 0, 0, 949, 950, 5, 105, 0, 0, 950, 951, 5, 110, 0, 0, 951, 952, 5, 116, 0, 0, 952, 953, 5, 49, 0, 0, 953, 954, 5, 50, 0, 0, 954, 1075, 5, 48, 0, 0, 955, 956, 5, 117, 0, 0, 956, 957, 5, 105, 0, 0, 957, 958, 5, 110, 0, 0, 958, 959, 5, 116, 0, 0, 959, 960, 5, 49, 0, 0, 960, 961, 5, 50, 0, 0, 961, 1075, 5, 56, 0, 0, 962, 963, 5, 117, 0, 0, 963, 964, 5, 105, 0, 0, 964, 965, 5, 110, 0, 0, 965, 966, 5, 116, 0, 0, 966, 967, 5, 49, 0, 0, 967, 968, 5, 51, 0, 0, 968, 1075, 5, 54, 0, 0, 969, 970, 5, 117, 0, 0, 970, 971, 5, 105, 0, 0, 971, 972, 5, 110, 0, 0, 972, 973, 5, 116, 0, 0, 973, 974, 5, 49, 0, 0, 974, 975, 5, 52, 0, 0, 975, 1075, 5, 52, 0, 0, 976, 977, 5, 117, 0, 0, 977, 978, 5, 105, 0, 0, 978, 979, 5, 110, 0, 0, 979, 980, 5, 116, 0, 0, 980, 981, 5, 49, 0, 0, 981, 982, 5, 53, 0, 0, 982, 1075, 5, 50, 0, 0, 983, 984, 5, 117, 0, 0, 984, 985, 5, 105, 0, 0, 985, 986, 5, 110, 0, 0, 986, 987, 5, 116, 0, 0, 987, 988, 5, 49, 0, 0, 988, 989, 5, 54, 0, 0, 989, 1075, 5, 48, 0, 0, 990, 991, 5, 117, 0, 0, 991, 992, 5, 105, 0, 0, 992, 993, 5, 110, 0, 0, 993, 994, 5, 116, 0, 0, 994, 995, 5, 49, 0, 0, 995, 996, 5, 54, 0, 0, 996, 1075, 5, 56, 0, 0, 997, 998, 5, 117, 0, 0, 998, 999, 5, 105, 0, 0, 999, 1000, 5, 110, 0, 0, 1000, 1001, 5, 116, 0, 0, 1001, 1002, 5, 49, 0, 0, 1002, 1003, 5, 55, 0, 0, 1003, 1075, 5, 54, 0, 0, 1004, 1005, 5, 117, 0, 0, 1005, 1006, 5, 105, 0, 0, 1006, 1007, 5, 110, 0, 0, 1007, 1008, 5, 116, 0, 0, 1008, 1009, 5, 49, 0, 0, 1009, 1010, 5, 56, 0, 0, 1010, 1075, 5, 52, 0, 0, 1011, 1012, 5, 117, 0, 0, 1012, 1013, 5, 105, 0, 0, 1013, 1014, 5, 110, 0, 0, 1014, 1015, 5, 116, 0, 0, 1015, 1016, 5, 49, 0, 0, 1016, 1017, 5, 57, 0, 0, 1017, 1075, 5, 50, 0, 0, 1018, 1019, 5, 117, 0, 0, 1019, 1020, 5, 105, 0, 0, 1020, 1021, 5, 110, 0, 0, 1021, 1022, 5, 116, 0, 0, 1022, 1023, 5, 50, 0, 0, 1023, 1024, 5, 48, 0, 0, 1024, 1075, 5, 48, 0, 0, 1025, 1026, 5, 117, 0, 0, 1026, 1027, 5, 105, 0, 0, 1027, 1028, 5, 110, 0, 0, 1028, 1029, 5, 116, 0, 0, 1029, 1030, 5, 50, 0, 0, 1030, 1031, 5, 48, 0, 0, 1031, 1075, 5, 56, 0, 0, 1032, 1033, 5, 117, 0, 0, 1033, 1034, 5, 105, 0, 0, 1034, 1035, 5, 110, 0, 0, 1035, 1036, 5, 116, 0, 0, 1036, 1037, 5, 50, 0, 0, 1037, 1038, 5, 49, 0, 0, 1038, 1075, 5, 54, 0, 0, 1039, 1040, 5, 117, 0, 0, 1040, 1041, 5, 105, 0, 0, 1041, 1042, 5, 110, 0, 0, 1042, 1043, 5, 116, 0, 0, 1043, 1044, 5, 50, 0, 0, 1044, 1045, 5, 50, 0, 0, 1045, 1075, 5, 52, 0, 0, 1046, 1047, 5, 117, 0, 0, 1047, 1048, 5, 105, 0, 0, 1048, 1049, 5, 110, 0, 0, 1049, 1050, 5, 116, 0, 0, 1050, 1051, 5, 50, 0, 0, 1051, 1052, 5, 51, 0, 0, 1052, 1075, 5, 50, 0, 0, 1053, 1054, 5, 117, 0, 0, 1054, 1055, 5, 105, 0, 0, 1055, 1056, 5, 110, 0, 0, 1056, 1057, 5, 116, 0, 0, 1057, 1058, 5, 50, 0, 0, 1058, 1059, 5, 52, 0, 0, 1059, 1075, 5, 48, 0, 0, 1060, 1061, 5, 117, 0, 0, 1061, 1062, 5, 105, 0, 0, 1062, 1063, 5, 110, 0, 0, 1063, 1064, 5, 116, 0, 0, 1064, 1065, 5, 50, 0, 0, 1065, 1066, 5, 52, 0, 0, 1066, 1075, 5, 56, 0, 0, 1067, 1068, 5, 117, 0, 0, 1068, 1069, 5, 105, 0, 0, 1069, 1070, 5, 110, 0, 0, 1070, 1071, 5, 116, 0, 0, 1071, 1072, 5, 50, 0, 0, 1072, 1073, 5, 53, 0, 0, 1073, 1075, 5, 54, 0, 0, 1074, 859, 1, 0, 0, 0, 1074, 863, 1, 0, 0, 0, 1074, 868, 1, 0, 0, 0, 1074, 874, 1, 0, 0, 0, 1074, 880, 1, 0, 0, 0, 1074, 886, 1, 0, 0, 0, 1074, 892, 1, 0, 0, 0, 1074, 898, 1, 0, 0, 0, 1074, 904, 1, 0, 0, 0, 1074, 910, 1, 0, 0, 0, 1074, 916, 1, 0, 0, 0, 1074, 922, 1, 0, 0, 0, 1074, 928, 1, 0, 0, 0, 1074, 934, 1, 0, 0, 0, 1074, 941, 1, 0, 0, 0, 1074, 948, 1, 0, 0, 0, 1074, 955, 1, 0, 0, 0, 1074, 962, 1, 0, 0, 0, 1074, 969, 1, 0, 0, 0, 1074, 976, 1, 0, 0, 0, 1074, 983, 1, 0, 0, 0, 1074, 990, 1, 0, 0, 0, 1074, 997, 1, 0, 0, 0, 1074, 1004, 1, 0, 0, 0, 1074, 1011, 1, 0, 0, 0, 1074, 1018, 1, 0, 0, 0, 1074, 1025, 1, 0, 0, 0, 1074, 1032, 1, 0, 0, 0, 1074, 1039, 1, 0, 0, 0, 1074, 1046, 1, 0, 0, 0, 1074, 1053, 1, 0, 0, 0, 1074, 1060, 1, 0, 0, 0, 1074, 1067, 1, 0, 0, 0, 1075, 188, 1, 0, 0, 0, 1076, 1077, 5, 98, 0, 0, 1077, 1078, 5, 121, 0, 0, 1078, 1079, 5, 116, 0, 0, 1079, 1080, 5, 101, 0, 0, 1080, 1297, 5, 115, 0, 0, 1081, 1082, 5, 98, 0, 0, 1082, 1083, 5, 121, 0, 0, 1083, 1084, 5, 116, 0, 0, 1084, 1085, 5, 101, 0, 0, 1085, 1086, 5, 115, 0, 0, 1086, 1297, 5, 49, 0, 0, 1087, 1088, 5, 98, 0, 0, 1088, 1089, 5, 121, 0, 0, 1089, 1090, 5, 116, 0, 0, 1090, 1091, 5, 101, 0, 0, 1091, 1092, 5, 115, 0, 0, 1092, 1297, 5, 50, 0, 0, 1093, 1094, 5, 98, 0, 0, 1094, 1095, 5, 121, 0, 0, 1095, 1096, 5, 116, 0, 0, 1096, 1097, 5, 101, 0, 0, 1097, 1098, 5, 115, 0, 0, 1098, 1297, 5, 51, 0, 0, 1099, 1100, 5, 98, 0, 0, 1100, 1101, 5, 121, 0, 0, 1101, 1102, 5, 116, 0, 0, 1102, 1103, 5, 101, 0, 0, 1103, 1104, 5, 115, 0, 0, 1104, 1297, 5, 52, 0, 0, 1105, 1106, 5, 98, 0, 0, 1106, 1107, 5, 121, 0, 0, 1107, 1108, 5, 116, 0, 0, 1108, 1109, 5, 101, 0, 0, 1109, 1110, 5, 115, 0, 0, 1110, 1297, 5, 53, 0, 0, 1111, 1112, 5, 98, 0, 0, 1112, 1113, 5, 121, 0, 0, 1113, 1114, 5, 116, 0, 0, 1114, 1115, 5, 101, 0, 0, 1115, 1116, 5, 115, 0, 0, 1116, 1297, 5, 54, 0, 0, 1117, 1118, 5, 98, 0, 0, 1118, 1119, 5, 121, 0, 0, 1119, 1120, 5, 116, 0, 0, 1120, 1121, 5, 101, 0, 0, 1121, 1122, 5, 115, 0, 0, 1122, 1297, 5, 55, 0, 0, 1123, 1124, 5, 98, 0, 0, 1124, 1125, 5, 121, 0, 0, 1125, 1126, 5, 116, 0, 0, 1126, 1127, 5, 101, 0, 0, 1127, 1128, 5, 115, 0, 0, 1128, 1297, 5, 56, 0, 0, 1129, 1130, 5, 98, 0, 0, 1130, 1131, 5, 121, 0, 0, 1131, 1132, 5, 116, 0, 0, 1132, 1133, 5, 101, 0, 0, 1133, 1134, 5, 115, 0, 0, 1134, 1297, 5, 57, 0, 0, 1135, 1136, 5, 98, 0, 0, 1136, 1137, 5, 121, 0, 0, 1137, 1138, 5, 116, 0, 0, 1138, 1139, 5, 101, 0, 0, 1139, 1140, 5, 115, 0, 0, 1140, 1141, 5, 49, 0, 0, 1141, 1297, 5, 48, 0, 0, 1142, 1143, 5, 98, 0, 0, 1143, 1144, 5, 121, 0, 0, 1144, 1145, 5, 116, 0, 0, 1145, 1146, 5, 101, 0, 0, 1146, 1147, 5, 115, 0, 0, 1147, 1148, 5, 49, 0, 0, 1148, 1297, 5, 49, 0, 0, 1149, 1150, 5, 98, 0, 0, 1150, 1151, 5, 121, 0, 0, 1151, 1152, 5, 116, 0, 0, 1152, 1153, 5, 101, 0, 0, 1153, 1154, 5, 115, 0, 0, 1154, 1155, 5, 49, 0, 0, 1155, 1297, 5, 50, 0, 0, 1156, 1157, 5, 98, 0, 0, 1157, 1158, 5, 121, 0, 0, 1158, 1159, 5, 116, 0, 0, 1159, 1160, 5, 101, 0, 0, 1160, 1161, 5, 115, 0, 0, 1161, 1162, 5, 49, 0, 0, 1162, 1297, 5, 51, 0, 0, 1163, 1164, 5, 98, 0, 0, 1164, 1165, 5, 121, 0, 0, 1165, 1166, 5, 116, 0, 0, 1166, 1167, 5, 101, 0, 0, 1167, 1168, 5, 115, 0, 0, 1168, 1169, 5, 49, 0, 0, 1169, 1297, 5, 52, 0, 0, 1170, 1171, 5, 98, 0, 0, 1171, 1172, 5, 121, 0, 0, 1172, 1173, 5, 116, 0, 0, 1173, 1174, 5, 101, 0, 0, 1174, 1175, 5, 115, 0, 0, 1175, 1176, 5, 49, 0, 0, 1176, 1297, 5, 53, 0, 0, 1177, 1178, 5, 98, 0, 0, 1178, 1179, 5, 121, 0, 0, 1179, 1180, 5, 116, 0, 0, 1180, 1181, 5, 101, 0, 0, 1181, 1182, 5, 115, 0, 0, 1182, 1183, 5, 49, 0, 0, 1183, 1297, 5, 54, 0, 0, 1184, 1185, 5, 98, 0, 0, 1185, 1186, 5, 121, 0, 0, 1186, 1187, 5, 116, 0, 0, 1187, 1188, 5, 101, 0, 0, 1188, 1189, 5, 115, 0, 0, 1189, 1190, 5, 49, 0, 0, 1190, 1297, 5, 55, 0, 0, 1191, 1192, 5, 98, 0, 0, 1192, 1193, 5, 121, 0, 0, 1193, 1194, 5, 116, 0, 0, 1194, 1195, 5, 101, 0, 0, 1195, 1196, 5, 115, 0, 0, 1196, 1197, 5, 49, 0, 0, 1197, 1297, 5, 56, 0, 0, 1198, 1199, 5, 98, 0, 0, 1199, 1200, 5, 121, 0, 0, 1200, 1201, 5, 116, 0, 0, 1201, 1202, 5, 101, 0, 0, 1202, 1203, 5, 115, 0, 0, 1203, 1204, 5, 49, 0, 0, 1204, 1297, 5, 57, 0, 0, 1205, 1206, 5, 98, 0, 0, 1206, 1207, 5, 121, 0, 0, 1207, 1208, 5, 116, 0, 0, 1208, 1209, 5, 101, 0, 0, 1209, 1210, 5, 115, 0, 0, 1210, 1211, 5, 50, 0, 0, 1211, 1297, 5, 48, 0, 0, 1212, 1213, 5, 98, 0, 0, 1213, 1214, 5, 121, 0, 0, 1214, 1215, 5, 116, 0, 0, 1215, 1216, 5, 101, 0, 0, 1216, 1217, 5, 115, 0, 0, 1217, 1218, 5, 50, 0, 0, 1218, 1297, 5, 49, 0, 0, 1219, 1220, 5, 98, 0, 0, 1220, 1221, 5, 121, 0, 0, 1221, 1222, 5, 116, 0, 0, 1222, 1223, 5, 101, 0, 0, 1223, 1224, 5, 115, 0, 0, 1224, 1225, 5, 50, 0, 0, 1225, 1297, 5, 50, 0, 0, 1226, 1227, 5, 98, 0, 0, 1227, 1228, 5, 121, 0, 0, 1228, 1229, 5, 116, 0, 0, 1229, 1230, 5, 101, 0, 0, 1230, 1231, 5, 115, 0, 0, 1231, 1232, 5, 50, 0, 0, 1232, 1297, 5, 51, 0, 0, 1233, 1234, 5, 98, 0, 0, 1234, 1235, 5, 121, 0, 0, 1235, 1236, 5, 116, 0, 0, 1236, 1237, 5, 101, 0, 0, 1237, 1238, 5, 115, 0, 0, 1238, 1239, 5, 50, 0, 0, 1239, 1297, 5, 52, 0, 0, 1240, 1241, 5, 98, 0, 0, 1241, 1242, 5, 121, 0, 0, 1242, 1243, 5, 116, 0, 0, 1243, 1244, 5, 101, 0, 0, 1244, 1245, 5, 115, 0, 0, 1245, 1246, 5, 50, 0, 0, 1246, 1297, 5, 53, 0, 0, 1247, 1248, 5, 98, 0, 0, 1248, 1249, 5, 121, 0, 0, 1249, 1250, 5, 116, 0, 0, 1250, 1251, 5, 101, 0, 0, 1251, 1252, 5, 115, 0, 0, 1252, 1253, 5, 50, 0, 0, 1253, 1297, 5, 54, 0, 0, 1254, 1255, 5, 98, 0, 0, 1255, 1256, 5, 121, 0, 0, 1256, 1257, 5, 116, 0, 0, 1257, 1258, 5, 101, 0, 0, 1258, 1259, 5, 115, 0, 0, 1259, 1260, 5, 50, 0, 0, 1260, 1297, 5, 55, 0, 0, 1261, 1262, 5, 98, 0, 0, 1262, 1263, 5, 121, 0, 0, 1263, 1264, 5, 116, 0, 0, 1264, 1265, 5, 101, 0, 0, 1265, 1266, 5, 115, 0, 0, 1266, 1267, 5, 50, 0, 0, 1267, 1297, 5, 56, 0, 0, 1268, 1269, 5, 98, 0, 0, 1269, 1270, 5, 121, 0, 0, 1270, 1271, 5, 116, 0, 0, 1271, 1272, 5, 101, 0, 0, 1272, 1273, 5, 115, 0, 0, 1273, 1274, 5, 50, 0, 0, 1274, 1297, 5, 57, 0, 0, 1275, 1276, 5, 98, 0, 0, 1276, 1277, 5, 121, 0, 0, 1277, 1278, 5, 116, 0, 0, 1278, 1279, 5, 101, 0, 0, 1279, 1280, 5, 115, 0, 0, 1280, 1281, 5, 51, 0, 0, 1281, 1297, 5, 48, 0, 0, 1282, 1283, 5, 98, 0, 0, 1283, 1284, 5, 121, 0, 0, 1284, 1285, 5, 116, 0, 0, 1285, 1286, 5, 101, 0, 0, 1286, 1287, 5, 115, 0, 0, 1287, 1288, 5, 51, 0, 0, 1288, 1297, 5, 49, 0, 0, 1289, 1290, 5, 98, 0, 0, 1290, 1291, 5, 121, 0, 0, 1291, 1292, 5, 116, 0, 0, 1292, 1293, 5, 101, 0, 0, 1293, 1294, 5, 115, 0, 0, 1294, 1295, 5, 51, 0, 0, 1295, 1297, 5, 50, 0, 0, 1296, 1076, 1, 0, 0, 0, 1296, 1081, 1, 0, 0, 0, 1296, 1087, 1, 0, 0, 0, 1296, 1093, 1, 0, 0, 0, 1296, 1099, 1, 0, 0, 0, 1296, 1105, 1, 0, 0, 0, 1296, 1111, 1, 0, 0, 0, 1296, 1117, 1, 0, 0, 0, 1296, 1123, 1, 0, 0, 0, 1296, 1129, 1, 0, 0, 0, 1296, 1135, 1, 0, 0, 0, 1296, 1142, 1, 0, 0, 0, 1296, 1149, 1, 0, 0, 0, 1296, 1156, 1, 0, 0, 0, 1296, 1163, 1, 0, 0, 0, 1296, 1170, 1, 0, 0, 0, 1296, 1177, 1, 0, 0, 0, 1296, 1184, 1, 0, 0, 0, 1296, 1191, 1, 0, 0, 0, 1296, 1198, 1, 0, 0, 0, 1296, 1205, 1, 0, 0, 0, 1296, 1212, 1, 0, 0, 0, 1296, 1219, 1, 0, 0, 0, 1296, 1226, 1, 0, 0, 0, 1296, 1233, 1, 0, 0, 0, 1296, 1240, 1, 0, 0, 0, 1296, 1247, 1, 0, 0, 0, 1296, 1254, 1, 0, 0, 0, 1296, 1261, 1, 0, 0, 0, 1296, 1268, 1, 0, 0, 0, 1296, 1275, 1, 0, 0, 0, 1296, 1282, 1, 0, 0, 0, 1296, 1289, 1, 0, 0, 0, 1297, 190, 1, 0, 0, 0, 1298, 1299, 5, 102, 0, 0, 1299, 1300, 5, 105, 0, 0, 1300, 1301, 5, 120, 0, 0, 1301, 1302, 5, 101, 0, 0, 1302, 1321, 5, 100, 0, 0, 1303, 1304, 5, 102, 0, 0, 1304, 1305, 5, 105, 0, 0, 1305, 1306, 5, 120, 0, 0, 1306, 1307, 5, 101, 0, 0, 1307, 1308, 5, 100, 0, 0, 1308, 1310, 1, 0, 0, 0, 1309, 1311, 7, 0, 0, 0, 1310, 1309, 1, 0, 0, 0, 1311, 1312, 1, 0, 0, 0, 1312, 1310, 1, 0, 0, 0, 1312, 1313, 1, 0, 0, 0, 1313, 1314, 1, 0, 0, 0, 1314, 1316, 5, 120, 0, 0, 1315, 1317, 7, 0, 0, 0, 1316, 1315, 1, 0, 0, 0, 1317, 1318, 1, 0, 0, 0, 1318, 1316, 1, 0, 0, 0, 1318, 1319, 1, 0, 0, 0, 1319, 1321, 1, 0, 0, 0, 1320, 1298, 1, 0, 0, 0, 1320, 1303, 1, 0, 0, 0, 1321, 192, 1, 0, 0, 0, 1322, 1323, 5, 117, 0, 0, 1323, 1324, 5, 102, 0, 0, 1324, 1325, 5, 105, 0, 0, 1325, 1326, 5, 120, 0, 0, 1326, 1327, 5, 101, 0, 0, 1327, 1347, 5, 100, 0, 0, 1328, 1329, 5, 117, 0, 0, 1329, 1330, 5, 102, 0, 0, 1330, 1331, 5, 105, 0, 0, 1331, 1332, 5, 120, 0, 0, 1332, 1333, 5, 101, 0, 0, 1333, 1334, 5, 100, 0, 0, 1334, 1336, 1, 0, 0, 0, 1335, 1337, 7, 0, 0, 0, 1336, 1335, 1, 0, 0, 0, 1337, 1338, 1, 0, 0, 0, 1338, 1336, 1, 0, 0, 0, 1338, 1339, 1, 0, 0, 0, 1339, 1340, 1, 0, 0, 0, 1340, 1342, 5, 120, 0, 0, 1341, 1343, 7, 0, 0, 0, 1342, 1341, 1, 0, 0, 0, 1343, 1344, 1, 0, 0, 0, 1344, 1342, 1, 0, 0, 0, 1344, 1345, 1, 0, 0, 0, 1345, 1347, 1, 0, 0, 0, 1346, 1322, 1, 0, 0, 0, 1346, 1328, 1, 0, 0, 0, 1347, 194, 1, 0, 0, 0, 1348, 1349, 5, 116, 0, 0, 1349, 1350, 5, 114, 0, 0, 1350, 1351, 5, 117, 0, 0, 1351, 1358, 5, 101, 0, 0, 1352, 1353, 5, 102, 0, 0, 1353, 1354, 5, 97, 0, 0, 1354, 1355, 5, 108, 0, 0, 1355, 1356, 5, 115, 0, 0, 1356, 1358, 5, 101, 0, 0, 1357, 1348, 1, 0, 0, 0, 1357, 1352, 1, 0, 0, 0, 1358, 196, 1, 0, 0, 0, 1359, 1366, 3, 199, 99, 0, 1360, 1362, 3, 199, 99, 0, 1361, 1360, 1, 0, 0, 0, 1361, 1362, 1, 0, 0, 0, 1362, 1363, 1, 0, 0, 0, 1363, 1364, 5, 46, 0, 0, 1364, 1366, 3, 199, 99, 0, 1365, 1359, 1, 0, 0, 0, 1365, 1361, 1, 0, 0, 0, 1366, 1372, 1, 0, 0, 0, 1367, 1369, 7, 1, 0, 0, 1368, 1370, 5, 45, 0, 0, 1369, 1368, 1, 0, 0, 0, 1369, 1370, 1, 0, 0, 0, 1370, 1371, 1, 0, 0, 0, 1371, 1373, 3, 199, 99, 0, 1372, 1367, 1, 0, 0, 0, 1372, 1373, 1, 0, 0, 0, 1373, 198, 1, 0, 0, 0, 1374, 1381, 7, 0, 0, 0, 1375, 1377, 5, 95, 0, 0, 1376, 1375, 1, 0, 0, 0, 1376, 1377, 1, 0, 0, 0, 1377, 1378, 1, 0, 0, 0, 1378, 1380, 7, 0, 0, 0, 1379, 1376, 1, 0, 0, 0, 1380, 1383, 1, 0, 0, 0, 1381, 1379, 1, 0, 0, 0, 1381, 1382, 1, 0, 0, 0, 1382, 200, 1, 0, 0, 0, 1383, 1381, 1, 0, 0, 0, 1384, 1385, 5, 48, 0, 0, 1385, 1386, 7, 2, 0, 0, 1386, 1387, 3, 203, 101, 0, 1387, 202, 1, 0, 0, 0, 1388, 1395, 3, 211, 105, 0, 1389, 1391, 5, 95, 0, 0, 1390, 1389, 1, 0, 0, 0, 1390, 1391, 1, 0, 0, 0, 1391, 1392, 1, 0, 0, 0, 1392, 1394, 3, 211, 105, 0, 1393, 1390, 1, 0, 0, 0, 1394, 1397, 1, 0, 0, 0, 1395, 1393, 1, 0, 0, 0, 1395, 1396, 1, 0, 0, 0, 1396, 204, 1, 0, 0, 0, 1397, 1395, 1, 0, 0, 0, 1398, 1399, 5, 119, 0, 0, 1399, 1400, 5, 101, 0, 0, 1400, 1451, 5, 105, 0, 0, 1401, 1402, 5, 115, 0, 0, 1402, 1403, 5, 122, 0, 0, 1403, 1404, 5, 97, 0, 0, 1404, 1405, 5, 98, 0, 0, 1405, 1451, 5, 111, 0, 0, 1406, 1407, 5, 102, 0, 0, 1407, 1408, 5, 105, 0, 0, 1408, 1409, 5, 110, 0, 0, 1409, 1410, 5, 110, 0, 0, 1410, 1411, 5, 101, 0, 0, 1411, 1451, 5, 121, 0, 0, 1412, 1413, 5, 101, 0, 0, 1413, 1414, 5, 116, 0, 0, 1414, 1415, 5, 104, 0, 0, 1415, 1416, 5, 101, 0, 0, 1416, 1451, 5, 114, 0, 0, 1417, 1418, 5, 115, 0, 0, 1418, 1419, 5, 101, 0, 0, 1419, 1420, 5, 99, 0, 0, 1420, 1421, 5, 111, 0, 0, 1421, 1422, 5, 110, 0, 0, 1422, 1423, 5, 100, 0, 0, 1423, 1451, 5, 115, 0, 0, 1424, 1425, 5, 109, 0, 0, 1425, 1426, 5, 105, 0, 0, 1426, 1427, 5, 110, 0, 0, 1427, 1428, 5, 117, 0, 0, 1428, 1429, 5, 116, 0, 0, 1429, 1430, 5, 101, 0, 0, 1430, 1451, 5, 115, 0, 0, 1431, 1432, 5, 104, 0, 0, 1432, 1433, 5, 111, 0, 0, 1433, 1434, 5, 117, 0, 0, 1434, 1435, 5, 114, 0, 0, 1435, 1451, 5, 115, 0, 0, 1436, 1437, 5, 100, 0, 0, 1437, 1438, 5, 97, 0, 0, 1438, 1439, 5, 121, 0, 0, 1439, 1451, 5, 115, 0, 0, 1440, 1441, 5, 119, 0, 0, 1441, 1442, 5, 101, 0, 0, 1442, 1443, 5, 101, 0, 0, 1443, 1444, 5, 107, 0, 0, 1444, 1451, 5, 115, 0, 0, 1445, 1446, 5, 121, 0, 0, 1446, 1447, 5, 101, 0, 0, 1447, 1448, 5, 97, 0, 0, 1448, 1449, 5, 114, 0, 0, 1449, 1451, 5, 115, 0, 0, 1450, 1398, 1, 0, 0, 0, 1450, 1401, 1, 0, 0, 0, 1450, 1406, 1, 0, 0, 0, 1450, 1412, 1, 0, 0, 0, 1450, 1417, 1, 0, 0, 0, 1450, 1424, 1, 0, 0, 0, 1450, 1431, 1, 0, 0, 0, 1450, 1436, 1, 0, 0, 0, 1450, 1440, 1, 0, 0, 0, 1450, 1445, 1, 0, 0, 0, 1451, 206, 1, 0, 0, 0, 1452, 1453, 5, 104, 0, 0, 1453, 1454, 5, 101, 0, 0, 1454, 1455, 5, 120, 0, 0, 1455, 1466, 1, 0, 0, 0, 1456, 1458, 5, 34, 0, 0, 1457, 1459, 3, 203, 101, 0, 1458, 1457, 1, 0, 0, 0, 1458, 1459, 1, 0, 0, 0, 1459, 1460, 1, 0, 0, 0, 1460, 1467, 5, 34, 0, 0, 1461, 1463, 5, 39, 0, 0, 1462, 1464, 3, 203, 101, 0, 1463, 1462, 1, 0, 0, 0, 1463, 1464, 1, 0, 0, 0, 1464, 1465, 1, 0, 0, 0, 1465, 1467, 5, 39, 0, 0, 1466, 1456, 1, 0, 0, 0, 1466, 1461, 1, 0, 0, 0, 1467, 208, 1, 0, 0, 0, 1468, 1469, 3, 211, 105, 0, 1469, 1470, 3, 211, 105, 0, 1470, 210, 1, 0, 0, 0, 1471, 1472, 7, 3, 0, 0, 1472, 212, 1, 0, 0, 0, 1473, 1474, 5, 97, 0, 0, 1474, 1475, 5, 102, 0, 0, 1475, 1476, 5, 116, 0, 0, 1476, 1477, 5, 101, 0, 0, 1477, 1546, 5, 114, 0, 0, 1478, 1479, 5, 99, 0, 0, 1479, 1480, 5, 97, 0, 0, 1480, 1481, 5, 115, 0, 0, 1481, 1546, 5, 101, 0, 0, 1482, 1483, 5, 100, 0, 0, 1483, 1484, 5, 101, 0, 0, 1484, 1485, 5, 102, 0, 0, 1485, 1486, 5, 97, 0, 0, 1486, 1487, 5, 117, 0, 0, 1487, 1488, 5, 108, 0, 0, 1488, 1546, 5, 116, 0, 0, 1489, 1490, 5, 102, 0, 0, 1490, 1491, 5, 105, 0, 0, 1491, 1492, 5, 110, 0, 0, 1492, 1493, 5, 97, 0, 0, 1493, 1546, 5, 108, 0, 0, 1494, 1495, 5, 105, 0, 0, 1495, 1546, 5, 110, 0, 0, 1496, 1497, 5, 105, 0, 0, 1497, 1498, 5, 110, 0, 0, 1498, 1499, 5, 108, 0, 0, 1499, 1500, 5, 105, 0, 0, 1500, 1501, 5, 110, 0, 0, 1501, 1546, 5, 101, 0, 0, 1502, 1503, 5, 108, 0, 0, 1503, 1504, 5, 101, 0, 0, 1504, 1546, 5, 116, 0, 0, 1505, 1506, 5, 109, 0, 0, 1506, 1507, 5, 97, 0, 0, 1507, 1508, 5, 116, 0, 0, 1508, 1509, 5, 99, 0, 0, 1509, 1546, 5, 104, 0, 0, 1510, 1511, 5, 110, 0, 0, 1511, 1512, 5, 117, 0, 0, 1512, 1513, 5, 108, 0, 0, 1513, 1546, 5, 108, 0, 0, 1514, 1515, 5, 111, 0, 0, 1515, 1546, 5, 102, 0, 0, 1516, 1517, 5, 114, 0, 0, 1517, 1518, 5, 101, 0, 0, 1518, 1519, 5, 108, 0, 0, 1519, 1520, 5, 111, 0, 0, 1520, 1521, 5, 99, 0, 0, 1521, 1522, 5, 97, 0, 0, 1522, 1523, 5, 116, 0, 0, 1523, 1524, 5, 97, 0, 0, 1524, 1525, 5, 98, 0, 0, 1525, 1526, 5, 108, 0, 0, 1526, 1546, 5, 101, 0, 0, 1527, 1528, 5, 115, 0, 0, 1528, 1529, 5, 116, 0, 0, 1529, 1530, 5, 97, 0, 0, 1530, 1531, 5, 116, 0, 0, 1531, 1532, 5, 105, 0, 0, 1532, 1546, 5, 99, 0, 0, 1533, 1534, 5, 115, 0, 0, 1534, 1535, 5, 119, 0, 0, 1535, 1536, 5, 105, 0, 0, 1536, 1537, 5, 116, 0, 0, 1537, 1538, 5, 99, 0, 0, 1538, 1546, 5, 104, 0, 0, 1539, 1540, 5, 116, 0, 0, 1540, 1541, 5, 121, 0, 0, 1541, 1542, 5, 112, 0, 0, 1542, 1543, 5, 101, 0, 0, 1543, 1544, 5, 111, 0, 0, 1544, 1546, 5, 102, 0, 0, 1545, 1473, 1, 0, 0, 0, 1545, 1478, 1, 0, 0, 0, 1545, 1482, 1, 0, 0, 0, 1545, 1489, 1, 0, 0, 0, 1545, 1494, 1, 0, 0, 0, 1545, 1496, 1, 0, 0, 0, 1545, 1502, 1, 0, 0, 0, 1545, 1505, 1, 0, 0, 0, 1545, 1510, 1, 0, 0, 0, 1545, 1514, 1, 0, 0, 0, 1545, 1516, 1, 0, 0, 0, 1545, 1527, 1, 0, 0, 0, 1545, 1533, 1, 0, 0, 0, 1545, 1539, 1, 0, 0, 0, 1546, 214, 1, 0, 0, 0, 1547, 1548, 5, 97, 0, 0, 1548, 1549, 5, 110, 0, 0, 1549, 1550, 5, 111, 0, 0, 1550, 1551, 5, 110, 0, 0, 1551, 1552, 5, 121, 0, 0, 1552, 1553, 5, 109, 0, 0, 1553, 1554, 5, 111, 0, 0, 1554, 1555, 5, 117, 0, 0, 1555, 1556, 5, 115, 0, 0, 1556, 216, 1, 0, 0, 0, 1557, 1558, 5, 98, 0, 0, 1558, 1559, 5, 114, 0, 0, 1559, 1560, 5, 101, 0, 0, 1560, 1561, 5, 97, 0, 0, 1561, 1562, 5, 107, 0, 0, 1562, 218, 1, 0, 0, 0, 1563, 1564, 5, 99, 0, 0, 1564, 1565, 5, 111, 0, 0, 1565, 1566, 5, 110, 0, 0, 1566, 1567, 5, 115, 0, 0, 1567, 1568, 5, 116, 0, 0, 1568, 1569, 5, 97, 0, 0, 1569, 1570, 5, 110, 0, 0, 1570, 1571, 5, 116, 0, 0, 1571, 220, 1, 0, 0, 0, 1572, 1573, 5, 105, 0, 0, 1573, 1574, 5, 109, 0, 0, 1574, 1575, 5, 109, 0, 0, 1575, 1576, 5, 117, 0, 0, 1576, 1577, 5, 116, 0, 0, 1577, 1578, 5, 97, 0, 0, 1578, 1579, 5, 98, 0, 0, 1579, 1580, 5, 108, 0, 0, 1580, 1581, 5, 101, 0, 0, 1581, 222, 1, 0, 0, 0, 1582, 1583, 5, 99, 0, 0, 1583, 1584, 5, 111, 0, 0, 1584, 1585, 5, 110, 0, 0, 1585, 1586, 5, 116, 0, 0, 1586, 1587, 5, 105, 0, 0, 1587, 1588, 5, 110, 0, 0, 1588, 1589, 5, 117, 0, 0, 1589, 1590, 5, 101, 0, 0, 1590, 224, 1, 0, 0, 0, 1591, 1592, 5, 108, 0, 0, 1592, 1593, 5, 101, 0, 0, 1593, 1594, 5, 97, 0, 0, 1594, 1595, 5, 118, 0, 0, 1595, 1596, 5, 101, 0, 0, 1596, 226, 1, 0, 0, 0, 1597, 1598, 5, 101, 0, 0, 1598, 1599, 5, 120, 0, 0, 1599, 1600, 5, 116, 0, 0, 1600, 1601, 5, 101, 0, 0, 1601, 1602, 5, 114, 0, 0, 1602, 1603, 5, 110, 0, 0, 1603, 1604, 5, 97, 0, 0, 1604, 1605, 5, 108, 0, 0, 1605, 228, 1, 0, 0, 0, 1606, 1607, 5, 105, 0, 0, 1607, 1608, 5, 110, 0, 0, 1608, 1609, 5, 100, 0, 0, 1609, 1610, 5, 101, 0, 0, 1610, 1611, 5, 120, 0, 0, 1611, 1612, 5, 101, 0, 0, 1612, 1613, 5, 100, 0, 0, 1613, 230, 1, 0, 0, 0, 1614, 1615, 5, 105, 0, 0, 1615, 1616, 5, 110, 0, 0, 1616, 1617, 5, 116, 0, 0, 1617, 1618, 5, 101, 0, 0, 1618, 1619, 5, 114, 0, 0, 1619, 1620, 5, 110, 0, 0, 1620, 1621, 5, 97, 0, 0, 1621, 1622, 5, 108, 0, 0, 1622, 232, 1, 0, 0, 0, 1623, 1624, 5, 112, 0, 0, 1624, 1625, 5, 97, 0, 0, 1625, 1626, 5, 121, 0, 0, 1626, 1627, 5, 97, 0, 0, 1627, 1628, 5, 98, 0, 0, 1628, 1629, 5, 108, 0, 0, 1629, 1630, 5, 101, 0, 0, 1630, 234, 1, 0, 0, 0, 1631, 1632, 5, 112, 0, 0, 1632, 1633, 5, 114, 0, 0, 1633, 1634, 5, 105, 0, 0, 1634, 1635, 5, 118, 0, 0, 1635, 1636, 5, 97, 0, 0, 1636, 1637, 5, 116, 0, 0, 1637, 1638, 5, 101, 0, 0, 1638, 236, 1, 0, 0, 0, 1639, 1640, 5, 112, 0, 0, 1640, 1641, 5, 117, 0, 0, 1641, 1642, 5, 98, 0, 0, 1642, 1643, 5, 108, 0, 0, 1643, 1644, 5, 105, 0, 0, 1644, 1645, 5, 99, 0, 0, 1645, 238, 1, 0, 0, 0, 1646, 1647, 5, 118, 0, 0, 1647, 1648, 5, 105, 0, 0, 1648, 1649, 5, 114, 0, 0, 1649, 1650, 5, 116, 0, 0, 1650, 1651, 5, 117, 0, 0, 1651, 1652, 5, 97, 0, 0, 1652, 1653, 5, 108, 0, 0, 1653, 240, 1, 0, 0, 0, 1654, 1655, 5, 112, 0, 0, 1655, 1656, 5, 117, 0, 0, 1656, 1657, 5, 114, 0, 0, 1657, 1658, 5, 101, 0, 0, 1658, 242, 1, 0, 0, 0, 1659, 1660, 5, 116, 0, 0, 1660, 1661, 5, 121, 0, 0, 1661, 1662, 5, 112, 0, 0, 1662, 1663, 5, 101, 0, 0, 1663, 244, 1, 0, 0, 0, 1664, 1665, 5, 118, 0, 0, 1665, 1666, 5, 105, 0, 0, 1666, 1667, 5, 101, 0, 0, 1667, 1668, 5, 119, 0, 0, 1668, 246, 1, 0, 0, 0, 1669, 1670, 5, 99, 0, 0, 1670, 1671, 5, 111, 0, 0, 1671, 1672, 5, 110, 0, 0, 1672, 1673, 5, 115, 0, 0, 1673, 1674, 5, 116, 0, 0, 1674, 1675, 5, 114, 0, 0, 1675, 1676, 5, 117, 0, 0, 1676, 1677, 5, 99, 0, 0, 1677, 1678, 5, 116, 0, 0, 1678, 1679, 5, 111, 0, 0, 1679, 1680, 5, 114, 0, 0, 1680, 248, 1, 0, 0, 0, 1681, 1682, 5, 102, 0, 0, 1682, 1683, 5, 97, 0, 0, 1683, 1684, 5, 108, 0, 0, 1684, 1685, 5, 108, 0, 0, 1685, 1686, 5, 98, 0, 0, 1686, 1687, 5, 97, 0, 0, 1687, 1688, 5, 99, 0, 0, 1688, 1689, 5, 107, 0, 0, 1689, 250, 1, 0, 0, 0, 1690, 1691, 5, 114, 0, 0, 1691, 1692, 5, 101, 0, 0, 1692, 1693, 5, 99, 0, 0, 1693, 1694, 5, 101, 0, 0, 1694, 1695, 5, 105, 0, 0, 1695, 1696, 5, 118, 0, 0, 1696, 1697, 5, 101, 0, 0, 1697, 252, 1, 0, 0, 0, 1698, 1702, 3, 255, 127, 0, 1699, 1701, 3, 257, 128, 0, 1700, 1699, 1, 0, 0, 0, 1701, 1704, 1, 0, 0, 0, 1702, 1700, 1, 0, 0, 0, 1702, 1703, 1, 0, 0, 0, 1703, 254, 1, 0, 0, 0, 1704, 1702, 1, 0, 0, 0, 1705, 1706, 7, 4, 0, 0, 1706, 256, 1, 0, 0, 0, 1707, 1708, 7, 5, 0, 0, 1708, 258, 1, 0, 0, 0, 1709, 1713, 5, 34, 0, 0, 1710, 1712, 3, 261, 130, 0, 1711, 1710, 1, 0, 0, 0, 1712, 1715, 1, 0, 0, 0, 1713, 1711, 1, 0, 0, 0, 1713, 1714, 1, 0, 0, 0, 1714, 1716, 1, 0, 0, 0, 1715, 1713, 1, 0, 0, 0, 1716, 1726, 5, 34, 0, 0, 1717, 1721, 5, 39, 0, 0, 1718, 1720, 3, 263, 131, 0, 1719, 1718, 1, 0, 0, 0, 1720, 1723, 1, 0, 0, 0, 1721, 1719, 1, 0, 0, 0, 1721, 1722, 1, 0, 0, 0, 1722, 1724, 1, 0, 0, 0, 1723, 1721, 1, 0, 0, 0, 1724, 1726, 5, 39, 0, 0, 1725, 1709, 1, 0, 0, 0, 1725, 1717, 1, 0, 0, 0, 1726, 260, 1, 0, 0, 0, 1727, 1731, 8, 6, 0, 0, 1728, 1729, 5, 92, 0, 0, 1729, 1731, 9, 0, 0, 0, 1730, 1727, 1, 0, 0, 0, 1730, 1728, 1, 0, 0, 0, 1731, 262, 1, 0, 0, 0, 1732, 1736, 8, 7, 0, 0, 1733, 1734, 5, 92, 0, 0, 1734, 1736, 9, 0, 0, 0, 1735, 1732, 1, 0, 0, 0, 1735, 1733, 1, 0, 0, 0, 1736, 264, 1, 0, 0, 0, 1737, 1739, 7, 0, 0, 0, 1738, 1737, 1, 0, 0, 0, 1739, 1740, 1, 0, 0, 0, 1740, 1738, 1, 0, 0, 0, 1740, 1741, 1, 0, 0, 0, 1741, 1742, 1, 0, 0, 0, 1742, 1744, 5, 46, 0, 0, 1743, 1745, 7, 0, 0, 0, 1744, 1743, 1, 0, 0, 0, 1745, 1746, 1, 0, 0, 0, 1746, 1744, 1, 0, 0, 0, 1746, 1747, 1, 0, 0, 0, 1747, 1754, 1, 0, 0, 0, 1748, 1750, 5, 46, 0, 0, 1749, 1751, 7, 0, 0, 0, 1750, 1749, 1, 0, 0, 0, 1751, 1752, 1, 0, 0, 0, 1752, 1750, 1, 0, 0, 0, 1752, 1753, 1, 0, 0, 0, 1753, 1755, 1, 0, 0, 0, 1754, 1748, 1, 0, 0, 0, 1754, 1755, 1, 0, 0, 0, 1755, 266, 1, 0, 0, 0, 1756, 1758, 7, 8, 0, 0, 1757, 1756, 1, 0, 0, 0, 1758, 1759, 1, 0, 0, 0, 1759, 1757, 1, 0, 0, 0, 1759, 1760, 1, 0, 0, 0, 1760, 1761, 1, 0, 0, 0, 1761, 1762, 6, 133, 0, 0, 1762, 268, 1, 0, 0, 0, 1763, 1764, 5, 47, 0, 0, 1764, 1765, 5, 42, 0, 0, 1765, 1769, 1, 0, 0, 0, 1766, 1768, 9, 0, 0, 0, 1767, 1766, 1, 0, 0, 0, 1768, 1771, 1, 0, 0, 0, 1769, 1770, 1, 0, 0, 0, 1769, 1767, 1, 0, 0, 0, 1770, 1772, 1, 0, 0, 0, 1771, 1769, 1, 0, 0, 0, 1772, 1773, 5, 42, 0, 0, 1773, 1774, 5, 47, 0, 0, 1774, 1775, 1, 0, 0, 0, 1775, 1776, 6, 134, 1, 0, 1776, 270, 1, 0, 0, 0, 1777, 1778, 5, 47, 0, 0, 1778, 1779, 5, 47, 0, 0, 1779, 1783, 1, 0, 0, 0, 1780, 1782, 8, 9, 0, 0, 1781, 1780, 1, 0, 0, 0, 1782, 1785, 1, 0, 0, 0, 1783, 1781, 1, 0, 0, 0, 1783, 1784, 1, 0, 0, 0, 1784, 1786, 1, 0, 0, 0, 1785, 1783, 1, 0, 0, 0, 1786, 1787, 6, 135, 1, 0, 1787, 272, 1, 0, 0, 0, 37, 0, 857, 1074, 1296, 1312, 1318, 1320, 1338, 1344, 1346, 1357, 1361, 1365, 1369, 1372, 1376, 1381, 1390, 1395, 1450, 1458, 1463, 1466, 1545, 1702, 1713, 1721, 1725, 1730, 1735, 1740, 1746, 1752, 1754, 1759, 1769, 1783, 2, 6, 0, 0, 0, 1, 0] \ No newline at end of file diff --git a/vanguard/aleo/parser/.antlr/SolidityLexer.java b/vanguard/aleo/parser/.antlr/SolidityLexer.java new file mode 100644 index 0000000..bf7de3e --- /dev/null +++ b/vanguard/aleo/parser/.antlr/SolidityLexer.java @@ -0,0 +1,1267 @@ +// Generated from /Users/joseph/Desktop/UCSB/24winter/vanguard-aleo/vanguard/aleo/parser/Solidity.g4 by ANTLR 4.13.1 +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.*; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) +public class SolidityLexer extends Lexer { + static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, + T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, + T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, + T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31, + T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38, + T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, T__44=45, + T__45=46, T__46=47, T__47=48, T__48=49, T__49=50, T__50=51, T__51=52, + T__52=53, T__53=54, T__54=55, T__55=56, T__56=57, T__57=58, T__58=59, + T__59=60, T__60=61, T__61=62, T__62=63, T__63=64, T__64=65, T__65=66, + T__66=67, T__67=68, T__68=69, T__69=70, T__70=71, T__71=72, T__72=73, + T__73=74, T__74=75, T__75=76, T__76=77, T__77=78, T__78=79, T__79=80, + T__80=81, T__81=82, T__82=83, T__83=84, T__84=85, T__85=86, T__86=87, + T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, Int=93, Uint=94, Byte=95, + Fixed=96, Ufixed=97, BooleanLiteral=98, DecimalNumber=99, HexNumber=100, + NumberUnit=101, HexLiteralFragment=102, ReservedKeyword=103, AnonymousKeyword=104, + BreakKeyword=105, ConstantKeyword=106, ImmutableKeyword=107, ContinueKeyword=108, + LeaveKeyword=109, ExternalKeyword=110, IndexedKeyword=111, InternalKeyword=112, + PayableKeyword=113, PrivateKeyword=114, PublicKeyword=115, VirtualKeyword=116, + PureKeyword=117, TypeKeyword=118, ViewKeyword=119, ConstructorKeyword=120, + FallbackKeyword=121, ReceiveKeyword=122, Identifier=123, StringLiteralFragment=124, + VersionLiteral=125, WS=126, COMMENT=127, LINE_COMMENT=128; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }; + + public static String[] modeNames = { + "DEFAULT_MODE" + }; + + private static String[] makeRuleNames() { + return new String[] { + "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", "T__7", "T__8", + "T__9", "T__10", "T__11", "T__12", "T__13", "T__14", "T__15", "T__16", + "T__17", "T__18", "T__19", "T__20", "T__21", "T__22", "T__23", "T__24", + "T__25", "T__26", "T__27", "T__28", "T__29", "T__30", "T__31", "T__32", + "T__33", "T__34", "T__35", "T__36", "T__37", "T__38", "T__39", "T__40", + "T__41", "T__42", "T__43", "T__44", "T__45", "T__46", "T__47", "T__48", + "T__49", "T__50", "T__51", "T__52", "T__53", "T__54", "T__55", "T__56", + "T__57", "T__58", "T__59", "T__60", "T__61", "T__62", "T__63", "T__64", + "T__65", "T__66", "T__67", "T__68", "T__69", "T__70", "T__71", "T__72", + "T__73", "T__74", "T__75", "T__76", "T__77", "T__78", "T__79", "T__80", + "T__81", "T__82", "T__83", "T__84", "T__85", "T__86", "T__87", "T__88", + "T__89", "T__90", "T__91", "Int", "Uint", "Byte", "Fixed", "Ufixed", + "BooleanLiteral", "DecimalNumber", "DecimalDigits", "HexNumber", "HexDigits", + "NumberUnit", "HexLiteralFragment", "HexPair", "HexCharacter", "ReservedKeyword", + "AnonymousKeyword", "BreakKeyword", "ConstantKeyword", "ImmutableKeyword", + "ContinueKeyword", "LeaveKeyword", "ExternalKeyword", "IndexedKeyword", + "InternalKeyword", "PayableKeyword", "PrivateKeyword", "PublicKeyword", + "VirtualKeyword", "PureKeyword", "TypeKeyword", "ViewKeyword", "ConstructorKeyword", + "FallbackKeyword", "ReceiveKeyword", "Identifier", "IdentifierStart", + "IdentifierPart", "StringLiteralFragment", "DoubleQuotedStringCharacter", + "SingleQuotedStringCharacter", "VersionLiteral", "WS", "COMMENT", "LINE_COMMENT" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, "'pragma'", "';'", "'^'", "'~'", "'>='", "'>'", "'<'", "'<='", + "'='", "'import'", "'as'", "'*'", "'from'", "'{'", "','", "'}'", "'abstract'", + "'contract'", "'interface'", "'library'", "'is'", "'('", "')'", "'override'", + "'using'", "'for'", "'struct'", "'modifier'", "'function'", "'returns'", + "'event'", "'enum'", "'['", "']'", "'.'", "'mapping'", "'=>'", "'memory'", + "'storage'", "'calldata'", "'if'", "'else'", "'try'", "'catch'", "'while'", + "'assembly'", "'do'", "'return'", "'throw'", "'emit'", "'var'", "'address'", + "'bool'", "'string'", "'byte'", "'++'", "'--'", "'new'", "':'", "'+'", + "'-'", "'after'", "'delete'", "'!'", "'**'", "'/'", "'%'", "'<<'", "'>>'", + "'&'", "'|'", "'=='", "'!='", "'&&'", "'||'", "'?'", "'|='", "'^='", + "'&='", "'<<='", "'>>='", "'+='", "'-='", "'*='", "'/='", "'%='", "'let'", + "':='", "'=:'", "'switch'", "'case'", "'default'", null, null, null, + null, null, null, null, null, null, null, null, "'anonymous'", "'break'", + "'constant'", "'immutable'", "'continue'", "'leave'", "'external'", "'indexed'", + "'internal'", "'payable'", "'private'", "'public'", "'virtual'", "'pure'", + "'type'", "'view'", "'constructor'", "'fallback'", "'receive'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, "Int", "Uint", + "Byte", "Fixed", "Ufixed", "BooleanLiteral", "DecimalNumber", "HexNumber", + "NumberUnit", "HexLiteralFragment", "ReservedKeyword", "AnonymousKeyword", + "BreakKeyword", "ConstantKeyword", "ImmutableKeyword", "ContinueKeyword", + "LeaveKeyword", "ExternalKeyword", "IndexedKeyword", "InternalKeyword", + "PayableKeyword", "PrivateKeyword", "PublicKeyword", "VirtualKeyword", + "PureKeyword", "TypeKeyword", "ViewKeyword", "ConstructorKeyword", "FallbackKeyword", + "ReceiveKeyword", "Identifier", "StringLiteralFragment", "VersionLiteral", + "WS", "COMMENT", "LINE_COMMENT" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + + public SolidityLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "Solidity.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getChannelNames() { return channelNames; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + public static final String _serializedATN = + "\u0004\u0000\u0080\u06fc\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002"+ + "\u0001\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002"+ + "\u0004\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002"+ + "\u0007\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002"+ + "\u000b\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e"+ + "\u0002\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011"+ + "\u0002\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014"+ + "\u0002\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017"+ + "\u0002\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a"+ + "\u0002\u001b\u0007\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d"+ + "\u0002\u001e\u0007\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!"+ + "\u0007!\u0002\"\u0007\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002"+ + "&\u0007&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002"+ + "+\u0007+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u0002"+ + "0\u00070\u00021\u00071\u00022\u00072\u00023\u00073\u00024\u00074\u0002"+ + "5\u00075\u00026\u00076\u00027\u00077\u00028\u00078\u00029\u00079\u0002"+ + ":\u0007:\u0002;\u0007;\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002"+ + "?\u0007?\u0002@\u0007@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002"+ + "D\u0007D\u0002E\u0007E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002"+ + "I\u0007I\u0002J\u0007J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002"+ + "N\u0007N\u0002O\u0007O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002"+ + "S\u0007S\u0002T\u0007T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002"+ + "X\u0007X\u0002Y\u0007Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002"+ + "]\u0007]\u0002^\u0007^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002"+ + "b\u0007b\u0002c\u0007c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002"+ + "g\u0007g\u0002h\u0007h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002"+ + "l\u0007l\u0002m\u0007m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002"+ + "q\u0007q\u0002r\u0007r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002"+ + "v\u0007v\u0002w\u0007w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002"+ + "{\u0007{\u0002|\u0007|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f"+ + "\u0002\u0080\u0007\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082"+ + "\u0002\u0083\u0007\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085"+ + "\u0002\u0086\u0007\u0086\u0002\u0087\u0007\u0087\u0001\u0000\u0001\u0000"+ + "\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001"+ + "\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006"+ + "\u0001\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001\t\u0001\t\u0001"+ + "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\n\u0001\n\u0001\n\u0001\u000b"+ + "\u0001\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\r\u0001\r\u0001"+ + "\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u0010\u0001\u0010\u0001"+ + "\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001"+ + "\u0010\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001"+ + "\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001"+ + "\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001"+ + "\u0012\u0001\u0012\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001"+ + "\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014\u0001"+ + "\u0014\u0001\u0015\u0001\u0015\u0001\u0016\u0001\u0016\u0001\u0017\u0001"+ + "\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+ + "\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001"+ + "\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001"+ + "\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+ + "\u001a\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001"+ + "\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0001"+ + "\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001"+ + "\u001c\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+ + "\u001d\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0001"+ + "\u001e\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001"+ + "\u001f\u0001\u001f\u0001 \u0001 \u0001!\u0001!\u0001\"\u0001\"\u0001#"+ + "\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001$\u0001$\u0001"+ + "$\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001&\u0001&\u0001"+ + "&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001\'\u0001\'\u0001\'\u0001\'\u0001"+ + "\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001(\u0001(\u0001(\u0001)\u0001)"+ + "\u0001)\u0001)\u0001)\u0001*\u0001*\u0001*\u0001*\u0001+\u0001+\u0001"+ + "+\u0001+\u0001+\u0001+\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ + "-\u0001-\u0001-\u0001-\u0001-\u0001-\u0001-\u0001-\u0001-\u0001.\u0001"+ + ".\u0001.\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u00010\u0001"+ + "0\u00010\u00010\u00010\u00010\u00011\u00011\u00011\u00011\u00011\u0001"+ + "2\u00012\u00012\u00012\u00013\u00013\u00013\u00013\u00013\u00013\u0001"+ + "3\u00013\u00014\u00014\u00014\u00014\u00014\u00015\u00015\u00015\u0001"+ + "5\u00015\u00015\u00015\u00016\u00016\u00016\u00016\u00016\u00017\u0001"+ + "7\u00017\u00018\u00018\u00018\u00019\u00019\u00019\u00019\u0001:\u0001"+ + ":\u0001;\u0001;\u0001<\u0001<\u0001=\u0001=\u0001=\u0001=\u0001=\u0001"+ + "=\u0001>\u0001>\u0001>\u0001>\u0001>\u0001>\u0001>\u0001?\u0001?\u0001"+ + "@\u0001@\u0001@\u0001A\u0001A\u0001B\u0001B\u0001C\u0001C\u0001C\u0001"+ + "D\u0001D\u0001D\u0001E\u0001E\u0001F\u0001F\u0001G\u0001G\u0001G\u0001"+ + "H\u0001H\u0001H\u0001I\u0001I\u0001I\u0001J\u0001J\u0001J\u0001K\u0001"+ + "K\u0001L\u0001L\u0001L\u0001M\u0001M\u0001M\u0001N\u0001N\u0001N\u0001"+ + "O\u0001O\u0001O\u0001O\u0001P\u0001P\u0001P\u0001P\u0001Q\u0001Q\u0001"+ + "Q\u0001R\u0001R\u0001R\u0001S\u0001S\u0001S\u0001T\u0001T\u0001T\u0001"+ + "U\u0001U\u0001U\u0001V\u0001V\u0001V\u0001V\u0001W\u0001W\u0001W\u0001"+ + "X\u0001X\u0001X\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001"+ + "Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001[\u0001[\u0001[\u0001[\u0001[\u0001"+ + "[\u0001[\u0001[\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0003\\\u035a\b\\\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+ + "]\u0001]\u0001]\u0003]\u0433\b]\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ + "^\u0001^\u0001^\u0001^\u0001^\u0003^\u0511\b^\u0001_\u0001_\u0001_\u0001"+ + "_\u0001_\u0001_\u0001_\u0001_\u0001_\u0001_\u0001_\u0001_\u0004_\u051f"+ + "\b_\u000b_\f_\u0520\u0001_\u0001_\u0004_\u0525\b_\u000b_\f_\u0526\u0003"+ + "_\u0529\b_\u0001`\u0001`\u0001`\u0001`\u0001`\u0001`\u0001`\u0001`\u0001"+ + "`\u0001`\u0001`\u0001`\u0001`\u0001`\u0004`\u0539\b`\u000b`\f`\u053a\u0001"+ + "`\u0001`\u0004`\u053f\b`\u000b`\f`\u0540\u0003`\u0543\b`\u0001a\u0001"+ + "a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0003a\u054e\ba\u0001"+ + "b\u0001b\u0003b\u0552\bb\u0001b\u0001b\u0003b\u0556\bb\u0001b\u0001b\u0003"+ + "b\u055a\bb\u0001b\u0003b\u055d\bb\u0001c\u0001c\u0003c\u0561\bc\u0001"+ + "c\u0005c\u0564\bc\nc\fc\u0567\tc\u0001d\u0001d\u0001d\u0001d\u0001e\u0001"+ + "e\u0003e\u056f\be\u0001e\u0005e\u0572\be\ne\fe\u0575\te\u0001f\u0001f"+ + "\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001"+ + "f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001"+ + "f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001"+ + "f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001"+ + "f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001"+ + "f\u0003f\u05ab\bf\u0001g\u0001g\u0001g\u0001g\u0001g\u0001g\u0003g\u05b3"+ + "\bg\u0001g\u0001g\u0001g\u0003g\u05b8\bg\u0001g\u0003g\u05bb\bg\u0001"+ + "h\u0001h\u0001h\u0001i\u0001i\u0001j\u0001j\u0001j\u0001j\u0001j\u0001"+ + "j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001"+ + "j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001"+ + "j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001"+ + "j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001"+ + "j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001"+ + "j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001"+ + "j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0003j\u060a\bj\u0001k\u0001"+ + "k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001k\u0001l\u0001"+ + "l\u0001l\u0001l\u0001l\u0001l\u0001m\u0001m\u0001m\u0001m\u0001m\u0001"+ + "m\u0001m\u0001m\u0001m\u0001n\u0001n\u0001n\u0001n\u0001n\u0001n\u0001"+ + "n\u0001n\u0001n\u0001n\u0001o\u0001o\u0001o\u0001o\u0001o\u0001o\u0001"+ + "o\u0001o\u0001o\u0001p\u0001p\u0001p\u0001p\u0001p\u0001p\u0001q\u0001"+ + "q\u0001q\u0001q\u0001q\u0001q\u0001q\u0001q\u0001q\u0001r\u0001r\u0001"+ + "r\u0001r\u0001r\u0001r\u0001r\u0001r\u0001s\u0001s\u0001s\u0001s\u0001"+ + "s\u0001s\u0001s\u0001s\u0001s\u0001t\u0001t\u0001t\u0001t\u0001t\u0001"+ + "t\u0001t\u0001t\u0001u\u0001u\u0001u\u0001u\u0001u\u0001u\u0001u\u0001"+ + "u\u0001v\u0001v\u0001v\u0001v\u0001v\u0001v\u0001v\u0001w\u0001w\u0001"+ + "w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001x\u0001x\u0001x\u0001x\u0001"+ + "x\u0001y\u0001y\u0001y\u0001y\u0001y\u0001z\u0001z\u0001z\u0001z\u0001"+ + "z\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0001"+ + "{\u0001{\u0001{\u0001|\u0001|\u0001|\u0001|\u0001|\u0001|\u0001|\u0001"+ + "|\u0001|\u0001}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001}\u0001"+ + "~\u0001~\u0005~\u06a5\b~\n~\f~\u06a8\t~\u0001\u007f\u0001\u007f\u0001"+ + "\u0080\u0001\u0080\u0001\u0081\u0001\u0081\u0005\u0081\u06b0\b\u0081\n"+ + "\u0081\f\u0081\u06b3\t\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0005"+ + "\u0081\u06b8\b\u0081\n\u0081\f\u0081\u06bb\t\u0081\u0001\u0081\u0003\u0081"+ + "\u06be\b\u0081\u0001\u0082\u0001\u0082\u0001\u0082\u0003\u0082\u06c3\b"+ + "\u0082\u0001\u0083\u0001\u0083\u0001\u0083\u0003\u0083\u06c8\b\u0083\u0001"+ + "\u0084\u0004\u0084\u06cb\b\u0084\u000b\u0084\f\u0084\u06cc\u0001\u0084"+ + "\u0001\u0084\u0004\u0084\u06d1\b\u0084\u000b\u0084\f\u0084\u06d2\u0001"+ + "\u0084\u0001\u0084\u0004\u0084\u06d7\b\u0084\u000b\u0084\f\u0084\u06d8"+ + "\u0003\u0084\u06db\b\u0084\u0001\u0085\u0004\u0085\u06de\b\u0085\u000b"+ + "\u0085\f\u0085\u06df\u0001\u0085\u0001\u0085\u0001\u0086\u0001\u0086\u0001"+ + "\u0086\u0001\u0086\u0005\u0086\u06e8\b\u0086\n\u0086\f\u0086\u06eb\t\u0086"+ + "\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0087"+ + "\u0001\u0087\u0001\u0087\u0001\u0087\u0005\u0087\u06f6\b\u0087\n\u0087"+ + "\f\u0087\u06f9\t\u0087\u0001\u0087\u0001\u0087\u0001\u06e9\u0000\u0088"+ + "\u0001\u0001\u0003\u0002\u0005\u0003\u0007\u0004\t\u0005\u000b\u0006\r"+ + "\u0007\u000f\b\u0011\t\u0013\n\u0015\u000b\u0017\f\u0019\r\u001b\u000e"+ + "\u001d\u000f\u001f\u0010!\u0011#\u0012%\u0013\'\u0014)\u0015+\u0016-\u0017"+ + "/\u00181\u00193\u001a5\u001b7\u001c9\u001d;\u001e=\u001f? A!C\"E#G$I%"+ + "K&M\'O(Q)S*U+W,Y-[.]/_0a1c2e3g4i5k6m7o8q9s:u;w}?\u007f@\u0081A\u0083"+ + "B\u0085C\u0087D\u0089E\u008bF\u008dG\u008fH\u0091I\u0093J\u0095K\u0097"+ + "L\u0099M\u009bN\u009dO\u009fP\u00a1Q\u00a3R\u00a5S\u00a7T\u00a9U\u00ab"+ + "V\u00adW\u00afX\u00b1Y\u00b3Z\u00b5[\u00b7\\\u00b9]\u00bb^\u00bd_\u00bf"+ + "`\u00c1a\u00c3b\u00c5c\u00c7\u0000\u00c9d\u00cb\u0000\u00cde\u00cff\u00d1"+ + "\u0000\u00d3\u0000\u00d5g\u00d7h\u00d9i\u00dbj\u00ddk\u00dfl\u00e1m\u00e3"+ + "n\u00e5o\u00e7p\u00e9q\u00ebr\u00eds\u00eft\u00f1u\u00f3v\u00f5w\u00f7"+ + "x\u00f9y\u00fbz\u00fd{\u00ff\u0000\u0101\u0000\u0103|\u0105\u0000\u0107"+ + "\u0000\u0109}\u010b~\u010d\u007f\u010f\u0080\u0001\u0000\n\u0001\u0000"+ + "09\u0002\u0000EEee\u0002\u0000XXxx\u0003\u000009AFaf\u0004\u0000$$AZ_"+ + "_az\u0005\u0000$$09AZ__az\u0004\u0000\n\n\r\r\"\"\\\\\u0004\u0000\n\n"+ + "\r\r\'\'\\\\\u0003\u0000\t\n\f\r \u0002\u0000\n\n\r\r\u0788\u0000\u0001"+ + "\u0001\u0000\u0000\u0000\u0000\u0003\u0001\u0000\u0000\u0000\u0000\u0005"+ + "\u0001\u0000\u0000\u0000\u0000\u0007\u0001\u0000\u0000\u0000\u0000\t\u0001"+ + "\u0000\u0000\u0000\u0000\u000b\u0001\u0000\u0000\u0000\u0000\r\u0001\u0000"+ + "\u0000\u0000\u0000\u000f\u0001\u0000\u0000\u0000\u0000\u0011\u0001\u0000"+ + "\u0000\u0000\u0000\u0013\u0001\u0000\u0000\u0000\u0000\u0015\u0001\u0000"+ + "\u0000\u0000\u0000\u0017\u0001\u0000\u0000\u0000\u0000\u0019\u0001\u0000"+ + "\u0000\u0000\u0000\u001b\u0001\u0000\u0000\u0000\u0000\u001d\u0001\u0000"+ + "\u0000\u0000\u0000\u001f\u0001\u0000\u0000\u0000\u0000!\u0001\u0000\u0000"+ + "\u0000\u0000#\u0001\u0000\u0000\u0000\u0000%\u0001\u0000\u0000\u0000\u0000"+ + "\'\u0001\u0000\u0000\u0000\u0000)\u0001\u0000\u0000\u0000\u0000+\u0001"+ + "\u0000\u0000\u0000\u0000-\u0001\u0000\u0000\u0000\u0000/\u0001\u0000\u0000"+ + "\u0000\u00001\u0001\u0000\u0000\u0000\u00003\u0001\u0000\u0000\u0000\u0000"+ + "5\u0001\u0000\u0000\u0000\u00007\u0001\u0000\u0000\u0000\u00009\u0001"+ + "\u0000\u0000\u0000\u0000;\u0001\u0000\u0000\u0000\u0000=\u0001\u0000\u0000"+ + "\u0000\u0000?\u0001\u0000\u0000\u0000\u0000A\u0001\u0000\u0000\u0000\u0000"+ + "C\u0001\u0000\u0000\u0000\u0000E\u0001\u0000\u0000\u0000\u0000G\u0001"+ + "\u0000\u0000\u0000\u0000I\u0001\u0000\u0000\u0000\u0000K\u0001\u0000\u0000"+ + "\u0000\u0000M\u0001\u0000\u0000\u0000\u0000O\u0001\u0000\u0000\u0000\u0000"+ + "Q\u0001\u0000\u0000\u0000\u0000S\u0001\u0000\u0000\u0000\u0000U\u0001"+ + "\u0000\u0000\u0000\u0000W\u0001\u0000\u0000\u0000\u0000Y\u0001\u0000\u0000"+ + "\u0000\u0000[\u0001\u0000\u0000\u0000\u0000]\u0001\u0000\u0000\u0000\u0000"+ + "_\u0001\u0000\u0000\u0000\u0000a\u0001\u0000\u0000\u0000\u0000c\u0001"+ + "\u0000\u0000\u0000\u0000e\u0001\u0000\u0000\u0000\u0000g\u0001\u0000\u0000"+ + "\u0000\u0000i\u0001\u0000\u0000\u0000\u0000k\u0001\u0000\u0000\u0000\u0000"+ + "m\u0001\u0000\u0000\u0000\u0000o\u0001\u0000\u0000\u0000\u0000q\u0001"+ + "\u0000\u0000\u0000\u0000s\u0001\u0000\u0000\u0000\u0000u\u0001\u0000\u0000"+ + "\u0000\u0000w\u0001\u0000\u0000\u0000\u0000y\u0001\u0000\u0000\u0000\u0000"+ + "{\u0001\u0000\u0000\u0000\u0000}\u0001\u0000\u0000\u0000\u0000\u007f\u0001"+ + "\u0000\u0000\u0000\u0000\u0081\u0001\u0000\u0000\u0000\u0000\u0083\u0001"+ + "\u0000\u0000\u0000\u0000\u0085\u0001\u0000\u0000\u0000\u0000\u0087\u0001"+ + "\u0000\u0000\u0000\u0000\u0089\u0001\u0000\u0000\u0000\u0000\u008b\u0001"+ + "\u0000\u0000\u0000\u0000\u008d\u0001\u0000\u0000\u0000\u0000\u008f\u0001"+ + "\u0000\u0000\u0000\u0000\u0091\u0001\u0000\u0000\u0000\u0000\u0093\u0001"+ + "\u0000\u0000\u0000\u0000\u0095\u0001\u0000\u0000\u0000\u0000\u0097\u0001"+ + "\u0000\u0000\u0000\u0000\u0099\u0001\u0000\u0000\u0000\u0000\u009b\u0001"+ + "\u0000\u0000\u0000\u0000\u009d\u0001\u0000\u0000\u0000\u0000\u009f\u0001"+ + "\u0000\u0000\u0000\u0000\u00a1\u0001\u0000\u0000\u0000\u0000\u00a3\u0001"+ + "\u0000\u0000\u0000\u0000\u00a5\u0001\u0000\u0000\u0000\u0000\u00a7\u0001"+ + "\u0000\u0000\u0000\u0000\u00a9\u0001\u0000\u0000\u0000\u0000\u00ab\u0001"+ + "\u0000\u0000\u0000\u0000\u00ad\u0001\u0000\u0000\u0000\u0000\u00af\u0001"+ + "\u0000\u0000\u0000\u0000\u00b1\u0001\u0000\u0000\u0000\u0000\u00b3\u0001"+ + "\u0000\u0000\u0000\u0000\u00b5\u0001\u0000\u0000\u0000\u0000\u00b7\u0001"+ + "\u0000\u0000\u0000\u0000\u00b9\u0001\u0000\u0000\u0000\u0000\u00bb\u0001"+ + "\u0000\u0000\u0000\u0000\u00bd\u0001\u0000\u0000\u0000\u0000\u00bf\u0001"+ + "\u0000\u0000\u0000\u0000\u00c1\u0001\u0000\u0000\u0000\u0000\u00c3\u0001"+ + "\u0000\u0000\u0000\u0000\u00c5\u0001\u0000\u0000\u0000\u0000\u00c9\u0001"+ + "\u0000\u0000\u0000\u0000\u00cd\u0001\u0000\u0000\u0000\u0000\u00cf\u0001"+ + "\u0000\u0000\u0000\u0000\u00d5\u0001\u0000\u0000\u0000\u0000\u00d7\u0001"+ + "\u0000\u0000\u0000\u0000\u00d9\u0001\u0000\u0000\u0000\u0000\u00db\u0001"+ + "\u0000\u0000\u0000\u0000\u00dd\u0001\u0000\u0000\u0000\u0000\u00df\u0001"+ + "\u0000\u0000\u0000\u0000\u00e1\u0001\u0000\u0000\u0000\u0000\u00e3\u0001"+ + "\u0000\u0000\u0000\u0000\u00e5\u0001\u0000\u0000\u0000\u0000\u00e7\u0001"+ + "\u0000\u0000\u0000\u0000\u00e9\u0001\u0000\u0000\u0000\u0000\u00eb\u0001"+ + "\u0000\u0000\u0000\u0000\u00ed\u0001\u0000\u0000\u0000\u0000\u00ef\u0001"+ + "\u0000\u0000\u0000\u0000\u00f1\u0001\u0000\u0000\u0000\u0000\u00f3\u0001"+ + "\u0000\u0000\u0000\u0000\u00f5\u0001\u0000\u0000\u0000\u0000\u00f7\u0001"+ + "\u0000\u0000\u0000\u0000\u00f9\u0001\u0000\u0000\u0000\u0000\u00fb\u0001"+ + "\u0000\u0000\u0000\u0000\u00fd\u0001\u0000\u0000\u0000\u0000\u0103\u0001"+ + "\u0000\u0000\u0000\u0000\u0109\u0001\u0000\u0000\u0000\u0000\u010b\u0001"+ + "\u0000\u0000\u0000\u0000\u010d\u0001\u0000\u0000\u0000\u0000\u010f\u0001"+ + "\u0000\u0000\u0000\u0001\u0111\u0001\u0000\u0000\u0000\u0003\u0118\u0001"+ + "\u0000\u0000\u0000\u0005\u011a\u0001\u0000\u0000\u0000\u0007\u011c\u0001"+ + "\u0000\u0000\u0000\t\u011e\u0001\u0000\u0000\u0000\u000b\u0121\u0001\u0000"+ + "\u0000\u0000\r\u0123\u0001\u0000\u0000\u0000\u000f\u0125\u0001\u0000\u0000"+ + "\u0000\u0011\u0128\u0001\u0000\u0000\u0000\u0013\u012a\u0001\u0000\u0000"+ + "\u0000\u0015\u0131\u0001\u0000\u0000\u0000\u0017\u0134\u0001\u0000\u0000"+ + "\u0000\u0019\u0136\u0001\u0000\u0000\u0000\u001b\u013b\u0001\u0000\u0000"+ + "\u0000\u001d\u013d\u0001\u0000\u0000\u0000\u001f\u013f\u0001\u0000\u0000"+ + "\u0000!\u0141\u0001\u0000\u0000\u0000#\u014a\u0001\u0000\u0000\u0000%"+ + "\u0153\u0001\u0000\u0000\u0000\'\u015d\u0001\u0000\u0000\u0000)\u0165"+ + "\u0001\u0000\u0000\u0000+\u0168\u0001\u0000\u0000\u0000-\u016a\u0001\u0000"+ + "\u0000\u0000/\u016c\u0001\u0000\u0000\u00001\u0175\u0001\u0000\u0000\u0000"+ + "3\u017b\u0001\u0000\u0000\u00005\u017f\u0001\u0000\u0000\u00007\u0186"+ + "\u0001\u0000\u0000\u00009\u018f\u0001\u0000\u0000\u0000;\u0198\u0001\u0000"+ + "\u0000\u0000=\u01a0\u0001\u0000\u0000\u0000?\u01a6\u0001\u0000\u0000\u0000"+ + "A\u01ab\u0001\u0000\u0000\u0000C\u01ad\u0001\u0000\u0000\u0000E\u01af"+ + "\u0001\u0000\u0000\u0000G\u01b1\u0001\u0000\u0000\u0000I\u01b9\u0001\u0000"+ + "\u0000\u0000K\u01bc\u0001\u0000\u0000\u0000M\u01c3\u0001\u0000\u0000\u0000"+ + "O\u01cb\u0001\u0000\u0000\u0000Q\u01d4\u0001\u0000\u0000\u0000S\u01d7"+ + "\u0001\u0000\u0000\u0000U\u01dc\u0001\u0000\u0000\u0000W\u01e0\u0001\u0000"+ + "\u0000\u0000Y\u01e6\u0001\u0000\u0000\u0000[\u01ec\u0001\u0000\u0000\u0000"+ + "]\u01f5\u0001\u0000\u0000\u0000_\u01f8\u0001\u0000\u0000\u0000a\u01ff"+ + "\u0001\u0000\u0000\u0000c\u0205\u0001\u0000\u0000\u0000e\u020a\u0001\u0000"+ + "\u0000\u0000g\u020e\u0001\u0000\u0000\u0000i\u0216\u0001\u0000\u0000\u0000"+ + "k\u021b\u0001\u0000\u0000\u0000m\u0222\u0001\u0000\u0000\u0000o\u0227"+ + "\u0001\u0000\u0000\u0000q\u022a\u0001\u0000\u0000\u0000s\u022d\u0001\u0000"+ + "\u0000\u0000u\u0231\u0001\u0000\u0000\u0000w\u0233\u0001\u0000\u0000\u0000"+ + "y\u0235\u0001\u0000\u0000\u0000{\u0237\u0001\u0000\u0000\u0000}\u023d"+ + "\u0001\u0000\u0000\u0000\u007f\u0244\u0001\u0000\u0000\u0000\u0081\u0246"+ + "\u0001\u0000\u0000\u0000\u0083\u0249\u0001\u0000\u0000\u0000\u0085\u024b"+ + "\u0001\u0000\u0000\u0000\u0087\u024d\u0001\u0000\u0000\u0000\u0089\u0250"+ + "\u0001\u0000\u0000\u0000\u008b\u0253\u0001\u0000\u0000\u0000\u008d\u0255"+ + "\u0001\u0000\u0000\u0000\u008f\u0257\u0001\u0000\u0000\u0000\u0091\u025a"+ + "\u0001\u0000\u0000\u0000\u0093\u025d\u0001\u0000\u0000\u0000\u0095\u0260"+ + "\u0001\u0000\u0000\u0000\u0097\u0263\u0001\u0000\u0000\u0000\u0099\u0265"+ + "\u0001\u0000\u0000\u0000\u009b\u0268\u0001\u0000\u0000\u0000\u009d\u026b"+ + "\u0001\u0000\u0000\u0000\u009f\u026e\u0001\u0000\u0000\u0000\u00a1\u0272"+ + "\u0001\u0000\u0000\u0000\u00a3\u0276\u0001\u0000\u0000\u0000\u00a5\u0279"+ + "\u0001\u0000\u0000\u0000\u00a7\u027c\u0001\u0000\u0000\u0000\u00a9\u027f"+ + "\u0001\u0000\u0000\u0000\u00ab\u0282\u0001\u0000\u0000\u0000\u00ad\u0285"+ + "\u0001\u0000\u0000\u0000\u00af\u0289\u0001\u0000\u0000\u0000\u00b1\u028c"+ + "\u0001\u0000\u0000\u0000\u00b3\u028f\u0001\u0000\u0000\u0000\u00b5\u0296"+ + "\u0001\u0000\u0000\u0000\u00b7\u029b\u0001\u0000\u0000\u0000\u00b9\u0359"+ + "\u0001\u0000\u0000\u0000\u00bb\u0432\u0001\u0000\u0000\u0000\u00bd\u0510"+ + "\u0001\u0000\u0000\u0000\u00bf\u0528\u0001\u0000\u0000\u0000\u00c1\u0542"+ + "\u0001\u0000\u0000\u0000\u00c3\u054d\u0001\u0000\u0000\u0000\u00c5\u0555"+ + "\u0001\u0000\u0000\u0000\u00c7\u055e\u0001\u0000\u0000\u0000\u00c9\u0568"+ + "\u0001\u0000\u0000\u0000\u00cb\u056c\u0001\u0000\u0000\u0000\u00cd\u05aa"+ + "\u0001\u0000\u0000\u0000\u00cf\u05ac\u0001\u0000\u0000\u0000\u00d1\u05bc"+ + "\u0001\u0000\u0000\u0000\u00d3\u05bf\u0001\u0000\u0000\u0000\u00d5\u0609"+ + "\u0001\u0000\u0000\u0000\u00d7\u060b\u0001\u0000\u0000\u0000\u00d9\u0615"+ + "\u0001\u0000\u0000\u0000\u00db\u061b\u0001\u0000\u0000\u0000\u00dd\u0624"+ + "\u0001\u0000\u0000\u0000\u00df\u062e\u0001\u0000\u0000\u0000\u00e1\u0637"+ + "\u0001\u0000\u0000\u0000\u00e3\u063d\u0001\u0000\u0000\u0000\u00e5\u0646"+ + "\u0001\u0000\u0000\u0000\u00e7\u064e\u0001\u0000\u0000\u0000\u00e9\u0657"+ + "\u0001\u0000\u0000\u0000\u00eb\u065f\u0001\u0000\u0000\u0000\u00ed\u0667"+ + "\u0001\u0000\u0000\u0000\u00ef\u066e\u0001\u0000\u0000\u0000\u00f1\u0676"+ + "\u0001\u0000\u0000\u0000\u00f3\u067b\u0001\u0000\u0000\u0000\u00f5\u0680"+ + "\u0001\u0000\u0000\u0000\u00f7\u0685\u0001\u0000\u0000\u0000\u00f9\u0691"+ + "\u0001\u0000\u0000\u0000\u00fb\u069a\u0001\u0000\u0000\u0000\u00fd\u06a2"+ + "\u0001\u0000\u0000\u0000\u00ff\u06a9\u0001\u0000\u0000\u0000\u0101\u06ab"+ + "\u0001\u0000\u0000\u0000\u0103\u06bd\u0001\u0000\u0000\u0000\u0105\u06c2"+ + "\u0001\u0000\u0000\u0000\u0107\u06c7\u0001\u0000\u0000\u0000\u0109\u06ca"+ + "\u0001\u0000\u0000\u0000\u010b\u06dd\u0001\u0000\u0000\u0000\u010d\u06e3"+ + "\u0001\u0000\u0000\u0000\u010f\u06f1\u0001\u0000\u0000\u0000\u0111\u0112"+ + "\u0005p\u0000\u0000\u0112\u0113\u0005r\u0000\u0000\u0113\u0114\u0005a"+ + "\u0000\u0000\u0114\u0115\u0005g\u0000\u0000\u0115\u0116\u0005m\u0000\u0000"+ + "\u0116\u0117\u0005a\u0000\u0000\u0117\u0002\u0001\u0000\u0000\u0000\u0118"+ + "\u0119\u0005;\u0000\u0000\u0119\u0004\u0001\u0000\u0000\u0000\u011a\u011b"+ + "\u0005^\u0000\u0000\u011b\u0006\u0001\u0000\u0000\u0000\u011c\u011d\u0005"+ + "~\u0000\u0000\u011d\b\u0001\u0000\u0000\u0000\u011e\u011f\u0005>\u0000"+ + "\u0000\u011f\u0120\u0005=\u0000\u0000\u0120\n\u0001\u0000\u0000\u0000"+ + "\u0121\u0122\u0005>\u0000\u0000\u0122\f\u0001\u0000\u0000\u0000\u0123"+ + "\u0124\u0005<\u0000\u0000\u0124\u000e\u0001\u0000\u0000\u0000\u0125\u0126"+ + "\u0005<\u0000\u0000\u0126\u0127\u0005=\u0000\u0000\u0127\u0010\u0001\u0000"+ + "\u0000\u0000\u0128\u0129\u0005=\u0000\u0000\u0129\u0012\u0001\u0000\u0000"+ + "\u0000\u012a\u012b\u0005i\u0000\u0000\u012b\u012c\u0005m\u0000\u0000\u012c"+ + "\u012d\u0005p\u0000\u0000\u012d\u012e\u0005o\u0000\u0000\u012e\u012f\u0005"+ + "r\u0000\u0000\u012f\u0130\u0005t\u0000\u0000\u0130\u0014\u0001\u0000\u0000"+ + "\u0000\u0131\u0132\u0005a\u0000\u0000\u0132\u0133\u0005s\u0000\u0000\u0133"+ + "\u0016\u0001\u0000\u0000\u0000\u0134\u0135\u0005*\u0000\u0000\u0135\u0018"+ + "\u0001\u0000\u0000\u0000\u0136\u0137\u0005f\u0000\u0000\u0137\u0138\u0005"+ + "r\u0000\u0000\u0138\u0139\u0005o\u0000\u0000\u0139\u013a\u0005m\u0000"+ + "\u0000\u013a\u001a\u0001\u0000\u0000\u0000\u013b\u013c\u0005{\u0000\u0000"+ + "\u013c\u001c\u0001\u0000\u0000\u0000\u013d\u013e\u0005,\u0000\u0000\u013e"+ + "\u001e\u0001\u0000\u0000\u0000\u013f\u0140\u0005}\u0000\u0000\u0140 \u0001"+ + "\u0000\u0000\u0000\u0141\u0142\u0005a\u0000\u0000\u0142\u0143\u0005b\u0000"+ + "\u0000\u0143\u0144\u0005s\u0000\u0000\u0144\u0145\u0005t\u0000\u0000\u0145"+ + "\u0146\u0005r\u0000\u0000\u0146\u0147\u0005a\u0000\u0000\u0147\u0148\u0005"+ + "c\u0000\u0000\u0148\u0149\u0005t\u0000\u0000\u0149\"\u0001\u0000\u0000"+ + "\u0000\u014a\u014b\u0005c\u0000\u0000\u014b\u014c\u0005o\u0000\u0000\u014c"+ + "\u014d\u0005n\u0000\u0000\u014d\u014e\u0005t\u0000\u0000\u014e\u014f\u0005"+ + "r\u0000\u0000\u014f\u0150\u0005a\u0000\u0000\u0150\u0151\u0005c\u0000"+ + "\u0000\u0151\u0152\u0005t\u0000\u0000\u0152$\u0001\u0000\u0000\u0000\u0153"+ + "\u0154\u0005i\u0000\u0000\u0154\u0155\u0005n\u0000\u0000\u0155\u0156\u0005"+ + "t\u0000\u0000\u0156\u0157\u0005e\u0000\u0000\u0157\u0158\u0005r\u0000"+ + "\u0000\u0158\u0159\u0005f\u0000\u0000\u0159\u015a\u0005a\u0000\u0000\u015a"+ + "\u015b\u0005c\u0000\u0000\u015b\u015c\u0005e\u0000\u0000\u015c&\u0001"+ + "\u0000\u0000\u0000\u015d\u015e\u0005l\u0000\u0000\u015e\u015f\u0005i\u0000"+ + "\u0000\u015f\u0160\u0005b\u0000\u0000\u0160\u0161\u0005r\u0000\u0000\u0161"+ + "\u0162\u0005a\u0000\u0000\u0162\u0163\u0005r\u0000\u0000\u0163\u0164\u0005"+ + "y\u0000\u0000\u0164(\u0001\u0000\u0000\u0000\u0165\u0166\u0005i\u0000"+ + "\u0000\u0166\u0167\u0005s\u0000\u0000\u0167*\u0001\u0000\u0000\u0000\u0168"+ + "\u0169\u0005(\u0000\u0000\u0169,\u0001\u0000\u0000\u0000\u016a\u016b\u0005"+ + ")\u0000\u0000\u016b.\u0001\u0000\u0000\u0000\u016c\u016d\u0005o\u0000"+ + "\u0000\u016d\u016e\u0005v\u0000\u0000\u016e\u016f\u0005e\u0000\u0000\u016f"+ + "\u0170\u0005r\u0000\u0000\u0170\u0171\u0005r\u0000\u0000\u0171\u0172\u0005"+ + "i\u0000\u0000\u0172\u0173\u0005d\u0000\u0000\u0173\u0174\u0005e\u0000"+ + "\u0000\u01740\u0001\u0000\u0000\u0000\u0175\u0176\u0005u\u0000\u0000\u0176"+ + "\u0177\u0005s\u0000\u0000\u0177\u0178\u0005i\u0000\u0000\u0178\u0179\u0005"+ + "n\u0000\u0000\u0179\u017a\u0005g\u0000\u0000\u017a2\u0001\u0000\u0000"+ + "\u0000\u017b\u017c\u0005f\u0000\u0000\u017c\u017d\u0005o\u0000\u0000\u017d"+ + "\u017e\u0005r\u0000\u0000\u017e4\u0001\u0000\u0000\u0000\u017f\u0180\u0005"+ + "s\u0000\u0000\u0180\u0181\u0005t\u0000\u0000\u0181\u0182\u0005r\u0000"+ + "\u0000\u0182\u0183\u0005u\u0000\u0000\u0183\u0184\u0005c\u0000\u0000\u0184"+ + "\u0185\u0005t\u0000\u0000\u01856\u0001\u0000\u0000\u0000\u0186\u0187\u0005"+ + "m\u0000\u0000\u0187\u0188\u0005o\u0000\u0000\u0188\u0189\u0005d\u0000"+ + "\u0000\u0189\u018a\u0005i\u0000\u0000\u018a\u018b\u0005f\u0000\u0000\u018b"+ + "\u018c\u0005i\u0000\u0000\u018c\u018d\u0005e\u0000\u0000\u018d\u018e\u0005"+ + "r\u0000\u0000\u018e8\u0001\u0000\u0000\u0000\u018f\u0190\u0005f\u0000"+ + "\u0000\u0190\u0191\u0005u\u0000\u0000\u0191\u0192\u0005n\u0000\u0000\u0192"+ + "\u0193\u0005c\u0000\u0000\u0193\u0194\u0005t\u0000\u0000\u0194\u0195\u0005"+ + "i\u0000\u0000\u0195\u0196\u0005o\u0000\u0000\u0196\u0197\u0005n\u0000"+ + "\u0000\u0197:\u0001\u0000\u0000\u0000\u0198\u0199\u0005r\u0000\u0000\u0199"+ + "\u019a\u0005e\u0000\u0000\u019a\u019b\u0005t\u0000\u0000\u019b\u019c\u0005"+ + "u\u0000\u0000\u019c\u019d\u0005r\u0000\u0000\u019d\u019e\u0005n\u0000"+ + "\u0000\u019e\u019f\u0005s\u0000\u0000\u019f<\u0001\u0000\u0000\u0000\u01a0"+ + "\u01a1\u0005e\u0000\u0000\u01a1\u01a2\u0005v\u0000\u0000\u01a2\u01a3\u0005"+ + "e\u0000\u0000\u01a3\u01a4\u0005n\u0000\u0000\u01a4\u01a5\u0005t\u0000"+ + "\u0000\u01a5>\u0001\u0000\u0000\u0000\u01a6\u01a7\u0005e\u0000\u0000\u01a7"+ + "\u01a8\u0005n\u0000\u0000\u01a8\u01a9\u0005u\u0000\u0000\u01a9\u01aa\u0005"+ + "m\u0000\u0000\u01aa@\u0001\u0000\u0000\u0000\u01ab\u01ac\u0005[\u0000"+ + "\u0000\u01acB\u0001\u0000\u0000\u0000\u01ad\u01ae\u0005]\u0000\u0000\u01ae"+ + "D\u0001\u0000\u0000\u0000\u01af\u01b0\u0005.\u0000\u0000\u01b0F\u0001"+ + "\u0000\u0000\u0000\u01b1\u01b2\u0005m\u0000\u0000\u01b2\u01b3\u0005a\u0000"+ + "\u0000\u01b3\u01b4\u0005p\u0000\u0000\u01b4\u01b5\u0005p\u0000\u0000\u01b5"+ + "\u01b6\u0005i\u0000\u0000\u01b6\u01b7\u0005n\u0000\u0000\u01b7\u01b8\u0005"+ + "g\u0000\u0000\u01b8H\u0001\u0000\u0000\u0000\u01b9\u01ba\u0005=\u0000"+ + "\u0000\u01ba\u01bb\u0005>\u0000\u0000\u01bbJ\u0001\u0000\u0000\u0000\u01bc"+ + "\u01bd\u0005m\u0000\u0000\u01bd\u01be\u0005e\u0000\u0000\u01be\u01bf\u0005"+ + "m\u0000\u0000\u01bf\u01c0\u0005o\u0000\u0000\u01c0\u01c1\u0005r\u0000"+ + "\u0000\u01c1\u01c2\u0005y\u0000\u0000\u01c2L\u0001\u0000\u0000\u0000\u01c3"+ + "\u01c4\u0005s\u0000\u0000\u01c4\u01c5\u0005t\u0000\u0000\u01c5\u01c6\u0005"+ + "o\u0000\u0000\u01c6\u01c7\u0005r\u0000\u0000\u01c7\u01c8\u0005a\u0000"+ + "\u0000\u01c8\u01c9\u0005g\u0000\u0000\u01c9\u01ca\u0005e\u0000\u0000\u01ca"+ + "N\u0001\u0000\u0000\u0000\u01cb\u01cc\u0005c\u0000\u0000\u01cc\u01cd\u0005"+ + "a\u0000\u0000\u01cd\u01ce\u0005l\u0000\u0000\u01ce\u01cf\u0005l\u0000"+ + "\u0000\u01cf\u01d0\u0005d\u0000\u0000\u01d0\u01d1\u0005a\u0000\u0000\u01d1"+ + "\u01d2\u0005t\u0000\u0000\u01d2\u01d3\u0005a\u0000\u0000\u01d3P\u0001"+ + "\u0000\u0000\u0000\u01d4\u01d5\u0005i\u0000\u0000\u01d5\u01d6\u0005f\u0000"+ + "\u0000\u01d6R\u0001\u0000\u0000\u0000\u01d7\u01d8\u0005e\u0000\u0000\u01d8"+ + "\u01d9\u0005l\u0000\u0000\u01d9\u01da\u0005s\u0000\u0000\u01da\u01db\u0005"+ + "e\u0000\u0000\u01dbT\u0001\u0000\u0000\u0000\u01dc\u01dd\u0005t\u0000"+ + "\u0000\u01dd\u01de\u0005r\u0000\u0000\u01de\u01df\u0005y\u0000\u0000\u01df"+ + "V\u0001\u0000\u0000\u0000\u01e0\u01e1\u0005c\u0000\u0000\u01e1\u01e2\u0005"+ + "a\u0000\u0000\u01e2\u01e3\u0005t\u0000\u0000\u01e3\u01e4\u0005c\u0000"+ + "\u0000\u01e4\u01e5\u0005h\u0000\u0000\u01e5X\u0001\u0000\u0000\u0000\u01e6"+ + "\u01e7\u0005w\u0000\u0000\u01e7\u01e8\u0005h\u0000\u0000\u01e8\u01e9\u0005"+ + "i\u0000\u0000\u01e9\u01ea\u0005l\u0000\u0000\u01ea\u01eb\u0005e\u0000"+ + "\u0000\u01ebZ\u0001\u0000\u0000\u0000\u01ec\u01ed\u0005a\u0000\u0000\u01ed"+ + "\u01ee\u0005s\u0000\u0000\u01ee\u01ef\u0005s\u0000\u0000\u01ef\u01f0\u0005"+ + "e\u0000\u0000\u01f0\u01f1\u0005m\u0000\u0000\u01f1\u01f2\u0005b\u0000"+ + "\u0000\u01f2\u01f3\u0005l\u0000\u0000\u01f3\u01f4\u0005y\u0000\u0000\u01f4"+ + "\\\u0001\u0000\u0000\u0000\u01f5\u01f6\u0005d\u0000\u0000\u01f6\u01f7"+ + "\u0005o\u0000\u0000\u01f7^\u0001\u0000\u0000\u0000\u01f8\u01f9\u0005r"+ + "\u0000\u0000\u01f9\u01fa\u0005e\u0000\u0000\u01fa\u01fb\u0005t\u0000\u0000"+ + "\u01fb\u01fc\u0005u\u0000\u0000\u01fc\u01fd\u0005r\u0000\u0000\u01fd\u01fe"+ + "\u0005n\u0000\u0000\u01fe`\u0001\u0000\u0000\u0000\u01ff\u0200\u0005t"+ + "\u0000\u0000\u0200\u0201\u0005h\u0000\u0000\u0201\u0202\u0005r\u0000\u0000"+ + "\u0202\u0203\u0005o\u0000\u0000\u0203\u0204\u0005w\u0000\u0000\u0204b"+ + "\u0001\u0000\u0000\u0000\u0205\u0206\u0005e\u0000\u0000\u0206\u0207\u0005"+ + "m\u0000\u0000\u0207\u0208\u0005i\u0000\u0000\u0208\u0209\u0005t\u0000"+ + "\u0000\u0209d\u0001\u0000\u0000\u0000\u020a\u020b\u0005v\u0000\u0000\u020b"+ + "\u020c\u0005a\u0000\u0000\u020c\u020d\u0005r\u0000\u0000\u020df\u0001"+ + "\u0000\u0000\u0000\u020e\u020f\u0005a\u0000\u0000\u020f\u0210\u0005d\u0000"+ + "\u0000\u0210\u0211\u0005d\u0000\u0000\u0211\u0212\u0005r\u0000\u0000\u0212"+ + "\u0213\u0005e\u0000\u0000\u0213\u0214\u0005s\u0000\u0000\u0214\u0215\u0005"+ + "s\u0000\u0000\u0215h\u0001\u0000\u0000\u0000\u0216\u0217\u0005b\u0000"+ + "\u0000\u0217\u0218\u0005o\u0000\u0000\u0218\u0219\u0005o\u0000\u0000\u0219"+ + "\u021a\u0005l\u0000\u0000\u021aj\u0001\u0000\u0000\u0000\u021b\u021c\u0005"+ + "s\u0000\u0000\u021c\u021d\u0005t\u0000\u0000\u021d\u021e\u0005r\u0000"+ + "\u0000\u021e\u021f\u0005i\u0000\u0000\u021f\u0220\u0005n\u0000\u0000\u0220"+ + "\u0221\u0005g\u0000\u0000\u0221l\u0001\u0000\u0000\u0000\u0222\u0223\u0005"+ + "b\u0000\u0000\u0223\u0224\u0005y\u0000\u0000\u0224\u0225\u0005t\u0000"+ + "\u0000\u0225\u0226\u0005e\u0000\u0000\u0226n\u0001\u0000\u0000\u0000\u0227"+ + "\u0228\u0005+\u0000\u0000\u0228\u0229\u0005+\u0000\u0000\u0229p\u0001"+ + "\u0000\u0000\u0000\u022a\u022b\u0005-\u0000\u0000\u022b\u022c\u0005-\u0000"+ + "\u0000\u022cr\u0001\u0000\u0000\u0000\u022d\u022e\u0005n\u0000\u0000\u022e"+ + "\u022f\u0005e\u0000\u0000\u022f\u0230\u0005w\u0000\u0000\u0230t\u0001"+ + "\u0000\u0000\u0000\u0231\u0232\u0005:\u0000\u0000\u0232v\u0001\u0000\u0000"+ + "\u0000\u0233\u0234\u0005+\u0000\u0000\u0234x\u0001\u0000\u0000\u0000\u0235"+ + "\u0236\u0005-\u0000\u0000\u0236z\u0001\u0000\u0000\u0000\u0237\u0238\u0005"+ + "a\u0000\u0000\u0238\u0239\u0005f\u0000\u0000\u0239\u023a\u0005t\u0000"+ + "\u0000\u023a\u023b\u0005e\u0000\u0000\u023b\u023c\u0005r\u0000\u0000\u023c"+ + "|\u0001\u0000\u0000\u0000\u023d\u023e\u0005d\u0000\u0000\u023e\u023f\u0005"+ + "e\u0000\u0000\u023f\u0240\u0005l\u0000\u0000\u0240\u0241\u0005e\u0000"+ + "\u0000\u0241\u0242\u0005t\u0000\u0000\u0242\u0243\u0005e\u0000\u0000\u0243"+ + "~\u0001\u0000\u0000\u0000\u0244\u0245\u0005!\u0000\u0000\u0245\u0080\u0001"+ + "\u0000\u0000\u0000\u0246\u0247\u0005*\u0000\u0000\u0247\u0248\u0005*\u0000"+ + "\u0000\u0248\u0082\u0001\u0000\u0000\u0000\u0249\u024a\u0005/\u0000\u0000"+ + "\u024a\u0084\u0001\u0000\u0000\u0000\u024b\u024c\u0005%\u0000\u0000\u024c"+ + "\u0086\u0001\u0000\u0000\u0000\u024d\u024e\u0005<\u0000\u0000\u024e\u024f"+ + "\u0005<\u0000\u0000\u024f\u0088\u0001\u0000\u0000\u0000\u0250\u0251\u0005"+ + ">\u0000\u0000\u0251\u0252\u0005>\u0000\u0000\u0252\u008a\u0001\u0000\u0000"+ + "\u0000\u0253\u0254\u0005&\u0000\u0000\u0254\u008c\u0001\u0000\u0000\u0000"+ + "\u0255\u0256\u0005|\u0000\u0000\u0256\u008e\u0001\u0000\u0000\u0000\u0257"+ + "\u0258\u0005=\u0000\u0000\u0258\u0259\u0005=\u0000\u0000\u0259\u0090\u0001"+ + "\u0000\u0000\u0000\u025a\u025b\u0005!\u0000\u0000\u025b\u025c\u0005=\u0000"+ + "\u0000\u025c\u0092\u0001\u0000\u0000\u0000\u025d\u025e\u0005&\u0000\u0000"+ + "\u025e\u025f\u0005&\u0000\u0000\u025f\u0094\u0001\u0000\u0000\u0000\u0260"+ + "\u0261\u0005|\u0000\u0000\u0261\u0262\u0005|\u0000\u0000\u0262\u0096\u0001"+ + "\u0000\u0000\u0000\u0263\u0264\u0005?\u0000\u0000\u0264\u0098\u0001\u0000"+ + "\u0000\u0000\u0265\u0266\u0005|\u0000\u0000\u0266\u0267\u0005=\u0000\u0000"+ + "\u0267\u009a\u0001\u0000\u0000\u0000\u0268\u0269\u0005^\u0000\u0000\u0269"+ + "\u026a\u0005=\u0000\u0000\u026a\u009c\u0001\u0000\u0000\u0000\u026b\u026c"+ + "\u0005&\u0000\u0000\u026c\u026d\u0005=\u0000\u0000\u026d\u009e\u0001\u0000"+ + "\u0000\u0000\u026e\u026f\u0005<\u0000\u0000\u026f\u0270\u0005<\u0000\u0000"+ + "\u0270\u0271\u0005=\u0000\u0000\u0271\u00a0\u0001\u0000\u0000\u0000\u0272"+ + "\u0273\u0005>\u0000\u0000\u0273\u0274\u0005>\u0000\u0000\u0274\u0275\u0005"+ + "=\u0000\u0000\u0275\u00a2\u0001\u0000\u0000\u0000\u0276\u0277\u0005+\u0000"+ + "\u0000\u0277\u0278\u0005=\u0000\u0000\u0278\u00a4\u0001\u0000\u0000\u0000"+ + "\u0279\u027a\u0005-\u0000\u0000\u027a\u027b\u0005=\u0000\u0000\u027b\u00a6"+ + "\u0001\u0000\u0000\u0000\u027c\u027d\u0005*\u0000\u0000\u027d\u027e\u0005"+ + "=\u0000\u0000\u027e\u00a8\u0001\u0000\u0000\u0000\u027f\u0280\u0005/\u0000"+ + "\u0000\u0280\u0281\u0005=\u0000\u0000\u0281\u00aa\u0001\u0000\u0000\u0000"+ + "\u0282\u0283\u0005%\u0000\u0000\u0283\u0284\u0005=\u0000\u0000\u0284\u00ac"+ + "\u0001\u0000\u0000\u0000\u0285\u0286\u0005l\u0000\u0000\u0286\u0287\u0005"+ + "e\u0000\u0000\u0287\u0288\u0005t\u0000\u0000\u0288\u00ae\u0001\u0000\u0000"+ + "\u0000\u0289\u028a\u0005:\u0000\u0000\u028a\u028b\u0005=\u0000\u0000\u028b"+ + "\u00b0\u0001\u0000\u0000\u0000\u028c\u028d\u0005=\u0000\u0000\u028d\u028e"+ + "\u0005:\u0000\u0000\u028e\u00b2\u0001\u0000\u0000\u0000\u028f\u0290\u0005"+ + "s\u0000\u0000\u0290\u0291\u0005w\u0000\u0000\u0291\u0292\u0005i\u0000"+ + "\u0000\u0292\u0293\u0005t\u0000\u0000\u0293\u0294\u0005c\u0000\u0000\u0294"+ + "\u0295\u0005h\u0000\u0000\u0295\u00b4\u0001\u0000\u0000\u0000\u0296\u0297"+ + "\u0005c\u0000\u0000\u0297\u0298\u0005a\u0000\u0000\u0298\u0299\u0005s"+ + "\u0000\u0000\u0299\u029a\u0005e\u0000\u0000\u029a\u00b6\u0001\u0000\u0000"+ + "\u0000\u029b\u029c\u0005d\u0000\u0000\u029c\u029d\u0005e\u0000\u0000\u029d"+ + "\u029e\u0005f\u0000\u0000\u029e\u029f\u0005a\u0000\u0000\u029f\u02a0\u0005"+ + "u\u0000\u0000\u02a0\u02a1\u0005l\u0000\u0000\u02a1\u02a2\u0005t\u0000"+ + "\u0000\u02a2\u00b8\u0001\u0000\u0000\u0000\u02a3\u02a4\u0005i\u0000\u0000"+ + "\u02a4\u02a5\u0005n\u0000\u0000\u02a5\u035a\u0005t\u0000\u0000\u02a6\u02a7"+ + "\u0005i\u0000\u0000\u02a7\u02a8\u0005n\u0000\u0000\u02a8\u02a9\u0005t"+ + "\u0000\u0000\u02a9\u035a\u00058\u0000\u0000\u02aa\u02ab\u0005i\u0000\u0000"+ + "\u02ab\u02ac\u0005n\u0000\u0000\u02ac\u02ad\u0005t\u0000\u0000\u02ad\u02ae"+ + "\u00051\u0000\u0000\u02ae\u035a\u00056\u0000\u0000\u02af\u02b0\u0005i"+ + "\u0000\u0000\u02b0\u02b1\u0005n\u0000\u0000\u02b1\u02b2\u0005t\u0000\u0000"+ + "\u02b2\u02b3\u00052\u0000\u0000\u02b3\u035a\u00054\u0000\u0000\u02b4\u02b5"+ + "\u0005i\u0000\u0000\u02b5\u02b6\u0005n\u0000\u0000\u02b6\u02b7\u0005t"+ + "\u0000\u0000\u02b7\u02b8\u00053\u0000\u0000\u02b8\u035a\u00052\u0000\u0000"+ + "\u02b9\u02ba\u0005i\u0000\u0000\u02ba\u02bb\u0005n\u0000\u0000\u02bb\u02bc"+ + "\u0005t\u0000\u0000\u02bc\u02bd\u00054\u0000\u0000\u02bd\u035a\u00050"+ + "\u0000\u0000\u02be\u02bf\u0005i\u0000\u0000\u02bf\u02c0\u0005n\u0000\u0000"+ + "\u02c0\u02c1\u0005t\u0000\u0000\u02c1\u02c2\u00054\u0000\u0000\u02c2\u035a"+ + "\u00058\u0000\u0000\u02c3\u02c4\u0005i\u0000\u0000\u02c4\u02c5\u0005n"+ + "\u0000\u0000\u02c5\u02c6\u0005t\u0000\u0000\u02c6\u02c7\u00055\u0000\u0000"+ + "\u02c7\u035a\u00056\u0000\u0000\u02c8\u02c9\u0005i\u0000\u0000\u02c9\u02ca"+ + "\u0005n\u0000\u0000\u02ca\u02cb\u0005t\u0000\u0000\u02cb\u02cc\u00056"+ + "\u0000\u0000\u02cc\u035a\u00054\u0000\u0000\u02cd\u02ce\u0005i\u0000\u0000"+ + "\u02ce\u02cf\u0005n\u0000\u0000\u02cf\u02d0\u0005t\u0000\u0000\u02d0\u02d1"+ + "\u00057\u0000\u0000\u02d1\u035a\u00052\u0000\u0000\u02d2\u02d3\u0005i"+ + "\u0000\u0000\u02d3\u02d4\u0005n\u0000\u0000\u02d4\u02d5\u0005t\u0000\u0000"+ + "\u02d5\u02d6\u00058\u0000\u0000\u02d6\u035a\u00050\u0000\u0000\u02d7\u02d8"+ + "\u0005i\u0000\u0000\u02d8\u02d9\u0005n\u0000\u0000\u02d9\u02da\u0005t"+ + "\u0000\u0000\u02da\u02db\u00058\u0000\u0000\u02db\u035a\u00058\u0000\u0000"+ + "\u02dc\u02dd\u0005i\u0000\u0000\u02dd\u02de\u0005n\u0000\u0000\u02de\u02df"+ + "\u0005t\u0000\u0000\u02df\u02e0\u00059\u0000\u0000\u02e0\u035a\u00056"+ + "\u0000\u0000\u02e1\u02e2\u0005i\u0000\u0000\u02e2\u02e3\u0005n\u0000\u0000"+ + "\u02e3\u02e4\u0005t\u0000\u0000\u02e4\u02e5\u00051\u0000\u0000\u02e5\u02e6"+ + "\u00050\u0000\u0000\u02e6\u035a\u00054\u0000\u0000\u02e7\u02e8\u0005i"+ + "\u0000\u0000\u02e8\u02e9\u0005n\u0000\u0000\u02e9\u02ea\u0005t\u0000\u0000"+ + "\u02ea\u02eb\u00051\u0000\u0000\u02eb\u02ec\u00051\u0000\u0000\u02ec\u035a"+ + "\u00052\u0000\u0000\u02ed\u02ee\u0005i\u0000\u0000\u02ee\u02ef\u0005n"+ + "\u0000\u0000\u02ef\u02f0\u0005t\u0000\u0000\u02f0\u02f1\u00051\u0000\u0000"+ + "\u02f1\u02f2\u00052\u0000\u0000\u02f2\u035a\u00050\u0000\u0000\u02f3\u02f4"+ + "\u0005i\u0000\u0000\u02f4\u02f5\u0005n\u0000\u0000\u02f5\u02f6\u0005t"+ + "\u0000\u0000\u02f6\u02f7\u00051\u0000\u0000\u02f7\u02f8\u00052\u0000\u0000"+ + "\u02f8\u035a\u00058\u0000\u0000\u02f9\u02fa\u0005i\u0000\u0000\u02fa\u02fb"+ + "\u0005n\u0000\u0000\u02fb\u02fc\u0005t\u0000\u0000\u02fc\u02fd\u00051"+ + "\u0000\u0000\u02fd\u02fe\u00053\u0000\u0000\u02fe\u035a\u00056\u0000\u0000"+ + "\u02ff\u0300\u0005i\u0000\u0000\u0300\u0301\u0005n\u0000\u0000\u0301\u0302"+ + "\u0005t\u0000\u0000\u0302\u0303\u00051\u0000\u0000\u0303\u0304\u00054"+ + "\u0000\u0000\u0304\u035a\u00054\u0000\u0000\u0305\u0306\u0005i\u0000\u0000"+ + "\u0306\u0307\u0005n\u0000\u0000\u0307\u0308\u0005t\u0000\u0000\u0308\u0309"+ + "\u00051\u0000\u0000\u0309\u030a\u00055\u0000\u0000\u030a\u035a\u00052"+ + "\u0000\u0000\u030b\u030c\u0005i\u0000\u0000\u030c\u030d\u0005n\u0000\u0000"+ + "\u030d\u030e\u0005t\u0000\u0000\u030e\u030f\u00051\u0000\u0000\u030f\u0310"+ + "\u00056\u0000\u0000\u0310\u035a\u00050\u0000\u0000\u0311\u0312\u0005i"+ + "\u0000\u0000\u0312\u0313\u0005n\u0000\u0000\u0313\u0314\u0005t\u0000\u0000"+ + "\u0314\u0315\u00051\u0000\u0000\u0315\u0316\u00056\u0000\u0000\u0316\u035a"+ + "\u00058\u0000\u0000\u0317\u0318\u0005i\u0000\u0000\u0318\u0319\u0005n"+ + "\u0000\u0000\u0319\u031a\u0005t\u0000\u0000\u031a\u031b\u00051\u0000\u0000"+ + "\u031b\u031c\u00057\u0000\u0000\u031c\u035a\u00056\u0000\u0000\u031d\u031e"+ + "\u0005i\u0000\u0000\u031e\u031f\u0005n\u0000\u0000\u031f\u0320\u0005t"+ + "\u0000\u0000\u0320\u0321\u00051\u0000\u0000\u0321\u0322\u00058\u0000\u0000"+ + "\u0322\u035a\u00054\u0000\u0000\u0323\u0324\u0005i\u0000\u0000\u0324\u0325"+ + "\u0005n\u0000\u0000\u0325\u0326\u0005t\u0000\u0000\u0326\u0327\u00051"+ + "\u0000\u0000\u0327\u0328\u00059\u0000\u0000\u0328\u035a\u00052\u0000\u0000"+ + "\u0329\u032a\u0005i\u0000\u0000\u032a\u032b\u0005n\u0000\u0000\u032b\u032c"+ + "\u0005t\u0000\u0000\u032c\u032d\u00052\u0000\u0000\u032d\u032e\u00050"+ + "\u0000\u0000\u032e\u035a\u00050\u0000\u0000\u032f\u0330\u0005i\u0000\u0000"+ + "\u0330\u0331\u0005n\u0000\u0000\u0331\u0332\u0005t\u0000\u0000\u0332\u0333"+ + "\u00052\u0000\u0000\u0333\u0334\u00050\u0000\u0000\u0334\u035a\u00058"+ + "\u0000\u0000\u0335\u0336\u0005i\u0000\u0000\u0336\u0337\u0005n\u0000\u0000"+ + "\u0337\u0338\u0005t\u0000\u0000\u0338\u0339\u00052\u0000\u0000\u0339\u033a"+ + "\u00051\u0000\u0000\u033a\u035a\u00056\u0000\u0000\u033b\u033c\u0005i"+ + "\u0000\u0000\u033c\u033d\u0005n\u0000\u0000\u033d\u033e\u0005t\u0000\u0000"+ + "\u033e\u033f\u00052\u0000\u0000\u033f\u0340\u00052\u0000\u0000\u0340\u035a"+ + "\u00054\u0000\u0000\u0341\u0342\u0005i\u0000\u0000\u0342\u0343\u0005n"+ + "\u0000\u0000\u0343\u0344\u0005t\u0000\u0000\u0344\u0345\u00052\u0000\u0000"+ + "\u0345\u0346\u00053\u0000\u0000\u0346\u035a\u00052\u0000\u0000\u0347\u0348"+ + "\u0005i\u0000\u0000\u0348\u0349\u0005n\u0000\u0000\u0349\u034a\u0005t"+ + "\u0000\u0000\u034a\u034b\u00052\u0000\u0000\u034b\u034c\u00054\u0000\u0000"+ + "\u034c\u035a\u00050\u0000\u0000\u034d\u034e\u0005i\u0000\u0000\u034e\u034f"+ + "\u0005n\u0000\u0000\u034f\u0350\u0005t\u0000\u0000\u0350\u0351\u00052"+ + "\u0000\u0000\u0351\u0352\u00054\u0000\u0000\u0352\u035a\u00058\u0000\u0000"+ + "\u0353\u0354\u0005i\u0000\u0000\u0354\u0355\u0005n\u0000\u0000\u0355\u0356"+ + "\u0005t\u0000\u0000\u0356\u0357\u00052\u0000\u0000\u0357\u0358\u00055"+ + "\u0000\u0000\u0358\u035a\u00056\u0000\u0000\u0359\u02a3\u0001\u0000\u0000"+ + "\u0000\u0359\u02a6\u0001\u0000\u0000\u0000\u0359\u02aa\u0001\u0000\u0000"+ + "\u0000\u0359\u02af\u0001\u0000\u0000\u0000\u0359\u02b4\u0001\u0000\u0000"+ + "\u0000\u0359\u02b9\u0001\u0000\u0000\u0000\u0359\u02be\u0001\u0000\u0000"+ + "\u0000\u0359\u02c3\u0001\u0000\u0000\u0000\u0359\u02c8\u0001\u0000\u0000"+ + "\u0000\u0359\u02cd\u0001\u0000\u0000\u0000\u0359\u02d2\u0001\u0000\u0000"+ + "\u0000\u0359\u02d7\u0001\u0000\u0000\u0000\u0359\u02dc\u0001\u0000\u0000"+ + "\u0000\u0359\u02e1\u0001\u0000\u0000\u0000\u0359\u02e7\u0001\u0000\u0000"+ + "\u0000\u0359\u02ed\u0001\u0000\u0000\u0000\u0359\u02f3\u0001\u0000\u0000"+ + "\u0000\u0359\u02f9\u0001\u0000\u0000\u0000\u0359\u02ff\u0001\u0000\u0000"+ + "\u0000\u0359\u0305\u0001\u0000\u0000\u0000\u0359\u030b\u0001\u0000\u0000"+ + "\u0000\u0359\u0311\u0001\u0000\u0000\u0000\u0359\u0317\u0001\u0000\u0000"+ + "\u0000\u0359\u031d\u0001\u0000\u0000\u0000\u0359\u0323\u0001\u0000\u0000"+ + "\u0000\u0359\u0329\u0001\u0000\u0000\u0000\u0359\u032f\u0001\u0000\u0000"+ + "\u0000\u0359\u0335\u0001\u0000\u0000\u0000\u0359\u033b\u0001\u0000\u0000"+ + "\u0000\u0359\u0341\u0001\u0000\u0000\u0000\u0359\u0347\u0001\u0000\u0000"+ + "\u0000\u0359\u034d\u0001\u0000\u0000\u0000\u0359\u0353\u0001\u0000\u0000"+ + "\u0000\u035a\u00ba\u0001\u0000\u0000\u0000\u035b\u035c\u0005u\u0000\u0000"+ + "\u035c\u035d\u0005i\u0000\u0000\u035d\u035e\u0005n\u0000\u0000\u035e\u0433"+ + "\u0005t\u0000\u0000\u035f\u0360\u0005u\u0000\u0000\u0360\u0361\u0005i"+ + "\u0000\u0000\u0361\u0362\u0005n\u0000\u0000\u0362\u0363\u0005t\u0000\u0000"+ + "\u0363\u0433\u00058\u0000\u0000\u0364\u0365\u0005u\u0000\u0000\u0365\u0366"+ + "\u0005i\u0000\u0000\u0366\u0367\u0005n\u0000\u0000\u0367\u0368\u0005t"+ + "\u0000\u0000\u0368\u0369\u00051\u0000\u0000\u0369\u0433\u00056\u0000\u0000"+ + "\u036a\u036b\u0005u\u0000\u0000\u036b\u036c\u0005i\u0000\u0000\u036c\u036d"+ + "\u0005n\u0000\u0000\u036d\u036e\u0005t\u0000\u0000\u036e\u036f\u00052"+ + "\u0000\u0000\u036f\u0433\u00054\u0000\u0000\u0370\u0371\u0005u\u0000\u0000"+ + "\u0371\u0372\u0005i\u0000\u0000\u0372\u0373\u0005n\u0000\u0000\u0373\u0374"+ + "\u0005t\u0000\u0000\u0374\u0375\u00053\u0000\u0000\u0375\u0433\u00052"+ + "\u0000\u0000\u0376\u0377\u0005u\u0000\u0000\u0377\u0378\u0005i\u0000\u0000"+ + "\u0378\u0379\u0005n\u0000\u0000\u0379\u037a\u0005t\u0000\u0000\u037a\u037b"+ + "\u00054\u0000\u0000\u037b\u0433\u00050\u0000\u0000\u037c\u037d\u0005u"+ + "\u0000\u0000\u037d\u037e\u0005i\u0000\u0000\u037e\u037f\u0005n\u0000\u0000"+ + "\u037f\u0380\u0005t\u0000\u0000\u0380\u0381\u00054\u0000\u0000\u0381\u0433"+ + "\u00058\u0000\u0000\u0382\u0383\u0005u\u0000\u0000\u0383\u0384\u0005i"+ + "\u0000\u0000\u0384\u0385\u0005n\u0000\u0000\u0385\u0386\u0005t\u0000\u0000"+ + "\u0386\u0387\u00055\u0000\u0000\u0387\u0433\u00056\u0000\u0000\u0388\u0389"+ + "\u0005u\u0000\u0000\u0389\u038a\u0005i\u0000\u0000\u038a\u038b\u0005n"+ + "\u0000\u0000\u038b\u038c\u0005t\u0000\u0000\u038c\u038d\u00056\u0000\u0000"+ + "\u038d\u0433\u00054\u0000\u0000\u038e\u038f\u0005u\u0000\u0000\u038f\u0390"+ + "\u0005i\u0000\u0000\u0390\u0391\u0005n\u0000\u0000\u0391\u0392\u0005t"+ + "\u0000\u0000\u0392\u0393\u00057\u0000\u0000\u0393\u0433\u00052\u0000\u0000"+ + "\u0394\u0395\u0005u\u0000\u0000\u0395\u0396\u0005i\u0000\u0000\u0396\u0397"+ + "\u0005n\u0000\u0000\u0397\u0398\u0005t\u0000\u0000\u0398\u0399\u00058"+ + "\u0000\u0000\u0399\u0433\u00050\u0000\u0000\u039a\u039b\u0005u\u0000\u0000"+ + "\u039b\u039c\u0005i\u0000\u0000\u039c\u039d\u0005n\u0000\u0000\u039d\u039e"+ + "\u0005t\u0000\u0000\u039e\u039f\u00058\u0000\u0000\u039f\u0433\u00058"+ + "\u0000\u0000\u03a0\u03a1\u0005u\u0000\u0000\u03a1\u03a2\u0005i\u0000\u0000"+ + "\u03a2\u03a3\u0005n\u0000\u0000\u03a3\u03a4\u0005t\u0000\u0000\u03a4\u03a5"+ + "\u00059\u0000\u0000\u03a5\u0433\u00056\u0000\u0000\u03a6\u03a7\u0005u"+ + "\u0000\u0000\u03a7\u03a8\u0005i\u0000\u0000\u03a8\u03a9\u0005n\u0000\u0000"+ + "\u03a9\u03aa\u0005t\u0000\u0000\u03aa\u03ab\u00051\u0000\u0000\u03ab\u03ac"+ + "\u00050\u0000\u0000\u03ac\u0433\u00054\u0000\u0000\u03ad\u03ae\u0005u"+ + "\u0000\u0000\u03ae\u03af\u0005i\u0000\u0000\u03af\u03b0\u0005n\u0000\u0000"+ + "\u03b0\u03b1\u0005t\u0000\u0000\u03b1\u03b2\u00051\u0000\u0000\u03b2\u03b3"+ + "\u00051\u0000\u0000\u03b3\u0433\u00052\u0000\u0000\u03b4\u03b5\u0005u"+ + "\u0000\u0000\u03b5\u03b6\u0005i\u0000\u0000\u03b6\u03b7\u0005n\u0000\u0000"+ + "\u03b7\u03b8\u0005t\u0000\u0000\u03b8\u03b9\u00051\u0000\u0000\u03b9\u03ba"+ + "\u00052\u0000\u0000\u03ba\u0433\u00050\u0000\u0000\u03bb\u03bc\u0005u"+ + "\u0000\u0000\u03bc\u03bd\u0005i\u0000\u0000\u03bd\u03be\u0005n\u0000\u0000"+ + "\u03be\u03bf\u0005t\u0000\u0000\u03bf\u03c0\u00051\u0000\u0000\u03c0\u03c1"+ + "\u00052\u0000\u0000\u03c1\u0433\u00058\u0000\u0000\u03c2\u03c3\u0005u"+ + "\u0000\u0000\u03c3\u03c4\u0005i\u0000\u0000\u03c4\u03c5\u0005n\u0000\u0000"+ + "\u03c5\u03c6\u0005t\u0000\u0000\u03c6\u03c7\u00051\u0000\u0000\u03c7\u03c8"+ + "\u00053\u0000\u0000\u03c8\u0433\u00056\u0000\u0000\u03c9\u03ca\u0005u"+ + "\u0000\u0000\u03ca\u03cb\u0005i\u0000\u0000\u03cb\u03cc\u0005n\u0000\u0000"+ + "\u03cc\u03cd\u0005t\u0000\u0000\u03cd\u03ce\u00051\u0000\u0000\u03ce\u03cf"+ + "\u00054\u0000\u0000\u03cf\u0433\u00054\u0000\u0000\u03d0\u03d1\u0005u"+ + "\u0000\u0000\u03d1\u03d2\u0005i\u0000\u0000\u03d2\u03d3\u0005n\u0000\u0000"+ + "\u03d3\u03d4\u0005t\u0000\u0000\u03d4\u03d5\u00051\u0000\u0000\u03d5\u03d6"+ + "\u00055\u0000\u0000\u03d6\u0433\u00052\u0000\u0000\u03d7\u03d8\u0005u"+ + "\u0000\u0000\u03d8\u03d9\u0005i\u0000\u0000\u03d9\u03da\u0005n\u0000\u0000"+ + "\u03da\u03db\u0005t\u0000\u0000\u03db\u03dc\u00051\u0000\u0000\u03dc\u03dd"+ + "\u00056\u0000\u0000\u03dd\u0433\u00050\u0000\u0000\u03de\u03df\u0005u"+ + "\u0000\u0000\u03df\u03e0\u0005i\u0000\u0000\u03e0\u03e1\u0005n\u0000\u0000"+ + "\u03e1\u03e2\u0005t\u0000\u0000\u03e2\u03e3\u00051\u0000\u0000\u03e3\u03e4"+ + "\u00056\u0000\u0000\u03e4\u0433\u00058\u0000\u0000\u03e5\u03e6\u0005u"+ + "\u0000\u0000\u03e6\u03e7\u0005i\u0000\u0000\u03e7\u03e8\u0005n\u0000\u0000"+ + "\u03e8\u03e9\u0005t\u0000\u0000\u03e9\u03ea\u00051\u0000\u0000\u03ea\u03eb"+ + "\u00057\u0000\u0000\u03eb\u0433\u00056\u0000\u0000\u03ec\u03ed\u0005u"+ + "\u0000\u0000\u03ed\u03ee\u0005i\u0000\u0000\u03ee\u03ef\u0005n\u0000\u0000"+ + "\u03ef\u03f0\u0005t\u0000\u0000\u03f0\u03f1\u00051\u0000\u0000\u03f1\u03f2"+ + "\u00058\u0000\u0000\u03f2\u0433\u00054\u0000\u0000\u03f3\u03f4\u0005u"+ + "\u0000\u0000\u03f4\u03f5\u0005i\u0000\u0000\u03f5\u03f6\u0005n\u0000\u0000"+ + "\u03f6\u03f7\u0005t\u0000\u0000\u03f7\u03f8\u00051\u0000\u0000\u03f8\u03f9"+ + "\u00059\u0000\u0000\u03f9\u0433\u00052\u0000\u0000\u03fa\u03fb\u0005u"+ + "\u0000\u0000\u03fb\u03fc\u0005i\u0000\u0000\u03fc\u03fd\u0005n\u0000\u0000"+ + "\u03fd\u03fe\u0005t\u0000\u0000\u03fe\u03ff\u00052\u0000\u0000\u03ff\u0400"+ + "\u00050\u0000\u0000\u0400\u0433\u00050\u0000\u0000\u0401\u0402\u0005u"+ + "\u0000\u0000\u0402\u0403\u0005i\u0000\u0000\u0403\u0404\u0005n\u0000\u0000"+ + "\u0404\u0405\u0005t\u0000\u0000\u0405\u0406\u00052\u0000\u0000\u0406\u0407"+ + "\u00050\u0000\u0000\u0407\u0433\u00058\u0000\u0000\u0408\u0409\u0005u"+ + "\u0000\u0000\u0409\u040a\u0005i\u0000\u0000\u040a\u040b\u0005n\u0000\u0000"+ + "\u040b\u040c\u0005t\u0000\u0000\u040c\u040d\u00052\u0000\u0000\u040d\u040e"+ + "\u00051\u0000\u0000\u040e\u0433\u00056\u0000\u0000\u040f\u0410\u0005u"+ + "\u0000\u0000\u0410\u0411\u0005i\u0000\u0000\u0411\u0412\u0005n\u0000\u0000"+ + "\u0412\u0413\u0005t\u0000\u0000\u0413\u0414\u00052\u0000\u0000\u0414\u0415"+ + "\u00052\u0000\u0000\u0415\u0433\u00054\u0000\u0000\u0416\u0417\u0005u"+ + "\u0000\u0000\u0417\u0418\u0005i\u0000\u0000\u0418\u0419\u0005n\u0000\u0000"+ + "\u0419\u041a\u0005t\u0000\u0000\u041a\u041b\u00052\u0000\u0000\u041b\u041c"+ + "\u00053\u0000\u0000\u041c\u0433\u00052\u0000\u0000\u041d\u041e\u0005u"+ + "\u0000\u0000\u041e\u041f\u0005i\u0000\u0000\u041f\u0420\u0005n\u0000\u0000"+ + "\u0420\u0421\u0005t\u0000\u0000\u0421\u0422\u00052\u0000\u0000\u0422\u0423"+ + "\u00054\u0000\u0000\u0423\u0433\u00050\u0000\u0000\u0424\u0425\u0005u"+ + "\u0000\u0000\u0425\u0426\u0005i\u0000\u0000\u0426\u0427\u0005n\u0000\u0000"+ + "\u0427\u0428\u0005t\u0000\u0000\u0428\u0429\u00052\u0000\u0000\u0429\u042a"+ + "\u00054\u0000\u0000\u042a\u0433\u00058\u0000\u0000\u042b\u042c\u0005u"+ + "\u0000\u0000\u042c\u042d\u0005i\u0000\u0000\u042d\u042e\u0005n\u0000\u0000"+ + "\u042e\u042f\u0005t\u0000\u0000\u042f\u0430\u00052\u0000\u0000\u0430\u0431"+ + "\u00055\u0000\u0000\u0431\u0433\u00056\u0000\u0000\u0432\u035b\u0001\u0000"+ + "\u0000\u0000\u0432\u035f\u0001\u0000\u0000\u0000\u0432\u0364\u0001\u0000"+ + "\u0000\u0000\u0432\u036a\u0001\u0000\u0000\u0000\u0432\u0370\u0001\u0000"+ + "\u0000\u0000\u0432\u0376\u0001\u0000\u0000\u0000\u0432\u037c\u0001\u0000"+ + "\u0000\u0000\u0432\u0382\u0001\u0000\u0000\u0000\u0432\u0388\u0001\u0000"+ + "\u0000\u0000\u0432\u038e\u0001\u0000\u0000\u0000\u0432\u0394\u0001\u0000"+ + "\u0000\u0000\u0432\u039a\u0001\u0000\u0000\u0000\u0432\u03a0\u0001\u0000"+ + "\u0000\u0000\u0432\u03a6\u0001\u0000\u0000\u0000\u0432\u03ad\u0001\u0000"+ + "\u0000\u0000\u0432\u03b4\u0001\u0000\u0000\u0000\u0432\u03bb\u0001\u0000"+ + "\u0000\u0000\u0432\u03c2\u0001\u0000\u0000\u0000\u0432\u03c9\u0001\u0000"+ + "\u0000\u0000\u0432\u03d0\u0001\u0000\u0000\u0000\u0432\u03d7\u0001\u0000"+ + "\u0000\u0000\u0432\u03de\u0001\u0000\u0000\u0000\u0432\u03e5\u0001\u0000"+ + "\u0000\u0000\u0432\u03ec\u0001\u0000\u0000\u0000\u0432\u03f3\u0001\u0000"+ + "\u0000\u0000\u0432\u03fa\u0001\u0000\u0000\u0000\u0432\u0401\u0001\u0000"+ + "\u0000\u0000\u0432\u0408\u0001\u0000\u0000\u0000\u0432\u040f\u0001\u0000"+ + "\u0000\u0000\u0432\u0416\u0001\u0000\u0000\u0000\u0432\u041d\u0001\u0000"+ + "\u0000\u0000\u0432\u0424\u0001\u0000\u0000\u0000\u0432\u042b\u0001\u0000"+ + "\u0000\u0000\u0433\u00bc\u0001\u0000\u0000\u0000\u0434\u0435\u0005b\u0000"+ + "\u0000\u0435\u0436\u0005y\u0000\u0000\u0436\u0437\u0005t\u0000\u0000\u0437"+ + "\u0438\u0005e\u0000\u0000\u0438\u0511\u0005s\u0000\u0000\u0439\u043a\u0005"+ + "b\u0000\u0000\u043a\u043b\u0005y\u0000\u0000\u043b\u043c\u0005t\u0000"+ + "\u0000\u043c\u043d\u0005e\u0000\u0000\u043d\u043e\u0005s\u0000\u0000\u043e"+ + "\u0511\u00051\u0000\u0000\u043f\u0440\u0005b\u0000\u0000\u0440\u0441\u0005"+ + "y\u0000\u0000\u0441\u0442\u0005t\u0000\u0000\u0442\u0443\u0005e\u0000"+ + "\u0000\u0443\u0444\u0005s\u0000\u0000\u0444\u0511\u00052\u0000\u0000\u0445"+ + "\u0446\u0005b\u0000\u0000\u0446\u0447\u0005y\u0000\u0000\u0447\u0448\u0005"+ + "t\u0000\u0000\u0448\u0449\u0005e\u0000\u0000\u0449\u044a\u0005s\u0000"+ + "\u0000\u044a\u0511\u00053\u0000\u0000\u044b\u044c\u0005b\u0000\u0000\u044c"+ + "\u044d\u0005y\u0000\u0000\u044d\u044e\u0005t\u0000\u0000\u044e\u044f\u0005"+ + "e\u0000\u0000\u044f\u0450\u0005s\u0000\u0000\u0450\u0511\u00054\u0000"+ + "\u0000\u0451\u0452\u0005b\u0000\u0000\u0452\u0453\u0005y\u0000\u0000\u0453"+ + "\u0454\u0005t\u0000\u0000\u0454\u0455\u0005e\u0000\u0000\u0455\u0456\u0005"+ + "s\u0000\u0000\u0456\u0511\u00055\u0000\u0000\u0457\u0458\u0005b\u0000"+ + "\u0000\u0458\u0459\u0005y\u0000\u0000\u0459\u045a\u0005t\u0000\u0000\u045a"+ + "\u045b\u0005e\u0000\u0000\u045b\u045c\u0005s\u0000\u0000\u045c\u0511\u0005"+ + "6\u0000\u0000\u045d\u045e\u0005b\u0000\u0000\u045e\u045f\u0005y\u0000"+ + "\u0000\u045f\u0460\u0005t\u0000\u0000\u0460\u0461\u0005e\u0000\u0000\u0461"+ + "\u0462\u0005s\u0000\u0000\u0462\u0511\u00057\u0000\u0000\u0463\u0464\u0005"+ + "b\u0000\u0000\u0464\u0465\u0005y\u0000\u0000\u0465\u0466\u0005t\u0000"+ + "\u0000\u0466\u0467\u0005e\u0000\u0000\u0467\u0468\u0005s\u0000\u0000\u0468"+ + "\u0511\u00058\u0000\u0000\u0469\u046a\u0005b\u0000\u0000\u046a\u046b\u0005"+ + "y\u0000\u0000\u046b\u046c\u0005t\u0000\u0000\u046c\u046d\u0005e\u0000"+ + "\u0000\u046d\u046e\u0005s\u0000\u0000\u046e\u0511\u00059\u0000\u0000\u046f"+ + "\u0470\u0005b\u0000\u0000\u0470\u0471\u0005y\u0000\u0000\u0471\u0472\u0005"+ + "t\u0000\u0000\u0472\u0473\u0005e\u0000\u0000\u0473\u0474\u0005s\u0000"+ + "\u0000\u0474\u0475\u00051\u0000\u0000\u0475\u0511\u00050\u0000\u0000\u0476"+ + "\u0477\u0005b\u0000\u0000\u0477\u0478\u0005y\u0000\u0000\u0478\u0479\u0005"+ + "t\u0000\u0000\u0479\u047a\u0005e\u0000\u0000\u047a\u047b\u0005s\u0000"+ + "\u0000\u047b\u047c\u00051\u0000\u0000\u047c\u0511\u00051\u0000\u0000\u047d"+ + "\u047e\u0005b\u0000\u0000\u047e\u047f\u0005y\u0000\u0000\u047f\u0480\u0005"+ + "t\u0000\u0000\u0480\u0481\u0005e\u0000\u0000\u0481\u0482\u0005s\u0000"+ + "\u0000\u0482\u0483\u00051\u0000\u0000\u0483\u0511\u00052\u0000\u0000\u0484"+ + "\u0485\u0005b\u0000\u0000\u0485\u0486\u0005y\u0000\u0000\u0486\u0487\u0005"+ + "t\u0000\u0000\u0487\u0488\u0005e\u0000\u0000\u0488\u0489\u0005s\u0000"+ + "\u0000\u0489\u048a\u00051\u0000\u0000\u048a\u0511\u00053\u0000\u0000\u048b"+ + "\u048c\u0005b\u0000\u0000\u048c\u048d\u0005y\u0000\u0000\u048d\u048e\u0005"+ + "t\u0000\u0000\u048e\u048f\u0005e\u0000\u0000\u048f\u0490\u0005s\u0000"+ + "\u0000\u0490\u0491\u00051\u0000\u0000\u0491\u0511\u00054\u0000\u0000\u0492"+ + "\u0493\u0005b\u0000\u0000\u0493\u0494\u0005y\u0000\u0000\u0494\u0495\u0005"+ + "t\u0000\u0000\u0495\u0496\u0005e\u0000\u0000\u0496\u0497\u0005s\u0000"+ + "\u0000\u0497\u0498\u00051\u0000\u0000\u0498\u0511\u00055\u0000\u0000\u0499"+ + "\u049a\u0005b\u0000\u0000\u049a\u049b\u0005y\u0000\u0000\u049b\u049c\u0005"+ + "t\u0000\u0000\u049c\u049d\u0005e\u0000\u0000\u049d\u049e\u0005s\u0000"+ + "\u0000\u049e\u049f\u00051\u0000\u0000\u049f\u0511\u00056\u0000\u0000\u04a0"+ + "\u04a1\u0005b\u0000\u0000\u04a1\u04a2\u0005y\u0000\u0000\u04a2\u04a3\u0005"+ + "t\u0000\u0000\u04a3\u04a4\u0005e\u0000\u0000\u04a4\u04a5\u0005s\u0000"+ + "\u0000\u04a5\u04a6\u00051\u0000\u0000\u04a6\u0511\u00057\u0000\u0000\u04a7"+ + "\u04a8\u0005b\u0000\u0000\u04a8\u04a9\u0005y\u0000\u0000\u04a9\u04aa\u0005"+ + "t\u0000\u0000\u04aa\u04ab\u0005e\u0000\u0000\u04ab\u04ac\u0005s\u0000"+ + "\u0000\u04ac\u04ad\u00051\u0000\u0000\u04ad\u0511\u00058\u0000\u0000\u04ae"+ + "\u04af\u0005b\u0000\u0000\u04af\u04b0\u0005y\u0000\u0000\u04b0\u04b1\u0005"+ + "t\u0000\u0000\u04b1\u04b2\u0005e\u0000\u0000\u04b2\u04b3\u0005s\u0000"+ + "\u0000\u04b3\u04b4\u00051\u0000\u0000\u04b4\u0511\u00059\u0000\u0000\u04b5"+ + "\u04b6\u0005b\u0000\u0000\u04b6\u04b7\u0005y\u0000\u0000\u04b7\u04b8\u0005"+ + "t\u0000\u0000\u04b8\u04b9\u0005e\u0000\u0000\u04b9\u04ba\u0005s\u0000"+ + "\u0000\u04ba\u04bb\u00052\u0000\u0000\u04bb\u0511\u00050\u0000\u0000\u04bc"+ + "\u04bd\u0005b\u0000\u0000\u04bd\u04be\u0005y\u0000\u0000\u04be\u04bf\u0005"+ + "t\u0000\u0000\u04bf\u04c0\u0005e\u0000\u0000\u04c0\u04c1\u0005s\u0000"+ + "\u0000\u04c1\u04c2\u00052\u0000\u0000\u04c2\u0511\u00051\u0000\u0000\u04c3"+ + "\u04c4\u0005b\u0000\u0000\u04c4\u04c5\u0005y\u0000\u0000\u04c5\u04c6\u0005"+ + "t\u0000\u0000\u04c6\u04c7\u0005e\u0000\u0000\u04c7\u04c8\u0005s\u0000"+ + "\u0000\u04c8\u04c9\u00052\u0000\u0000\u04c9\u0511\u00052\u0000\u0000\u04ca"+ + "\u04cb\u0005b\u0000\u0000\u04cb\u04cc\u0005y\u0000\u0000\u04cc\u04cd\u0005"+ + "t\u0000\u0000\u04cd\u04ce\u0005e\u0000\u0000\u04ce\u04cf\u0005s\u0000"+ + "\u0000\u04cf\u04d0\u00052\u0000\u0000\u04d0\u0511\u00053\u0000\u0000\u04d1"+ + "\u04d2\u0005b\u0000\u0000\u04d2\u04d3\u0005y\u0000\u0000\u04d3\u04d4\u0005"+ + "t\u0000\u0000\u04d4\u04d5\u0005e\u0000\u0000\u04d5\u04d6\u0005s\u0000"+ + "\u0000\u04d6\u04d7\u00052\u0000\u0000\u04d7\u0511\u00054\u0000\u0000\u04d8"+ + "\u04d9\u0005b\u0000\u0000\u04d9\u04da\u0005y\u0000\u0000\u04da\u04db\u0005"+ + "t\u0000\u0000\u04db\u04dc\u0005e\u0000\u0000\u04dc\u04dd\u0005s\u0000"+ + "\u0000\u04dd\u04de\u00052\u0000\u0000\u04de\u0511\u00055\u0000\u0000\u04df"+ + "\u04e0\u0005b\u0000\u0000\u04e0\u04e1\u0005y\u0000\u0000\u04e1\u04e2\u0005"+ + "t\u0000\u0000\u04e2\u04e3\u0005e\u0000\u0000\u04e3\u04e4\u0005s\u0000"+ + "\u0000\u04e4\u04e5\u00052\u0000\u0000\u04e5\u0511\u00056\u0000\u0000\u04e6"+ + "\u04e7\u0005b\u0000\u0000\u04e7\u04e8\u0005y\u0000\u0000\u04e8\u04e9\u0005"+ + "t\u0000\u0000\u04e9\u04ea\u0005e\u0000\u0000\u04ea\u04eb\u0005s\u0000"+ + "\u0000\u04eb\u04ec\u00052\u0000\u0000\u04ec\u0511\u00057\u0000\u0000\u04ed"+ + "\u04ee\u0005b\u0000\u0000\u04ee\u04ef\u0005y\u0000\u0000\u04ef\u04f0\u0005"+ + "t\u0000\u0000\u04f0\u04f1\u0005e\u0000\u0000\u04f1\u04f2\u0005s\u0000"+ + "\u0000\u04f2\u04f3\u00052\u0000\u0000\u04f3\u0511\u00058\u0000\u0000\u04f4"+ + "\u04f5\u0005b\u0000\u0000\u04f5\u04f6\u0005y\u0000\u0000\u04f6\u04f7\u0005"+ + "t\u0000\u0000\u04f7\u04f8\u0005e\u0000\u0000\u04f8\u04f9\u0005s\u0000"+ + "\u0000\u04f9\u04fa\u00052\u0000\u0000\u04fa\u0511\u00059\u0000\u0000\u04fb"+ + "\u04fc\u0005b\u0000\u0000\u04fc\u04fd\u0005y\u0000\u0000\u04fd\u04fe\u0005"+ + "t\u0000\u0000\u04fe\u04ff\u0005e\u0000\u0000\u04ff\u0500\u0005s\u0000"+ + "\u0000\u0500\u0501\u00053\u0000\u0000\u0501\u0511\u00050\u0000\u0000\u0502"+ + "\u0503\u0005b\u0000\u0000\u0503\u0504\u0005y\u0000\u0000\u0504\u0505\u0005"+ + "t\u0000\u0000\u0505\u0506\u0005e\u0000\u0000\u0506\u0507\u0005s\u0000"+ + "\u0000\u0507\u0508\u00053\u0000\u0000\u0508\u0511\u00051\u0000\u0000\u0509"+ + "\u050a\u0005b\u0000\u0000\u050a\u050b\u0005y\u0000\u0000\u050b\u050c\u0005"+ + "t\u0000\u0000\u050c\u050d\u0005e\u0000\u0000\u050d\u050e\u0005s\u0000"+ + "\u0000\u050e\u050f\u00053\u0000\u0000\u050f\u0511\u00052\u0000\u0000\u0510"+ + "\u0434\u0001\u0000\u0000\u0000\u0510\u0439\u0001\u0000\u0000\u0000\u0510"+ + "\u043f\u0001\u0000\u0000\u0000\u0510\u0445\u0001\u0000\u0000\u0000\u0510"+ + "\u044b\u0001\u0000\u0000\u0000\u0510\u0451\u0001\u0000\u0000\u0000\u0510"+ + "\u0457\u0001\u0000\u0000\u0000\u0510\u045d\u0001\u0000\u0000\u0000\u0510"+ + "\u0463\u0001\u0000\u0000\u0000\u0510\u0469\u0001\u0000\u0000\u0000\u0510"+ + "\u046f\u0001\u0000\u0000\u0000\u0510\u0476\u0001\u0000\u0000\u0000\u0510"+ + "\u047d\u0001\u0000\u0000\u0000\u0510\u0484\u0001\u0000\u0000\u0000\u0510"+ + "\u048b\u0001\u0000\u0000\u0000\u0510\u0492\u0001\u0000\u0000\u0000\u0510"+ + "\u0499\u0001\u0000\u0000\u0000\u0510\u04a0\u0001\u0000\u0000\u0000\u0510"+ + "\u04a7\u0001\u0000\u0000\u0000\u0510\u04ae\u0001\u0000\u0000\u0000\u0510"+ + "\u04b5\u0001\u0000\u0000\u0000\u0510\u04bc\u0001\u0000\u0000\u0000\u0510"+ + "\u04c3\u0001\u0000\u0000\u0000\u0510\u04ca\u0001\u0000\u0000\u0000\u0510"+ + "\u04d1\u0001\u0000\u0000\u0000\u0510\u04d8\u0001\u0000\u0000\u0000\u0510"+ + "\u04df\u0001\u0000\u0000\u0000\u0510\u04e6\u0001\u0000\u0000\u0000\u0510"+ + "\u04ed\u0001\u0000\u0000\u0000\u0510\u04f4\u0001\u0000\u0000\u0000\u0510"+ + "\u04fb\u0001\u0000\u0000\u0000\u0510\u0502\u0001\u0000\u0000\u0000\u0510"+ + "\u0509\u0001\u0000\u0000\u0000\u0511\u00be\u0001\u0000\u0000\u0000\u0512"+ + "\u0513\u0005f\u0000\u0000\u0513\u0514\u0005i\u0000\u0000\u0514\u0515\u0005"+ + "x\u0000\u0000\u0515\u0516\u0005e\u0000\u0000\u0516\u0529\u0005d\u0000"+ + "\u0000\u0517\u0518\u0005f\u0000\u0000\u0518\u0519\u0005i\u0000\u0000\u0519"+ + "\u051a\u0005x\u0000\u0000\u051a\u051b\u0005e\u0000\u0000\u051b\u051c\u0005"+ + "d\u0000\u0000\u051c\u051e\u0001\u0000\u0000\u0000\u051d\u051f\u0007\u0000"+ + "\u0000\u0000\u051e\u051d\u0001\u0000\u0000\u0000\u051f\u0520\u0001\u0000"+ + "\u0000\u0000\u0520\u051e\u0001\u0000\u0000\u0000\u0520\u0521\u0001\u0000"+ + "\u0000\u0000\u0521\u0522\u0001\u0000\u0000\u0000\u0522\u0524\u0005x\u0000"+ + "\u0000\u0523\u0525\u0007\u0000\u0000\u0000\u0524\u0523\u0001\u0000\u0000"+ + "\u0000\u0525\u0526\u0001\u0000\u0000\u0000\u0526\u0524\u0001\u0000\u0000"+ + "\u0000\u0526\u0527\u0001\u0000\u0000\u0000\u0527\u0529\u0001\u0000\u0000"+ + "\u0000\u0528\u0512\u0001\u0000\u0000\u0000\u0528\u0517\u0001\u0000\u0000"+ + "\u0000\u0529\u00c0\u0001\u0000\u0000\u0000\u052a\u052b\u0005u\u0000\u0000"+ + "\u052b\u052c\u0005f\u0000\u0000\u052c\u052d\u0005i\u0000\u0000\u052d\u052e"+ + "\u0005x\u0000\u0000\u052e\u052f\u0005e\u0000\u0000\u052f\u0543\u0005d"+ + "\u0000\u0000\u0530\u0531\u0005u\u0000\u0000\u0531\u0532\u0005f\u0000\u0000"+ + "\u0532\u0533\u0005i\u0000\u0000\u0533\u0534\u0005x\u0000\u0000\u0534\u0535"+ + "\u0005e\u0000\u0000\u0535\u0536\u0005d\u0000\u0000\u0536\u0538\u0001\u0000"+ + "\u0000\u0000\u0537\u0539\u0007\u0000\u0000\u0000\u0538\u0537\u0001\u0000"+ + "\u0000\u0000\u0539\u053a\u0001\u0000\u0000\u0000\u053a\u0538\u0001\u0000"+ + "\u0000\u0000\u053a\u053b\u0001\u0000\u0000\u0000\u053b\u053c\u0001\u0000"+ + "\u0000\u0000\u053c\u053e\u0005x\u0000\u0000\u053d\u053f\u0007\u0000\u0000"+ + "\u0000\u053e\u053d\u0001\u0000\u0000\u0000\u053f\u0540\u0001\u0000\u0000"+ + "\u0000\u0540\u053e\u0001\u0000\u0000\u0000\u0540\u0541\u0001\u0000\u0000"+ + "\u0000\u0541\u0543\u0001\u0000\u0000\u0000\u0542\u052a\u0001\u0000\u0000"+ + "\u0000\u0542\u0530\u0001\u0000\u0000\u0000\u0543\u00c2\u0001\u0000\u0000"+ + "\u0000\u0544\u0545\u0005t\u0000\u0000\u0545\u0546\u0005r\u0000\u0000\u0546"+ + "\u0547\u0005u\u0000\u0000\u0547\u054e\u0005e\u0000\u0000\u0548\u0549\u0005"+ + "f\u0000\u0000\u0549\u054a\u0005a\u0000\u0000\u054a\u054b\u0005l\u0000"+ + "\u0000\u054b\u054c\u0005s\u0000\u0000\u054c\u054e\u0005e\u0000\u0000\u054d"+ + "\u0544\u0001\u0000\u0000\u0000\u054d\u0548\u0001\u0000\u0000\u0000\u054e"+ + "\u00c4\u0001\u0000\u0000\u0000\u054f\u0556\u0003\u00c7c\u0000\u0550\u0552"+ + "\u0003\u00c7c\u0000\u0551\u0550\u0001\u0000\u0000\u0000\u0551\u0552\u0001"+ + "\u0000\u0000\u0000\u0552\u0553\u0001\u0000\u0000\u0000\u0553\u0554\u0005"+ + ".\u0000\u0000\u0554\u0556\u0003\u00c7c\u0000\u0555\u054f\u0001\u0000\u0000"+ + "\u0000\u0555\u0551\u0001\u0000\u0000\u0000\u0556\u055c\u0001\u0000\u0000"+ + "\u0000\u0557\u0559\u0007\u0001\u0000\u0000\u0558\u055a\u0005-\u0000\u0000"+ + "\u0559\u0558\u0001\u0000\u0000\u0000\u0559\u055a\u0001\u0000\u0000\u0000"+ + "\u055a\u055b\u0001\u0000\u0000\u0000\u055b\u055d\u0003\u00c7c\u0000\u055c"+ + "\u0557\u0001\u0000\u0000\u0000\u055c\u055d\u0001\u0000\u0000\u0000\u055d"+ + "\u00c6\u0001\u0000\u0000\u0000\u055e\u0565\u0007\u0000\u0000\u0000\u055f"+ + "\u0561\u0005_\u0000\u0000\u0560\u055f\u0001\u0000\u0000\u0000\u0560\u0561"+ + "\u0001\u0000\u0000\u0000\u0561\u0562\u0001\u0000\u0000\u0000\u0562\u0564"+ + "\u0007\u0000\u0000\u0000\u0563\u0560\u0001\u0000\u0000\u0000\u0564\u0567"+ + "\u0001\u0000\u0000\u0000\u0565\u0563\u0001\u0000\u0000\u0000\u0565\u0566"+ + "\u0001\u0000\u0000\u0000\u0566\u00c8\u0001\u0000\u0000\u0000\u0567\u0565"+ + "\u0001\u0000\u0000\u0000\u0568\u0569\u00050\u0000\u0000\u0569\u056a\u0007"+ + "\u0002\u0000\u0000\u056a\u056b\u0003\u00cbe\u0000\u056b\u00ca\u0001\u0000"+ + "\u0000\u0000\u056c\u0573\u0003\u00d3i\u0000\u056d\u056f\u0005_\u0000\u0000"+ + "\u056e\u056d\u0001\u0000\u0000\u0000\u056e\u056f\u0001\u0000\u0000\u0000"+ + "\u056f\u0570\u0001\u0000\u0000\u0000\u0570\u0572\u0003\u00d3i\u0000\u0571"+ + "\u056e\u0001\u0000\u0000\u0000\u0572\u0575\u0001\u0000\u0000\u0000\u0573"+ + "\u0571\u0001\u0000\u0000\u0000\u0573\u0574\u0001\u0000\u0000\u0000\u0574"+ + "\u00cc\u0001\u0000\u0000\u0000\u0575\u0573\u0001\u0000\u0000\u0000\u0576"+ + "\u0577\u0005w\u0000\u0000\u0577\u0578\u0005e\u0000\u0000\u0578\u05ab\u0005"+ + "i\u0000\u0000\u0579\u057a\u0005s\u0000\u0000\u057a\u057b\u0005z\u0000"+ + "\u0000\u057b\u057c\u0005a\u0000\u0000\u057c\u057d\u0005b\u0000\u0000\u057d"+ + "\u05ab\u0005o\u0000\u0000\u057e\u057f\u0005f\u0000\u0000\u057f\u0580\u0005"+ + "i\u0000\u0000\u0580\u0581\u0005n\u0000\u0000\u0581\u0582\u0005n\u0000"+ + "\u0000\u0582\u0583\u0005e\u0000\u0000\u0583\u05ab\u0005y\u0000\u0000\u0584"+ + "\u0585\u0005e\u0000\u0000\u0585\u0586\u0005t\u0000\u0000\u0586\u0587\u0005"+ + "h\u0000\u0000\u0587\u0588\u0005e\u0000\u0000\u0588\u05ab\u0005r\u0000"+ + "\u0000\u0589\u058a\u0005s\u0000\u0000\u058a\u058b\u0005e\u0000\u0000\u058b"+ + "\u058c\u0005c\u0000\u0000\u058c\u058d\u0005o\u0000\u0000\u058d\u058e\u0005"+ + "n\u0000\u0000\u058e\u058f\u0005d\u0000\u0000\u058f\u05ab\u0005s\u0000"+ + "\u0000\u0590\u0591\u0005m\u0000\u0000\u0591\u0592\u0005i\u0000\u0000\u0592"+ + "\u0593\u0005n\u0000\u0000\u0593\u0594\u0005u\u0000\u0000\u0594\u0595\u0005"+ + "t\u0000\u0000\u0595\u0596\u0005e\u0000\u0000\u0596\u05ab\u0005s\u0000"+ + "\u0000\u0597\u0598\u0005h\u0000\u0000\u0598\u0599\u0005o\u0000\u0000\u0599"+ + "\u059a\u0005u\u0000\u0000\u059a\u059b\u0005r\u0000\u0000\u059b\u05ab\u0005"+ + "s\u0000\u0000\u059c\u059d\u0005d\u0000\u0000\u059d\u059e\u0005a\u0000"+ + "\u0000\u059e\u059f\u0005y\u0000\u0000\u059f\u05ab\u0005s\u0000\u0000\u05a0"+ + "\u05a1\u0005w\u0000\u0000\u05a1\u05a2\u0005e\u0000\u0000\u05a2\u05a3\u0005"+ + "e\u0000\u0000\u05a3\u05a4\u0005k\u0000\u0000\u05a4\u05ab\u0005s\u0000"+ + "\u0000\u05a5\u05a6\u0005y\u0000\u0000\u05a6\u05a7\u0005e\u0000\u0000\u05a7"+ + "\u05a8\u0005a\u0000\u0000\u05a8\u05a9\u0005r\u0000\u0000\u05a9\u05ab\u0005"+ + "s\u0000\u0000\u05aa\u0576\u0001\u0000\u0000\u0000\u05aa\u0579\u0001\u0000"+ + "\u0000\u0000\u05aa\u057e\u0001\u0000\u0000\u0000\u05aa\u0584\u0001\u0000"+ + "\u0000\u0000\u05aa\u0589\u0001\u0000\u0000\u0000\u05aa\u0590\u0001\u0000"+ + "\u0000\u0000\u05aa\u0597\u0001\u0000\u0000\u0000\u05aa\u059c\u0001\u0000"+ + "\u0000\u0000\u05aa\u05a0\u0001\u0000\u0000\u0000\u05aa\u05a5\u0001\u0000"+ + "\u0000\u0000\u05ab\u00ce\u0001\u0000\u0000\u0000\u05ac\u05ad\u0005h\u0000"+ + "\u0000\u05ad\u05ae\u0005e\u0000\u0000\u05ae\u05af\u0005x\u0000\u0000\u05af"+ + "\u05ba\u0001\u0000\u0000\u0000\u05b0\u05b2\u0005\"\u0000\u0000\u05b1\u05b3"+ + "\u0003\u00cbe\u0000\u05b2\u05b1\u0001\u0000\u0000\u0000\u05b2\u05b3\u0001"+ + "\u0000\u0000\u0000\u05b3\u05b4\u0001\u0000\u0000\u0000\u05b4\u05bb\u0005"+ + "\"\u0000\u0000\u05b5\u05b7\u0005\'\u0000\u0000\u05b6\u05b8\u0003\u00cb"+ + "e\u0000\u05b7\u05b6\u0001\u0000\u0000\u0000\u05b7\u05b8\u0001\u0000\u0000"+ + "\u0000\u05b8\u05b9\u0001\u0000\u0000\u0000\u05b9\u05bb\u0005\'\u0000\u0000"+ + "\u05ba\u05b0\u0001\u0000\u0000\u0000\u05ba\u05b5\u0001\u0000\u0000\u0000"+ + "\u05bb\u00d0\u0001\u0000\u0000\u0000\u05bc\u05bd\u0003\u00d3i\u0000\u05bd"+ + "\u05be\u0003\u00d3i\u0000\u05be\u00d2\u0001\u0000\u0000\u0000\u05bf\u05c0"+ + "\u0007\u0003\u0000\u0000\u05c0\u00d4\u0001\u0000\u0000\u0000\u05c1\u05c2"+ + "\u0005a\u0000\u0000\u05c2\u05c3\u0005f\u0000\u0000\u05c3\u05c4\u0005t"+ + "\u0000\u0000\u05c4\u05c5\u0005e\u0000\u0000\u05c5\u060a\u0005r\u0000\u0000"+ + "\u05c6\u05c7\u0005c\u0000\u0000\u05c7\u05c8\u0005a\u0000\u0000\u05c8\u05c9"+ + "\u0005s\u0000\u0000\u05c9\u060a\u0005e\u0000\u0000\u05ca\u05cb\u0005d"+ + "\u0000\u0000\u05cb\u05cc\u0005e\u0000\u0000\u05cc\u05cd\u0005f\u0000\u0000"+ + "\u05cd\u05ce\u0005a\u0000\u0000\u05ce\u05cf\u0005u\u0000\u0000\u05cf\u05d0"+ + "\u0005l\u0000\u0000\u05d0\u060a\u0005t\u0000\u0000\u05d1\u05d2\u0005f"+ + "\u0000\u0000\u05d2\u05d3\u0005i\u0000\u0000\u05d3\u05d4\u0005n\u0000\u0000"+ + "\u05d4\u05d5\u0005a\u0000\u0000\u05d5\u060a\u0005l\u0000\u0000\u05d6\u05d7"+ + "\u0005i\u0000\u0000\u05d7\u060a\u0005n\u0000\u0000\u05d8\u05d9\u0005i"+ + "\u0000\u0000\u05d9\u05da\u0005n\u0000\u0000\u05da\u05db\u0005l\u0000\u0000"+ + "\u05db\u05dc\u0005i\u0000\u0000\u05dc\u05dd\u0005n\u0000\u0000\u05dd\u060a"+ + "\u0005e\u0000\u0000\u05de\u05df\u0005l\u0000\u0000\u05df\u05e0\u0005e"+ + "\u0000\u0000\u05e0\u060a\u0005t\u0000\u0000\u05e1\u05e2\u0005m\u0000\u0000"+ + "\u05e2\u05e3\u0005a\u0000\u0000\u05e3\u05e4\u0005t\u0000\u0000\u05e4\u05e5"+ + "\u0005c\u0000\u0000\u05e5\u060a\u0005h\u0000\u0000\u05e6\u05e7\u0005n"+ + "\u0000\u0000\u05e7\u05e8\u0005u\u0000\u0000\u05e8\u05e9\u0005l\u0000\u0000"+ + "\u05e9\u060a\u0005l\u0000\u0000\u05ea\u05eb\u0005o\u0000\u0000\u05eb\u060a"+ + "\u0005f\u0000\u0000\u05ec\u05ed\u0005r\u0000\u0000\u05ed\u05ee\u0005e"+ + "\u0000\u0000\u05ee\u05ef\u0005l\u0000\u0000\u05ef\u05f0\u0005o\u0000\u0000"+ + "\u05f0\u05f1\u0005c\u0000\u0000\u05f1\u05f2\u0005a\u0000\u0000\u05f2\u05f3"+ + "\u0005t\u0000\u0000\u05f3\u05f4\u0005a\u0000\u0000\u05f4\u05f5\u0005b"+ + "\u0000\u0000\u05f5\u05f6\u0005l\u0000\u0000\u05f6\u060a\u0005e\u0000\u0000"+ + "\u05f7\u05f8\u0005s\u0000\u0000\u05f8\u05f9\u0005t\u0000\u0000\u05f9\u05fa"+ + "\u0005a\u0000\u0000\u05fa\u05fb\u0005t\u0000\u0000\u05fb\u05fc\u0005i"+ + "\u0000\u0000\u05fc\u060a\u0005c\u0000\u0000\u05fd\u05fe\u0005s\u0000\u0000"+ + "\u05fe\u05ff\u0005w\u0000\u0000\u05ff\u0600\u0005i\u0000\u0000\u0600\u0601"+ + "\u0005t\u0000\u0000\u0601\u0602\u0005c\u0000\u0000\u0602\u060a\u0005h"+ + "\u0000\u0000\u0603\u0604\u0005t\u0000\u0000\u0604\u0605\u0005y\u0000\u0000"+ + "\u0605\u0606\u0005p\u0000\u0000\u0606\u0607\u0005e\u0000\u0000\u0607\u0608"+ + "\u0005o\u0000\u0000\u0608\u060a\u0005f\u0000\u0000\u0609\u05c1\u0001\u0000"+ + "\u0000\u0000\u0609\u05c6\u0001\u0000\u0000\u0000\u0609\u05ca\u0001\u0000"+ + "\u0000\u0000\u0609\u05d1\u0001\u0000\u0000\u0000\u0609\u05d6\u0001\u0000"+ + "\u0000\u0000\u0609\u05d8\u0001\u0000\u0000\u0000\u0609\u05de\u0001\u0000"+ + "\u0000\u0000\u0609\u05e1\u0001\u0000\u0000\u0000\u0609\u05e6\u0001\u0000"+ + "\u0000\u0000\u0609\u05ea\u0001\u0000\u0000\u0000\u0609\u05ec\u0001\u0000"+ + "\u0000\u0000\u0609\u05f7\u0001\u0000\u0000\u0000\u0609\u05fd\u0001\u0000"+ + "\u0000\u0000\u0609\u0603\u0001\u0000\u0000\u0000\u060a\u00d6\u0001\u0000"+ + "\u0000\u0000\u060b\u060c\u0005a\u0000\u0000\u060c\u060d\u0005n\u0000\u0000"+ + "\u060d\u060e\u0005o\u0000\u0000\u060e\u060f\u0005n\u0000\u0000\u060f\u0610"+ + "\u0005y\u0000\u0000\u0610\u0611\u0005m\u0000\u0000\u0611\u0612\u0005o"+ + "\u0000\u0000\u0612\u0613\u0005u\u0000\u0000\u0613\u0614\u0005s\u0000\u0000"+ + "\u0614\u00d8\u0001\u0000\u0000\u0000\u0615\u0616\u0005b\u0000\u0000\u0616"+ + "\u0617\u0005r\u0000\u0000\u0617\u0618\u0005e\u0000\u0000\u0618\u0619\u0005"+ + "a\u0000\u0000\u0619\u061a\u0005k\u0000\u0000\u061a\u00da\u0001\u0000\u0000"+ + "\u0000\u061b\u061c\u0005c\u0000\u0000\u061c\u061d\u0005o\u0000\u0000\u061d"+ + "\u061e\u0005n\u0000\u0000\u061e\u061f\u0005s\u0000\u0000\u061f\u0620\u0005"+ + "t\u0000\u0000\u0620\u0621\u0005a\u0000\u0000\u0621\u0622\u0005n\u0000"+ + "\u0000\u0622\u0623\u0005t\u0000\u0000\u0623\u00dc\u0001\u0000\u0000\u0000"+ + "\u0624\u0625\u0005i\u0000\u0000\u0625\u0626\u0005m\u0000\u0000\u0626\u0627"+ + "\u0005m\u0000\u0000\u0627\u0628\u0005u\u0000\u0000\u0628\u0629\u0005t"+ + "\u0000\u0000\u0629\u062a\u0005a\u0000\u0000\u062a\u062b\u0005b\u0000\u0000"+ + "\u062b\u062c\u0005l\u0000\u0000\u062c\u062d\u0005e\u0000\u0000\u062d\u00de"+ + "\u0001\u0000\u0000\u0000\u062e\u062f\u0005c\u0000\u0000\u062f\u0630\u0005"+ + "o\u0000\u0000\u0630\u0631\u0005n\u0000\u0000\u0631\u0632\u0005t\u0000"+ + "\u0000\u0632\u0633\u0005i\u0000\u0000\u0633\u0634\u0005n\u0000\u0000\u0634"+ + "\u0635\u0005u\u0000\u0000\u0635\u0636\u0005e\u0000\u0000\u0636\u00e0\u0001"+ + "\u0000\u0000\u0000\u0637\u0638\u0005l\u0000\u0000\u0638\u0639\u0005e\u0000"+ + "\u0000\u0639\u063a\u0005a\u0000\u0000\u063a\u063b\u0005v\u0000\u0000\u063b"+ + "\u063c\u0005e\u0000\u0000\u063c\u00e2\u0001\u0000\u0000\u0000\u063d\u063e"+ + "\u0005e\u0000\u0000\u063e\u063f\u0005x\u0000\u0000\u063f\u0640\u0005t"+ + "\u0000\u0000\u0640\u0641\u0005e\u0000\u0000\u0641\u0642\u0005r\u0000\u0000"+ + "\u0642\u0643\u0005n\u0000\u0000\u0643\u0644\u0005a\u0000\u0000\u0644\u0645"+ + "\u0005l\u0000\u0000\u0645\u00e4\u0001\u0000\u0000\u0000\u0646\u0647\u0005"+ + "i\u0000\u0000\u0647\u0648\u0005n\u0000\u0000\u0648\u0649\u0005d\u0000"+ + "\u0000\u0649\u064a\u0005e\u0000\u0000\u064a\u064b\u0005x\u0000\u0000\u064b"+ + "\u064c\u0005e\u0000\u0000\u064c\u064d\u0005d\u0000\u0000\u064d\u00e6\u0001"+ + "\u0000\u0000\u0000\u064e\u064f\u0005i\u0000\u0000\u064f\u0650\u0005n\u0000"+ + "\u0000\u0650\u0651\u0005t\u0000\u0000\u0651\u0652\u0005e\u0000\u0000\u0652"+ + "\u0653\u0005r\u0000\u0000\u0653\u0654\u0005n\u0000\u0000\u0654\u0655\u0005"+ + "a\u0000\u0000\u0655\u0656\u0005l\u0000\u0000\u0656\u00e8\u0001\u0000\u0000"+ + "\u0000\u0657\u0658\u0005p\u0000\u0000\u0658\u0659\u0005a\u0000\u0000\u0659"+ + "\u065a\u0005y\u0000\u0000\u065a\u065b\u0005a\u0000\u0000\u065b\u065c\u0005"+ + "b\u0000\u0000\u065c\u065d\u0005l\u0000\u0000\u065d\u065e\u0005e\u0000"+ + "\u0000\u065e\u00ea\u0001\u0000\u0000\u0000\u065f\u0660\u0005p\u0000\u0000"+ + "\u0660\u0661\u0005r\u0000\u0000\u0661\u0662\u0005i\u0000\u0000\u0662\u0663"+ + "\u0005v\u0000\u0000\u0663\u0664\u0005a\u0000\u0000\u0664\u0665\u0005t"+ + "\u0000\u0000\u0665\u0666\u0005e\u0000\u0000\u0666\u00ec\u0001\u0000\u0000"+ + "\u0000\u0667\u0668\u0005p\u0000\u0000\u0668\u0669\u0005u\u0000\u0000\u0669"+ + "\u066a\u0005b\u0000\u0000\u066a\u066b\u0005l\u0000\u0000\u066b\u066c\u0005"+ + "i\u0000\u0000\u066c\u066d\u0005c\u0000\u0000\u066d\u00ee\u0001\u0000\u0000"+ + "\u0000\u066e\u066f\u0005v\u0000\u0000\u066f\u0670\u0005i\u0000\u0000\u0670"+ + "\u0671\u0005r\u0000\u0000\u0671\u0672\u0005t\u0000\u0000\u0672\u0673\u0005"+ + "u\u0000\u0000\u0673\u0674\u0005a\u0000\u0000\u0674\u0675\u0005l\u0000"+ + "\u0000\u0675\u00f0\u0001\u0000\u0000\u0000\u0676\u0677\u0005p\u0000\u0000"+ + "\u0677\u0678\u0005u\u0000\u0000\u0678\u0679\u0005r\u0000\u0000\u0679\u067a"+ + "\u0005e\u0000\u0000\u067a\u00f2\u0001\u0000\u0000\u0000\u067b\u067c\u0005"+ + "t\u0000\u0000\u067c\u067d\u0005y\u0000\u0000\u067d\u067e\u0005p\u0000"+ + "\u0000\u067e\u067f\u0005e\u0000\u0000\u067f\u00f4\u0001\u0000\u0000\u0000"+ + "\u0680\u0681\u0005v\u0000\u0000\u0681\u0682\u0005i\u0000\u0000\u0682\u0683"+ + "\u0005e\u0000\u0000\u0683\u0684\u0005w\u0000\u0000\u0684\u00f6\u0001\u0000"+ + "\u0000\u0000\u0685\u0686\u0005c\u0000\u0000\u0686\u0687\u0005o\u0000\u0000"+ + "\u0687\u0688\u0005n\u0000\u0000\u0688\u0689\u0005s\u0000\u0000\u0689\u068a"+ + "\u0005t\u0000\u0000\u068a\u068b\u0005r\u0000\u0000\u068b\u068c\u0005u"+ + "\u0000\u0000\u068c\u068d\u0005c\u0000\u0000\u068d\u068e\u0005t\u0000\u0000"+ + "\u068e\u068f\u0005o\u0000\u0000\u068f\u0690\u0005r\u0000\u0000\u0690\u00f8"+ + "\u0001\u0000\u0000\u0000\u0691\u0692\u0005f\u0000\u0000\u0692\u0693\u0005"+ + "a\u0000\u0000\u0693\u0694\u0005l\u0000\u0000\u0694\u0695\u0005l\u0000"+ + "\u0000\u0695\u0696\u0005b\u0000\u0000\u0696\u0697\u0005a\u0000\u0000\u0697"+ + "\u0698\u0005c\u0000\u0000\u0698\u0699\u0005k\u0000\u0000\u0699\u00fa\u0001"+ + "\u0000\u0000\u0000\u069a\u069b\u0005r\u0000\u0000\u069b\u069c\u0005e\u0000"+ + "\u0000\u069c\u069d\u0005c\u0000\u0000\u069d\u069e\u0005e\u0000\u0000\u069e"+ + "\u069f\u0005i\u0000\u0000\u069f\u06a0\u0005v\u0000\u0000\u06a0\u06a1\u0005"+ + "e\u0000\u0000\u06a1\u00fc\u0001\u0000\u0000\u0000\u06a2\u06a6\u0003\u00ff"+ + "\u007f\u0000\u06a3\u06a5\u0003\u0101\u0080\u0000\u06a4\u06a3\u0001\u0000"+ + "\u0000\u0000\u06a5\u06a8\u0001\u0000\u0000\u0000\u06a6\u06a4\u0001\u0000"+ + "\u0000\u0000\u06a6\u06a7\u0001\u0000\u0000\u0000\u06a7\u00fe\u0001\u0000"+ + "\u0000\u0000\u06a8\u06a6\u0001\u0000\u0000\u0000\u06a9\u06aa\u0007\u0004"+ + "\u0000\u0000\u06aa\u0100\u0001\u0000\u0000\u0000\u06ab\u06ac\u0007\u0005"+ + "\u0000\u0000\u06ac\u0102\u0001\u0000\u0000\u0000\u06ad\u06b1\u0005\"\u0000"+ + "\u0000\u06ae\u06b0\u0003\u0105\u0082\u0000\u06af\u06ae\u0001\u0000\u0000"+ + "\u0000\u06b0\u06b3\u0001\u0000\u0000\u0000\u06b1\u06af\u0001\u0000\u0000"+ + "\u0000\u06b1\u06b2\u0001\u0000\u0000\u0000\u06b2\u06b4\u0001\u0000\u0000"+ + "\u0000\u06b3\u06b1\u0001\u0000\u0000\u0000\u06b4\u06be\u0005\"\u0000\u0000"+ + "\u06b5\u06b9\u0005\'\u0000\u0000\u06b6\u06b8\u0003\u0107\u0083\u0000\u06b7"+ + "\u06b6\u0001\u0000\u0000\u0000\u06b8\u06bb\u0001\u0000\u0000\u0000\u06b9"+ + "\u06b7\u0001\u0000\u0000\u0000\u06b9\u06ba\u0001\u0000\u0000\u0000\u06ba"+ + "\u06bc\u0001\u0000\u0000\u0000\u06bb\u06b9\u0001\u0000\u0000\u0000\u06bc"+ + "\u06be\u0005\'\u0000\u0000\u06bd\u06ad\u0001\u0000\u0000\u0000\u06bd\u06b5"+ + "\u0001\u0000\u0000\u0000\u06be\u0104\u0001\u0000\u0000\u0000\u06bf\u06c3"+ + "\b\u0006\u0000\u0000\u06c0\u06c1\u0005\\\u0000\u0000\u06c1\u06c3\t\u0000"+ + "\u0000\u0000\u06c2\u06bf\u0001\u0000\u0000\u0000\u06c2\u06c0\u0001\u0000"+ + "\u0000\u0000\u06c3\u0106\u0001\u0000\u0000\u0000\u06c4\u06c8\b\u0007\u0000"+ + "\u0000\u06c5\u06c6\u0005\\\u0000\u0000\u06c6\u06c8\t\u0000\u0000\u0000"+ + "\u06c7\u06c4\u0001\u0000\u0000\u0000\u06c7\u06c5\u0001\u0000\u0000\u0000"+ + "\u06c8\u0108\u0001\u0000\u0000\u0000\u06c9\u06cb\u0007\u0000\u0000\u0000"+ + "\u06ca\u06c9\u0001\u0000\u0000\u0000\u06cb\u06cc\u0001\u0000\u0000\u0000"+ + "\u06cc\u06ca\u0001\u0000\u0000\u0000\u06cc\u06cd\u0001\u0000\u0000\u0000"+ + "\u06cd\u06ce\u0001\u0000\u0000\u0000\u06ce\u06d0\u0005.\u0000\u0000\u06cf"+ + "\u06d1\u0007\u0000\u0000\u0000\u06d0\u06cf\u0001\u0000\u0000\u0000\u06d1"+ + "\u06d2\u0001\u0000\u0000\u0000\u06d2\u06d0\u0001\u0000\u0000\u0000\u06d2"+ + "\u06d3\u0001\u0000\u0000\u0000\u06d3\u06da\u0001\u0000\u0000\u0000\u06d4"+ + "\u06d6\u0005.\u0000\u0000\u06d5\u06d7\u0007\u0000\u0000\u0000\u06d6\u06d5"+ + "\u0001\u0000\u0000\u0000\u06d7\u06d8\u0001\u0000\u0000\u0000\u06d8\u06d6"+ + "\u0001\u0000\u0000\u0000\u06d8\u06d9\u0001\u0000\u0000\u0000\u06d9\u06db"+ + "\u0001\u0000\u0000\u0000\u06da\u06d4\u0001\u0000\u0000\u0000\u06da\u06db"+ + "\u0001\u0000\u0000\u0000\u06db\u010a\u0001\u0000\u0000\u0000\u06dc\u06de"+ + "\u0007\b\u0000\u0000\u06dd\u06dc\u0001\u0000\u0000\u0000\u06de\u06df\u0001"+ + "\u0000\u0000\u0000\u06df\u06dd\u0001\u0000\u0000\u0000\u06df\u06e0\u0001"+ + "\u0000\u0000\u0000\u06e0\u06e1\u0001\u0000\u0000\u0000\u06e1\u06e2\u0006"+ + "\u0085\u0000\u0000\u06e2\u010c\u0001\u0000\u0000\u0000\u06e3\u06e4\u0005"+ + "/\u0000\u0000\u06e4\u06e5\u0005*\u0000\u0000\u06e5\u06e9\u0001\u0000\u0000"+ + "\u0000\u06e6\u06e8\t\u0000\u0000\u0000\u06e7\u06e6\u0001\u0000\u0000\u0000"+ + "\u06e8\u06eb\u0001\u0000\u0000\u0000\u06e9\u06ea\u0001\u0000\u0000\u0000"+ + "\u06e9\u06e7\u0001\u0000\u0000\u0000\u06ea\u06ec\u0001\u0000\u0000\u0000"+ + "\u06eb\u06e9\u0001\u0000\u0000\u0000\u06ec\u06ed\u0005*\u0000\u0000\u06ed"+ + "\u06ee\u0005/\u0000\u0000\u06ee\u06ef\u0001\u0000\u0000\u0000\u06ef\u06f0"+ + "\u0006\u0086\u0001\u0000\u06f0\u010e\u0001\u0000\u0000\u0000\u06f1\u06f2"+ + "\u0005/\u0000\u0000\u06f2\u06f3\u0005/\u0000\u0000\u06f3\u06f7\u0001\u0000"+ + "\u0000\u0000\u06f4\u06f6\b\t\u0000\u0000\u06f5\u06f4\u0001\u0000\u0000"+ + "\u0000\u06f6\u06f9\u0001\u0000\u0000\u0000\u06f7\u06f5\u0001\u0000\u0000"+ + "\u0000\u06f7\u06f8\u0001\u0000\u0000\u0000\u06f8\u06fa\u0001\u0000\u0000"+ + "\u0000\u06f9\u06f7\u0001\u0000\u0000\u0000\u06fa\u06fb\u0006\u0087\u0001"+ + "\u0000\u06fb\u0110\u0001\u0000\u0000\u0000%\u0000\u0359\u0432\u0510\u0520"+ + "\u0526\u0528\u053a\u0540\u0542\u054d\u0551\u0555\u0559\u055c\u0560\u0565"+ + "\u056e\u0573\u05aa\u05b2\u05b7\u05ba\u0609\u06a6\u06b1\u06b9\u06bd\u06c2"+ + "\u06c7\u06cc\u06d2\u06d8\u06da\u06df\u06e9\u06f7\u0002\u0006\u0000\u0000"+ + "\u0000\u0001\u0000"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/vanguard/aleo/parser/.antlr/SolidityLexer.tokens b/vanguard/aleo/parser/.antlr/SolidityLexer.tokens new file mode 100644 index 0000000..ffcbd26 --- /dev/null +++ b/vanguard/aleo/parser/.antlr/SolidityLexer.tokens @@ -0,0 +1,239 @@ +T__0=1 +T__1=2 +T__2=3 +T__3=4 +T__4=5 +T__5=6 +T__6=7 +T__7=8 +T__8=9 +T__9=10 +T__10=11 +T__11=12 +T__12=13 +T__13=14 +T__14=15 +T__15=16 +T__16=17 +T__17=18 +T__18=19 +T__19=20 +T__20=21 +T__21=22 +T__22=23 +T__23=24 +T__24=25 +T__25=26 +T__26=27 +T__27=28 +T__28=29 +T__29=30 +T__30=31 +T__31=32 +T__32=33 +T__33=34 +T__34=35 +T__35=36 +T__36=37 +T__37=38 +T__38=39 +T__39=40 +T__40=41 +T__41=42 +T__42=43 +T__43=44 +T__44=45 +T__45=46 +T__46=47 +T__47=48 +T__48=49 +T__49=50 +T__50=51 +T__51=52 +T__52=53 +T__53=54 +T__54=55 +T__55=56 +T__56=57 +T__57=58 +T__58=59 +T__59=60 +T__60=61 +T__61=62 +T__62=63 +T__63=64 +T__64=65 +T__65=66 +T__66=67 +T__67=68 +T__68=69 +T__69=70 +T__70=71 +T__71=72 +T__72=73 +T__73=74 +T__74=75 +T__75=76 +T__76=77 +T__77=78 +T__78=79 +T__79=80 +T__80=81 +T__81=82 +T__82=83 +T__83=84 +T__84=85 +T__85=86 +T__86=87 +T__87=88 +T__88=89 +T__89=90 +T__90=91 +T__91=92 +Int=93 +Uint=94 +Byte=95 +Fixed=96 +Ufixed=97 +BooleanLiteral=98 +DecimalNumber=99 +HexNumber=100 +NumberUnit=101 +HexLiteralFragment=102 +ReservedKeyword=103 +AnonymousKeyword=104 +BreakKeyword=105 +ConstantKeyword=106 +ImmutableKeyword=107 +ContinueKeyword=108 +LeaveKeyword=109 +ExternalKeyword=110 +IndexedKeyword=111 +InternalKeyword=112 +PayableKeyword=113 +PrivateKeyword=114 +PublicKeyword=115 +VirtualKeyword=116 +PureKeyword=117 +TypeKeyword=118 +ViewKeyword=119 +ConstructorKeyword=120 +FallbackKeyword=121 +ReceiveKeyword=122 +Identifier=123 +StringLiteralFragment=124 +VersionLiteral=125 +WS=126 +COMMENT=127 +LINE_COMMENT=128 +'pragma'=1 +';'=2 +'^'=3 +'~'=4 +'>='=5 +'>'=6 +'<'=7 +'<='=8 +'='=9 +'import'=10 +'as'=11 +'*'=12 +'from'=13 +'{'=14 +','=15 +'}'=16 +'abstract'=17 +'contract'=18 +'interface'=19 +'library'=20 +'is'=21 +'('=22 +')'=23 +'override'=24 +'using'=25 +'for'=26 +'struct'=27 +'modifier'=28 +'function'=29 +'returns'=30 +'event'=31 +'enum'=32 +'['=33 +']'=34 +'.'=35 +'mapping'=36 +'=>'=37 +'memory'=38 +'storage'=39 +'calldata'=40 +'if'=41 +'else'=42 +'try'=43 +'catch'=44 +'while'=45 +'assembly'=46 +'do'=47 +'return'=48 +'throw'=49 +'emit'=50 +'var'=51 +'address'=52 +'bool'=53 +'string'=54 +'byte'=55 +'++'=56 +'--'=57 +'new'=58 +':'=59 +'+'=60 +'-'=61 +'after'=62 +'delete'=63 +'!'=64 +'**'=65 +'/'=66 +'%'=67 +'<<'=68 +'>>'=69 +'&'=70 +'|'=71 +'=='=72 +'!='=73 +'&&'=74 +'||'=75 +'?'=76 +'|='=77 +'^='=78 +'&='=79 +'<<='=80 +'>>='=81 +'+='=82 +'-='=83 +'*='=84 +'/='=85 +'%='=86 +'let'=87 +':='=88 +'=:'=89 +'switch'=90 +'case'=91 +'default'=92 +'anonymous'=104 +'break'=105 +'constant'=106 +'immutable'=107 +'continue'=108 +'leave'=109 +'external'=110 +'indexed'=111 +'internal'=112 +'payable'=113 +'private'=114 +'public'=115 +'virtual'=116 +'pure'=117 +'type'=118 +'view'=119 +'constructor'=120 +'fallback'=121 +'receive'=122 diff --git a/vanguard/aleo/parser/.antlr/SolidityParser.java b/vanguard/aleo/parser/.antlr/SolidityParser.java new file mode 100644 index 0000000..2e3897c --- /dev/null +++ b/vanguard/aleo/parser/.antlr/SolidityParser.java @@ -0,0 +1,7225 @@ +// Generated from /Users/joseph/Desktop/UCSB/24winter/vanguard-aleo/vanguard/aleo/parser/Solidity.g4 by ANTLR 4.13.1 +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"}) +public class SolidityParser extends Parser { + static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, + T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, + T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, + T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31, + T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38, + T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, T__44=45, + T__45=46, T__46=47, T__47=48, T__48=49, T__49=50, T__50=51, T__51=52, + T__52=53, T__53=54, T__54=55, T__55=56, T__56=57, T__57=58, T__58=59, + T__59=60, T__60=61, T__61=62, T__62=63, T__63=64, T__64=65, T__65=66, + T__66=67, T__67=68, T__68=69, T__69=70, T__70=71, T__71=72, T__72=73, + T__73=74, T__74=75, T__75=76, T__76=77, T__77=78, T__78=79, T__79=80, + T__80=81, T__81=82, T__82=83, T__83=84, T__84=85, T__85=86, T__86=87, + T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, Int=93, Uint=94, Byte=95, + Fixed=96, Ufixed=97, BooleanLiteral=98, DecimalNumber=99, HexNumber=100, + NumberUnit=101, HexLiteralFragment=102, ReservedKeyword=103, AnonymousKeyword=104, + BreakKeyword=105, ConstantKeyword=106, ImmutableKeyword=107, ContinueKeyword=108, + LeaveKeyword=109, ExternalKeyword=110, IndexedKeyword=111, InternalKeyword=112, + PayableKeyword=113, PrivateKeyword=114, PublicKeyword=115, VirtualKeyword=116, + PureKeyword=117, TypeKeyword=118, ViewKeyword=119, ConstructorKeyword=120, + FallbackKeyword=121, ReceiveKeyword=122, Identifier=123, StringLiteralFragment=124, + VersionLiteral=125, WS=126, COMMENT=127, LINE_COMMENT=128; + public static final int + RULE_sourceUnit = 0, RULE_pragmaDirective = 1, RULE_pragmaName = 2, RULE_pragmaValue = 3, + RULE_version = 4, RULE_versionConstraint = 5, RULE_versionOperator = 6, + RULE_importDirective = 7, RULE_importDeclaration = 8, RULE_contractDefinition = 9, + RULE_inheritanceSpecifier = 10, RULE_contractPart = 11, RULE_stateVariableDeclaration = 12, + RULE_overrideSpecifier = 13, RULE_usingForDeclaration = 14, RULE_structDefinition = 15, + RULE_modifierDefinition = 16, RULE_functionDefinition = 17, RULE_functionDescriptor = 18, + RULE_returnParameters = 19, RULE_modifierList = 20, RULE_modifierInvocation = 21, + RULE_eventDefinition = 22, RULE_enumDefinition = 23, RULE_enumValue = 24, + RULE_parameterList = 25, RULE_parameter = 26, RULE_eventParameterList = 27, + RULE_eventParameter = 28, RULE_variableDeclaration = 29, RULE_typeName = 30, + RULE_userDefinedTypeName = 31, RULE_mapping = 32, RULE_functionTypeName = 33, + RULE_storageLocation = 34, RULE_stateMutability = 35, RULE_block = 36, + RULE_statement = 37, RULE_expressionStatement = 38, RULE_ifStatement = 39, + RULE_tryStatement = 40, RULE_catchClause = 41, RULE_whileStatement = 42, + RULE_forStatement = 43, RULE_simpleStatement = 44, RULE_inlineAssemblyStatement = 45, + RULE_doWhileStatement = 46, RULE_continueStatement = 47, RULE_breakStatement = 48, + RULE_returnStatement = 49, RULE_throwStatement = 50, RULE_emitStatement = 51, + RULE_variableDeclarationStatement = 52, RULE_variableDeclarationList = 53, + RULE_identifierList = 54, RULE_elementaryTypeName = 55, RULE_expression = 56, + RULE_primaryExpression = 57, RULE_expressionList = 58, RULE_nameValueList = 59, + RULE_nameValue = 60, RULE_functionCallArguments = 61, RULE_functionCall = 62, + RULE_tupleExpression = 63, RULE_typeNameExpression = 64, RULE_assemblyItem = 65, + RULE_assemblyBlock = 66, RULE_assemblyExpression = 67, RULE_assemblyCall = 68, + RULE_assemblyLocalDefinition = 69, RULE_assemblyAssignment = 70, RULE_assemblyIdentifierList = 71, + RULE_assemblyStackAssignment = 72, RULE_labelDefinition = 73, RULE_assemblySwitch = 74, + RULE_assemblyCase = 75, RULE_assemblyFunctionDefinition = 76, RULE_assemblyFunctionReturns = 77, + RULE_assemblyFor = 78, RULE_assemblyIf = 79, RULE_assemblyLiteral = 80, + RULE_assemblyTypedVariableList = 81, RULE_assemblyType = 82, RULE_subAssembly = 83, + RULE_numberLiteral = 84, RULE_identifier = 85, RULE_hexLiteral = 86, RULE_stringLiteral = 87; + private static String[] makeRuleNames() { + return new String[] { + "sourceUnit", "pragmaDirective", "pragmaName", "pragmaValue", "version", + "versionConstraint", "versionOperator", "importDirective", "importDeclaration", + "contractDefinition", "inheritanceSpecifier", "contractPart", "stateVariableDeclaration", + "overrideSpecifier", "usingForDeclaration", "structDefinition", "modifierDefinition", + "functionDefinition", "functionDescriptor", "returnParameters", "modifierList", + "modifierInvocation", "eventDefinition", "enumDefinition", "enumValue", + "parameterList", "parameter", "eventParameterList", "eventParameter", + "variableDeclaration", "typeName", "userDefinedTypeName", "mapping", + "functionTypeName", "storageLocation", "stateMutability", "block", "statement", + "expressionStatement", "ifStatement", "tryStatement", "catchClause", + "whileStatement", "forStatement", "simpleStatement", "inlineAssemblyStatement", + "doWhileStatement", "continueStatement", "breakStatement", "returnStatement", + "throwStatement", "emitStatement", "variableDeclarationStatement", "variableDeclarationList", + "identifierList", "elementaryTypeName", "expression", "primaryExpression", + "expressionList", "nameValueList", "nameValue", "functionCallArguments", + "functionCall", "tupleExpression", "typeNameExpression", "assemblyItem", + "assemblyBlock", "assemblyExpression", "assemblyCall", "assemblyLocalDefinition", + "assemblyAssignment", "assemblyIdentifierList", "assemblyStackAssignment", + "labelDefinition", "assemblySwitch", "assemblyCase", "assemblyFunctionDefinition", + "assemblyFunctionReturns", "assemblyFor", "assemblyIf", "assemblyLiteral", + "assemblyTypedVariableList", "assemblyType", "subAssembly", "numberLiteral", + "identifier", "hexLiteral", "stringLiteral" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, "'pragma'", "';'", "'^'", "'~'", "'>='", "'>'", "'<'", "'<='", + "'='", "'import'", "'as'", "'*'", "'from'", "'{'", "','", "'}'", "'abstract'", + "'contract'", "'interface'", "'library'", "'is'", "'('", "')'", "'override'", + "'using'", "'for'", "'struct'", "'modifier'", "'function'", "'returns'", + "'event'", "'enum'", "'['", "']'", "'.'", "'mapping'", "'=>'", "'memory'", + "'storage'", "'calldata'", "'if'", "'else'", "'try'", "'catch'", "'while'", + "'assembly'", "'do'", "'return'", "'throw'", "'emit'", "'var'", "'address'", + "'bool'", "'string'", "'byte'", "'++'", "'--'", "'new'", "':'", "'+'", + "'-'", "'after'", "'delete'", "'!'", "'**'", "'/'", "'%'", "'<<'", "'>>'", + "'&'", "'|'", "'=='", "'!='", "'&&'", "'||'", "'?'", "'|='", "'^='", + "'&='", "'<<='", "'>>='", "'+='", "'-='", "'*='", "'/='", "'%='", "'let'", + "':='", "'=:'", "'switch'", "'case'", "'default'", null, null, null, + null, null, null, null, null, null, null, null, "'anonymous'", "'break'", + "'constant'", "'immutable'", "'continue'", "'leave'", "'external'", "'indexed'", + "'internal'", "'payable'", "'private'", "'public'", "'virtual'", "'pure'", + "'type'", "'view'", "'constructor'", "'fallback'", "'receive'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, "Int", "Uint", + "Byte", "Fixed", "Ufixed", "BooleanLiteral", "DecimalNumber", "HexNumber", + "NumberUnit", "HexLiteralFragment", "ReservedKeyword", "AnonymousKeyword", + "BreakKeyword", "ConstantKeyword", "ImmutableKeyword", "ContinueKeyword", + "LeaveKeyword", "ExternalKeyword", "IndexedKeyword", "InternalKeyword", + "PayableKeyword", "PrivateKeyword", "PublicKeyword", "VirtualKeyword", + "PureKeyword", "TypeKeyword", "ViewKeyword", "ConstructorKeyword", "FallbackKeyword", + "ReceiveKeyword", "Identifier", "StringLiteralFragment", "VersionLiteral", + "WS", "COMMENT", "LINE_COMMENT" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getGrammarFileName() { return "Solidity.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public SolidityParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @SuppressWarnings("CheckReturnValue") + public static class SourceUnitContext extends ParserRuleContext { + public TerminalNode EOF() { return getToken(SolidityParser.EOF, 0); } + public List pragmaDirective() { + return getRuleContexts(PragmaDirectiveContext.class); + } + public PragmaDirectiveContext pragmaDirective(int i) { + return getRuleContext(PragmaDirectiveContext.class,i); + } + public List importDirective() { + return getRuleContexts(ImportDirectiveContext.class); + } + public ImportDirectiveContext importDirective(int i) { + return getRuleContext(ImportDirectiveContext.class,i); + } + public List structDefinition() { + return getRuleContexts(StructDefinitionContext.class); + } + public StructDefinitionContext structDefinition(int i) { + return getRuleContext(StructDefinitionContext.class,i); + } + public List enumDefinition() { + return getRuleContexts(EnumDefinitionContext.class); + } + public EnumDefinitionContext enumDefinition(int i) { + return getRuleContext(EnumDefinitionContext.class,i); + } + public List contractDefinition() { + return getRuleContexts(ContractDefinitionContext.class); + } + public ContractDefinitionContext contractDefinition(int i) { + return getRuleContext(ContractDefinitionContext.class,i); + } + public SourceUnitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sourceUnit; } + } + + public final SourceUnitContext sourceUnit() throws RecognitionException { + SourceUnitContext _localctx = new SourceUnitContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_sourceUnit); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(183); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4431152130L) != 0)) { + { + setState(181); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__0: + { + setState(176); + pragmaDirective(); + } + break; + case T__9: + { + setState(177); + importDirective(); + } + break; + case T__26: + { + setState(178); + structDefinition(); + } + break; + case T__31: + { + setState(179); + enumDefinition(); + } + break; + case T__16: + case T__17: + case T__18: + case T__19: + { + setState(180); + contractDefinition(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(185); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(186); + match(EOF); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PragmaDirectiveContext extends ParserRuleContext { + public PragmaNameContext pragmaName() { + return getRuleContext(PragmaNameContext.class,0); + } + public PragmaValueContext pragmaValue() { + return getRuleContext(PragmaValueContext.class,0); + } + public PragmaDirectiveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_pragmaDirective; } + } + + public final PragmaDirectiveContext pragmaDirective() throws RecognitionException { + PragmaDirectiveContext _localctx = new PragmaDirectiveContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_pragmaDirective); + try { + enterOuterAlt(_localctx, 1); + { + setState(188); + match(T__0); + setState(189); + pragmaName(); + setState(190); + pragmaValue(); + setState(191); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PragmaNameContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public PragmaNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_pragmaName; } + } + + public final PragmaNameContext pragmaName() throws RecognitionException { + PragmaNameContext _localctx = new PragmaNameContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_pragmaName); + try { + enterOuterAlt(_localctx, 1); + { + setState(193); + identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PragmaValueContext extends ParserRuleContext { + public VersionContext version() { + return getRuleContext(VersionContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public PragmaValueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_pragmaValue; } + } + + public final PragmaValueContext pragmaValue() throws RecognitionException { + PragmaValueContext _localctx = new PragmaValueContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_pragmaValue); + try { + setState(197); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(195); + version(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(196); + expression(0); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VersionContext extends ParserRuleContext { + public List versionConstraint() { + return getRuleContexts(VersionConstraintContext.class); + } + public VersionConstraintContext versionConstraint(int i) { + return getRuleContext(VersionConstraintContext.class,i); + } + public VersionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_version; } + } + + public final VersionContext version() throws RecognitionException { + VersionContext _localctx = new VersionContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_version); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(199); + versionConstraint(); + setState(201); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1016L) != 0) || _la==VersionLiteral) { + { + setState(200); + versionConstraint(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VersionConstraintContext extends ParserRuleContext { + public TerminalNode VersionLiteral() { return getToken(SolidityParser.VersionLiteral, 0); } + public VersionOperatorContext versionOperator() { + return getRuleContext(VersionOperatorContext.class,0); + } + public VersionConstraintContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_versionConstraint; } + } + + public final VersionConstraintContext versionConstraint() throws RecognitionException { + VersionConstraintContext _localctx = new VersionConstraintContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_versionConstraint); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(204); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1016L) != 0)) { + { + setState(203); + versionOperator(); + } + } + + setState(206); + match(VersionLiteral); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VersionOperatorContext extends ParserRuleContext { + public VersionOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_versionOperator; } + } + + public final VersionOperatorContext versionOperator() throws RecognitionException { + VersionOperatorContext _localctx = new VersionOperatorContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_versionOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(208); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 1016L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ImportDirectiveContext extends ParserRuleContext { + public TerminalNode StringLiteralFragment() { return getToken(SolidityParser.StringLiteralFragment, 0); } + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public List importDeclaration() { + return getRuleContexts(ImportDeclarationContext.class); + } + public ImportDeclarationContext importDeclaration(int i) { + return getRuleContext(ImportDeclarationContext.class,i); + } + public ImportDirectiveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_importDirective; } + } + + public final ImportDirectiveContext importDirective() throws RecognitionException { + ImportDirectiveContext _localctx = new ImportDirectiveContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_importDirective); + int _la; + try { + setState(244); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(210); + match(T__9); + setState(211); + match(StringLiteralFragment); + setState(214); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__10) { + { + setState(212); + match(T__10); + setState(213); + identifier(); + } + } + + setState(216); + match(T__1); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(217); + match(T__9); + setState(220); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__11: + { + setState(218); + match(T__11); + } + break; + case T__12: + case T__39: + case T__51: + case Identifier: + { + setState(219); + identifier(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(224); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__10) { + { + setState(222); + match(T__10); + setState(223); + identifier(); + } + } + + setState(226); + match(T__12); + setState(227); + match(StringLiteralFragment); + setState(228); + match(T__1); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(229); + match(T__9); + setState(230); + match(T__13); + setState(231); + importDeclaration(); + setState(236); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__14) { + { + { + setState(232); + match(T__14); + setState(233); + importDeclaration(); + } + } + setState(238); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(239); + match(T__15); + setState(240); + match(T__12); + setState(241); + match(StringLiteralFragment); + setState(242); + match(T__1); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ImportDeclarationContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public ImportDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_importDeclaration; } + } + + public final ImportDeclarationContext importDeclaration() throws RecognitionException { + ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_importDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(246); + identifier(); + setState(249); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__10) { + { + setState(247); + match(T__10); + setState(248); + identifier(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ContractDefinitionContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List inheritanceSpecifier() { + return getRuleContexts(InheritanceSpecifierContext.class); + } + public InheritanceSpecifierContext inheritanceSpecifier(int i) { + return getRuleContext(InheritanceSpecifierContext.class,i); + } + public List contractPart() { + return getRuleContexts(ContractPartContext.class); + } + public ContractPartContext contractPart(int i) { + return getRuleContext(ContractPartContext.class,i); + } + public ContractDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_contractDefinition; } + } + + public final ContractDefinitionContext contractDefinition() throws RecognitionException { + ContractDefinitionContext _localctx = new ContractDefinitionContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_contractDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(252); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__16) { + { + setState(251); + match(T__16); + } + } + + setState(254); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 1835008L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(255); + identifier(); + setState(265); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__20) { + { + setState(256); + match(T__20); + setState(257); + inheritanceSpecifier(); + setState(262); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__14) { + { + { + setState(258); + match(T__14); + setState(259); + inheritanceSpecifier(); + } + } + setState(264); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(267); + match(T__13); + setState(271); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 69806969870884864L) != 0) || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 2013265951L) != 0)) { + { + { + setState(268); + contractPart(); + } + } + setState(273); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(274); + match(T__15); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class InheritanceSpecifierContext extends ParserRuleContext { + public UserDefinedTypeNameContext userDefinedTypeName() { + return getRuleContext(UserDefinedTypeNameContext.class,0); + } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public InheritanceSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_inheritanceSpecifier; } + } + + public final InheritanceSpecifierContext inheritanceSpecifier() throws RecognitionException { + InheritanceSpecifierContext _localctx = new InheritanceSpecifierContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_inheritanceSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(276); + userDefinedTypeName(); + setState(282); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__21) { + { + setState(277); + match(T__21); + setState(279); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -578711444011343856L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1747960017153163265L) != 0)) { + { + setState(278); + expressionList(); + } + } + + setState(281); + match(T__22); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ContractPartContext extends ParserRuleContext { + public StateVariableDeclarationContext stateVariableDeclaration() { + return getRuleContext(StateVariableDeclarationContext.class,0); + } + public UsingForDeclarationContext usingForDeclaration() { + return getRuleContext(UsingForDeclarationContext.class,0); + } + public StructDefinitionContext structDefinition() { + return getRuleContext(StructDefinitionContext.class,0); + } + public ModifierDefinitionContext modifierDefinition() { + return getRuleContext(ModifierDefinitionContext.class,0); + } + public FunctionDefinitionContext functionDefinition() { + return getRuleContext(FunctionDefinitionContext.class,0); + } + public EventDefinitionContext eventDefinition() { + return getRuleContext(EventDefinitionContext.class,0); + } + public EnumDefinitionContext enumDefinition() { + return getRuleContext(EnumDefinitionContext.class,0); + } + public ContractPartContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_contractPart; } + } + + public final ContractPartContext contractPart() throws RecognitionException { + ContractPartContext _localctx = new ContractPartContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_contractPart); + try { + setState(291); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(284); + stateVariableDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(285); + usingForDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(286); + structDefinition(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(287); + modifierDefinition(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(288); + functionDefinition(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(289); + eventDefinition(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(290); + enumDefinition(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StateVariableDeclarationContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List PublicKeyword() { return getTokens(SolidityParser.PublicKeyword); } + public TerminalNode PublicKeyword(int i) { + return getToken(SolidityParser.PublicKeyword, i); + } + public List InternalKeyword() { return getTokens(SolidityParser.InternalKeyword); } + public TerminalNode InternalKeyword(int i) { + return getToken(SolidityParser.InternalKeyword, i); + } + public List PrivateKeyword() { return getTokens(SolidityParser.PrivateKeyword); } + public TerminalNode PrivateKeyword(int i) { + return getToken(SolidityParser.PrivateKeyword, i); + } + public List ConstantKeyword() { return getTokens(SolidityParser.ConstantKeyword); } + public TerminalNode ConstantKeyword(int i) { + return getToken(SolidityParser.ConstantKeyword, i); + } + public List ImmutableKeyword() { return getTokens(SolidityParser.ImmutableKeyword); } + public TerminalNode ImmutableKeyword(int i) { + return getToken(SolidityParser.ImmutableKeyword, i); + } + public List overrideSpecifier() { + return getRuleContexts(OverrideSpecifierContext.class); + } + public OverrideSpecifierContext overrideSpecifier(int i) { + return getRuleContext(OverrideSpecifierContext.class,i); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StateVariableDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stateVariableDeclaration; } + } + + public final StateVariableDeclarationContext stateVariableDeclaration() throws RecognitionException { + StateVariableDeclarationContext _localctx = new StateVariableDeclarationContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_stateVariableDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(293); + typeName(0); + setState(302); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__23 || ((((_la - 106)) & ~0x3f) == 0 && ((1L << (_la - 106)) & 835L) != 0)) { + { + setState(300); + _errHandler.sync(this); + switch (_input.LA(1)) { + case PublicKeyword: + { + setState(294); + match(PublicKeyword); + } + break; + case InternalKeyword: + { + setState(295); + match(InternalKeyword); + } + break; + case PrivateKeyword: + { + setState(296); + match(PrivateKeyword); + } + break; + case ConstantKeyword: + { + setState(297); + match(ConstantKeyword); + } + break; + case ImmutableKeyword: + { + setState(298); + match(ImmutableKeyword); + } + break; + case T__23: + { + setState(299); + overrideSpecifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(304); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(305); + identifier(); + setState(308); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__8) { + { + setState(306); + match(T__8); + setState(307); + expression(0); + } + } + + setState(310); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OverrideSpecifierContext extends ParserRuleContext { + public List userDefinedTypeName() { + return getRuleContexts(UserDefinedTypeNameContext.class); + } + public UserDefinedTypeNameContext userDefinedTypeName(int i) { + return getRuleContext(UserDefinedTypeNameContext.class,i); + } + public OverrideSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_overrideSpecifier; } + } + + public final OverrideSpecifierContext overrideSpecifier() throws RecognitionException { + OverrideSpecifierContext _localctx = new OverrideSpecifierContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_overrideSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(312); + match(T__23); + setState(324); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) { + case 1: + { + setState(313); + match(T__21); + setState(314); + userDefinedTypeName(); + setState(319); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__14) { + { + { + setState(315); + match(T__14); + setState(316); + userDefinedTypeName(); + } + } + setState(321); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(322); + match(T__22); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UsingForDeclarationContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public UsingForDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_usingForDeclaration; } + } + + public final UsingForDeclarationContext usingForDeclaration() throws RecognitionException { + UsingForDeclarationContext _localctx = new UsingForDeclarationContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_usingForDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(326); + match(T__24); + setState(327); + identifier(); + setState(328); + match(T__25); + setState(331); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__11: + { + setState(329); + match(T__11); + } + break; + case T__12: + case T__28: + case T__35: + case T__39: + case T__50: + case T__51: + case T__52: + case T__53: + case T__54: + case Int: + case Uint: + case Byte: + case Fixed: + case Ufixed: + case Identifier: + { + setState(330); + typeName(0); + } + break; + default: + throw new NoViableAltException(this); + } + setState(333); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StructDefinitionContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List variableDeclaration() { + return getRuleContexts(VariableDeclarationContext.class); + } + public VariableDeclarationContext variableDeclaration(int i) { + return getRuleContext(VariableDeclarationContext.class,i); + } + public StructDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_structDefinition; } + } + + public final StructDefinitionContext structDefinition() throws RecognitionException { + StructDefinitionContext _localctx = new StructDefinitionContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_structDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(335); + match(T__26); + setState(336); + identifier(); + setState(337); + match(T__13); + setState(348); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 69806962992226304L) != 0) || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 1073741855L) != 0)) { + { + setState(338); + variableDeclaration(); + setState(339); + match(T__1); + setState(345); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 69806962992226304L) != 0) || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 1073741855L) != 0)) { + { + { + setState(340); + variableDeclaration(); + setState(341); + match(T__1); + } + } + setState(347); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(350); + match(T__15); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ModifierDefinitionContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public ParameterListContext parameterList() { + return getRuleContext(ParameterListContext.class,0); + } + public List VirtualKeyword() { return getTokens(SolidityParser.VirtualKeyword); } + public TerminalNode VirtualKeyword(int i) { + return getToken(SolidityParser.VirtualKeyword, i); + } + public List overrideSpecifier() { + return getRuleContexts(OverrideSpecifierContext.class); + } + public OverrideSpecifierContext overrideSpecifier(int i) { + return getRuleContext(OverrideSpecifierContext.class,i); + } + public ModifierDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_modifierDefinition; } + } + + public final ModifierDefinitionContext modifierDefinition() throws RecognitionException { + ModifierDefinitionContext _localctx = new ModifierDefinitionContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_modifierDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(352); + match(T__27); + setState(353); + identifier(); + setState(355); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__21) { + { + setState(354); + parameterList(); + } + } + + setState(361); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__23 || _la==VirtualKeyword) { + { + setState(359); + _errHandler.sync(this); + switch (_input.LA(1)) { + case VirtualKeyword: + { + setState(357); + match(VirtualKeyword); + } + break; + case T__23: + { + setState(358); + overrideSpecifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(363); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(366); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__1: + { + setState(364); + match(T__1); + } + break; + case T__13: + { + setState(365); + block(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionDefinitionContext extends ParserRuleContext { + public FunctionDescriptorContext functionDescriptor() { + return getRuleContext(FunctionDescriptorContext.class,0); + } + public ParameterListContext parameterList() { + return getRuleContext(ParameterListContext.class,0); + } + public ModifierListContext modifierList() { + return getRuleContext(ModifierListContext.class,0); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public ReturnParametersContext returnParameters() { + return getRuleContext(ReturnParametersContext.class,0); + } + public FunctionDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionDefinition; } + } + + public final FunctionDefinitionContext functionDefinition() throws RecognitionException { + FunctionDefinitionContext _localctx = new FunctionDefinitionContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_functionDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(368); + functionDescriptor(); + setState(369); + parameterList(); + setState(370); + modifierList(); + setState(372); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__29) { + { + setState(371); + returnParameters(); + } + } + + setState(376); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__1: + { + setState(374); + match(T__1); + } + break; + case T__13: + { + setState(375); + block(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionDescriptorContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode ReceiveKeyword() { return getToken(SolidityParser.ReceiveKeyword, 0); } + public TerminalNode FallbackKeyword() { return getToken(SolidityParser.FallbackKeyword, 0); } + public TerminalNode ConstructorKeyword() { return getToken(SolidityParser.ConstructorKeyword, 0); } + public FunctionDescriptorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionDescriptor; } + } + + public final FunctionDescriptorContext functionDescriptor() throws RecognitionException { + FunctionDescriptorContext _localctx = new FunctionDescriptorContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_functionDescriptor); + try { + setState(387); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__28: + enterOuterAlt(_localctx, 1); + { + setState(378); + match(T__28); + setState(382); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__12: + case T__39: + case T__51: + case Identifier: + { + setState(379); + identifier(); + } + break; + case ReceiveKeyword: + { + setState(380); + match(ReceiveKeyword); + } + break; + case FallbackKeyword: + { + setState(381); + match(FallbackKeyword); + } + break; + case T__21: + break; + default: + break; + } + } + break; + case ConstructorKeyword: + enterOuterAlt(_localctx, 2); + { + setState(384); + match(ConstructorKeyword); + } + break; + case FallbackKeyword: + enterOuterAlt(_localctx, 3); + { + setState(385); + match(FallbackKeyword); + } + break; + case ReceiveKeyword: + enterOuterAlt(_localctx, 4); + { + setState(386); + match(ReceiveKeyword); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReturnParametersContext extends ParserRuleContext { + public ParameterListContext parameterList() { + return getRuleContext(ParameterListContext.class,0); + } + public ReturnParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_returnParameters; } + } + + public final ReturnParametersContext returnParameters() throws RecognitionException { + ReturnParametersContext _localctx = new ReturnParametersContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_returnParameters); + try { + enterOuterAlt(_localctx, 1); + { + setState(389); + match(T__29); + setState(390); + parameterList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ModifierListContext extends ParserRuleContext { + public List modifierInvocation() { + return getRuleContexts(ModifierInvocationContext.class); + } + public ModifierInvocationContext modifierInvocation(int i) { + return getRuleContext(ModifierInvocationContext.class,i); + } + public List stateMutability() { + return getRuleContexts(StateMutabilityContext.class); + } + public StateMutabilityContext stateMutability(int i) { + return getRuleContext(StateMutabilityContext.class,i); + } + public List ExternalKeyword() { return getTokens(SolidityParser.ExternalKeyword); } + public TerminalNode ExternalKeyword(int i) { + return getToken(SolidityParser.ExternalKeyword, i); + } + public List PublicKeyword() { return getTokens(SolidityParser.PublicKeyword); } + public TerminalNode PublicKeyword(int i) { + return getToken(SolidityParser.PublicKeyword, i); + } + public List InternalKeyword() { return getTokens(SolidityParser.InternalKeyword); } + public TerminalNode InternalKeyword(int i) { + return getToken(SolidityParser.InternalKeyword, i); + } + public List PrivateKeyword() { return getTokens(SolidityParser.PrivateKeyword); } + public TerminalNode PrivateKeyword(int i) { + return getToken(SolidityParser.PrivateKeyword, i); + } + public List VirtualKeyword() { return getTokens(SolidityParser.VirtualKeyword); } + public TerminalNode VirtualKeyword(int i) { + return getToken(SolidityParser.VirtualKeyword, i); + } + public List overrideSpecifier() { + return getRuleContexts(OverrideSpecifierContext.class); + } + public OverrideSpecifierContext overrideSpecifier(int i) { + return getRuleContext(OverrideSpecifierContext.class,i); + } + public ModifierListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_modifierList; } + } + + public final ModifierListContext modifierList() throws RecognitionException { + ModifierListContext _localctx = new ModifierListContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_modifierList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(402); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,35,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + setState(400); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__12: + case T__39: + case T__51: + case Identifier: + { + setState(392); + modifierInvocation(); + } + break; + case ConstantKeyword: + case PayableKeyword: + case PureKeyword: + case ViewKeyword: + { + setState(393); + stateMutability(); + } + break; + case ExternalKeyword: + { + setState(394); + match(ExternalKeyword); + } + break; + case PublicKeyword: + { + setState(395); + match(PublicKeyword); + } + break; + case InternalKeyword: + { + setState(396); + match(InternalKeyword); + } + break; + case PrivateKeyword: + { + setState(397); + match(PrivateKeyword); + } + break; + case VirtualKeyword: + { + setState(398); + match(VirtualKeyword); + } + break; + case T__23: + { + setState(399); + overrideSpecifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(404); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,35,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ModifierInvocationContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public ModifierInvocationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_modifierInvocation; } + } + + public final ModifierInvocationContext modifierInvocation() throws RecognitionException { + ModifierInvocationContext _localctx = new ModifierInvocationContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_modifierInvocation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(405); + identifier(); + setState(411); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { + case 1: + { + setState(406); + match(T__21); + setState(408); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -578711444011343856L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1747960017153163265L) != 0)) { + { + setState(407); + expressionList(); + } + } + + setState(410); + match(T__22); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EventDefinitionContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public EventParameterListContext eventParameterList() { + return getRuleContext(EventParameterListContext.class,0); + } + public TerminalNode AnonymousKeyword() { return getToken(SolidityParser.AnonymousKeyword, 0); } + public EventDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_eventDefinition; } + } + + public final EventDefinitionContext eventDefinition() throws RecognitionException { + EventDefinitionContext _localctx = new EventDefinitionContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_eventDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(413); + match(T__30); + setState(414); + identifier(); + setState(415); + eventParameterList(); + setState(417); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AnonymousKeyword) { + { + setState(416); + match(AnonymousKeyword); + } + } + + setState(419); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EnumDefinitionContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List enumValue() { + return getRuleContexts(EnumValueContext.class); + } + public EnumValueContext enumValue(int i) { + return getRuleContext(EnumValueContext.class,i); + } + public EnumDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumDefinition; } + } + + public final EnumDefinitionContext enumDefinition() throws RecognitionException { + EnumDefinitionContext _localctx = new EnumDefinitionContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_enumDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(421); + match(T__31); + setState(422); + identifier(); + setState(423); + match(T__13); + setState(425); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4504699139006464L) != 0) || _la==Identifier) { + { + setState(424); + enumValue(); + } + } + + setState(431); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__14) { + { + { + setState(427); + match(T__14); + setState(428); + enumValue(); + } + } + setState(433); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(434); + match(T__15); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EnumValueContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public EnumValueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumValue; } + } + + public final EnumValueContext enumValue() throws RecognitionException { + EnumValueContext _localctx = new EnumValueContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_enumValue); + try { + enterOuterAlt(_localctx, 1); + { + setState(436); + identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ParameterListContext extends ParserRuleContext { + public List parameter() { + return getRuleContexts(ParameterContext.class); + } + public ParameterContext parameter(int i) { + return getRuleContext(ParameterContext.class,i); + } + public ParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_parameterList; } + } + + public final ParameterListContext parameterList() throws RecognitionException { + ParameterListContext _localctx = new ParameterListContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_parameterList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(438); + match(T__21); + setState(447); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 69806962992226304L) != 0) || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 1073741855L) != 0)) { + { + setState(439); + parameter(); + setState(444); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__14) { + { + { + setState(440); + match(T__14); + setState(441); + parameter(); + } + } + setState(446); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(449); + match(T__22); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ParameterContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public StorageLocationContext storageLocation() { + return getRuleContext(StorageLocationContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public ParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_parameter; } + } + + public final ParameterContext parameter() throws RecognitionException { + ParameterContext _localctx = new ParameterContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_parameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(451); + typeName(0); + setState(453); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) { + case 1: + { + setState(452); + storageLocation(); + } + break; + } + setState(456); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4504699139006464L) != 0) || _la==Identifier) { + { + setState(455); + identifier(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EventParameterListContext extends ParserRuleContext { + public List eventParameter() { + return getRuleContexts(EventParameterContext.class); + } + public EventParameterContext eventParameter(int i) { + return getRuleContext(EventParameterContext.class,i); + } + public EventParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_eventParameterList; } + } + + public final EventParameterListContext eventParameterList() throws RecognitionException { + EventParameterListContext _localctx = new EventParameterListContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_eventParameterList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(458); + match(T__21); + setState(467); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 69806962992226304L) != 0) || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 1073741855L) != 0)) { + { + setState(459); + eventParameter(); + setState(464); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__14) { + { + { + setState(460); + match(T__14); + setState(461); + eventParameter(); + } + } + setState(466); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(469); + match(T__22); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EventParameterContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public TerminalNode IndexedKeyword() { return getToken(SolidityParser.IndexedKeyword, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public EventParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_eventParameter; } + } + + public final EventParameterContext eventParameter() throws RecognitionException { + EventParameterContext _localctx = new EventParameterContext(_ctx, getState()); + enterRule(_localctx, 56, RULE_eventParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(471); + typeName(0); + setState(473); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IndexedKeyword) { + { + setState(472); + match(IndexedKeyword); + } + } + + setState(476); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4504699139006464L) != 0) || _la==Identifier) { + { + setState(475); + identifier(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VariableDeclarationContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public StorageLocationContext storageLocation() { + return getRuleContext(StorageLocationContext.class,0); + } + public VariableDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclaration; } + } + + public final VariableDeclarationContext variableDeclaration() throws RecognitionException { + VariableDeclarationContext _localctx = new VariableDeclarationContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_variableDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(478); + typeName(0); + setState(480); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) { + case 1: + { + setState(479); + storageLocation(); + } + break; + } + setState(482); + identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeNameContext extends ParserRuleContext { + public ElementaryTypeNameContext elementaryTypeName() { + return getRuleContext(ElementaryTypeNameContext.class,0); + } + public UserDefinedTypeNameContext userDefinedTypeName() { + return getRuleContext(UserDefinedTypeNameContext.class,0); + } + public MappingContext mapping() { + return getRuleContext(MappingContext.class,0); + } + public FunctionTypeNameContext functionTypeName() { + return getRuleContext(FunctionTypeNameContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TypeNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeName; } + } + + public final TypeNameContext typeName() throws RecognitionException { + return typeName(0); + } + + private TypeNameContext typeName(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + TypeNameContext _localctx = new TypeNameContext(_ctx, _parentState); + TypeNameContext _prevctx = _localctx; + int _startState = 60; + enterRecursionRule(_localctx, 60, RULE_typeName, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(489); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { + case 1: + { + setState(485); + elementaryTypeName(); + } + break; + case 2: + { + setState(486); + userDefinedTypeName(); + } + break; + case 3: + { + setState(487); + mapping(); + } + break; + case 4: + { + setState(488); + functionTypeName(); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(499); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,52,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new TypeNameContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_typeName); + setState(491); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(492); + match(T__32); + setState(494); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -578711444011343856L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1747960017153163265L) != 0)) { + { + setState(493); + expression(0); + } + } + + setState(496); + match(T__33); + } + } + } + setState(501); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,52,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UserDefinedTypeNameContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public UserDefinedTypeNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_userDefinedTypeName; } + } + + public final UserDefinedTypeNameContext userDefinedTypeName() throws RecognitionException { + UserDefinedTypeNameContext _localctx = new UserDefinedTypeNameContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_userDefinedTypeName); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(502); + identifier(); + setState(507); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,53,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(503); + match(T__34); + setState(504); + identifier(); + } + } + } + setState(509); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,53,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MappingContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public ElementaryTypeNameContext elementaryTypeName() { + return getRuleContext(ElementaryTypeNameContext.class,0); + } + public UserDefinedTypeNameContext userDefinedTypeName() { + return getRuleContext(UserDefinedTypeNameContext.class,0); + } + public MappingContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_mapping; } + } + + public final MappingContext mapping() throws RecognitionException { + MappingContext _localctx = new MappingContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_mapping); + try { + enterOuterAlt(_localctx, 1); + { + setState(510); + match(T__35); + setState(511); + match(T__21); + setState(514); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) { + case 1: + { + setState(512); + elementaryTypeName(); + } + break; + case 2: + { + setState(513); + userDefinedTypeName(); + } + break; + } + setState(516); + match(T__36); + setState(517); + typeName(0); + setState(518); + match(T__22); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionTypeNameContext extends ParserRuleContext { + public ParameterListContext parameterList() { + return getRuleContext(ParameterListContext.class,0); + } + public ModifierListContext modifierList() { + return getRuleContext(ModifierListContext.class,0); + } + public ReturnParametersContext returnParameters() { + return getRuleContext(ReturnParametersContext.class,0); + } + public FunctionTypeNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionTypeName; } + } + + public final FunctionTypeNameContext functionTypeName() throws RecognitionException { + FunctionTypeNameContext _localctx = new FunctionTypeNameContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_functionTypeName); + try { + enterOuterAlt(_localctx, 1); + { + setState(520); + match(T__28); + setState(521); + parameterList(); + setState(522); + modifierList(); + setState(524); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { + case 1: + { + setState(523); + returnParameters(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StorageLocationContext extends ParserRuleContext { + public StorageLocationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_storageLocation; } + } + + public final StorageLocationContext storageLocation() throws RecognitionException { + StorageLocationContext _localctx = new StorageLocationContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_storageLocation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(526); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 1924145348608L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StateMutabilityContext extends ParserRuleContext { + public TerminalNode PureKeyword() { return getToken(SolidityParser.PureKeyword, 0); } + public TerminalNode ConstantKeyword() { return getToken(SolidityParser.ConstantKeyword, 0); } + public TerminalNode ViewKeyword() { return getToken(SolidityParser.ViewKeyword, 0); } + public TerminalNode PayableKeyword() { return getToken(SolidityParser.PayableKeyword, 0); } + public StateMutabilityContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stateMutability; } + } + + public final StateMutabilityContext stateMutability() throws RecognitionException { + StateMutabilityContext _localctx = new StateMutabilityContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_stateMutability); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(528); + _la = _input.LA(1); + if ( !(((((_la - 106)) & ~0x3f) == 0 && ((1L << (_la - 106)) & 10369L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BlockContext extends ParserRuleContext { + public List statement() { + return getRuleContexts(StatementContext.class); + } + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class,i); + } + public BlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_block; } + } + + public final BlockContext block() throws RecognitionException { + BlockContext _localctx = new BlockContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_block); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(530); + match(T__13); + setState(534); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -576483764129996784L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1747979808362463233L) != 0)) { + { + { + setState(531); + statement(); + } + } + setState(536); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(537); + match(T__15); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StatementContext extends ParserRuleContext { + public IfStatementContext ifStatement() { + return getRuleContext(IfStatementContext.class,0); + } + public TryStatementContext tryStatement() { + return getRuleContext(TryStatementContext.class,0); + } + public WhileStatementContext whileStatement() { + return getRuleContext(WhileStatementContext.class,0); + } + public ForStatementContext forStatement() { + return getRuleContext(ForStatementContext.class,0); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public InlineAssemblyStatementContext inlineAssemblyStatement() { + return getRuleContext(InlineAssemblyStatementContext.class,0); + } + public DoWhileStatementContext doWhileStatement() { + return getRuleContext(DoWhileStatementContext.class,0); + } + public ContinueStatementContext continueStatement() { + return getRuleContext(ContinueStatementContext.class,0); + } + public BreakStatementContext breakStatement() { + return getRuleContext(BreakStatementContext.class,0); + } + public ReturnStatementContext returnStatement() { + return getRuleContext(ReturnStatementContext.class,0); + } + public ThrowStatementContext throwStatement() { + return getRuleContext(ThrowStatementContext.class,0); + } + public EmitStatementContext emitStatement() { + return getRuleContext(EmitStatementContext.class,0); + } + public SimpleStatementContext simpleStatement() { + return getRuleContext(SimpleStatementContext.class,0); + } + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statement; } + } + + public final StatementContext statement() throws RecognitionException { + StatementContext _localctx = new StatementContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_statement); + try { + setState(552); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__40: + enterOuterAlt(_localctx, 1); + { + setState(539); + ifStatement(); + } + break; + case T__42: + enterOuterAlt(_localctx, 2); + { + setState(540); + tryStatement(); + } + break; + case T__44: + enterOuterAlt(_localctx, 3); + { + setState(541); + whileStatement(); + } + break; + case T__25: + enterOuterAlt(_localctx, 4); + { + setState(542); + forStatement(); + } + break; + case T__13: + enterOuterAlt(_localctx, 5); + { + setState(543); + block(); + } + break; + case T__45: + enterOuterAlt(_localctx, 6); + { + setState(544); + inlineAssemblyStatement(); + } + break; + case T__46: + enterOuterAlt(_localctx, 7); + { + setState(545); + doWhileStatement(); + } + break; + case ContinueKeyword: + enterOuterAlt(_localctx, 8); + { + setState(546); + continueStatement(); + } + break; + case BreakKeyword: + enterOuterAlt(_localctx, 9); + { + setState(547); + breakStatement(); + } + break; + case T__47: + enterOuterAlt(_localctx, 10); + { + setState(548); + returnStatement(); + } + break; + case T__48: + enterOuterAlt(_localctx, 11); + { + setState(549); + throwStatement(); + } + break; + case T__49: + enterOuterAlt(_localctx, 12); + { + setState(550); + emitStatement(); + } + break; + case T__3: + case T__12: + case T__21: + case T__28: + case T__32: + case T__35: + case T__39: + case T__50: + case T__51: + case T__52: + case T__53: + case T__54: + case T__55: + case T__56: + case T__57: + case T__59: + case T__60: + case T__61: + case T__62: + case T__63: + case Int: + case Uint: + case Byte: + case Fixed: + case Ufixed: + case BooleanLiteral: + case DecimalNumber: + case HexNumber: + case HexLiteralFragment: + case PayableKeyword: + case TypeKeyword: + case Identifier: + case StringLiteralFragment: + enterOuterAlt(_localctx, 13); + { + setState(551); + simpleStatement(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExpressionStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ExpressionStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionStatement; } + } + + public final ExpressionStatementContext expressionStatement() throws RecognitionException { + ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_expressionStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(554); + expression(0); + setState(555); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IfStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public List statement() { + return getRuleContexts(StatementContext.class); + } + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class,i); + } + public IfStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ifStatement; } + } + + public final IfStatementContext ifStatement() throws RecognitionException { + IfStatementContext _localctx = new IfStatementContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_ifStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(557); + match(T__40); + setState(558); + match(T__21); + setState(559); + expression(0); + setState(560); + match(T__22); + setState(561); + statement(); + setState(564); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) { + case 1: + { + setState(562); + match(T__41); + setState(563); + statement(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TryStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public ReturnParametersContext returnParameters() { + return getRuleContext(ReturnParametersContext.class,0); + } + public List catchClause() { + return getRuleContexts(CatchClauseContext.class); + } + public CatchClauseContext catchClause(int i) { + return getRuleContext(CatchClauseContext.class,i); + } + public TryStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tryStatement; } + } + + public final TryStatementContext tryStatement() throws RecognitionException { + TryStatementContext _localctx = new TryStatementContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_tryStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(566); + match(T__42); + setState(567); + expression(0); + setState(569); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__29) { + { + setState(568); + returnParameters(); + } + } + + setState(571); + block(); + setState(573); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(572); + catchClause(); + } + } + setState(575); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==T__43 ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CatchClauseContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public ParameterListContext parameterList() { + return getRuleContext(ParameterListContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public CatchClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catchClause; } + } + + public final CatchClauseContext catchClause() throws RecognitionException { + CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_catchClause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(577); + match(T__43); + setState(582); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4504699143200768L) != 0) || _la==Identifier) { + { + setState(579); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4504699139006464L) != 0) || _la==Identifier) { + { + setState(578); + identifier(); + } + } + + setState(581); + parameterList(); + } + } + + setState(584); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class WhileStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public WhileStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_whileStatement; } + } + + public final WhileStatementContext whileStatement() throws RecognitionException { + WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_whileStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(586); + match(T__44); + setState(587); + match(T__21); + setState(588); + expression(0); + setState(589); + match(T__22); + setState(590); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ForStatementContext extends ParserRuleContext { + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public SimpleStatementContext simpleStatement() { + return getRuleContext(SimpleStatementContext.class,0); + } + public ExpressionStatementContext expressionStatement() { + return getRuleContext(ExpressionStatementContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ForStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forStatement; } + } + + public final ForStatementContext forStatement() throws RecognitionException { + ForStatementContext _localctx = new ForStatementContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_forStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(592); + match(T__25); + setState(593); + match(T__21); + setState(596); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__3: + case T__12: + case T__21: + case T__28: + case T__32: + case T__35: + case T__39: + case T__50: + case T__51: + case T__52: + case T__53: + case T__54: + case T__55: + case T__56: + case T__57: + case T__59: + case T__60: + case T__61: + case T__62: + case T__63: + case Int: + case Uint: + case Byte: + case Fixed: + case Ufixed: + case BooleanLiteral: + case DecimalNumber: + case HexNumber: + case HexLiteralFragment: + case PayableKeyword: + case TypeKeyword: + case Identifier: + case StringLiteralFragment: + { + setState(594); + simpleStatement(); + } + break; + case T__1: + { + setState(595); + match(T__1); + } + break; + default: + throw new NoViableAltException(this); + } + setState(600); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__3: + case T__12: + case T__21: + case T__32: + case T__39: + case T__50: + case T__51: + case T__52: + case T__53: + case T__54: + case T__55: + case T__56: + case T__57: + case T__59: + case T__60: + case T__61: + case T__62: + case T__63: + case Int: + case Uint: + case Byte: + case Fixed: + case Ufixed: + case BooleanLiteral: + case DecimalNumber: + case HexNumber: + case HexLiteralFragment: + case PayableKeyword: + case TypeKeyword: + case Identifier: + case StringLiteralFragment: + { + setState(598); + expressionStatement(); + } + break; + case T__1: + { + setState(599); + match(T__1); + } + break; + default: + throw new NoViableAltException(this); + } + setState(603); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -578711444011343856L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1747960017153163265L) != 0)) { + { + setState(602); + expression(0); + } + } + + setState(605); + match(T__22); + setState(606); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SimpleStatementContext extends ParserRuleContext { + public VariableDeclarationStatementContext variableDeclarationStatement() { + return getRuleContext(VariableDeclarationStatementContext.class,0); + } + public ExpressionStatementContext expressionStatement() { + return getRuleContext(ExpressionStatementContext.class,0); + } + public SimpleStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simpleStatement; } + } + + public final SimpleStatementContext simpleStatement() throws RecognitionException { + SimpleStatementContext _localctx = new SimpleStatementContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_simpleStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(610); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,66,_ctx) ) { + case 1: + { + setState(608); + variableDeclarationStatement(); + } + break; + case 2: + { + setState(609); + expressionStatement(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class InlineAssemblyStatementContext extends ParserRuleContext { + public AssemblyBlockContext assemblyBlock() { + return getRuleContext(AssemblyBlockContext.class,0); + } + public TerminalNode StringLiteralFragment() { return getToken(SolidityParser.StringLiteralFragment, 0); } + public InlineAssemblyStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_inlineAssemblyStatement; } + } + + public final InlineAssemblyStatementContext inlineAssemblyStatement() throws RecognitionException { + InlineAssemblyStatementContext _localctx = new InlineAssemblyStatementContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_inlineAssemblyStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(612); + match(T__45); + setState(614); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==StringLiteralFragment) { + { + setState(613); + match(StringLiteralFragment); + } + } + + setState(616); + assemblyBlock(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class DoWhileStatementContext extends ParserRuleContext { + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public DoWhileStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_doWhileStatement; } + } + + public final DoWhileStatementContext doWhileStatement() throws RecognitionException { + DoWhileStatementContext _localctx = new DoWhileStatementContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_doWhileStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(618); + match(T__46); + setState(619); + statement(); + setState(620); + match(T__44); + setState(621); + match(T__21); + setState(622); + expression(0); + setState(623); + match(T__22); + setState(624); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ContinueStatementContext extends ParserRuleContext { + public TerminalNode ContinueKeyword() { return getToken(SolidityParser.ContinueKeyword, 0); } + public ContinueStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_continueStatement; } + } + + public final ContinueStatementContext continueStatement() throws RecognitionException { + ContinueStatementContext _localctx = new ContinueStatementContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_continueStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(626); + match(ContinueKeyword); + setState(627); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BreakStatementContext extends ParserRuleContext { + public TerminalNode BreakKeyword() { return getToken(SolidityParser.BreakKeyword, 0); } + public BreakStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_breakStatement; } + } + + public final BreakStatementContext breakStatement() throws RecognitionException { + BreakStatementContext _localctx = new BreakStatementContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_breakStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(629); + match(BreakKeyword); + setState(630); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ReturnStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ReturnStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_returnStatement; } + } + + public final ReturnStatementContext returnStatement() throws RecognitionException { + ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_returnStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(632); + match(T__47); + setState(634); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -578711444011343856L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1747960017153163265L) != 0)) { + { + setState(633); + expression(0); + } + } + + setState(636); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ThrowStatementContext extends ParserRuleContext { + public ThrowStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_throwStatement; } + } + + public final ThrowStatementContext throwStatement() throws RecognitionException { + ThrowStatementContext _localctx = new ThrowStatementContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_throwStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(638); + match(T__48); + setState(639); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EmitStatementContext extends ParserRuleContext { + public FunctionCallContext functionCall() { + return getRuleContext(FunctionCallContext.class,0); + } + public EmitStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_emitStatement; } + } + + public final EmitStatementContext emitStatement() throws RecognitionException { + EmitStatementContext _localctx = new EmitStatementContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_emitStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(641); + match(T__49); + setState(642); + functionCall(); + setState(643); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VariableDeclarationStatementContext extends ParserRuleContext { + public IdentifierListContext identifierList() { + return getRuleContext(IdentifierListContext.class,0); + } + public VariableDeclarationContext variableDeclaration() { + return getRuleContext(VariableDeclarationContext.class,0); + } + public VariableDeclarationListContext variableDeclarationList() { + return getRuleContext(VariableDeclarationListContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public VariableDeclarationStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclarationStatement; } + } + + public final VariableDeclarationStatementContext variableDeclarationStatement() throws RecognitionException { + VariableDeclarationStatementContext _localctx = new VariableDeclarationStatementContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_variableDeclarationStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(652); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) { + case 1: + { + setState(645); + match(T__50); + setState(646); + identifierList(); + } + break; + case 2: + { + setState(647); + variableDeclaration(); + } + break; + case 3: + { + setState(648); + match(T__21); + setState(649); + variableDeclarationList(); + setState(650); + match(T__22); + } + break; + } + setState(656); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__8) { + { + setState(654); + match(T__8); + setState(655); + expression(0); + } + } + + setState(658); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class VariableDeclarationListContext extends ParserRuleContext { + public List variableDeclaration() { + return getRuleContexts(VariableDeclarationContext.class); + } + public VariableDeclarationContext variableDeclaration(int i) { + return getRuleContext(VariableDeclarationContext.class,i); + } + public VariableDeclarationListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclarationList; } + } + + public final VariableDeclarationListContext variableDeclarationList() throws RecognitionException { + VariableDeclarationListContext _localctx = new VariableDeclarationListContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_variableDeclarationList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(661); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 69806962992226304L) != 0) || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 1073741855L) != 0)) { + { + setState(660); + variableDeclaration(); + } + } + + setState(669); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__14) { + { + { + setState(663); + match(T__14); + setState(665); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 69806962992226304L) != 0) || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 1073741855L) != 0)) { + { + setState(664); + variableDeclaration(); + } + } + + } + } + setState(671); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IdentifierListContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public IdentifierListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_identifierList; } + } + + public final IdentifierListContext identifierList() throws RecognitionException { + IdentifierListContext _localctx = new IdentifierListContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_identifierList); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(672); + match(T__21); + setState(679); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,75,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(674); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4504699139006464L) != 0) || _la==Identifier) { + { + setState(673); + identifier(); + } + } + + setState(676); + match(T__14); + } + } + } + setState(681); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,75,_ctx); + } + setState(683); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4504699139006464L) != 0) || _la==Identifier) { + { + setState(682); + identifier(); + } + } + + setState(685); + match(T__22); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ElementaryTypeNameContext extends ParserRuleContext { + public TerminalNode PayableKeyword() { return getToken(SolidityParser.PayableKeyword, 0); } + public TerminalNode Int() { return getToken(SolidityParser.Int, 0); } + public TerminalNode Uint() { return getToken(SolidityParser.Uint, 0); } + public TerminalNode Byte() { return getToken(SolidityParser.Byte, 0); } + public TerminalNode Fixed() { return getToken(SolidityParser.Fixed, 0); } + public TerminalNode Ufixed() { return getToken(SolidityParser.Ufixed, 0); } + public ElementaryTypeNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementaryTypeName; } + } + + public final ElementaryTypeNameContext elementaryTypeName() throws RecognitionException { + ElementaryTypeNameContext _localctx = new ElementaryTypeNameContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_elementaryTypeName); + try { + setState(700); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__51: + enterOuterAlt(_localctx, 1); + { + setState(687); + match(T__51); + setState(689); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) { + case 1: + { + setState(688); + match(PayableKeyword); + } + break; + } + } + break; + case T__52: + enterOuterAlt(_localctx, 2); + { + setState(691); + match(T__52); + } + break; + case T__53: + enterOuterAlt(_localctx, 3); + { + setState(692); + match(T__53); + } + break; + case T__50: + enterOuterAlt(_localctx, 4); + { + setState(693); + match(T__50); + } + break; + case Int: + enterOuterAlt(_localctx, 5); + { + setState(694); + match(Int); + } + break; + case Uint: + enterOuterAlt(_localctx, 6); + { + setState(695); + match(Uint); + } + break; + case T__54: + enterOuterAlt(_localctx, 7); + { + setState(696); + match(T__54); + } + break; + case Byte: + enterOuterAlt(_localctx, 8); + { + setState(697); + match(Byte); + } + break; + case Fixed: + enterOuterAlt(_localctx, 9); + { + setState(698); + match(Fixed); + } + break; + case Ufixed: + enterOuterAlt(_localctx, 10); + { + setState(699); + match(Ufixed); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExpressionContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public TerminalNode PayableKeyword() { return getToken(SolidityParser.PayableKeyword, 0); } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public PrimaryExpressionContext primaryExpression() { + return getRuleContext(PrimaryExpressionContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public NameValueListContext nameValueList() { + return getRuleContext(NameValueListContext.class,0); + } + public FunctionCallArgumentsContext functionCallArguments() { + return getRuleContext(FunctionCallArgumentsContext.class,0); + } + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expression; } + } + + public final ExpressionContext expression() throws RecognitionException { + return expression(0); + } + + private ExpressionContext expression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState); + ExpressionContext _prevctx = _localctx; + int _startState = 112; + enterRecursionRule(_localctx, 112, RULE_expression, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(725); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) { + case 1: + { + setState(703); + match(T__57); + setState(704); + typeName(0); + } + break; + case 2: + { + setState(705); + match(PayableKeyword); + setState(706); + match(T__21); + setState(707); + expression(0); + setState(708); + match(T__22); + } + break; + case 3: + { + setState(710); + match(T__21); + setState(711); + expression(0); + setState(712); + match(T__22); + } + break; + case 4: + { + setState(714); + _la = _input.LA(1); + if ( !(_la==T__55 || _la==T__56) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(715); + expression(19); + } + break; + case 5: + { + setState(716); + _la = _input.LA(1); + if ( !(_la==T__59 || _la==T__60) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(717); + expression(18); + } + break; + case 6: + { + setState(718); + _la = _input.LA(1); + if ( !(_la==T__61 || _la==T__62) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(719); + expression(17); + } + break; + case 7: + { + setState(720); + match(T__63); + setState(721); + expression(16); + } + break; + case 8: + { + setState(722); + match(T__3); + setState(723); + expression(15); + } + break; + case 9: + { + setState(724); + primaryExpression(); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(802); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,84,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(800); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) { + case 1: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(727); + if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)"); + setState(728); + match(T__64); + setState(729); + expression(15); + } + break; + case 2: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(730); + if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)"); + setState(731); + _la = _input.LA(1); + if ( !(((((_la - 12)) & ~0x3f) == 0 && ((1L << (_la - 12)) & 54043195528445953L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(732); + expression(14); + } + break; + case 3: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(733); + if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)"); + setState(734); + _la = _input.LA(1); + if ( !(_la==T__59 || _la==T__60) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(735); + expression(13); + } + break; + case 4: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(736); + if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)"); + setState(737); + _la = _input.LA(1); + if ( !(_la==T__67 || _la==T__68) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(738); + expression(12); + } + break; + case 5: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(739); + if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)"); + setState(740); + match(T__69); + setState(741); + expression(11); + } + break; + case 6: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(742); + if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); + setState(743); + match(T__2); + setState(744); + expression(10); + } + break; + case 7: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(745); + if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); + setState(746); + match(T__70); + setState(747); + expression(9); + } + break; + case 8: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(748); + if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)"); + setState(749); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 480L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(750); + expression(8); + } + break; + case 9: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(751); + if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)"); + setState(752); + _la = _input.LA(1); + if ( !(_la==T__71 || _la==T__72) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(753); + expression(7); + } + break; + case 10: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(754); + if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); + setState(755); + match(T__73); + setState(756); + expression(6); + } + break; + case 11: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(757); + if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); + setState(758); + match(T__74); + setState(759); + expression(5); + } + break; + case 12: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(760); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(761); + match(T__75); + setState(762); + expression(0); + setState(763); + match(T__58); + setState(764); + expression(4); + } + break; + case 13: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(766); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(767); + _la = _input.LA(1); + if ( !(_la==T__8 || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & 1023L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(768); + expression(3); + } + break; + case 14: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(769); + if (!(precpred(_ctx, 28))) throw new FailedPredicateException(this, "precpred(_ctx, 28)"); + setState(770); + _la = _input.LA(1); + if ( !(_la==T__55 || _la==T__56) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 15: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(771); + if (!(precpred(_ctx, 26))) throw new FailedPredicateException(this, "precpred(_ctx, 26)"); + setState(772); + match(T__32); + setState(774); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -578711444011343856L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1747960017153163265L) != 0)) { + { + setState(773); + expression(0); + } + } + + setState(776); + match(T__33); + } + break; + case 16: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(777); + if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)"); + setState(778); + match(T__32); + setState(780); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -578711444011343856L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1747960017153163265L) != 0)) { + { + setState(779); + expression(0); + } + } + + setState(782); + match(T__58); + setState(784); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -578711444011343856L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1747960017153163265L) != 0)) { + { + setState(783); + expression(0); + } + } + + setState(786); + match(T__33); + } + break; + case 17: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(787); + if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)"); + setState(788); + match(T__34); + setState(789); + identifier(); + } + break; + case 18: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(790); + if (!(precpred(_ctx, 23))) throw new FailedPredicateException(this, "precpred(_ctx, 23)"); + setState(791); + match(T__13); + setState(792); + nameValueList(); + setState(793); + match(T__15); + } + break; + case 19: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(795); + if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)"); + setState(796); + match(T__21); + setState(797); + functionCallArguments(); + setState(798); + match(T__22); + } + break; + } + } + } + setState(804); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,84,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PrimaryExpressionContext extends ParserRuleContext { + public TerminalNode BooleanLiteral() { return getToken(SolidityParser.BooleanLiteral, 0); } + public NumberLiteralContext numberLiteral() { + return getRuleContext(NumberLiteralContext.class,0); + } + public HexLiteralContext hexLiteral() { + return getRuleContext(HexLiteralContext.class,0); + } + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode TypeKeyword() { return getToken(SolidityParser.TypeKeyword, 0); } + public TupleExpressionContext tupleExpression() { + return getRuleContext(TupleExpressionContext.class,0); + } + public TypeNameExpressionContext typeNameExpression() { + return getRuleContext(TypeNameExpressionContext.class,0); + } + public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryExpression; } + } + + public final PrimaryExpressionContext primaryExpression() throws RecognitionException { + PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_primaryExpression); + try { + setState(821); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(805); + match(BooleanLiteral); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(806); + numberLiteral(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(807); + hexLiteral(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(808); + stringLiteral(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(809); + identifier(); + setState(812); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) { + case 1: + { + setState(810); + match(T__32); + setState(811); + match(T__33); + } + break; + } + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(814); + match(TypeKeyword); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(815); + tupleExpression(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(816); + typeNameExpression(); + setState(819); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) { + case 1: + { + setState(817); + match(T__32); + setState(818); + match(T__33); + } + break; + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ExpressionListContext extends ParserRuleContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public ExpressionListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionList; } + } + + public final ExpressionListContext expressionList() throws RecognitionException { + ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_expressionList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(823); + expression(0); + setState(828); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__14) { + { + { + setState(824); + match(T__14); + setState(825); + expression(0); + } + } + setState(830); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class NameValueListContext extends ParserRuleContext { + public List nameValue() { + return getRuleContexts(NameValueContext.class); + } + public NameValueContext nameValue(int i) { + return getRuleContext(NameValueContext.class,i); + } + public NameValueListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_nameValueList; } + } + + public final NameValueListContext nameValueList() throws RecognitionException { + NameValueListContext _localctx = new NameValueListContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_nameValueList); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(831); + nameValue(); + setState(836); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,89,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(832); + match(T__14); + setState(833); + nameValue(); + } + } + } + setState(838); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,89,_ctx); + } + setState(840); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__14) { + { + setState(839); + match(T__14); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class NameValueContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public NameValueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_nameValue; } + } + + public final NameValueContext nameValue() throws RecognitionException { + NameValueContext _localctx = new NameValueContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_nameValue); + try { + enterOuterAlt(_localctx, 1); + { + setState(842); + identifier(); + setState(843); + match(T__58); + setState(844); + expression(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionCallArgumentsContext extends ParserRuleContext { + public NameValueListContext nameValueList() { + return getRuleContext(NameValueListContext.class,0); + } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public FunctionCallArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionCallArguments; } + } + + public final FunctionCallArgumentsContext functionCallArguments() throws RecognitionException { + FunctionCallArgumentsContext _localctx = new FunctionCallArgumentsContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_functionCallArguments); + int _la; + try { + setState(854); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__13: + enterOuterAlt(_localctx, 1); + { + setState(846); + match(T__13); + setState(848); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4504699139006464L) != 0) || _la==Identifier) { + { + setState(847); + nameValueList(); + } + } + + setState(850); + match(T__15); + } + break; + case T__3: + case T__12: + case T__21: + case T__22: + case T__32: + case T__39: + case T__50: + case T__51: + case T__52: + case T__53: + case T__54: + case T__55: + case T__56: + case T__57: + case T__59: + case T__60: + case T__61: + case T__62: + case T__63: + case Int: + case Uint: + case Byte: + case Fixed: + case Ufixed: + case BooleanLiteral: + case DecimalNumber: + case HexNumber: + case HexLiteralFragment: + case PayableKeyword: + case TypeKeyword: + case Identifier: + case StringLiteralFragment: + enterOuterAlt(_localctx, 2); + { + setState(852); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -578711444011343856L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1747960017153163265L) != 0)) { + { + setState(851); + expressionList(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionCallContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public FunctionCallArgumentsContext functionCallArguments() { + return getRuleContext(FunctionCallArgumentsContext.class,0); + } + public FunctionCallContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionCall; } + } + + public final FunctionCallContext functionCall() throws RecognitionException { + FunctionCallContext _localctx = new FunctionCallContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_functionCall); + try { + enterOuterAlt(_localctx, 1); + { + setState(856); + expression(0); + setState(857); + match(T__21); + setState(858); + functionCallArguments(); + setState(859); + match(T__22); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TupleExpressionContext extends ParserRuleContext { + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TupleExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tupleExpression; } + } + + public final TupleExpressionContext tupleExpression() throws RecognitionException { + TupleExpressionContext _localctx = new TupleExpressionContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_tupleExpression); + int _la; + try { + setState(887); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__21: + enterOuterAlt(_localctx, 1); + { + setState(861); + match(T__21); + { + setState(863); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -578711444011343856L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1747960017153163265L) != 0)) { + { + setState(862); + expression(0); + } + } + + setState(871); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__14) { + { + { + setState(865); + match(T__14); + setState(867); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -578711444011343856L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1747960017153163265L) != 0)) { + { + setState(866); + expression(0); + } + } + + } + } + setState(873); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + setState(874); + match(T__22); + } + break; + case T__32: + enterOuterAlt(_localctx, 2); + { + setState(875); + match(T__32); + setState(884); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -578711444011343856L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1747960017153163265L) != 0)) { + { + setState(876); + expression(0); + setState(881); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__14) { + { + { + setState(877); + match(T__14); + setState(878); + expression(0); + } + } + setState(883); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(886); + match(T__33); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TypeNameExpressionContext extends ParserRuleContext { + public ElementaryTypeNameContext elementaryTypeName() { + return getRuleContext(ElementaryTypeNameContext.class,0); + } + public UserDefinedTypeNameContext userDefinedTypeName() { + return getRuleContext(UserDefinedTypeNameContext.class,0); + } + public TypeNameExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeNameExpression; } + } + + public final TypeNameExpressionContext typeNameExpression() throws RecognitionException { + TypeNameExpressionContext _localctx = new TypeNameExpressionContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_typeNameExpression); + try { + setState(891); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(889); + elementaryTypeName(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(890); + userDefinedTypeName(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyItemContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public AssemblyBlockContext assemblyBlock() { + return getRuleContext(AssemblyBlockContext.class,0); + } + public AssemblyExpressionContext assemblyExpression() { + return getRuleContext(AssemblyExpressionContext.class,0); + } + public AssemblyLocalDefinitionContext assemblyLocalDefinition() { + return getRuleContext(AssemblyLocalDefinitionContext.class,0); + } + public AssemblyAssignmentContext assemblyAssignment() { + return getRuleContext(AssemblyAssignmentContext.class,0); + } + public AssemblyStackAssignmentContext assemblyStackAssignment() { + return getRuleContext(AssemblyStackAssignmentContext.class,0); + } + public LabelDefinitionContext labelDefinition() { + return getRuleContext(LabelDefinitionContext.class,0); + } + public AssemblySwitchContext assemblySwitch() { + return getRuleContext(AssemblySwitchContext.class,0); + } + public AssemblyFunctionDefinitionContext assemblyFunctionDefinition() { + return getRuleContext(AssemblyFunctionDefinitionContext.class,0); + } + public AssemblyForContext assemblyFor() { + return getRuleContext(AssemblyForContext.class,0); + } + public AssemblyIfContext assemblyIf() { + return getRuleContext(AssemblyIfContext.class,0); + } + public TerminalNode BreakKeyword() { return getToken(SolidityParser.BreakKeyword, 0); } + public TerminalNode ContinueKeyword() { return getToken(SolidityParser.ContinueKeyword, 0); } + public TerminalNode LeaveKeyword() { return getToken(SolidityParser.LeaveKeyword, 0); } + public SubAssemblyContext subAssembly() { + return getRuleContext(SubAssemblyContext.class,0); + } + public NumberLiteralContext numberLiteral() { + return getRuleContext(NumberLiteralContext.class,0); + } + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class,0); + } + public HexLiteralContext hexLiteral() { + return getRuleContext(HexLiteralContext.class,0); + } + public AssemblyItemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyItem; } + } + + public final AssemblyItemContext assemblyItem() throws RecognitionException { + AssemblyItemContext _localctx = new AssemblyItemContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_assemblyItem); + try { + setState(911); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(893); + identifier(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(894); + assemblyBlock(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(895); + assemblyExpression(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(896); + assemblyLocalDefinition(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(897); + assemblyAssignment(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(898); + assemblyStackAssignment(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(899); + labelDefinition(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(900); + assemblySwitch(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(901); + assemblyFunctionDefinition(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(902); + assemblyFor(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(903); + assemblyIf(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(904); + match(BreakKeyword); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(905); + match(ContinueKeyword); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(906); + match(LeaveKeyword); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(907); + subAssembly(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(908); + numberLiteral(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(909); + stringLiteral(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(910); + hexLiteral(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyBlockContext extends ParserRuleContext { + public List assemblyItem() { + return getRuleContexts(AssemblyItemContext.class); + } + public AssemblyItemContext assemblyItem(int i) { + return getRuleContext(AssemblyItemContext.class,i); + } + public AssemblyBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyBlock; } + } + + public final AssemblyBlockContext assemblyBlock() throws RecognitionException { + AssemblyBlockContext _localctx = new AssemblyBlockContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_assemblyBlock); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(913); + match(T__13); + setState(917); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 40887539506110464L) != 0) || ((((_la - 87)) & ~0x3f) == 0 && ((1L << (_la - 87)) & 206165030925L) != 0)) { + { + { + setState(914); + assemblyItem(); + } + } + setState(919); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(920); + match(T__15); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyExpressionContext extends ParserRuleContext { + public AssemblyCallContext assemblyCall() { + return getRuleContext(AssemblyCallContext.class,0); + } + public AssemblyLiteralContext assemblyLiteral() { + return getRuleContext(AssemblyLiteralContext.class,0); + } + public AssemblyExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyExpression; } + } + + public final AssemblyExpressionContext assemblyExpression() throws RecognitionException { + AssemblyExpressionContext _localctx = new AssemblyExpressionContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_assemblyExpression); + try { + setState(924); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__12: + case T__39: + case T__47: + case T__51: + case T__54: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(922); + assemblyCall(); + } + break; + case BooleanLiteral: + case DecimalNumber: + case HexNumber: + case HexLiteralFragment: + case StringLiteralFragment: + enterOuterAlt(_localctx, 2); + { + setState(923); + assemblyLiteral(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyCallContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List assemblyExpression() { + return getRuleContexts(AssemblyExpressionContext.class); + } + public AssemblyExpressionContext assemblyExpression(int i) { + return getRuleContext(AssemblyExpressionContext.class,i); + } + public AssemblyCallContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyCall; } + } + + public final AssemblyCallContext assemblyCall() throws RecognitionException { + AssemblyCallContext _localctx = new AssemblyCallContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_assemblyCall); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(930); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) { + case 1: + { + setState(926); + match(T__47); + } + break; + case 2: + { + setState(927); + match(T__51); + } + break; + case 3: + { + setState(928); + match(T__54); + } + break; + case 4: + { + setState(929); + identifier(); + } + break; + } + setState(944); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__21) { + { + setState(932); + match(T__21); + setState(934); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 40814971134681088L) != 0) || ((((_la - 98)) & ~0x3f) == 0 && ((1L << (_la - 98)) & 100663319L) != 0)) { + { + setState(933); + assemblyExpression(); + } + } + + setState(940); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__14) { + { + { + setState(936); + match(T__14); + setState(937); + assemblyExpression(); + } + } + setState(942); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(943); + match(T__22); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyLocalDefinitionContext extends ParserRuleContext { + public AssemblyIdentifierListContext assemblyIdentifierList() { + return getRuleContext(AssemblyIdentifierListContext.class,0); + } + public AssemblyExpressionContext assemblyExpression() { + return getRuleContext(AssemblyExpressionContext.class,0); + } + public AssemblyLocalDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyLocalDefinition; } + } + + public final AssemblyLocalDefinitionContext assemblyLocalDefinition() throws RecognitionException { + AssemblyLocalDefinitionContext _localctx = new AssemblyLocalDefinitionContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_assemblyLocalDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(946); + match(T__86); + setState(947); + assemblyIdentifierList(); + setState(950); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__87) { + { + setState(948); + match(T__87); + setState(949); + assemblyExpression(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyAssignmentContext extends ParserRuleContext { + public AssemblyIdentifierListContext assemblyIdentifierList() { + return getRuleContext(AssemblyIdentifierListContext.class,0); + } + public AssemblyExpressionContext assemblyExpression() { + return getRuleContext(AssemblyExpressionContext.class,0); + } + public AssemblyAssignmentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyAssignment; } + } + + public final AssemblyAssignmentContext assemblyAssignment() throws RecognitionException { + AssemblyAssignmentContext _localctx = new AssemblyAssignmentContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_assemblyAssignment); + try { + enterOuterAlt(_localctx, 1); + { + setState(952); + assemblyIdentifierList(); + setState(953); + match(T__87); + setState(954); + assemblyExpression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyIdentifierListContext extends ParserRuleContext { + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public AssemblyIdentifierListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyIdentifierList; } + } + + public final AssemblyIdentifierListContext assemblyIdentifierList() throws RecognitionException { + AssemblyIdentifierListContext _localctx = new AssemblyIdentifierListContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_assemblyIdentifierList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(956); + identifier(); + setState(961); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__14) { + { + { + setState(957); + match(T__14); + setState(958); + identifier(); + } + } + setState(963); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyStackAssignmentContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public AssemblyStackAssignmentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyStackAssignment; } + } + + public final AssemblyStackAssignmentContext assemblyStackAssignment() throws RecognitionException { + AssemblyStackAssignmentContext _localctx = new AssemblyStackAssignmentContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_assemblyStackAssignment); + try { + enterOuterAlt(_localctx, 1); + { + setState(964); + match(T__88); + setState(965); + identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LabelDefinitionContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public LabelDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_labelDefinition; } + } + + public final LabelDefinitionContext labelDefinition() throws RecognitionException { + LabelDefinitionContext _localctx = new LabelDefinitionContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_labelDefinition); + try { + enterOuterAlt(_localctx, 1); + { + setState(967); + identifier(); + setState(968); + match(T__58); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblySwitchContext extends ParserRuleContext { + public AssemblyExpressionContext assemblyExpression() { + return getRuleContext(AssemblyExpressionContext.class,0); + } + public List assemblyCase() { + return getRuleContexts(AssemblyCaseContext.class); + } + public AssemblyCaseContext assemblyCase(int i) { + return getRuleContext(AssemblyCaseContext.class,i); + } + public AssemblySwitchContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblySwitch; } + } + + public final AssemblySwitchContext assemblySwitch() throws RecognitionException { + AssemblySwitchContext _localctx = new AssemblySwitchContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_assemblySwitch); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(970); + match(T__89); + setState(971); + assemblyExpression(); + setState(975); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__90 || _la==T__91) { + { + { + setState(972); + assemblyCase(); + } + } + setState(977); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyCaseContext extends ParserRuleContext { + public AssemblyLiteralContext assemblyLiteral() { + return getRuleContext(AssemblyLiteralContext.class,0); + } + public AssemblyBlockContext assemblyBlock() { + return getRuleContext(AssemblyBlockContext.class,0); + } + public AssemblyTypeContext assemblyType() { + return getRuleContext(AssemblyTypeContext.class,0); + } + public AssemblyCaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyCase; } + } + + public final AssemblyCaseContext assemblyCase() throws RecognitionException { + AssemblyCaseContext _localctx = new AssemblyCaseContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_assemblyCase); + int _la; + try { + setState(987); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__90: + enterOuterAlt(_localctx, 1); + { + setState(978); + match(T__90); + setState(979); + assemblyLiteral(); + setState(981); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__58) { + { + setState(980); + assemblyType(); + } + } + + setState(983); + assemblyBlock(); + } + break; + case T__91: + enterOuterAlt(_localctx, 2); + { + setState(985); + match(T__91); + setState(986); + assemblyBlock(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyFunctionDefinitionContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public AssemblyBlockContext assemblyBlock() { + return getRuleContext(AssemblyBlockContext.class,0); + } + public AssemblyTypedVariableListContext assemblyTypedVariableList() { + return getRuleContext(AssemblyTypedVariableListContext.class,0); + } + public AssemblyFunctionReturnsContext assemblyFunctionReturns() { + return getRuleContext(AssemblyFunctionReturnsContext.class,0); + } + public AssemblyFunctionDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyFunctionDefinition; } + } + + public final AssemblyFunctionDefinitionContext assemblyFunctionDefinition() throws RecognitionException { + AssemblyFunctionDefinitionContext _localctx = new AssemblyFunctionDefinitionContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_assemblyFunctionDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(989); + match(T__28); + setState(990); + identifier(); + setState(991); + match(T__21); + setState(993); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4504699139006464L) != 0) || _la==Identifier) { + { + setState(992); + assemblyTypedVariableList(); + } + } + + setState(995); + match(T__22); + setState(997); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__60) { + { + setState(996); + assemblyFunctionReturns(); + } + } + + setState(999); + assemblyBlock(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyFunctionReturnsContext extends ParserRuleContext { + public AssemblyTypedVariableListContext assemblyTypedVariableList() { + return getRuleContext(AssemblyTypedVariableListContext.class,0); + } + public AssemblyFunctionReturnsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyFunctionReturns; } + } + + public final AssemblyFunctionReturnsContext assemblyFunctionReturns() throws RecognitionException { + AssemblyFunctionReturnsContext _localctx = new AssemblyFunctionReturnsContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_assemblyFunctionReturns); + try { + enterOuterAlt(_localctx, 1); + { + { + setState(1001); + match(T__60); + setState(1002); + match(T__5); + setState(1003); + assemblyTypedVariableList(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyForContext extends ParserRuleContext { + public List assemblyBlock() { + return getRuleContexts(AssemblyBlockContext.class); + } + public AssemblyBlockContext assemblyBlock(int i) { + return getRuleContext(AssemblyBlockContext.class,i); + } + public AssemblyExpressionContext assemblyExpression() { + return getRuleContext(AssemblyExpressionContext.class,0); + } + public AssemblyForContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyFor; } + } + + public final AssemblyForContext assemblyFor() throws RecognitionException { + AssemblyForContext _localctx = new AssemblyForContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_assemblyFor); + try { + enterOuterAlt(_localctx, 1); + { + setState(1005); + match(T__25); + setState(1006); + assemblyBlock(); + setState(1007); + assemblyExpression(); + setState(1008); + assemblyBlock(); + setState(1009); + assemblyBlock(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyIfContext extends ParserRuleContext { + public AssemblyExpressionContext assemblyExpression() { + return getRuleContext(AssemblyExpressionContext.class,0); + } + public AssemblyBlockContext assemblyBlock() { + return getRuleContext(AssemblyBlockContext.class,0); + } + public AssemblyIfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyIf; } + } + + public final AssemblyIfContext assemblyIf() throws RecognitionException { + AssemblyIfContext _localctx = new AssemblyIfContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_assemblyIf); + try { + enterOuterAlt(_localctx, 1); + { + setState(1011); + match(T__40); + setState(1012); + assemblyExpression(); + setState(1013); + assemblyBlock(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyLiteralContext extends ParserRuleContext { + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class,0); + } + public TerminalNode DecimalNumber() { return getToken(SolidityParser.DecimalNumber, 0); } + public TerminalNode HexNumber() { return getToken(SolidityParser.HexNumber, 0); } + public HexLiteralContext hexLiteral() { + return getRuleContext(HexLiteralContext.class,0); + } + public TerminalNode BooleanLiteral() { return getToken(SolidityParser.BooleanLiteral, 0); } + public AssemblyTypeContext assemblyType() { + return getRuleContext(AssemblyTypeContext.class,0); + } + public AssemblyLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyLiteral; } + } + + public final AssemblyLiteralContext assemblyLiteral() throws RecognitionException { + AssemblyLiteralContext _localctx = new AssemblyLiteralContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_assemblyLiteral); + try { + enterOuterAlt(_localctx, 1); + { + setState(1020); + _errHandler.sync(this); + switch (_input.LA(1)) { + case StringLiteralFragment: + { + setState(1015); + stringLiteral(); + } + break; + case DecimalNumber: + { + setState(1016); + match(DecimalNumber); + } + break; + case HexNumber: + { + setState(1017); + match(HexNumber); + } + break; + case HexLiteralFragment: + { + setState(1018); + hexLiteral(); + } + break; + case BooleanLiteral: + { + setState(1019); + match(BooleanLiteral); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1023); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) { + case 1: + { + setState(1022); + assemblyType(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyTypedVariableListContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public AssemblyTypeContext assemblyType() { + return getRuleContext(AssemblyTypeContext.class,0); + } + public AssemblyTypedVariableListContext assemblyTypedVariableList() { + return getRuleContext(AssemblyTypedVariableListContext.class,0); + } + public AssemblyTypedVariableListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyTypedVariableList; } + } + + public final AssemblyTypedVariableListContext assemblyTypedVariableList() throws RecognitionException { + AssemblyTypedVariableListContext _localctx = new AssemblyTypedVariableListContext(_ctx, getState()); + enterRule(_localctx, 162, RULE_assemblyTypedVariableList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1025); + identifier(); + setState(1027); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__58) { + { + setState(1026); + assemblyType(); + } + } + + setState(1031); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__14) { + { + setState(1029); + match(T__14); + setState(1030); + assemblyTypedVariableList(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssemblyTypeContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public AssemblyTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assemblyType; } + } + + public final AssemblyTypeContext assemblyType() throws RecognitionException { + AssemblyTypeContext _localctx = new AssemblyTypeContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_assemblyType); + try { + enterOuterAlt(_localctx, 1); + { + setState(1033); + match(T__58); + setState(1034); + identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SubAssemblyContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public AssemblyBlockContext assemblyBlock() { + return getRuleContext(AssemblyBlockContext.class,0); + } + public SubAssemblyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_subAssembly; } + } + + public final SubAssemblyContext subAssembly() throws RecognitionException { + SubAssemblyContext _localctx = new SubAssemblyContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_subAssembly); + try { + enterOuterAlt(_localctx, 1); + { + setState(1036); + match(T__45); + setState(1037); + identifier(); + setState(1038); + assemblyBlock(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class NumberLiteralContext extends ParserRuleContext { + public TerminalNode DecimalNumber() { return getToken(SolidityParser.DecimalNumber, 0); } + public TerminalNode HexNumber() { return getToken(SolidityParser.HexNumber, 0); } + public TerminalNode NumberUnit() { return getToken(SolidityParser.NumberUnit, 0); } + public NumberLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_numberLiteral; } + } + + public final NumberLiteralContext numberLiteral() throws RecognitionException { + NumberLiteralContext _localctx = new NumberLiteralContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_numberLiteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1040); + _la = _input.LA(1); + if ( !(_la==DecimalNumber || _la==HexNumber) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1042); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) { + case 1: + { + setState(1041); + match(NumberUnit); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IdentifierContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(SolidityParser.Identifier, 0); } + public IdentifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_identifier; } + } + + public final IdentifierContext identifier() throws RecognitionException { + IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_identifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1044); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 4504699139006464L) != 0) || _la==Identifier) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class HexLiteralContext extends ParserRuleContext { + public List HexLiteralFragment() { return getTokens(SolidityParser.HexLiteralFragment); } + public TerminalNode HexLiteralFragment(int i) { + return getToken(SolidityParser.HexLiteralFragment, i); + } + public HexLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_hexLiteral; } + } + + public final HexLiteralContext hexLiteral() throws RecognitionException { + HexLiteralContext _localctx = new HexLiteralContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_hexLiteral); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1047); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1046); + match(HexLiteralFragment); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1049); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,120,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StringLiteralContext extends ParserRuleContext { + public List StringLiteralFragment() { return getTokens(SolidityParser.StringLiteralFragment); } + public TerminalNode StringLiteralFragment(int i) { + return getToken(SolidityParser.StringLiteralFragment, i); + } + public StringLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stringLiteral; } + } + + public final StringLiteralContext stringLiteral() throws RecognitionException { + StringLiteralContext _localctx = new StringLiteralContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_stringLiteral); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1052); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1051); + match(StringLiteralFragment); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1054); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,121,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 30: + return typeName_sempred((TypeNameContext)_localctx, predIndex); + case 56: + return expression_sempred((ExpressionContext)_localctx, predIndex); + } + return true; + } + private boolean typeName_sempred(TypeNameContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return precpred(_ctx, 2); + } + return true; + } + private boolean expression_sempred(ExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 1: + return precpred(_ctx, 14); + case 2: + return precpred(_ctx, 13); + case 3: + return precpred(_ctx, 12); + case 4: + return precpred(_ctx, 11); + case 5: + return precpred(_ctx, 10); + case 6: + return precpred(_ctx, 9); + case 7: + return precpred(_ctx, 8); + case 8: + return precpred(_ctx, 7); + case 9: + return precpred(_ctx, 6); + case 10: + return precpred(_ctx, 5); + case 11: + return precpred(_ctx, 4); + case 12: + return precpred(_ctx, 3); + case 13: + return precpred(_ctx, 2); + case 14: + return precpred(_ctx, 28); + case 15: + return precpred(_ctx, 26); + case 16: + return precpred(_ctx, 25); + case 17: + return precpred(_ctx, 24); + case 18: + return precpred(_ctx, 23); + case 19: + return precpred(_ctx, 22); + } + return true; + } + + public static final String _serializedATN = + "\u0004\u0001\u0080\u0421\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+ + "\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+ + "\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+ + "\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+ + "\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007"+ + "\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007"+ + "\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007"+ + "\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007"+ + "\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007"+ + "\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007"+ + "\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007"+ + "\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007"+ + "\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007"+ + ",\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u0007"+ + "1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007"+ + "6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007"+ + ";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007"+ + "@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007"+ + "E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007"+ + "J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007"+ + "O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007"+ + "T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0001\u0000\u0001\u0000\u0001"+ + "\u0000\u0001\u0000\u0001\u0000\u0005\u0000\u00b6\b\u0000\n\u0000\f\u0000"+ + "\u00b9\t\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001"+ + "\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003"+ + "\u0003\u0003\u00c6\b\u0003\u0001\u0004\u0001\u0004\u0003\u0004\u00ca\b"+ + "\u0004\u0001\u0005\u0003\u0005\u00cd\b\u0005\u0001\u0005\u0001\u0005\u0001"+ + "\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0003"+ + "\u0007\u00d7\b\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0003"+ + "\u0007\u00dd\b\u0007\u0001\u0007\u0001\u0007\u0003\u0007\u00e1\b\u0007"+ + "\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+ + "\u0001\u0007\u0001\u0007\u0005\u0007\u00eb\b\u0007\n\u0007\f\u0007\u00ee"+ + "\t\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0003"+ + "\u0007\u00f5\b\u0007\u0001\b\u0001\b\u0001\b\u0003\b\u00fa\b\b\u0001\t"+ + "\u0003\t\u00fd\b\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0005"+ + "\t\u0105\b\t\n\t\f\t\u0108\t\t\u0003\t\u010a\b\t\u0001\t\u0001\t\u0005"+ + "\t\u010e\b\t\n\t\f\t\u0111\t\t\u0001\t\u0001\t\u0001\n\u0001\n\u0001\n"+ + "\u0003\n\u0118\b\n\u0001\n\u0003\n\u011b\b\n\u0001\u000b\u0001\u000b\u0001"+ + "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u0124"+ + "\b\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0005"+ + "\f\u012d\b\f\n\f\f\f\u0130\t\f\u0001\f\u0001\f\u0001\f\u0003\f\u0135\b"+ + "\f\u0001\f\u0001\f\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0005\r\u013e"+ + "\b\r\n\r\f\r\u0141\t\r\u0001\r\u0001\r\u0003\r\u0145\b\r\u0001\u000e\u0001"+ + "\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0003\u000e\u014c\b\u000e\u0001"+ + "\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001"+ + "\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0005\u000f\u0158\b\u000f\n"+ + "\u000f\f\u000f\u015b\t\u000f\u0003\u000f\u015d\b\u000f\u0001\u000f\u0001"+ + "\u000f\u0001\u0010\u0001\u0010\u0001\u0010\u0003\u0010\u0164\b\u0010\u0001"+ + "\u0010\u0001\u0010\u0005\u0010\u0168\b\u0010\n\u0010\f\u0010\u016b\t\u0010"+ + "\u0001\u0010\u0001\u0010\u0003\u0010\u016f\b\u0010\u0001\u0011\u0001\u0011"+ + "\u0001\u0011\u0001\u0011\u0003\u0011\u0175\b\u0011\u0001\u0011\u0001\u0011"+ + "\u0003\u0011\u0179\b\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012"+ + "\u0003\u0012\u017f\b\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0003\u0012"+ + "\u0184\b\u0012\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014"+ + "\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+ + "\u0005\u0014\u0191\b\u0014\n\u0014\f\u0014\u0194\t\u0014\u0001\u0015\u0001"+ + "\u0015\u0001\u0015\u0003\u0015\u0199\b\u0015\u0001\u0015\u0003\u0015\u019c"+ + "\b\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u01a2"+ + "\b\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+ + "\u0017\u0003\u0017\u01aa\b\u0017\u0001\u0017\u0001\u0017\u0005\u0017\u01ae"+ + "\b\u0017\n\u0017\f\u0017\u01b1\t\u0017\u0001\u0017\u0001\u0017\u0001\u0018"+ + "\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0005\u0019"+ + "\u01bb\b\u0019\n\u0019\f\u0019\u01be\t\u0019\u0003\u0019\u01c0\b\u0019"+ + "\u0001\u0019\u0001\u0019\u0001\u001a\u0001\u001a\u0003\u001a\u01c6\b\u001a"+ + "\u0001\u001a\u0003\u001a\u01c9\b\u001a\u0001\u001b\u0001\u001b\u0001\u001b"+ + "\u0001\u001b\u0005\u001b\u01cf\b\u001b\n\u001b\f\u001b\u01d2\t\u001b\u0003"+ + "\u001b\u01d4\b\u001b\u0001\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0003"+ + "\u001c\u01da\b\u001c\u0001\u001c\u0003\u001c\u01dd\b\u001c\u0001\u001d"+ + "\u0001\u001d\u0003\u001d\u01e1\b\u001d\u0001\u001d\u0001\u001d\u0001\u001e"+ + "\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u01ea\b\u001e"+ + "\u0001\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u01ef\b\u001e\u0001\u001e"+ + "\u0005\u001e\u01f2\b\u001e\n\u001e\f\u001e\u01f5\t\u001e\u0001\u001f\u0001"+ + "\u001f\u0001\u001f\u0005\u001f\u01fa\b\u001f\n\u001f\f\u001f\u01fd\t\u001f"+ + "\u0001 \u0001 \u0001 \u0001 \u0003 \u0203\b \u0001 \u0001 \u0001 \u0001"+ + " \u0001!\u0001!\u0001!\u0001!\u0003!\u020d\b!\u0001\"\u0001\"\u0001#\u0001"+ + "#\u0001$\u0001$\u0005$\u0215\b$\n$\f$\u0218\t$\u0001$\u0001$\u0001%\u0001"+ + "%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001%\u0001"+ + "%\u0001%\u0003%\u0229\b%\u0001&\u0001&\u0001&\u0001\'\u0001\'\u0001\'"+ + "\u0001\'\u0001\'\u0001\'\u0001\'\u0003\'\u0235\b\'\u0001(\u0001(\u0001"+ + "(\u0003(\u023a\b(\u0001(\u0001(\u0004(\u023e\b(\u000b(\f(\u023f\u0001"+ + ")\u0001)\u0003)\u0244\b)\u0001)\u0003)\u0247\b)\u0001)\u0001)\u0001*\u0001"+ + "*\u0001*\u0001*\u0001*\u0001*\u0001+\u0001+\u0001+\u0001+\u0003+\u0255"+ + "\b+\u0001+\u0001+\u0003+\u0259\b+\u0001+\u0003+\u025c\b+\u0001+\u0001"+ + "+\u0001+\u0001,\u0001,\u0003,\u0263\b,\u0001-\u0001-\u0003-\u0267\b-\u0001"+ + "-\u0001-\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0001"+ + "/\u0001/\u0001/\u00010\u00010\u00010\u00011\u00011\u00031\u027b\b1\u0001"+ + "1\u00011\u00012\u00012\u00012\u00013\u00013\u00013\u00013\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00034\u028d\b4\u00014\u00014\u0003"+ + "4\u0291\b4\u00014\u00014\u00015\u00035\u0296\b5\u00015\u00015\u00035\u029a"+ + "\b5\u00055\u029c\b5\n5\f5\u029f\t5\u00016\u00016\u00036\u02a3\b6\u0001"+ + "6\u00056\u02a6\b6\n6\f6\u02a9\t6\u00016\u00036\u02ac\b6\u00016\u00016"+ + "\u00017\u00017\u00037\u02b2\b7\u00017\u00017\u00017\u00017\u00017\u0001"+ + "7\u00017\u00017\u00017\u00037\u02bd\b7\u00018\u00018\u00018\u00018\u0001"+ + "8\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u0001"+ + "8\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00038\u02d6"+ + "\b8\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u0001"+ + "8\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u0001"+ + "8\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u0001"+ + "8\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u0001"+ + "8\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00038\u0307\b8\u0001"+ + "8\u00018\u00018\u00018\u00038\u030d\b8\u00018\u00018\u00038\u0311\b8\u0001"+ + "8\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u00018\u0001"+ + "8\u00018\u00018\u00018\u00058\u0321\b8\n8\f8\u0324\t8\u00019\u00019\u0001"+ + "9\u00019\u00019\u00019\u00019\u00039\u032d\b9\u00019\u00019\u00019\u0001"+ + "9\u00019\u00039\u0334\b9\u00039\u0336\b9\u0001:\u0001:\u0001:\u0005:\u033b"+ + "\b:\n:\f:\u033e\t:\u0001;\u0001;\u0001;\u0005;\u0343\b;\n;\f;\u0346\t"+ + ";\u0001;\u0003;\u0349\b;\u0001<\u0001<\u0001<\u0001<\u0001=\u0001=\u0003"+ + "=\u0351\b=\u0001=\u0001=\u0003=\u0355\b=\u0003=\u0357\b=\u0001>\u0001"+ + ">\u0001>\u0001>\u0001>\u0001?\u0001?\u0003?\u0360\b?\u0001?\u0001?\u0003"+ + "?\u0364\b?\u0005?\u0366\b?\n?\f?\u0369\t?\u0001?\u0001?\u0001?\u0001?"+ + "\u0001?\u0005?\u0370\b?\n?\f?\u0373\t?\u0003?\u0375\b?\u0001?\u0003?\u0378"+ + "\b?\u0001@\u0001@\u0003@\u037c\b@\u0001A\u0001A\u0001A\u0001A\u0001A\u0001"+ + "A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0001"+ + "A\u0001A\u0001A\u0003A\u0390\bA\u0001B\u0001B\u0005B\u0394\bB\nB\fB\u0397"+ + "\tB\u0001B\u0001B\u0001C\u0001C\u0003C\u039d\bC\u0001D\u0001D\u0001D\u0001"+ + "D\u0003D\u03a3\bD\u0001D\u0001D\u0003D\u03a7\bD\u0001D\u0001D\u0005D\u03ab"+ + "\bD\nD\fD\u03ae\tD\u0001D\u0003D\u03b1\bD\u0001E\u0001E\u0001E\u0001E"+ + "\u0003E\u03b7\bE\u0001F\u0001F\u0001F\u0001F\u0001G\u0001G\u0001G\u0005"+ + "G\u03c0\bG\nG\fG\u03c3\tG\u0001H\u0001H\u0001H\u0001I\u0001I\u0001I\u0001"+ + "J\u0001J\u0001J\u0005J\u03ce\bJ\nJ\fJ\u03d1\tJ\u0001K\u0001K\u0001K\u0003"+ + "K\u03d6\bK\u0001K\u0001K\u0001K\u0001K\u0003K\u03dc\bK\u0001L\u0001L\u0001"+ + "L\u0001L\u0003L\u03e2\bL\u0001L\u0001L\u0003L\u03e6\bL\u0001L\u0001L\u0001"+ + "M\u0001M\u0001M\u0001M\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001"+ + "O\u0001O\u0001O\u0001O\u0001P\u0001P\u0001P\u0001P\u0001P\u0003P\u03fd"+ + "\bP\u0001P\u0003P\u0400\bP\u0001Q\u0001Q\u0003Q\u0404\bQ\u0001Q\u0001"+ + "Q\u0003Q\u0408\bQ\u0001R\u0001R\u0001R\u0001S\u0001S\u0001S\u0001S\u0001"+ + "T\u0001T\u0003T\u0413\bT\u0001U\u0001U\u0001V\u0004V\u0418\bV\u000bV\f"+ + "V\u0419\u0001W\u0004W\u041d\bW\u000bW\fW\u041e\u0001W\u0000\u0002@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+ + "\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c"+ + "\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u0000\u000e\u0001"+ + "\u0000\u0003\t\u0001\u0000\u0012\u0014\u0001\u0000&(\u0004\u0000jjqqu"+ + "uww\u0001\u000089\u0001\u0000<=\u0001\u0000>?\u0002\u0000\f\fBC\u0001"+ + "\u0000DE\u0001\u0000\u0005\b\u0001\u0000HI\u0002\u0000\t\tMV\u0001\u0000"+ + "cd\u0004\u0000\r\r((44{{\u04a2\u0000\u00b7\u0001\u0000\u0000\u0000\u0002"+ + "\u00bc\u0001\u0000\u0000\u0000\u0004\u00c1\u0001\u0000\u0000\u0000\u0006"+ + "\u00c5\u0001\u0000\u0000\u0000\b\u00c7\u0001\u0000\u0000\u0000\n\u00cc"+ + "\u0001\u0000\u0000\u0000\f\u00d0\u0001\u0000\u0000\u0000\u000e\u00f4\u0001"+ + "\u0000\u0000\u0000\u0010\u00f6\u0001\u0000\u0000\u0000\u0012\u00fc\u0001"+ + "\u0000\u0000\u0000\u0014\u0114\u0001\u0000\u0000\u0000\u0016\u0123\u0001"+ + "\u0000\u0000\u0000\u0018\u0125\u0001\u0000\u0000\u0000\u001a\u0138\u0001"+ + "\u0000\u0000\u0000\u001c\u0146\u0001\u0000\u0000\u0000\u001e\u014f\u0001"+ + "\u0000\u0000\u0000 \u0160\u0001\u0000\u0000\u0000\"\u0170\u0001\u0000"+ + "\u0000\u0000$\u0183\u0001\u0000\u0000\u0000&\u0185\u0001\u0000\u0000\u0000"+ + "(\u0192\u0001\u0000\u0000\u0000*\u0195\u0001\u0000\u0000\u0000,\u019d"+ + "\u0001\u0000\u0000\u0000.\u01a5\u0001\u0000\u0000\u00000\u01b4\u0001\u0000"+ + "\u0000\u00002\u01b6\u0001\u0000\u0000\u00004\u01c3\u0001\u0000\u0000\u0000"+ + "6\u01ca\u0001\u0000\u0000\u00008\u01d7\u0001\u0000\u0000\u0000:\u01de"+ + "\u0001\u0000\u0000\u0000<\u01e9\u0001\u0000\u0000\u0000>\u01f6\u0001\u0000"+ + "\u0000\u0000@\u01fe\u0001\u0000\u0000\u0000B\u0208\u0001\u0000\u0000\u0000"+ + "D\u020e\u0001\u0000\u0000\u0000F\u0210\u0001\u0000\u0000\u0000H\u0212"+ + "\u0001\u0000\u0000\u0000J\u0228\u0001\u0000\u0000\u0000L\u022a\u0001\u0000"+ + "\u0000\u0000N\u022d\u0001\u0000\u0000\u0000P\u0236\u0001\u0000\u0000\u0000"+ + "R\u0241\u0001\u0000\u0000\u0000T\u024a\u0001\u0000\u0000\u0000V\u0250"+ + "\u0001\u0000\u0000\u0000X\u0262\u0001\u0000\u0000\u0000Z\u0264\u0001\u0000"+ + "\u0000\u0000\\\u026a\u0001\u0000\u0000\u0000^\u0272\u0001\u0000\u0000"+ + "\u0000`\u0275\u0001\u0000\u0000\u0000b\u0278\u0001\u0000\u0000\u0000d"+ + "\u027e\u0001\u0000\u0000\u0000f\u0281\u0001\u0000\u0000\u0000h\u028c\u0001"+ + "\u0000\u0000\u0000j\u0295\u0001\u0000\u0000\u0000l\u02a0\u0001\u0000\u0000"+ + "\u0000n\u02bc\u0001\u0000\u0000\u0000p\u02d5\u0001\u0000\u0000\u0000r"+ + "\u0335\u0001\u0000\u0000\u0000t\u0337\u0001\u0000\u0000\u0000v\u033f\u0001"+ + "\u0000\u0000\u0000x\u034a\u0001\u0000\u0000\u0000z\u0356\u0001\u0000\u0000"+ + "\u0000|\u0358\u0001\u0000\u0000\u0000~\u0377\u0001\u0000\u0000\u0000\u0080"+ + "\u037b\u0001\u0000\u0000\u0000\u0082\u038f\u0001\u0000\u0000\u0000\u0084"+ + "\u0391\u0001\u0000\u0000\u0000\u0086\u039c\u0001\u0000\u0000\u0000\u0088"+ + "\u03a2\u0001\u0000\u0000\u0000\u008a\u03b2\u0001\u0000\u0000\u0000\u008c"+ + "\u03b8\u0001\u0000\u0000\u0000\u008e\u03bc\u0001\u0000\u0000\u0000\u0090"+ + "\u03c4\u0001\u0000\u0000\u0000\u0092\u03c7\u0001\u0000\u0000\u0000\u0094"+ + "\u03ca\u0001\u0000\u0000\u0000\u0096\u03db\u0001\u0000\u0000\u0000\u0098"+ + "\u03dd\u0001\u0000\u0000\u0000\u009a\u03e9\u0001\u0000\u0000\u0000\u009c"+ + "\u03ed\u0001\u0000\u0000\u0000\u009e\u03f3\u0001\u0000\u0000\u0000\u00a0"+ + "\u03fc\u0001\u0000\u0000\u0000\u00a2\u0401\u0001\u0000\u0000\u0000\u00a4"+ + "\u0409\u0001\u0000\u0000\u0000\u00a6\u040c\u0001\u0000\u0000\u0000\u00a8"+ + "\u0410\u0001\u0000\u0000\u0000\u00aa\u0414\u0001\u0000\u0000\u0000\u00ac"+ + "\u0417\u0001\u0000\u0000\u0000\u00ae\u041c\u0001\u0000\u0000\u0000\u00b0"+ + "\u00b6\u0003\u0002\u0001\u0000\u00b1\u00b6\u0003\u000e\u0007\u0000\u00b2"+ + "\u00b6\u0003\u001e\u000f\u0000\u00b3\u00b6\u0003.\u0017\u0000\u00b4\u00b6"+ + "\u0003\u0012\t\u0000\u00b5\u00b0\u0001\u0000\u0000\u0000\u00b5\u00b1\u0001"+ + "\u0000\u0000\u0000\u00b5\u00b2\u0001\u0000\u0000\u0000\u00b5\u00b3\u0001"+ + "\u0000\u0000\u0000\u00b5\u00b4\u0001\u0000\u0000\u0000\u00b6\u00b9\u0001"+ + "\u0000\u0000\u0000\u00b7\u00b5\u0001\u0000\u0000\u0000\u00b7\u00b8\u0001"+ + "\u0000\u0000\u0000\u00b8\u00ba\u0001\u0000\u0000\u0000\u00b9\u00b7\u0001"+ + "\u0000\u0000\u0000\u00ba\u00bb\u0005\u0000\u0000\u0001\u00bb\u0001\u0001"+ + "\u0000\u0000\u0000\u00bc\u00bd\u0005\u0001\u0000\u0000\u00bd\u00be\u0003"+ + "\u0004\u0002\u0000\u00be\u00bf\u0003\u0006\u0003\u0000\u00bf\u00c0\u0005"+ + "\u0002\u0000\u0000\u00c0\u0003\u0001\u0000\u0000\u0000\u00c1\u00c2\u0003"+ + "\u00aaU\u0000\u00c2\u0005\u0001\u0000\u0000\u0000\u00c3\u00c6\u0003\b"+ + "\u0004\u0000\u00c4\u00c6\u0003p8\u0000\u00c5\u00c3\u0001\u0000\u0000\u0000"+ + "\u00c5\u00c4\u0001\u0000\u0000\u0000\u00c6\u0007\u0001\u0000\u0000\u0000"+ + "\u00c7\u00c9\u0003\n\u0005\u0000\u00c8\u00ca\u0003\n\u0005\u0000\u00c9"+ + "\u00c8\u0001\u0000\u0000\u0000\u00c9\u00ca\u0001\u0000\u0000\u0000\u00ca"+ + "\t\u0001\u0000\u0000\u0000\u00cb\u00cd\u0003\f\u0006\u0000\u00cc\u00cb"+ + "\u0001\u0000\u0000\u0000\u00cc\u00cd\u0001\u0000\u0000\u0000\u00cd\u00ce"+ + "\u0001\u0000\u0000\u0000\u00ce\u00cf\u0005}\u0000\u0000\u00cf\u000b\u0001"+ + "\u0000\u0000\u0000\u00d0\u00d1\u0007\u0000\u0000\u0000\u00d1\r\u0001\u0000"+ + "\u0000\u0000\u00d2\u00d3\u0005\n\u0000\u0000\u00d3\u00d6\u0005|\u0000"+ + "\u0000\u00d4\u00d5\u0005\u000b\u0000\u0000\u00d5\u00d7\u0003\u00aaU\u0000"+ + "\u00d6\u00d4\u0001\u0000\u0000\u0000\u00d6\u00d7\u0001\u0000\u0000\u0000"+ + "\u00d7\u00d8\u0001\u0000\u0000\u0000\u00d8\u00f5\u0005\u0002\u0000\u0000"+ + "\u00d9\u00dc\u0005\n\u0000\u0000\u00da\u00dd\u0005\f\u0000\u0000\u00db"+ + "\u00dd\u0003\u00aaU\u0000\u00dc\u00da\u0001\u0000\u0000\u0000\u00dc\u00db"+ + "\u0001\u0000\u0000\u0000\u00dd\u00e0\u0001\u0000\u0000\u0000\u00de\u00df"+ + "\u0005\u000b\u0000\u0000\u00df\u00e1\u0003\u00aaU\u0000\u00e0\u00de\u0001"+ + "\u0000\u0000\u0000\u00e0\u00e1\u0001\u0000\u0000\u0000\u00e1\u00e2\u0001"+ + "\u0000\u0000\u0000\u00e2\u00e3\u0005\r\u0000\u0000\u00e3\u00e4\u0005|"+ + "\u0000\u0000\u00e4\u00f5\u0005\u0002\u0000\u0000\u00e5\u00e6\u0005\n\u0000"+ + "\u0000\u00e6\u00e7\u0005\u000e\u0000\u0000\u00e7\u00ec\u0003\u0010\b\u0000"+ + "\u00e8\u00e9\u0005\u000f\u0000\u0000\u00e9\u00eb\u0003\u0010\b\u0000\u00ea"+ + "\u00e8\u0001\u0000\u0000\u0000\u00eb\u00ee\u0001\u0000\u0000\u0000\u00ec"+ + "\u00ea\u0001\u0000\u0000\u0000\u00ec\u00ed\u0001\u0000\u0000\u0000\u00ed"+ + "\u00ef\u0001\u0000\u0000\u0000\u00ee\u00ec\u0001\u0000\u0000\u0000\u00ef"+ + "\u00f0\u0005\u0010\u0000\u0000\u00f0\u00f1\u0005\r\u0000\u0000\u00f1\u00f2"+ + "\u0005|\u0000\u0000\u00f2\u00f3\u0005\u0002\u0000\u0000\u00f3\u00f5\u0001"+ + "\u0000\u0000\u0000\u00f4\u00d2\u0001\u0000\u0000\u0000\u00f4\u00d9\u0001"+ + "\u0000\u0000\u0000\u00f4\u00e5\u0001\u0000\u0000\u0000\u00f5\u000f\u0001"+ + "\u0000\u0000\u0000\u00f6\u00f9\u0003\u00aaU\u0000\u00f7\u00f8\u0005\u000b"+ + "\u0000\u0000\u00f8\u00fa\u0003\u00aaU\u0000\u00f9\u00f7\u0001\u0000\u0000"+ + "\u0000\u00f9\u00fa\u0001\u0000\u0000\u0000\u00fa\u0011\u0001\u0000\u0000"+ + "\u0000\u00fb\u00fd\u0005\u0011\u0000\u0000\u00fc\u00fb\u0001\u0000\u0000"+ + "\u0000\u00fc\u00fd\u0001\u0000\u0000\u0000\u00fd\u00fe\u0001\u0000\u0000"+ + "\u0000\u00fe\u00ff\u0007\u0001\u0000\u0000\u00ff\u0109\u0003\u00aaU\u0000"+ + "\u0100\u0101\u0005\u0015\u0000\u0000\u0101\u0106\u0003\u0014\n\u0000\u0102"+ + "\u0103\u0005\u000f\u0000\u0000\u0103\u0105\u0003\u0014\n\u0000\u0104\u0102"+ + "\u0001\u0000\u0000\u0000\u0105\u0108\u0001\u0000\u0000\u0000\u0106\u0104"+ + "\u0001\u0000\u0000\u0000\u0106\u0107\u0001\u0000\u0000\u0000\u0107\u010a"+ + "\u0001\u0000\u0000\u0000\u0108\u0106\u0001\u0000\u0000\u0000\u0109\u0100"+ + "\u0001\u0000\u0000\u0000\u0109\u010a\u0001\u0000\u0000\u0000\u010a\u010b"+ + "\u0001\u0000\u0000\u0000\u010b\u010f\u0005\u000e\u0000\u0000\u010c\u010e"+ + "\u0003\u0016\u000b\u0000\u010d\u010c\u0001\u0000\u0000\u0000\u010e\u0111"+ + "\u0001\u0000\u0000\u0000\u010f\u010d\u0001\u0000\u0000\u0000\u010f\u0110"+ + "\u0001\u0000\u0000\u0000\u0110\u0112\u0001\u0000\u0000\u0000\u0111\u010f"+ + "\u0001\u0000\u0000\u0000\u0112\u0113\u0005\u0010\u0000\u0000\u0113\u0013"+ + "\u0001\u0000\u0000\u0000\u0114\u011a\u0003>\u001f\u0000\u0115\u0117\u0005"+ + "\u0016\u0000\u0000\u0116\u0118\u0003t:\u0000\u0117\u0116\u0001\u0000\u0000"+ + "\u0000\u0117\u0118\u0001\u0000\u0000\u0000\u0118\u0119\u0001\u0000\u0000"+ + "\u0000\u0119\u011b\u0005\u0017\u0000\u0000\u011a\u0115\u0001\u0000\u0000"+ + "\u0000\u011a\u011b\u0001\u0000\u0000\u0000\u011b\u0015\u0001\u0000\u0000"+ + "\u0000\u011c\u0124\u0003\u0018\f\u0000\u011d\u0124\u0003\u001c\u000e\u0000"+ + "\u011e\u0124\u0003\u001e\u000f\u0000\u011f\u0124\u0003 \u0010\u0000\u0120"+ + "\u0124\u0003\"\u0011\u0000\u0121\u0124\u0003,\u0016\u0000\u0122\u0124"+ + "\u0003.\u0017\u0000\u0123\u011c\u0001\u0000\u0000\u0000\u0123\u011d\u0001"+ + "\u0000\u0000\u0000\u0123\u011e\u0001\u0000\u0000\u0000\u0123\u011f\u0001"+ + "\u0000\u0000\u0000\u0123\u0120\u0001\u0000\u0000\u0000\u0123\u0121\u0001"+ + "\u0000\u0000\u0000\u0123\u0122\u0001\u0000\u0000\u0000\u0124\u0017\u0001"+ + "\u0000\u0000\u0000\u0125\u012e\u0003<\u001e\u0000\u0126\u012d\u0005s\u0000"+ + "\u0000\u0127\u012d\u0005p\u0000\u0000\u0128\u012d\u0005r\u0000\u0000\u0129"+ + "\u012d\u0005j\u0000\u0000\u012a\u012d\u0005k\u0000\u0000\u012b\u012d\u0003"+ + "\u001a\r\u0000\u012c\u0126\u0001\u0000\u0000\u0000\u012c\u0127\u0001\u0000"+ + "\u0000\u0000\u012c\u0128\u0001\u0000\u0000\u0000\u012c\u0129\u0001\u0000"+ + "\u0000\u0000\u012c\u012a\u0001\u0000\u0000\u0000\u012c\u012b\u0001\u0000"+ + "\u0000\u0000\u012d\u0130\u0001\u0000\u0000\u0000\u012e\u012c\u0001\u0000"+ + "\u0000\u0000\u012e\u012f\u0001\u0000\u0000\u0000\u012f\u0131\u0001\u0000"+ + "\u0000\u0000\u0130\u012e\u0001\u0000\u0000\u0000\u0131\u0134\u0003\u00aa"+ + "U\u0000\u0132\u0133\u0005\t\u0000\u0000\u0133\u0135\u0003p8\u0000\u0134"+ + "\u0132\u0001\u0000\u0000\u0000\u0134\u0135\u0001\u0000\u0000\u0000\u0135"+ + "\u0136\u0001\u0000\u0000\u0000\u0136\u0137\u0005\u0002\u0000\u0000\u0137"+ + "\u0019\u0001\u0000\u0000\u0000\u0138\u0144\u0005\u0018\u0000\u0000\u0139"+ + "\u013a\u0005\u0016\u0000\u0000\u013a\u013f\u0003>\u001f\u0000\u013b\u013c"+ + "\u0005\u000f\u0000\u0000\u013c\u013e\u0003>\u001f\u0000\u013d\u013b\u0001"+ + "\u0000\u0000\u0000\u013e\u0141\u0001\u0000\u0000\u0000\u013f\u013d\u0001"+ + "\u0000\u0000\u0000\u013f\u0140\u0001\u0000\u0000\u0000\u0140\u0142\u0001"+ + "\u0000\u0000\u0000\u0141\u013f\u0001\u0000\u0000\u0000\u0142\u0143\u0005"+ + "\u0017\u0000\u0000\u0143\u0145\u0001\u0000\u0000\u0000\u0144\u0139\u0001"+ + "\u0000\u0000\u0000\u0144\u0145\u0001\u0000\u0000\u0000\u0145\u001b\u0001"+ + "\u0000\u0000\u0000\u0146\u0147\u0005\u0019\u0000\u0000\u0147\u0148\u0003"+ + "\u00aaU\u0000\u0148\u014b\u0005\u001a\u0000\u0000\u0149\u014c\u0005\f"+ + "\u0000\u0000\u014a\u014c\u0003<\u001e\u0000\u014b\u0149\u0001\u0000\u0000"+ + "\u0000\u014b\u014a\u0001\u0000\u0000\u0000\u014c\u014d\u0001\u0000\u0000"+ + "\u0000\u014d\u014e\u0005\u0002\u0000\u0000\u014e\u001d\u0001\u0000\u0000"+ + "\u0000\u014f\u0150\u0005\u001b\u0000\u0000\u0150\u0151\u0003\u00aaU\u0000"+ + "\u0151\u015c\u0005\u000e\u0000\u0000\u0152\u0153\u0003:\u001d\u0000\u0153"+ + "\u0159\u0005\u0002\u0000\u0000\u0154\u0155\u0003:\u001d\u0000\u0155\u0156"+ + "\u0005\u0002\u0000\u0000\u0156\u0158\u0001\u0000\u0000\u0000\u0157\u0154"+ + "\u0001\u0000\u0000\u0000\u0158\u015b\u0001\u0000\u0000\u0000\u0159\u0157"+ + "\u0001\u0000\u0000\u0000\u0159\u015a\u0001\u0000\u0000\u0000\u015a\u015d"+ + "\u0001\u0000\u0000\u0000\u015b\u0159\u0001\u0000\u0000\u0000\u015c\u0152"+ + "\u0001\u0000\u0000\u0000\u015c\u015d\u0001\u0000\u0000\u0000\u015d\u015e"+ + "\u0001\u0000\u0000\u0000\u015e\u015f\u0005\u0010\u0000\u0000\u015f\u001f"+ + "\u0001\u0000\u0000\u0000\u0160\u0161\u0005\u001c\u0000\u0000\u0161\u0163"+ + "\u0003\u00aaU\u0000\u0162\u0164\u00032\u0019\u0000\u0163\u0162\u0001\u0000"+ + "\u0000\u0000\u0163\u0164\u0001\u0000\u0000\u0000\u0164\u0169\u0001\u0000"+ + "\u0000\u0000\u0165\u0168\u0005t\u0000\u0000\u0166\u0168\u0003\u001a\r"+ + "\u0000\u0167\u0165\u0001\u0000\u0000\u0000\u0167\u0166\u0001\u0000\u0000"+ + "\u0000\u0168\u016b\u0001\u0000\u0000\u0000\u0169\u0167\u0001\u0000\u0000"+ + "\u0000\u0169\u016a\u0001\u0000\u0000\u0000\u016a\u016e\u0001\u0000\u0000"+ + "\u0000\u016b\u0169\u0001\u0000\u0000\u0000\u016c\u016f\u0005\u0002\u0000"+ + "\u0000\u016d\u016f\u0003H$\u0000\u016e\u016c\u0001\u0000\u0000\u0000\u016e"+ + "\u016d\u0001\u0000\u0000\u0000\u016f!\u0001\u0000\u0000\u0000\u0170\u0171"+ + "\u0003$\u0012\u0000\u0171\u0172\u00032\u0019\u0000\u0172\u0174\u0003("+ + "\u0014\u0000\u0173\u0175\u0003&\u0013\u0000\u0174\u0173\u0001\u0000\u0000"+ + "\u0000\u0174\u0175\u0001\u0000\u0000\u0000\u0175\u0178\u0001\u0000\u0000"+ + "\u0000\u0176\u0179\u0005\u0002\u0000\u0000\u0177\u0179\u0003H$\u0000\u0178"+ + "\u0176\u0001\u0000\u0000\u0000\u0178\u0177\u0001\u0000\u0000\u0000\u0179"+ + "#\u0001\u0000\u0000\u0000\u017a\u017e\u0005\u001d\u0000\u0000\u017b\u017f"+ + "\u0003\u00aaU\u0000\u017c\u017f\u0005z\u0000\u0000\u017d\u017f\u0005y"+ + "\u0000\u0000\u017e\u017b\u0001\u0000\u0000\u0000\u017e\u017c\u0001\u0000"+ + "\u0000\u0000\u017e\u017d\u0001\u0000\u0000\u0000\u017e\u017f\u0001\u0000"+ + "\u0000\u0000\u017f\u0184\u0001\u0000\u0000\u0000\u0180\u0184\u0005x\u0000"+ + "\u0000\u0181\u0184\u0005y\u0000\u0000\u0182\u0184\u0005z\u0000\u0000\u0183"+ + "\u017a\u0001\u0000\u0000\u0000\u0183\u0180\u0001\u0000\u0000\u0000\u0183"+ + "\u0181\u0001\u0000\u0000\u0000\u0183\u0182\u0001\u0000\u0000\u0000\u0184"+ + "%\u0001\u0000\u0000\u0000\u0185\u0186\u0005\u001e\u0000\u0000\u0186\u0187"+ + "\u00032\u0019\u0000\u0187\'\u0001\u0000\u0000\u0000\u0188\u0191\u0003"+ + "*\u0015\u0000\u0189\u0191\u0003F#\u0000\u018a\u0191\u0005n\u0000\u0000"+ + "\u018b\u0191\u0005s\u0000\u0000\u018c\u0191\u0005p\u0000\u0000\u018d\u0191"+ + "\u0005r\u0000\u0000\u018e\u0191\u0005t\u0000\u0000\u018f\u0191\u0003\u001a"+ + "\r\u0000\u0190\u0188\u0001\u0000\u0000\u0000\u0190\u0189\u0001\u0000\u0000"+ + "\u0000\u0190\u018a\u0001\u0000\u0000\u0000\u0190\u018b\u0001\u0000\u0000"+ + "\u0000\u0190\u018c\u0001\u0000\u0000\u0000\u0190\u018d\u0001\u0000\u0000"+ + "\u0000\u0190\u018e\u0001\u0000\u0000\u0000\u0190\u018f\u0001\u0000\u0000"+ + "\u0000\u0191\u0194\u0001\u0000\u0000\u0000\u0192\u0190\u0001\u0000\u0000"+ + "\u0000\u0192\u0193\u0001\u0000\u0000\u0000\u0193)\u0001\u0000\u0000\u0000"+ + "\u0194\u0192\u0001\u0000\u0000\u0000\u0195\u019b\u0003\u00aaU\u0000\u0196"+ + "\u0198\u0005\u0016\u0000\u0000\u0197\u0199\u0003t:\u0000\u0198\u0197\u0001"+ + "\u0000\u0000\u0000\u0198\u0199\u0001\u0000\u0000\u0000\u0199\u019a\u0001"+ + "\u0000\u0000\u0000\u019a\u019c\u0005\u0017\u0000\u0000\u019b\u0196\u0001"+ + "\u0000\u0000\u0000\u019b\u019c\u0001\u0000\u0000\u0000\u019c+\u0001\u0000"+ + "\u0000\u0000\u019d\u019e\u0005\u001f\u0000\u0000\u019e\u019f\u0003\u00aa"+ + "U\u0000\u019f\u01a1\u00036\u001b\u0000\u01a0\u01a2\u0005h\u0000\u0000"+ + "\u01a1\u01a0\u0001\u0000\u0000\u0000\u01a1\u01a2\u0001\u0000\u0000\u0000"+ + "\u01a2\u01a3\u0001\u0000\u0000\u0000\u01a3\u01a4\u0005\u0002\u0000\u0000"+ + "\u01a4-\u0001\u0000\u0000\u0000\u01a5\u01a6\u0005 \u0000\u0000\u01a6\u01a7"+ + "\u0003\u00aaU\u0000\u01a7\u01a9\u0005\u000e\u0000\u0000\u01a8\u01aa\u0003"+ + "0\u0018\u0000\u01a9\u01a8\u0001\u0000\u0000\u0000\u01a9\u01aa\u0001\u0000"+ + "\u0000\u0000\u01aa\u01af\u0001\u0000\u0000\u0000\u01ab\u01ac\u0005\u000f"+ + "\u0000\u0000\u01ac\u01ae\u00030\u0018\u0000\u01ad\u01ab\u0001\u0000\u0000"+ + "\u0000\u01ae\u01b1\u0001\u0000\u0000\u0000\u01af\u01ad\u0001\u0000\u0000"+ + "\u0000\u01af\u01b0\u0001\u0000\u0000\u0000\u01b0\u01b2\u0001\u0000\u0000"+ + "\u0000\u01b1\u01af\u0001\u0000\u0000\u0000\u01b2\u01b3\u0005\u0010\u0000"+ + "\u0000\u01b3/\u0001\u0000\u0000\u0000\u01b4\u01b5\u0003\u00aaU\u0000\u01b5"+ + "1\u0001\u0000\u0000\u0000\u01b6\u01bf\u0005\u0016\u0000\u0000\u01b7\u01bc"+ + "\u00034\u001a\u0000\u01b8\u01b9\u0005\u000f\u0000\u0000\u01b9\u01bb\u0003"+ + "4\u001a\u0000\u01ba\u01b8\u0001\u0000\u0000\u0000\u01bb\u01be\u0001\u0000"+ + "\u0000\u0000\u01bc\u01ba\u0001\u0000\u0000\u0000\u01bc\u01bd\u0001\u0000"+ + "\u0000\u0000\u01bd\u01c0\u0001\u0000\u0000\u0000\u01be\u01bc\u0001\u0000"+ + "\u0000\u0000\u01bf\u01b7\u0001\u0000\u0000\u0000\u01bf\u01c0\u0001\u0000"+ + "\u0000\u0000\u01c0\u01c1\u0001\u0000\u0000\u0000\u01c1\u01c2\u0005\u0017"+ + "\u0000\u0000\u01c23\u0001\u0000\u0000\u0000\u01c3\u01c5\u0003<\u001e\u0000"+ + "\u01c4\u01c6\u0003D\"\u0000\u01c5\u01c4\u0001\u0000\u0000\u0000\u01c5"+ + "\u01c6\u0001\u0000\u0000\u0000\u01c6\u01c8\u0001\u0000\u0000\u0000\u01c7"+ + "\u01c9\u0003\u00aaU\u0000\u01c8\u01c7\u0001\u0000\u0000\u0000\u01c8\u01c9"+ + "\u0001\u0000\u0000\u0000\u01c95\u0001\u0000\u0000\u0000\u01ca\u01d3\u0005"+ + "\u0016\u0000\u0000\u01cb\u01d0\u00038\u001c\u0000\u01cc\u01cd\u0005\u000f"+ + "\u0000\u0000\u01cd\u01cf\u00038\u001c\u0000\u01ce\u01cc\u0001\u0000\u0000"+ + "\u0000\u01cf\u01d2\u0001\u0000\u0000\u0000\u01d0\u01ce\u0001\u0000\u0000"+ + "\u0000\u01d0\u01d1\u0001\u0000\u0000\u0000\u01d1\u01d4\u0001\u0000\u0000"+ + "\u0000\u01d2\u01d0\u0001\u0000\u0000\u0000\u01d3\u01cb\u0001\u0000\u0000"+ + "\u0000\u01d3\u01d4\u0001\u0000\u0000\u0000\u01d4\u01d5\u0001\u0000\u0000"+ + "\u0000\u01d5\u01d6\u0005\u0017\u0000\u0000\u01d67\u0001\u0000\u0000\u0000"+ + "\u01d7\u01d9\u0003<\u001e\u0000\u01d8\u01da\u0005o\u0000\u0000\u01d9\u01d8"+ + "\u0001\u0000\u0000\u0000\u01d9\u01da\u0001\u0000\u0000\u0000\u01da\u01dc"+ + "\u0001\u0000\u0000\u0000\u01db\u01dd\u0003\u00aaU\u0000\u01dc\u01db\u0001"+ + "\u0000\u0000\u0000\u01dc\u01dd\u0001\u0000\u0000\u0000\u01dd9\u0001\u0000"+ + "\u0000\u0000\u01de\u01e0\u0003<\u001e\u0000\u01df\u01e1\u0003D\"\u0000"+ + "\u01e0\u01df\u0001\u0000\u0000\u0000\u01e0\u01e1\u0001\u0000\u0000\u0000"+ + "\u01e1\u01e2\u0001\u0000\u0000\u0000\u01e2\u01e3\u0003\u00aaU\u0000\u01e3"+ + ";\u0001\u0000\u0000\u0000\u01e4\u01e5\u0006\u001e\uffff\uffff\u0000\u01e5"+ + "\u01ea\u0003n7\u0000\u01e6\u01ea\u0003>\u001f\u0000\u01e7\u01ea\u0003"+ + "@ \u0000\u01e8\u01ea\u0003B!\u0000\u01e9\u01e4\u0001\u0000\u0000\u0000"+ + "\u01e9\u01e6\u0001\u0000\u0000\u0000\u01e9\u01e7\u0001\u0000\u0000\u0000"+ + "\u01e9\u01e8\u0001\u0000\u0000\u0000\u01ea\u01f3\u0001\u0000\u0000\u0000"+ + "\u01eb\u01ec\n\u0002\u0000\u0000\u01ec\u01ee\u0005!\u0000\u0000\u01ed"+ + "\u01ef\u0003p8\u0000\u01ee\u01ed\u0001\u0000\u0000\u0000\u01ee\u01ef\u0001"+ + "\u0000\u0000\u0000\u01ef\u01f0\u0001\u0000\u0000\u0000\u01f0\u01f2\u0005"+ + "\"\u0000\u0000\u01f1\u01eb\u0001\u0000\u0000\u0000\u01f2\u01f5\u0001\u0000"+ + "\u0000\u0000\u01f3\u01f1\u0001\u0000\u0000\u0000\u01f3\u01f4\u0001\u0000"+ + "\u0000\u0000\u01f4=\u0001\u0000\u0000\u0000\u01f5\u01f3\u0001\u0000\u0000"+ + "\u0000\u01f6\u01fb\u0003\u00aaU\u0000\u01f7\u01f8\u0005#\u0000\u0000\u01f8"+ + "\u01fa\u0003\u00aaU\u0000\u01f9\u01f7\u0001\u0000\u0000\u0000\u01fa\u01fd"+ + "\u0001\u0000\u0000\u0000\u01fb\u01f9\u0001\u0000\u0000\u0000\u01fb\u01fc"+ + "\u0001\u0000\u0000\u0000\u01fc?\u0001\u0000\u0000\u0000\u01fd\u01fb\u0001"+ + "\u0000\u0000\u0000\u01fe\u01ff\u0005$\u0000\u0000\u01ff\u0202\u0005\u0016"+ + "\u0000\u0000\u0200\u0203\u0003n7\u0000\u0201\u0203\u0003>\u001f\u0000"+ + "\u0202\u0200\u0001\u0000\u0000\u0000\u0202\u0201\u0001\u0000\u0000\u0000"+ + "\u0203\u0204\u0001\u0000\u0000\u0000\u0204\u0205\u0005%\u0000\u0000\u0205"+ + "\u0206\u0003<\u001e\u0000\u0206\u0207\u0005\u0017\u0000\u0000\u0207A\u0001"+ + "\u0000\u0000\u0000\u0208\u0209\u0005\u001d\u0000\u0000\u0209\u020a\u0003"+ + "2\u0019\u0000\u020a\u020c\u0003(\u0014\u0000\u020b\u020d\u0003&\u0013"+ + "\u0000\u020c\u020b\u0001\u0000\u0000\u0000\u020c\u020d\u0001\u0000\u0000"+ + "\u0000\u020dC\u0001\u0000\u0000\u0000\u020e\u020f\u0007\u0002\u0000\u0000"+ + "\u020fE\u0001\u0000\u0000\u0000\u0210\u0211\u0007\u0003\u0000\u0000\u0211"+ + "G\u0001\u0000\u0000\u0000\u0212\u0216\u0005\u000e\u0000\u0000\u0213\u0215"+ + "\u0003J%\u0000\u0214\u0213\u0001\u0000\u0000\u0000\u0215\u0218\u0001\u0000"+ + "\u0000\u0000\u0216\u0214\u0001\u0000\u0000\u0000\u0216\u0217\u0001\u0000"+ + "\u0000\u0000\u0217\u0219\u0001\u0000\u0000\u0000\u0218\u0216\u0001\u0000"+ + "\u0000\u0000\u0219\u021a\u0005\u0010\u0000\u0000\u021aI\u0001\u0000\u0000"+ + "\u0000\u021b\u0229\u0003N\'\u0000\u021c\u0229\u0003P(\u0000\u021d\u0229"+ + "\u0003T*\u0000\u021e\u0229\u0003V+\u0000\u021f\u0229\u0003H$\u0000\u0220"+ + "\u0229\u0003Z-\u0000\u0221\u0229\u0003\\.\u0000\u0222\u0229\u0003^/\u0000"+ + "\u0223\u0229\u0003`0\u0000\u0224\u0229\u0003b1\u0000\u0225\u0229\u0003"+ + "d2\u0000\u0226\u0229\u0003f3\u0000\u0227\u0229\u0003X,\u0000\u0228\u021b"+ + "\u0001\u0000\u0000\u0000\u0228\u021c\u0001\u0000\u0000\u0000\u0228\u021d"+ + "\u0001\u0000\u0000\u0000\u0228\u021e\u0001\u0000\u0000\u0000\u0228\u021f"+ + "\u0001\u0000\u0000\u0000\u0228\u0220\u0001\u0000\u0000\u0000\u0228\u0221"+ + "\u0001\u0000\u0000\u0000\u0228\u0222\u0001\u0000\u0000\u0000\u0228\u0223"+ + "\u0001\u0000\u0000\u0000\u0228\u0224\u0001\u0000\u0000\u0000\u0228\u0225"+ + "\u0001\u0000\u0000\u0000\u0228\u0226\u0001\u0000\u0000\u0000\u0228\u0227"+ + "\u0001\u0000\u0000\u0000\u0229K\u0001\u0000\u0000\u0000\u022a\u022b\u0003"+ + "p8\u0000\u022b\u022c\u0005\u0002\u0000\u0000\u022cM\u0001\u0000\u0000"+ + "\u0000\u022d\u022e\u0005)\u0000\u0000\u022e\u022f\u0005\u0016\u0000\u0000"+ + "\u022f\u0230\u0003p8\u0000\u0230\u0231\u0005\u0017\u0000\u0000\u0231\u0234"+ + "\u0003J%\u0000\u0232\u0233\u0005*\u0000\u0000\u0233\u0235\u0003J%\u0000"+ + "\u0234\u0232\u0001\u0000\u0000\u0000\u0234\u0235\u0001\u0000\u0000\u0000"+ + "\u0235O\u0001\u0000\u0000\u0000\u0236\u0237\u0005+\u0000\u0000\u0237\u0239"+ + "\u0003p8\u0000\u0238\u023a\u0003&\u0013\u0000\u0239\u0238\u0001\u0000"+ + "\u0000\u0000\u0239\u023a\u0001\u0000\u0000\u0000\u023a\u023b\u0001\u0000"+ + "\u0000\u0000\u023b\u023d\u0003H$\u0000\u023c\u023e\u0003R)\u0000\u023d"+ + "\u023c\u0001\u0000\u0000\u0000\u023e\u023f\u0001\u0000\u0000\u0000\u023f"+ + "\u023d\u0001\u0000\u0000\u0000\u023f\u0240\u0001\u0000\u0000\u0000\u0240"+ + "Q\u0001\u0000\u0000\u0000\u0241\u0246\u0005,\u0000\u0000\u0242\u0244\u0003"+ + "\u00aaU\u0000\u0243\u0242\u0001\u0000\u0000\u0000\u0243\u0244\u0001\u0000"+ + "\u0000\u0000\u0244\u0245\u0001\u0000\u0000\u0000\u0245\u0247\u00032\u0019"+ + "\u0000\u0246\u0243\u0001\u0000\u0000\u0000\u0246\u0247\u0001\u0000\u0000"+ + "\u0000\u0247\u0248\u0001\u0000\u0000\u0000\u0248\u0249\u0003H$\u0000\u0249"+ + "S\u0001\u0000\u0000\u0000\u024a\u024b\u0005-\u0000\u0000\u024b\u024c\u0005"+ + "\u0016\u0000\u0000\u024c\u024d\u0003p8\u0000\u024d\u024e\u0005\u0017\u0000"+ + "\u0000\u024e\u024f\u0003J%\u0000\u024fU\u0001\u0000\u0000\u0000\u0250"+ + "\u0251\u0005\u001a\u0000\u0000\u0251\u0254\u0005\u0016\u0000\u0000\u0252"+ + "\u0255\u0003X,\u0000\u0253\u0255\u0005\u0002\u0000\u0000\u0254\u0252\u0001"+ + "\u0000\u0000\u0000\u0254\u0253\u0001\u0000\u0000\u0000\u0255\u0258\u0001"+ + "\u0000\u0000\u0000\u0256\u0259\u0003L&\u0000\u0257\u0259\u0005\u0002\u0000"+ + "\u0000\u0258\u0256\u0001\u0000\u0000\u0000\u0258\u0257\u0001\u0000\u0000"+ + "\u0000\u0259\u025b\u0001\u0000\u0000\u0000\u025a\u025c\u0003p8\u0000\u025b"+ + "\u025a\u0001\u0000\u0000\u0000\u025b\u025c\u0001\u0000\u0000\u0000\u025c"+ + "\u025d\u0001\u0000\u0000\u0000\u025d\u025e\u0005\u0017\u0000\u0000\u025e"+ + "\u025f\u0003J%\u0000\u025fW\u0001\u0000\u0000\u0000\u0260\u0263\u0003"+ + "h4\u0000\u0261\u0263\u0003L&\u0000\u0262\u0260\u0001\u0000\u0000\u0000"+ + "\u0262\u0261\u0001\u0000\u0000\u0000\u0263Y\u0001\u0000\u0000\u0000\u0264"+ + "\u0266\u0005.\u0000\u0000\u0265\u0267\u0005|\u0000\u0000\u0266\u0265\u0001"+ + "\u0000\u0000\u0000\u0266\u0267\u0001\u0000\u0000\u0000\u0267\u0268\u0001"+ + "\u0000\u0000\u0000\u0268\u0269\u0003\u0084B\u0000\u0269[\u0001\u0000\u0000"+ + "\u0000\u026a\u026b\u0005/\u0000\u0000\u026b\u026c\u0003J%\u0000\u026c"+ + "\u026d\u0005-\u0000\u0000\u026d\u026e\u0005\u0016\u0000\u0000\u026e\u026f"+ + "\u0003p8\u0000\u026f\u0270\u0005\u0017\u0000\u0000\u0270\u0271\u0005\u0002"+ + "\u0000\u0000\u0271]\u0001\u0000\u0000\u0000\u0272\u0273\u0005l\u0000\u0000"+ + "\u0273\u0274\u0005\u0002\u0000\u0000\u0274_\u0001\u0000\u0000\u0000\u0275"+ + "\u0276\u0005i\u0000\u0000\u0276\u0277\u0005\u0002\u0000\u0000\u0277a\u0001"+ + "\u0000\u0000\u0000\u0278\u027a\u00050\u0000\u0000\u0279\u027b\u0003p8"+ + "\u0000\u027a\u0279\u0001\u0000\u0000\u0000\u027a\u027b\u0001\u0000\u0000"+ + "\u0000\u027b\u027c\u0001\u0000\u0000\u0000\u027c\u027d\u0005\u0002\u0000"+ + "\u0000\u027dc\u0001\u0000\u0000\u0000\u027e\u027f\u00051\u0000\u0000\u027f"+ + "\u0280\u0005\u0002\u0000\u0000\u0280e\u0001\u0000\u0000\u0000\u0281\u0282"+ + "\u00052\u0000\u0000\u0282\u0283\u0003|>\u0000\u0283\u0284\u0005\u0002"+ + "\u0000\u0000\u0284g\u0001\u0000\u0000\u0000\u0285\u0286\u00053\u0000\u0000"+ + "\u0286\u028d\u0003l6\u0000\u0287\u028d\u0003:\u001d\u0000\u0288\u0289"+ + "\u0005\u0016\u0000\u0000\u0289\u028a\u0003j5\u0000\u028a\u028b\u0005\u0017"+ + "\u0000\u0000\u028b\u028d\u0001\u0000\u0000\u0000\u028c\u0285\u0001\u0000"+ + "\u0000\u0000\u028c\u0287\u0001\u0000\u0000\u0000\u028c\u0288\u0001\u0000"+ + "\u0000\u0000\u028d\u0290\u0001\u0000\u0000\u0000\u028e\u028f\u0005\t\u0000"+ + "\u0000\u028f\u0291\u0003p8\u0000\u0290\u028e\u0001\u0000\u0000\u0000\u0290"+ + "\u0291\u0001\u0000\u0000\u0000\u0291\u0292\u0001\u0000\u0000\u0000\u0292"+ + "\u0293\u0005\u0002\u0000\u0000\u0293i\u0001\u0000\u0000\u0000\u0294\u0296"+ + "\u0003:\u001d\u0000\u0295\u0294\u0001\u0000\u0000\u0000\u0295\u0296\u0001"+ + "\u0000\u0000\u0000\u0296\u029d\u0001\u0000\u0000\u0000\u0297\u0299\u0005"+ + "\u000f\u0000\u0000\u0298\u029a\u0003:\u001d\u0000\u0299\u0298\u0001\u0000"+ + "\u0000\u0000\u0299\u029a\u0001\u0000\u0000\u0000\u029a\u029c\u0001\u0000"+ + "\u0000\u0000\u029b\u0297\u0001\u0000\u0000\u0000\u029c\u029f\u0001\u0000"+ + "\u0000\u0000\u029d\u029b\u0001\u0000\u0000\u0000\u029d\u029e\u0001\u0000"+ + "\u0000\u0000\u029ek\u0001\u0000\u0000\u0000\u029f\u029d\u0001\u0000\u0000"+ + "\u0000\u02a0\u02a7\u0005\u0016\u0000\u0000\u02a1\u02a3\u0003\u00aaU\u0000"+ + "\u02a2\u02a1\u0001\u0000\u0000\u0000\u02a2\u02a3\u0001\u0000\u0000\u0000"+ + "\u02a3\u02a4\u0001\u0000\u0000\u0000\u02a4\u02a6\u0005\u000f\u0000\u0000"+ + "\u02a5\u02a2\u0001\u0000\u0000\u0000\u02a6\u02a9\u0001\u0000\u0000\u0000"+ + "\u02a7\u02a5\u0001\u0000\u0000\u0000\u02a7\u02a8\u0001\u0000\u0000\u0000"+ + "\u02a8\u02ab\u0001\u0000\u0000\u0000\u02a9\u02a7\u0001\u0000\u0000\u0000"+ + "\u02aa\u02ac\u0003\u00aaU\u0000\u02ab\u02aa\u0001\u0000\u0000\u0000\u02ab"+ + "\u02ac\u0001\u0000\u0000\u0000\u02ac\u02ad\u0001\u0000\u0000\u0000\u02ad"+ + "\u02ae\u0005\u0017\u0000\u0000\u02aem\u0001\u0000\u0000\u0000\u02af\u02b1"+ + "\u00054\u0000\u0000\u02b0\u02b2\u0005q\u0000\u0000\u02b1\u02b0\u0001\u0000"+ + "\u0000\u0000\u02b1\u02b2\u0001\u0000\u0000\u0000\u02b2\u02bd\u0001\u0000"+ + "\u0000\u0000\u02b3\u02bd\u00055\u0000\u0000\u02b4\u02bd\u00056\u0000\u0000"+ + "\u02b5\u02bd\u00053\u0000\u0000\u02b6\u02bd\u0005]\u0000\u0000\u02b7\u02bd"+ + "\u0005^\u0000\u0000\u02b8\u02bd\u00057\u0000\u0000\u02b9\u02bd\u0005_"+ + "\u0000\u0000\u02ba\u02bd\u0005`\u0000\u0000\u02bb\u02bd\u0005a\u0000\u0000"+ + "\u02bc\u02af\u0001\u0000\u0000\u0000\u02bc\u02b3\u0001\u0000\u0000\u0000"+ + "\u02bc\u02b4\u0001\u0000\u0000\u0000\u02bc\u02b5\u0001\u0000\u0000\u0000"+ + "\u02bc\u02b6\u0001\u0000\u0000\u0000\u02bc\u02b7\u0001\u0000\u0000\u0000"+ + "\u02bc\u02b8\u0001\u0000\u0000\u0000\u02bc\u02b9\u0001\u0000\u0000\u0000"+ + "\u02bc\u02ba\u0001\u0000\u0000\u0000\u02bc\u02bb\u0001\u0000\u0000\u0000"+ + "\u02bdo\u0001\u0000\u0000\u0000\u02be\u02bf\u00068\uffff\uffff\u0000\u02bf"+ + "\u02c0\u0005:\u0000\u0000\u02c0\u02d6\u0003<\u001e\u0000\u02c1\u02c2\u0005"+ + "q\u0000\u0000\u02c2\u02c3\u0005\u0016\u0000\u0000\u02c3\u02c4\u0003p8"+ + "\u0000\u02c4\u02c5\u0005\u0017\u0000\u0000\u02c5\u02d6\u0001\u0000\u0000"+ + "\u0000\u02c6\u02c7\u0005\u0016\u0000\u0000\u02c7\u02c8\u0003p8\u0000\u02c8"+ + "\u02c9\u0005\u0017\u0000\u0000\u02c9\u02d6\u0001\u0000\u0000\u0000\u02ca"+ + "\u02cb\u0007\u0004\u0000\u0000\u02cb\u02d6\u0003p8\u0013\u02cc\u02cd\u0007"+ + "\u0005\u0000\u0000\u02cd\u02d6\u0003p8\u0012\u02ce\u02cf\u0007\u0006\u0000"+ + "\u0000\u02cf\u02d6\u0003p8\u0011\u02d0\u02d1\u0005@\u0000\u0000\u02d1"+ + "\u02d6\u0003p8\u0010\u02d2\u02d3\u0005\u0004\u0000\u0000\u02d3\u02d6\u0003"+ + "p8\u000f\u02d4\u02d6\u0003r9\u0000\u02d5\u02be\u0001\u0000\u0000\u0000"+ + "\u02d5\u02c1\u0001\u0000\u0000\u0000\u02d5\u02c6\u0001\u0000\u0000\u0000"+ + "\u02d5\u02ca\u0001\u0000\u0000\u0000\u02d5\u02cc\u0001\u0000\u0000\u0000"+ + "\u02d5\u02ce\u0001\u0000\u0000\u0000\u02d5\u02d0\u0001\u0000\u0000\u0000"+ + "\u02d5\u02d2\u0001\u0000\u0000\u0000\u02d5\u02d4\u0001\u0000\u0000\u0000"+ + "\u02d6\u0322\u0001\u0000\u0000\u0000\u02d7\u02d8\n\u000e\u0000\u0000\u02d8"+ + "\u02d9\u0005A\u0000\u0000\u02d9\u0321\u0003p8\u000f\u02da\u02db\n\r\u0000"+ + "\u0000\u02db\u02dc\u0007\u0007\u0000\u0000\u02dc\u0321\u0003p8\u000e\u02dd"+ + "\u02de\n\f\u0000\u0000\u02de\u02df\u0007\u0005\u0000\u0000\u02df\u0321"+ + "\u0003p8\r\u02e0\u02e1\n\u000b\u0000\u0000\u02e1\u02e2\u0007\b\u0000\u0000"+ + "\u02e2\u0321\u0003p8\f\u02e3\u02e4\n\n\u0000\u0000\u02e4\u02e5\u0005F"+ + "\u0000\u0000\u02e5\u0321\u0003p8\u000b\u02e6\u02e7\n\t\u0000\u0000\u02e7"+ + "\u02e8\u0005\u0003\u0000\u0000\u02e8\u0321\u0003p8\n\u02e9\u02ea\n\b\u0000"+ + "\u0000\u02ea\u02eb\u0005G\u0000\u0000\u02eb\u0321\u0003p8\t\u02ec\u02ed"+ + "\n\u0007\u0000\u0000\u02ed\u02ee\u0007\t\u0000\u0000\u02ee\u0321\u0003"+ + "p8\b\u02ef\u02f0\n\u0006\u0000\u0000\u02f0\u02f1\u0007\n\u0000\u0000\u02f1"+ + "\u0321\u0003p8\u0007\u02f2\u02f3\n\u0005\u0000\u0000\u02f3\u02f4\u0005"+ + "J\u0000\u0000\u02f4\u0321\u0003p8\u0006\u02f5\u02f6\n\u0004\u0000\u0000"+ + "\u02f6\u02f7\u0005K\u0000\u0000\u02f7\u0321\u0003p8\u0005\u02f8\u02f9"+ + "\n\u0003\u0000\u0000\u02f9\u02fa\u0005L\u0000\u0000\u02fa\u02fb\u0003"+ + "p8\u0000\u02fb\u02fc\u0005;\u0000\u0000\u02fc\u02fd\u0003p8\u0004\u02fd"+ + "\u0321\u0001\u0000\u0000\u0000\u02fe\u02ff\n\u0002\u0000\u0000\u02ff\u0300"+ + "\u0007\u000b\u0000\u0000\u0300\u0321\u0003p8\u0003\u0301\u0302\n\u001c"+ + "\u0000\u0000\u0302\u0321\u0007\u0004\u0000\u0000\u0303\u0304\n\u001a\u0000"+ + "\u0000\u0304\u0306\u0005!\u0000\u0000\u0305\u0307\u0003p8\u0000\u0306"+ + "\u0305\u0001\u0000\u0000\u0000\u0306\u0307\u0001\u0000\u0000\u0000\u0307"+ + "\u0308\u0001\u0000\u0000\u0000\u0308\u0321\u0005\"\u0000\u0000\u0309\u030a"+ + "\n\u0019\u0000\u0000\u030a\u030c\u0005!\u0000\u0000\u030b\u030d\u0003"+ + "p8\u0000\u030c\u030b\u0001\u0000\u0000\u0000\u030c\u030d\u0001\u0000\u0000"+ + "\u0000\u030d\u030e\u0001\u0000\u0000\u0000\u030e\u0310\u0005;\u0000\u0000"+ + "\u030f\u0311\u0003p8\u0000\u0310\u030f\u0001\u0000\u0000\u0000\u0310\u0311"+ + "\u0001\u0000\u0000\u0000\u0311\u0312\u0001\u0000\u0000\u0000\u0312\u0321"+ + "\u0005\"\u0000\u0000\u0313\u0314\n\u0018\u0000\u0000\u0314\u0315\u0005"+ + "#\u0000\u0000\u0315\u0321\u0003\u00aaU\u0000\u0316\u0317\n\u0017\u0000"+ + "\u0000\u0317\u0318\u0005\u000e\u0000\u0000\u0318\u0319\u0003v;\u0000\u0319"+ + "\u031a\u0005\u0010\u0000\u0000\u031a\u0321\u0001\u0000\u0000\u0000\u031b"+ + "\u031c\n\u0016\u0000\u0000\u031c\u031d\u0005\u0016\u0000\u0000\u031d\u031e"+ + "\u0003z=\u0000\u031e\u031f\u0005\u0017\u0000\u0000\u031f\u0321\u0001\u0000"+ + "\u0000\u0000\u0320\u02d7\u0001\u0000\u0000\u0000\u0320\u02da\u0001\u0000"+ + "\u0000\u0000\u0320\u02dd\u0001\u0000\u0000\u0000\u0320\u02e0\u0001\u0000"+ + "\u0000\u0000\u0320\u02e3\u0001\u0000\u0000\u0000\u0320\u02e6\u0001\u0000"+ + "\u0000\u0000\u0320\u02e9\u0001\u0000\u0000\u0000\u0320\u02ec\u0001\u0000"+ + "\u0000\u0000\u0320\u02ef\u0001\u0000\u0000\u0000\u0320\u02f2\u0001\u0000"+ + "\u0000\u0000\u0320\u02f5\u0001\u0000\u0000\u0000\u0320\u02f8\u0001\u0000"+ + "\u0000\u0000\u0320\u02fe\u0001\u0000\u0000\u0000\u0320\u0301\u0001\u0000"+ + "\u0000\u0000\u0320\u0303\u0001\u0000\u0000\u0000\u0320\u0309\u0001\u0000"+ + "\u0000\u0000\u0320\u0313\u0001\u0000\u0000\u0000\u0320\u0316\u0001\u0000"+ + "\u0000\u0000\u0320\u031b\u0001\u0000\u0000\u0000\u0321\u0324\u0001\u0000"+ + "\u0000\u0000\u0322\u0320\u0001\u0000\u0000\u0000\u0322\u0323\u0001\u0000"+ + "\u0000\u0000\u0323q\u0001\u0000\u0000\u0000\u0324\u0322\u0001\u0000\u0000"+ + "\u0000\u0325\u0336\u0005b\u0000\u0000\u0326\u0336\u0003\u00a8T\u0000\u0327"+ + "\u0336\u0003\u00acV\u0000\u0328\u0336\u0003\u00aeW\u0000\u0329\u032c\u0003"+ + "\u00aaU\u0000\u032a\u032b\u0005!\u0000\u0000\u032b\u032d\u0005\"\u0000"+ + "\u0000\u032c\u032a\u0001\u0000\u0000\u0000\u032c\u032d\u0001\u0000\u0000"+ + "\u0000\u032d\u0336\u0001\u0000\u0000\u0000\u032e\u0336\u0005v\u0000\u0000"+ + "\u032f\u0336\u0003~?\u0000\u0330\u0333\u0003\u0080@\u0000\u0331\u0332"+ + "\u0005!\u0000\u0000\u0332\u0334\u0005\"\u0000\u0000\u0333\u0331\u0001"+ + "\u0000\u0000\u0000\u0333\u0334\u0001\u0000\u0000\u0000\u0334\u0336\u0001"+ + "\u0000\u0000\u0000\u0335\u0325\u0001\u0000\u0000\u0000\u0335\u0326\u0001"+ + "\u0000\u0000\u0000\u0335\u0327\u0001\u0000\u0000\u0000\u0335\u0328\u0001"+ + "\u0000\u0000\u0000\u0335\u0329\u0001\u0000\u0000\u0000\u0335\u032e\u0001"+ + "\u0000\u0000\u0000\u0335\u032f\u0001\u0000\u0000\u0000\u0335\u0330\u0001"+ + "\u0000\u0000\u0000\u0336s\u0001\u0000\u0000\u0000\u0337\u033c\u0003p8"+ + "\u0000\u0338\u0339\u0005\u000f\u0000\u0000\u0339\u033b\u0003p8\u0000\u033a"+ + "\u0338\u0001\u0000\u0000\u0000\u033b\u033e\u0001\u0000\u0000\u0000\u033c"+ + "\u033a\u0001\u0000\u0000\u0000\u033c\u033d\u0001\u0000\u0000\u0000\u033d"+ + "u\u0001\u0000\u0000\u0000\u033e\u033c\u0001\u0000\u0000\u0000\u033f\u0344"+ + "\u0003x<\u0000\u0340\u0341\u0005\u000f\u0000\u0000\u0341\u0343\u0003x"+ + "<\u0000\u0342\u0340\u0001\u0000\u0000\u0000\u0343\u0346\u0001\u0000\u0000"+ + "\u0000\u0344\u0342\u0001\u0000\u0000\u0000\u0344\u0345\u0001\u0000\u0000"+ + "\u0000\u0345\u0348\u0001\u0000\u0000\u0000\u0346\u0344\u0001\u0000\u0000"+ + "\u0000\u0347\u0349\u0005\u000f\u0000\u0000\u0348\u0347\u0001\u0000\u0000"+ + "\u0000\u0348\u0349\u0001\u0000\u0000\u0000\u0349w\u0001\u0000\u0000\u0000"+ + "\u034a\u034b\u0003\u00aaU\u0000\u034b\u034c\u0005;\u0000\u0000\u034c\u034d"+ + "\u0003p8\u0000\u034dy\u0001\u0000\u0000\u0000\u034e\u0350\u0005\u000e"+ + "\u0000\u0000\u034f\u0351\u0003v;\u0000\u0350\u034f\u0001\u0000\u0000\u0000"+ + "\u0350\u0351\u0001\u0000\u0000\u0000\u0351\u0352\u0001\u0000\u0000\u0000"+ + "\u0352\u0357\u0005\u0010\u0000\u0000\u0353\u0355\u0003t:\u0000\u0354\u0353"+ + "\u0001\u0000\u0000\u0000\u0354\u0355\u0001\u0000\u0000\u0000\u0355\u0357"+ + "\u0001\u0000\u0000\u0000\u0356\u034e\u0001\u0000\u0000\u0000\u0356\u0354"+ + "\u0001\u0000\u0000\u0000\u0357{\u0001\u0000\u0000\u0000\u0358\u0359\u0003"+ + "p8\u0000\u0359\u035a\u0005\u0016\u0000\u0000\u035a\u035b\u0003z=\u0000"+ + "\u035b\u035c\u0005\u0017\u0000\u0000\u035c}\u0001\u0000\u0000\u0000\u035d"+ + "\u035f\u0005\u0016\u0000\u0000\u035e\u0360\u0003p8\u0000\u035f\u035e\u0001"+ + "\u0000\u0000\u0000\u035f\u0360\u0001\u0000\u0000\u0000\u0360\u0367\u0001"+ + "\u0000\u0000\u0000\u0361\u0363\u0005\u000f\u0000\u0000\u0362\u0364\u0003"+ + "p8\u0000\u0363\u0362\u0001\u0000\u0000\u0000\u0363\u0364\u0001\u0000\u0000"+ + "\u0000\u0364\u0366\u0001\u0000\u0000\u0000\u0365\u0361\u0001\u0000\u0000"+ + "\u0000\u0366\u0369\u0001\u0000\u0000\u0000\u0367\u0365\u0001\u0000\u0000"+ + "\u0000\u0367\u0368\u0001\u0000\u0000\u0000\u0368\u036a\u0001\u0000\u0000"+ + "\u0000\u0369\u0367\u0001\u0000\u0000\u0000\u036a\u0378\u0005\u0017\u0000"+ + "\u0000\u036b\u0374\u0005!\u0000\u0000\u036c\u0371\u0003p8\u0000\u036d"+ + "\u036e\u0005\u000f\u0000\u0000\u036e\u0370\u0003p8\u0000\u036f\u036d\u0001"+ + "\u0000\u0000\u0000\u0370\u0373\u0001\u0000\u0000\u0000\u0371\u036f\u0001"+ + "\u0000\u0000\u0000\u0371\u0372\u0001\u0000\u0000\u0000\u0372\u0375\u0001"+ + "\u0000\u0000\u0000\u0373\u0371\u0001\u0000\u0000\u0000\u0374\u036c\u0001"+ + "\u0000\u0000\u0000\u0374\u0375\u0001\u0000\u0000\u0000\u0375\u0376\u0001"+ + "\u0000\u0000\u0000\u0376\u0378\u0005\"\u0000\u0000\u0377\u035d\u0001\u0000"+ + "\u0000\u0000\u0377\u036b\u0001\u0000\u0000\u0000\u0378\u007f\u0001\u0000"+ + "\u0000\u0000\u0379\u037c\u0003n7\u0000\u037a\u037c\u0003>\u001f\u0000"+ + "\u037b\u0379\u0001\u0000\u0000\u0000\u037b\u037a\u0001\u0000\u0000\u0000"+ + "\u037c\u0081\u0001\u0000\u0000\u0000\u037d\u0390\u0003\u00aaU\u0000\u037e"+ + "\u0390\u0003\u0084B\u0000\u037f\u0390\u0003\u0086C\u0000\u0380\u0390\u0003"+ + "\u008aE\u0000\u0381\u0390\u0003\u008cF\u0000\u0382\u0390\u0003\u0090H"+ + "\u0000\u0383\u0390\u0003\u0092I\u0000\u0384\u0390\u0003\u0094J\u0000\u0385"+ + "\u0390\u0003\u0098L\u0000\u0386\u0390\u0003\u009cN\u0000\u0387\u0390\u0003"+ + "\u009eO\u0000\u0388\u0390\u0005i\u0000\u0000\u0389\u0390\u0005l\u0000"+ + "\u0000\u038a\u0390\u0005m\u0000\u0000\u038b\u0390\u0003\u00a6S\u0000\u038c"+ + "\u0390\u0003\u00a8T\u0000\u038d\u0390\u0003\u00aeW\u0000\u038e\u0390\u0003"+ + "\u00acV\u0000\u038f\u037d\u0001\u0000\u0000\u0000\u038f\u037e\u0001\u0000"+ + "\u0000\u0000\u038f\u037f\u0001\u0000\u0000\u0000\u038f\u0380\u0001\u0000"+ + "\u0000\u0000\u038f\u0381\u0001\u0000\u0000\u0000\u038f\u0382\u0001\u0000"+ + "\u0000\u0000\u038f\u0383\u0001\u0000\u0000\u0000\u038f\u0384\u0001\u0000"+ + "\u0000\u0000\u038f\u0385\u0001\u0000\u0000\u0000\u038f\u0386\u0001\u0000"+ + "\u0000\u0000\u038f\u0387\u0001\u0000\u0000\u0000\u038f\u0388\u0001\u0000"+ + "\u0000\u0000\u038f\u0389\u0001\u0000\u0000\u0000\u038f\u038a\u0001\u0000"+ + "\u0000\u0000\u038f\u038b\u0001\u0000\u0000\u0000\u038f\u038c\u0001\u0000"+ + "\u0000\u0000\u038f\u038d\u0001\u0000\u0000\u0000\u038f\u038e\u0001\u0000"+ + "\u0000\u0000\u0390\u0083\u0001\u0000\u0000\u0000\u0391\u0395\u0005\u000e"+ + "\u0000\u0000\u0392\u0394\u0003\u0082A\u0000\u0393\u0392\u0001\u0000\u0000"+ + "\u0000\u0394\u0397\u0001\u0000\u0000\u0000\u0395\u0393\u0001\u0000\u0000"+ + "\u0000\u0395\u0396\u0001\u0000\u0000\u0000\u0396\u0398\u0001\u0000\u0000"+ + "\u0000\u0397\u0395\u0001\u0000\u0000\u0000\u0398\u0399\u0005\u0010\u0000"+ + "\u0000\u0399\u0085\u0001\u0000\u0000\u0000\u039a\u039d\u0003\u0088D\u0000"+ + "\u039b\u039d\u0003\u00a0P\u0000\u039c\u039a\u0001\u0000\u0000\u0000\u039c"+ + "\u039b\u0001\u0000\u0000\u0000\u039d\u0087\u0001\u0000\u0000\u0000\u039e"+ + "\u03a3\u00050\u0000\u0000\u039f\u03a3\u00054\u0000\u0000\u03a0\u03a3\u0005"+ + "7\u0000\u0000\u03a1\u03a3\u0003\u00aaU\u0000\u03a2\u039e\u0001\u0000\u0000"+ + "\u0000\u03a2\u039f\u0001\u0000\u0000\u0000\u03a2\u03a0\u0001\u0000\u0000"+ + "\u0000\u03a2\u03a1\u0001\u0000\u0000\u0000\u03a3\u03b0\u0001\u0000\u0000"+ + "\u0000\u03a4\u03a6\u0005\u0016\u0000\u0000\u03a5\u03a7\u0003\u0086C\u0000"+ + "\u03a6\u03a5\u0001\u0000\u0000\u0000\u03a6\u03a7\u0001\u0000\u0000\u0000"+ + "\u03a7\u03ac\u0001\u0000\u0000\u0000\u03a8\u03a9\u0005\u000f\u0000\u0000"+ + "\u03a9\u03ab\u0003\u0086C\u0000\u03aa\u03a8\u0001\u0000\u0000\u0000\u03ab"+ + "\u03ae\u0001\u0000\u0000\u0000\u03ac\u03aa\u0001\u0000\u0000\u0000\u03ac"+ + "\u03ad\u0001\u0000\u0000\u0000\u03ad\u03af\u0001\u0000\u0000\u0000\u03ae"+ + "\u03ac\u0001\u0000\u0000\u0000\u03af\u03b1\u0005\u0017\u0000\u0000\u03b0"+ + "\u03a4\u0001\u0000\u0000\u0000\u03b0\u03b1\u0001\u0000\u0000\u0000\u03b1"+ + "\u0089\u0001\u0000\u0000\u0000\u03b2\u03b3\u0005W\u0000\u0000\u03b3\u03b6"+ + "\u0003\u008eG\u0000\u03b4\u03b5\u0005X\u0000\u0000\u03b5\u03b7\u0003\u0086"+ + "C\u0000\u03b6\u03b4\u0001\u0000\u0000\u0000\u03b6\u03b7\u0001\u0000\u0000"+ + "\u0000\u03b7\u008b\u0001\u0000\u0000\u0000\u03b8\u03b9\u0003\u008eG\u0000"+ + "\u03b9\u03ba\u0005X\u0000\u0000\u03ba\u03bb\u0003\u0086C\u0000\u03bb\u008d"+ + "\u0001\u0000\u0000\u0000\u03bc\u03c1\u0003\u00aaU\u0000\u03bd\u03be\u0005"+ + "\u000f\u0000\u0000\u03be\u03c0\u0003\u00aaU\u0000\u03bf\u03bd\u0001\u0000"+ + "\u0000\u0000\u03c0\u03c3\u0001\u0000\u0000\u0000\u03c1\u03bf\u0001\u0000"+ + "\u0000\u0000\u03c1\u03c2\u0001\u0000\u0000\u0000\u03c2\u008f\u0001\u0000"+ + "\u0000\u0000\u03c3\u03c1\u0001\u0000\u0000\u0000\u03c4\u03c5\u0005Y\u0000"+ + "\u0000\u03c5\u03c6\u0003\u00aaU\u0000\u03c6\u0091\u0001\u0000\u0000\u0000"+ + "\u03c7\u03c8\u0003\u00aaU\u0000\u03c8\u03c9\u0005;\u0000\u0000\u03c9\u0093"+ + "\u0001\u0000\u0000\u0000\u03ca\u03cb\u0005Z\u0000\u0000\u03cb\u03cf\u0003"+ + "\u0086C\u0000\u03cc\u03ce\u0003\u0096K\u0000\u03cd\u03cc\u0001\u0000\u0000"+ + "\u0000\u03ce\u03d1\u0001\u0000\u0000\u0000\u03cf\u03cd\u0001\u0000\u0000"+ + "\u0000\u03cf\u03d0\u0001\u0000\u0000\u0000\u03d0\u0095\u0001\u0000\u0000"+ + "\u0000\u03d1\u03cf\u0001\u0000\u0000\u0000\u03d2\u03d3\u0005[\u0000\u0000"+ + "\u03d3\u03d5\u0003\u00a0P\u0000\u03d4\u03d6\u0003\u00a4R\u0000\u03d5\u03d4"+ + "\u0001\u0000\u0000\u0000\u03d5\u03d6\u0001\u0000\u0000\u0000\u03d6\u03d7"+ + "\u0001\u0000\u0000\u0000\u03d7\u03d8\u0003\u0084B\u0000\u03d8\u03dc\u0001"+ + "\u0000\u0000\u0000\u03d9\u03da\u0005\\\u0000\u0000\u03da\u03dc\u0003\u0084"+ + "B\u0000\u03db\u03d2\u0001\u0000\u0000\u0000\u03db\u03d9\u0001\u0000\u0000"+ + "\u0000\u03dc\u0097\u0001\u0000\u0000\u0000\u03dd\u03de\u0005\u001d\u0000"+ + "\u0000\u03de\u03df\u0003\u00aaU\u0000\u03df\u03e1\u0005\u0016\u0000\u0000"+ + "\u03e0\u03e2\u0003\u00a2Q\u0000\u03e1\u03e0\u0001\u0000\u0000\u0000\u03e1"+ + "\u03e2\u0001\u0000\u0000\u0000\u03e2\u03e3\u0001\u0000\u0000\u0000\u03e3"+ + "\u03e5\u0005\u0017\u0000\u0000\u03e4\u03e6\u0003\u009aM\u0000\u03e5\u03e4"+ + "\u0001\u0000\u0000\u0000\u03e5\u03e6\u0001\u0000\u0000\u0000\u03e6\u03e7"+ + "\u0001\u0000\u0000\u0000\u03e7\u03e8\u0003\u0084B\u0000\u03e8\u0099\u0001"+ + "\u0000\u0000\u0000\u03e9\u03ea\u0005=\u0000\u0000\u03ea\u03eb\u0005\u0006"+ + "\u0000\u0000\u03eb\u03ec\u0003\u00a2Q\u0000\u03ec\u009b\u0001\u0000\u0000"+ + "\u0000\u03ed\u03ee\u0005\u001a\u0000\u0000\u03ee\u03ef\u0003\u0084B\u0000"+ + "\u03ef\u03f0\u0003\u0086C\u0000\u03f0\u03f1\u0003\u0084B\u0000\u03f1\u03f2"+ + "\u0003\u0084B\u0000\u03f2\u009d\u0001\u0000\u0000\u0000\u03f3\u03f4\u0005"+ + ")\u0000\u0000\u03f4\u03f5\u0003\u0086C\u0000\u03f5\u03f6\u0003\u0084B"+ + "\u0000\u03f6\u009f\u0001\u0000\u0000\u0000\u03f7\u03fd\u0003\u00aeW\u0000"+ + "\u03f8\u03fd\u0005c\u0000\u0000\u03f9\u03fd\u0005d\u0000\u0000\u03fa\u03fd"+ + "\u0003\u00acV\u0000\u03fb\u03fd\u0005b\u0000\u0000\u03fc\u03f7\u0001\u0000"+ + "\u0000\u0000\u03fc\u03f8\u0001\u0000\u0000\u0000\u03fc\u03f9\u0001\u0000"+ + "\u0000\u0000\u03fc\u03fa\u0001\u0000\u0000\u0000\u03fc\u03fb\u0001\u0000"+ + "\u0000\u0000\u03fd\u03ff\u0001\u0000\u0000\u0000\u03fe\u0400\u0003\u00a4"+ + "R\u0000\u03ff\u03fe\u0001\u0000\u0000\u0000\u03ff\u0400\u0001\u0000\u0000"+ + "\u0000\u0400\u00a1\u0001\u0000\u0000\u0000\u0401\u0403\u0003\u00aaU\u0000"+ + "\u0402\u0404\u0003\u00a4R\u0000\u0403\u0402\u0001\u0000\u0000\u0000\u0403"+ + "\u0404\u0001\u0000\u0000\u0000\u0404\u0407\u0001\u0000\u0000\u0000\u0405"+ + "\u0406\u0005\u000f\u0000\u0000\u0406\u0408\u0003\u00a2Q\u0000\u0407\u0405"+ + "\u0001\u0000\u0000\u0000\u0407\u0408\u0001\u0000\u0000\u0000\u0408\u00a3"+ + "\u0001\u0000\u0000\u0000\u0409\u040a\u0005;\u0000\u0000\u040a\u040b\u0003"+ + "\u00aaU\u0000\u040b\u00a5\u0001\u0000\u0000\u0000\u040c\u040d\u0005.\u0000"+ + "\u0000\u040d\u040e\u0003\u00aaU\u0000\u040e\u040f\u0003\u0084B\u0000\u040f"+ + "\u00a7\u0001\u0000\u0000\u0000\u0410\u0412\u0007\f\u0000\u0000\u0411\u0413"+ + "\u0005e\u0000\u0000\u0412\u0411\u0001\u0000\u0000\u0000\u0412\u0413\u0001"+ + "\u0000\u0000\u0000\u0413\u00a9\u0001\u0000\u0000\u0000\u0414\u0415\u0007"+ + "\r\u0000\u0000\u0415\u00ab\u0001\u0000\u0000\u0000\u0416\u0418\u0005f"+ + "\u0000\u0000\u0417\u0416\u0001\u0000\u0000\u0000\u0418\u0419\u0001\u0000"+ + "\u0000\u0000\u0419\u0417\u0001\u0000\u0000\u0000\u0419\u041a\u0001\u0000"+ + "\u0000\u0000\u041a\u00ad\u0001\u0000\u0000\u0000\u041b\u041d\u0005|\u0000"+ + "\u0000\u041c\u041b\u0001\u0000\u0000\u0000\u041d\u041e\u0001\u0000\u0000"+ + "\u0000\u041e\u041c\u0001\u0000\u0000\u0000\u041e\u041f\u0001\u0000\u0000"+ + "\u0000\u041f\u00af\u0001\u0000\u0000\u0000z\u00b5\u00b7\u00c5\u00c9\u00cc"+ + "\u00d6\u00dc\u00e0\u00ec\u00f4\u00f9\u00fc\u0106\u0109\u010f\u0117\u011a"+ + "\u0123\u012c\u012e\u0134\u013f\u0144\u014b\u0159\u015c\u0163\u0167\u0169"+ + "\u016e\u0174\u0178\u017e\u0183\u0190\u0192\u0198\u019b\u01a1\u01a9\u01af"+ + "\u01bc\u01bf\u01c5\u01c8\u01d0\u01d3\u01d9\u01dc\u01e0\u01e9\u01ee\u01f3"+ + "\u01fb\u0202\u020c\u0216\u0228\u0234\u0239\u023f\u0243\u0246\u0254\u0258"+ + "\u025b\u0262\u0266\u027a\u028c\u0290\u0295\u0299\u029d\u02a2\u02a7\u02ab"+ + "\u02b1\u02bc\u02d5\u0306\u030c\u0310\u0320\u0322\u032c\u0333\u0335\u033c"+ + "\u0344\u0348\u0350\u0354\u0356\u035f\u0363\u0367\u0371\u0374\u0377\u037b"+ + "\u038f\u0395\u039c\u03a2\u03a6\u03ac\u03b0\u03b6\u03c1\u03cf\u03d5\u03db"+ + "\u03e1\u03e5\u03fc\u03ff\u0403\u0407\u0412\u0419\u041e"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/vanguard/aleo/parser/.antlr/aleo.interp b/vanguard/aleo/parser/.antlr/aleo.interp new file mode 100644 index 0000000..ebfdefe --- /dev/null +++ b/vanguard/aleo/parser/.antlr/aleo.interp @@ -0,0 +1,443 @@ +token literal names: +null +'program' +';' +'import' +'mapping' +':' +'key' +'as' +'value' +'struct' +'record' +'owner' +'address.public' +'address.private' +'closure' +'input' +'output' +'function' +'finalize' +'contains' +'[' +']' +'into' +'get' +'get.or_use' +'set' +'remove' +'rand.chacha' +'position' +'to' +'await' +'ternary' +'sign.verify' +'sign_verify' +'call' +'async' +'-' +'_' +'u32' +'aleo1' +'sign1' +'0' +'2' +'3' +'4' +'5' +'6' +'7' +'8' +'9' +'a' +'c' +'d' +'e' +'f' +'g' +'h' +'j' +'k' +'l' +'m' +'n' +'p' +'q' +'r' +'s' +'t' +'u' +'v' +'w' +'x' +'y' +'z' +'true' +'false' +'u8' +'u16' +'u64' +'u128' +'i8' +'i16' +'i32' +'i64' +'i128' +'field' +'group' +'scalar' +'address' +'boolean' +'signature' +'.constant' +'.public' +'.private' +'.record' +'.future' +'.' +'group::GEN' +'self.signer' +'self.caller' +'block.height' +'/' +'group.x' +'group.y' +'abs' +'abs.w' +'double' +'inv' +'neg' +'not' +'square' +'sqrt' +'add' +'add.w' +'sub' +'sub.w' +'mul' +'mul.w' +'div' +'div.w' +'rem' +'rem.w' +'pow' +'pow.w' +'shl' +'shl.w' +'shr' +'shr.w' +'mod' +'and' +'or' +'xor' +'nand' +'nor' +'gt' +'gte' +'lt' +'lte' +'is.eq' +'is.neq' +'assert.eq' +'assert.neq' +'commit.bhp' +'256' +'512' +'768' +'1024' +'commit.ped' +'64' +'128' +'hash.bhp' +'hash.ped' +'hash.psd' +'hash.keccak' +'384' +'hash.sha3_' +'hash_many.psd' +'cast' +'cast.lossy' +'branch.eq' +'branch.neq' +null +null +null +null +null +null +null +null +null + +token symbolic names: +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +Letter +UL +LL +DIGIT +COMMENT +BLOCK_COMMENT +LINE_COMMENT +WS +CWS + +rule names: +start +program +ximport +mapping +mapping_key +mapping_value +struct +record +closure +closure_input +closure_output +function +function_input +function_output +finalize +finalize_input +command +contains +get +get_or_use +set +remove +random +position +branch +xawait +instruction +unary +binary +ternary +is +assert +commit +hash1 +hash2 +hash +signverify +cast +call +xasync +literal +signed_literal +unsigned_literal +integer_literal +field_literal +group_literal +scalar_literal +arithmetic_literal +u32_literal +address_literal +signature_literal +address_or_signature_char +boolean_literal +unsigned_type +signed_type +integer_type +field_type +group_type +scalar_type +arithmetic_type +address_type +boolean_type +signature_type +literal_type +array_type +plaintext_type +value_type +mapping_type +finalize_type +entry_type +register_type +program_id +program_name +program_domain +register +register_access +register_accessor +access_by_field +access_by_index +operand +tuple +entry +locator +cast_destination +label +identifier +lowercase_identifier +unary_op +binary_op +is_op +assert_op +commit_op +hash1_op +hash2_op +cast_op +branch_op + + +atn: +[4, 1, 168, 2009, 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, 1, 0, 1, 0, 1, 1, 5, 1, 196, 8, 1, 10, 1, 12, 1, 199, 9, 1, 1, 1, 5, 1, 202, 8, 1, 10, 1, 12, 1, 205, 9, 1, 1, 1, 1, 1, 5, 1, 209, 8, 1, 10, 1, 12, 1, 212, 9, 1, 1, 1, 1, 1, 5, 1, 216, 8, 1, 10, 1, 12, 1, 219, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 227, 8, 1, 11, 1, 12, 1, 228, 1, 1, 5, 1, 232, 8, 1, 10, 1, 12, 1, 235, 9, 1, 1, 2, 5, 2, 238, 8, 2, 10, 2, 12, 2, 241, 9, 2, 1, 2, 1, 2, 5, 2, 245, 8, 2, 10, 2, 12, 2, 248, 9, 2, 1, 2, 1, 2, 5, 2, 252, 8, 2, 10, 2, 12, 2, 255, 9, 2, 1, 2, 1, 2, 1, 3, 5, 3, 260, 8, 3, 10, 3, 12, 3, 263, 9, 3, 1, 3, 1, 3, 5, 3, 267, 8, 3, 10, 3, 12, 3, 270, 9, 3, 1, 3, 1, 3, 5, 3, 274, 8, 3, 10, 3, 12, 3, 277, 9, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 5, 4, 284, 8, 4, 10, 4, 12, 4, 287, 9, 4, 1, 4, 1, 4, 5, 4, 291, 8, 4, 10, 4, 12, 4, 294, 9, 4, 1, 4, 1, 4, 5, 4, 298, 8, 4, 10, 4, 12, 4, 301, 9, 4, 1, 4, 1, 4, 5, 4, 305, 8, 4, 10, 4, 12, 4, 308, 9, 4, 1, 4, 1, 4, 1, 5, 5, 5, 313, 8, 5, 10, 5, 12, 5, 316, 9, 5, 1, 5, 1, 5, 5, 5, 320, 8, 5, 10, 5, 12, 5, 323, 9, 5, 1, 5, 1, 5, 5, 5, 327, 8, 5, 10, 5, 12, 5, 330, 9, 5, 1, 5, 1, 5, 5, 5, 334, 8, 5, 10, 5, 12, 5, 337, 9, 5, 1, 5, 1, 5, 1, 6, 5, 6, 342, 8, 6, 10, 6, 12, 6, 345, 9, 6, 1, 6, 1, 6, 5, 6, 349, 8, 6, 10, 6, 12, 6, 352, 9, 6, 1, 6, 1, 6, 5, 6, 356, 8, 6, 10, 6, 12, 6, 359, 9, 6, 1, 6, 1, 6, 4, 6, 363, 8, 6, 11, 6, 12, 6, 364, 1, 7, 5, 7, 368, 8, 7, 10, 7, 12, 7, 371, 9, 7, 1, 7, 1, 7, 5, 7, 375, 8, 7, 10, 7, 12, 7, 378, 9, 7, 1, 7, 1, 7, 5, 7, 382, 8, 7, 10, 7, 12, 7, 385, 9, 7, 1, 7, 1, 7, 5, 7, 389, 8, 7, 10, 7, 12, 7, 392, 9, 7, 1, 7, 1, 7, 5, 7, 396, 8, 7, 10, 7, 12, 7, 399, 9, 7, 1, 7, 1, 7, 5, 7, 403, 8, 7, 10, 7, 12, 7, 406, 9, 7, 1, 7, 1, 7, 5, 7, 410, 8, 7, 10, 7, 12, 7, 413, 9, 7, 1, 7, 1, 7, 5, 7, 417, 8, 7, 10, 7, 12, 7, 420, 9, 7, 1, 8, 5, 8, 423, 8, 8, 10, 8, 12, 8, 426, 9, 8, 1, 8, 1, 8, 5, 8, 430, 8, 8, 10, 8, 12, 8, 433, 9, 8, 1, 8, 1, 8, 5, 8, 437, 8, 8, 10, 8, 12, 8, 440, 9, 8, 1, 8, 1, 8, 5, 8, 444, 8, 8, 10, 8, 12, 8, 447, 9, 8, 1, 8, 4, 8, 450, 8, 8, 11, 8, 12, 8, 451, 1, 8, 5, 8, 455, 8, 8, 10, 8, 12, 8, 458, 9, 8, 1, 9, 5, 9, 461, 8, 9, 10, 9, 12, 9, 464, 9, 9, 1, 9, 1, 9, 5, 9, 468, 8, 9, 10, 9, 12, 9, 471, 9, 9, 1, 9, 1, 9, 5, 9, 475, 8, 9, 10, 9, 12, 9, 478, 9, 9, 1, 9, 1, 9, 5, 9, 482, 8, 9, 10, 9, 12, 9, 485, 9, 9, 1, 9, 1, 9, 5, 9, 489, 8, 9, 10, 9, 12, 9, 492, 9, 9, 1, 9, 1, 9, 1, 10, 5, 10, 497, 8, 10, 10, 10, 12, 10, 500, 9, 10, 1, 10, 1, 10, 5, 10, 504, 8, 10, 10, 10, 12, 10, 507, 9, 10, 1, 10, 1, 10, 5, 10, 511, 8, 10, 10, 10, 12, 10, 514, 9, 10, 1, 10, 1, 10, 5, 10, 518, 8, 10, 10, 10, 12, 10, 521, 9, 10, 1, 10, 1, 10, 5, 10, 525, 8, 10, 10, 10, 12, 10, 528, 9, 10, 1, 10, 1, 10, 1, 11, 5, 11, 533, 8, 11, 10, 11, 12, 11, 536, 9, 11, 1, 11, 1, 11, 5, 11, 540, 8, 11, 10, 11, 12, 11, 543, 9, 11, 1, 11, 1, 11, 5, 11, 547, 8, 11, 10, 11, 12, 11, 550, 9, 11, 1, 11, 1, 11, 5, 11, 554, 8, 11, 10, 11, 12, 11, 557, 9, 11, 1, 11, 5, 11, 560, 8, 11, 10, 11, 12, 11, 563, 9, 11, 1, 11, 5, 11, 566, 8, 11, 10, 11, 12, 11, 569, 9, 11, 1, 11, 3, 11, 572, 8, 11, 1, 12, 5, 12, 575, 8, 12, 10, 12, 12, 12, 578, 9, 12, 1, 12, 1, 12, 5, 12, 582, 8, 12, 10, 12, 12, 12, 585, 9, 12, 1, 12, 1, 12, 5, 12, 589, 8, 12, 10, 12, 12, 12, 592, 9, 12, 1, 12, 1, 12, 5, 12, 596, 8, 12, 10, 12, 12, 12, 599, 9, 12, 1, 12, 1, 12, 5, 12, 603, 8, 12, 10, 12, 12, 12, 606, 9, 12, 1, 12, 1, 12, 1, 13, 5, 13, 611, 8, 13, 10, 13, 12, 13, 614, 9, 13, 1, 13, 1, 13, 5, 13, 618, 8, 13, 10, 13, 12, 13, 621, 9, 13, 1, 13, 1, 13, 5, 13, 625, 8, 13, 10, 13, 12, 13, 628, 9, 13, 1, 13, 1, 13, 5, 13, 632, 8, 13, 10, 13, 12, 13, 635, 9, 13, 1, 13, 1, 13, 5, 13, 639, 8, 13, 10, 13, 12, 13, 642, 9, 13, 1, 13, 1, 13, 1, 14, 5, 14, 647, 8, 14, 10, 14, 12, 14, 650, 9, 14, 1, 14, 1, 14, 5, 14, 654, 8, 14, 10, 14, 12, 14, 657, 9, 14, 1, 14, 1, 14, 5, 14, 661, 8, 14, 10, 14, 12, 14, 664, 9, 14, 1, 14, 1, 14, 5, 14, 668, 8, 14, 10, 14, 12, 14, 671, 9, 14, 1, 14, 4, 14, 674, 8, 14, 11, 14, 12, 14, 675, 1, 15, 5, 15, 679, 8, 15, 10, 15, 12, 15, 682, 9, 15, 1, 15, 1, 15, 5, 15, 686, 8, 15, 10, 15, 12, 15, 689, 9, 15, 1, 15, 1, 15, 5, 15, 693, 8, 15, 10, 15, 12, 15, 696, 9, 15, 1, 15, 1, 15, 5, 15, 700, 8, 15, 10, 15, 12, 15, 703, 9, 15, 1, 15, 1, 15, 5, 15, 707, 8, 15, 10, 15, 12, 15, 710, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 724, 8, 16, 1, 17, 5, 17, 727, 8, 17, 10, 17, 12, 17, 730, 9, 17, 1, 17, 1, 17, 5, 17, 734, 8, 17, 10, 17, 12, 17, 737, 9, 17, 1, 17, 1, 17, 1, 17, 5, 17, 742, 8, 17, 10, 17, 12, 17, 745, 9, 17, 1, 17, 1, 17, 5, 17, 749, 8, 17, 10, 17, 12, 17, 752, 9, 17, 1, 17, 1, 17, 5, 17, 756, 8, 17, 10, 17, 12, 17, 759, 9, 17, 1, 17, 1, 17, 5, 17, 763, 8, 17, 10, 17, 12, 17, 766, 9, 17, 1, 17, 1, 17, 5, 17, 770, 8, 17, 10, 17, 12, 17, 773, 9, 17, 1, 17, 1, 17, 1, 18, 5, 18, 778, 8, 18, 10, 18, 12, 18, 781, 9, 18, 1, 18, 1, 18, 5, 18, 785, 8, 18, 10, 18, 12, 18, 788, 9, 18, 1, 18, 1, 18, 1, 18, 5, 18, 793, 8, 18, 10, 18, 12, 18, 796, 9, 18, 1, 18, 1, 18, 5, 18, 800, 8, 18, 10, 18, 12, 18, 803, 9, 18, 1, 18, 1, 18, 5, 18, 807, 8, 18, 10, 18, 12, 18, 810, 9, 18, 1, 18, 1, 18, 5, 18, 814, 8, 18, 10, 18, 12, 18, 817, 9, 18, 1, 18, 1, 18, 5, 18, 821, 8, 18, 10, 18, 12, 18, 824, 9, 18, 1, 18, 1, 18, 1, 19, 5, 19, 829, 8, 19, 10, 19, 12, 19, 832, 9, 19, 1, 19, 1, 19, 5, 19, 836, 8, 19, 10, 19, 12, 19, 839, 9, 19, 1, 19, 1, 19, 1, 19, 5, 19, 844, 8, 19, 10, 19, 12, 19, 847, 9, 19, 1, 19, 1, 19, 5, 19, 851, 8, 19, 10, 19, 12, 19, 854, 9, 19, 1, 19, 1, 19, 5, 19, 858, 8, 19, 10, 19, 12, 19, 861, 9, 19, 1, 19, 1, 19, 5, 19, 865, 8, 19, 10, 19, 12, 19, 868, 9, 19, 1, 19, 1, 19, 5, 19, 872, 8, 19, 10, 19, 12, 19, 875, 9, 19, 1, 19, 1, 19, 5, 19, 879, 8, 19, 10, 19, 12, 19, 882, 9, 19, 1, 19, 1, 19, 1, 20, 5, 20, 887, 8, 20, 10, 20, 12, 20, 890, 9, 20, 1, 20, 1, 20, 5, 20, 894, 8, 20, 10, 20, 12, 20, 897, 9, 20, 1, 20, 1, 20, 5, 20, 901, 8, 20, 10, 20, 12, 20, 904, 9, 20, 1, 20, 1, 20, 5, 20, 908, 8, 20, 10, 20, 12, 20, 911, 9, 20, 1, 20, 1, 20, 1, 20, 5, 20, 916, 8, 20, 10, 20, 12, 20, 919, 9, 20, 1, 20, 1, 20, 5, 20, 923, 8, 20, 10, 20, 12, 20, 926, 9, 20, 1, 20, 1, 20, 5, 20, 930, 8, 20, 10, 20, 12, 20, 933, 9, 20, 1, 20, 1, 20, 1, 21, 5, 21, 938, 8, 21, 10, 21, 12, 21, 941, 9, 21, 1, 21, 1, 21, 5, 21, 945, 8, 21, 10, 21, 12, 21, 948, 9, 21, 1, 21, 1, 21, 1, 21, 5, 21, 953, 8, 21, 10, 21, 12, 21, 956, 9, 21, 1, 21, 1, 21, 5, 21, 960, 8, 21, 10, 21, 12, 21, 963, 9, 21, 1, 21, 1, 21, 5, 21, 967, 8, 21, 10, 21, 12, 21, 970, 9, 21, 1, 21, 1, 21, 1, 22, 5, 22, 975, 8, 22, 10, 22, 12, 22, 978, 9, 22, 1, 22, 1, 22, 5, 22, 982, 8, 22, 10, 22, 12, 22, 985, 9, 22, 1, 22, 5, 22, 988, 8, 22, 10, 22, 12, 22, 991, 9, 22, 1, 22, 5, 22, 994, 8, 22, 10, 22, 12, 22, 997, 9, 22, 1, 22, 1, 22, 5, 22, 1001, 8, 22, 10, 22, 12, 22, 1004, 9, 22, 1, 22, 1, 22, 5, 22, 1008, 8, 22, 10, 22, 12, 22, 1011, 9, 22, 1, 22, 1, 22, 5, 22, 1015, 8, 22, 10, 22, 12, 22, 1018, 9, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 1024, 8, 22, 1, 22, 5, 22, 1027, 8, 22, 10, 22, 12, 22, 1030, 9, 22, 1, 22, 1, 22, 1, 23, 5, 23, 1035, 8, 23, 10, 23, 12, 23, 1038, 9, 23, 1, 23, 1, 23, 5, 23, 1042, 8, 23, 10, 23, 12, 23, 1045, 9, 23, 1, 23, 1, 23, 5, 23, 1049, 8, 23, 10, 23, 12, 23, 1052, 9, 23, 1, 23, 1, 23, 1, 24, 5, 24, 1057, 8, 24, 10, 24, 12, 24, 1060, 9, 24, 1, 24, 1, 24, 5, 24, 1064, 8, 24, 10, 24, 12, 24, 1067, 9, 24, 1, 24, 5, 24, 1070, 8, 24, 10, 24, 12, 24, 1073, 9, 24, 1, 24, 1, 24, 5, 24, 1077, 8, 24, 10, 24, 12, 24, 1080, 9, 24, 1, 24, 1, 24, 5, 24, 1084, 8, 24, 10, 24, 12, 24, 1087, 9, 24, 1, 24, 1, 24, 5, 24, 1091, 8, 24, 10, 24, 12, 24, 1094, 9, 24, 1, 24, 1, 24, 5, 24, 1098, 8, 24, 10, 24, 12, 24, 1101, 9, 24, 1, 24, 1, 24, 1, 25, 5, 25, 1106, 8, 25, 10, 25, 12, 25, 1109, 9, 25, 1, 25, 1, 25, 5, 25, 1113, 8, 25, 10, 25, 12, 25, 1116, 9, 25, 1, 25, 1, 25, 5, 25, 1120, 8, 25, 10, 25, 12, 25, 1123, 9, 25, 1, 25, 1, 25, 1, 26, 5, 26, 1128, 8, 26, 10, 26, 12, 26, 1131, 9, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 1144, 8, 26, 1, 26, 5, 26, 1147, 8, 26, 10, 26, 12, 26, 1150, 9, 26, 1, 26, 1, 26, 1, 27, 1, 27, 5, 27, 1156, 8, 27, 10, 27, 12, 27, 1159, 9, 27, 1, 27, 1, 27, 5, 27, 1163, 8, 27, 10, 27, 12, 27, 1166, 9, 27, 1, 27, 1, 27, 5, 27, 1170, 8, 27, 10, 27, 12, 27, 1173, 9, 27, 1, 27, 1, 27, 1, 28, 1, 28, 5, 28, 1179, 8, 28, 10, 28, 12, 28, 1182, 9, 28, 1, 28, 1, 28, 5, 28, 1186, 8, 28, 10, 28, 12, 28, 1189, 9, 28, 1, 28, 1, 28, 5, 28, 1193, 8, 28, 10, 28, 12, 28, 1196, 9, 28, 1, 28, 1, 28, 5, 28, 1200, 8, 28, 10, 28, 12, 28, 1203, 9, 28, 1, 28, 1, 28, 1, 29, 1, 29, 5, 29, 1209, 8, 29, 10, 29, 12, 29, 1212, 9, 29, 1, 29, 1, 29, 5, 29, 1216, 8, 29, 10, 29, 12, 29, 1219, 9, 29, 1, 29, 1, 29, 5, 29, 1223, 8, 29, 10, 29, 12, 29, 1226, 9, 29, 1, 29, 1, 29, 5, 29, 1230, 8, 29, 10, 29, 12, 29, 1233, 9, 29, 1, 29, 1, 29, 5, 29, 1237, 8, 29, 10, 29, 12, 29, 1240, 9, 29, 1, 29, 1, 29, 1, 30, 1, 30, 5, 30, 1246, 8, 30, 10, 30, 12, 30, 1249, 9, 30, 1, 30, 1, 30, 5, 30, 1253, 8, 30, 10, 30, 12, 30, 1256, 9, 30, 1, 30, 1, 30, 5, 30, 1260, 8, 30, 10, 30, 12, 30, 1263, 9, 30, 1, 30, 1, 30, 5, 30, 1267, 8, 30, 10, 30, 12, 30, 1270, 9, 30, 1, 30, 1, 30, 1, 31, 1, 31, 5, 31, 1276, 8, 31, 10, 31, 12, 31, 1279, 9, 31, 1, 31, 1, 31, 5, 31, 1283, 8, 31, 10, 31, 12, 31, 1286, 9, 31, 1, 31, 1, 31, 1, 32, 1, 32, 5, 32, 1292, 8, 32, 10, 32, 12, 32, 1295, 9, 32, 1, 32, 1, 32, 5, 32, 1299, 8, 32, 10, 32, 12, 32, 1302, 9, 32, 1, 32, 1, 32, 5, 32, 1306, 8, 32, 10, 32, 12, 32, 1309, 9, 32, 1, 32, 1, 32, 5, 32, 1313, 8, 32, 10, 32, 12, 32, 1316, 9, 32, 1, 32, 1, 32, 5, 32, 1320, 8, 32, 10, 32, 12, 32, 1323, 9, 32, 1, 32, 1, 32, 5, 32, 1327, 8, 32, 10, 32, 12, 32, 1330, 9, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1335, 8, 32, 1, 33, 1, 33, 5, 33, 1339, 8, 33, 10, 33, 12, 33, 1342, 9, 33, 1, 33, 1, 33, 5, 33, 1346, 8, 33, 10, 33, 12, 33, 1349, 9, 33, 1, 33, 1, 33, 5, 33, 1353, 8, 33, 10, 33, 12, 33, 1356, 9, 33, 1, 33, 1, 33, 5, 33, 1360, 8, 33, 10, 33, 12, 33, 1363, 9, 33, 1, 33, 1, 33, 5, 33, 1367, 8, 33, 10, 33, 12, 33, 1370, 9, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 1377, 8, 33, 1, 34, 1, 34, 5, 34, 1381, 8, 34, 10, 34, 12, 34, 1384, 9, 34, 1, 34, 1, 34, 5, 34, 1388, 8, 34, 10, 34, 12, 34, 1391, 9, 34, 1, 34, 1, 34, 5, 34, 1395, 8, 34, 10, 34, 12, 34, 1398, 9, 34, 1, 34, 1, 34, 5, 34, 1402, 8, 34, 10, 34, 12, 34, 1405, 9, 34, 1, 34, 1, 34, 5, 34, 1409, 8, 34, 10, 34, 12, 34, 1412, 9, 34, 1, 34, 1, 34, 5, 34, 1416, 8, 34, 10, 34, 12, 34, 1419, 9, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 1426, 8, 34, 1, 35, 1, 35, 3, 35, 1430, 8, 35, 1, 36, 1, 36, 5, 36, 1434, 8, 36, 10, 36, 12, 36, 1437, 9, 36, 1, 36, 1, 36, 5, 36, 1441, 8, 36, 10, 36, 12, 36, 1444, 9, 36, 1, 36, 1, 36, 5, 36, 1448, 8, 36, 10, 36, 12, 36, 1451, 9, 36, 1, 36, 1, 36, 5, 36, 1455, 8, 36, 10, 36, 12, 36, 1458, 9, 36, 1, 36, 1, 36, 5, 36, 1462, 8, 36, 10, 36, 12, 36, 1465, 9, 36, 1, 36, 1, 36, 1, 37, 1, 37, 5, 37, 1471, 8, 37, 10, 37, 12, 37, 1474, 9, 37, 1, 37, 4, 37, 1477, 8, 37, 11, 37, 12, 37, 1478, 1, 37, 5, 37, 1482, 8, 37, 10, 37, 12, 37, 1485, 9, 37, 1, 37, 1, 37, 5, 37, 1489, 8, 37, 10, 37, 12, 37, 1492, 9, 37, 1, 37, 1, 37, 5, 37, 1496, 8, 37, 10, 37, 12, 37, 1499, 9, 37, 1, 37, 1, 37, 5, 37, 1503, 8, 37, 10, 37, 12, 37, 1506, 9, 37, 1, 37, 1, 37, 1, 38, 1, 38, 5, 38, 1512, 8, 38, 10, 38, 12, 38, 1515, 9, 38, 1, 38, 1, 38, 3, 38, 1519, 8, 38, 1, 38, 5, 38, 1522, 8, 38, 10, 38, 12, 38, 1525, 9, 38, 1, 38, 5, 38, 1528, 8, 38, 10, 38, 12, 38, 1531, 9, 38, 1, 38, 5, 38, 1534, 8, 38, 10, 38, 12, 38, 1537, 9, 38, 1, 38, 1, 38, 1, 38, 4, 38, 1542, 8, 38, 11, 38, 12, 38, 1543, 3, 38, 1546, 8, 38, 1, 39, 5, 39, 1549, 8, 39, 10, 39, 12, 39, 1552, 9, 39, 1, 39, 1, 39, 5, 39, 1556, 8, 39, 10, 39, 12, 39, 1559, 9, 39, 1, 39, 1, 39, 5, 39, 1563, 8, 39, 10, 39, 12, 39, 1566, 9, 39, 1, 39, 5, 39, 1569, 8, 39, 10, 39, 12, 39, 1572, 9, 39, 1, 39, 5, 39, 1575, 8, 39, 10, 39, 12, 39, 1578, 9, 39, 1, 39, 1, 39, 5, 39, 1582, 8, 39, 10, 39, 12, 39, 1585, 9, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1593, 8, 40, 1, 41, 3, 41, 1596, 8, 41, 1, 41, 1, 41, 5, 41, 1600, 8, 41, 10, 41, 12, 41, 1603, 9, 41, 4, 41, 1605, 8, 41, 11, 41, 12, 41, 1606, 1, 41, 1, 41, 1, 42, 3, 42, 1612, 8, 42, 1, 42, 1, 42, 5, 42, 1616, 8, 42, 10, 42, 12, 42, 1619, 9, 42, 4, 42, 1621, 8, 42, 11, 42, 12, 42, 1622, 1, 42, 1, 42, 1, 43, 1, 43, 3, 43, 1629, 8, 43, 1, 44, 3, 44, 1632, 8, 44, 1, 44, 1, 44, 5, 44, 1636, 8, 44, 10, 44, 12, 44, 1639, 9, 44, 4, 44, 1641, 8, 44, 11, 44, 12, 44, 1642, 1, 44, 1, 44, 1, 45, 3, 45, 1648, 8, 45, 1, 45, 1, 45, 5, 45, 1652, 8, 45, 10, 45, 12, 45, 1655, 9, 45, 4, 45, 1657, 8, 45, 11, 45, 12, 45, 1658, 1, 45, 1, 45, 1, 46, 3, 46, 1664, 8, 46, 1, 46, 1, 46, 5, 46, 1668, 8, 46, 10, 46, 12, 46, 1671, 9, 46, 4, 46, 1673, 8, 46, 11, 46, 12, 46, 1674, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 1683, 8, 47, 1, 48, 3, 48, 1686, 8, 48, 1, 48, 1, 48, 5, 48, 1690, 8, 48, 10, 48, 12, 48, 1693, 9, 48, 4, 48, 1695, 8, 48, 11, 48, 12, 48, 1696, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 5, 49, 1704, 8, 49, 10, 49, 12, 49, 1707, 9, 49, 4, 49, 1709, 8, 49, 11, 49, 12, 49, 1710, 1, 50, 1, 50, 1, 50, 5, 50, 1716, 8, 50, 10, 50, 12, 50, 1719, 9, 50, 4, 50, 1721, 8, 50, 11, 50, 12, 50, 1722, 1, 51, 1, 51, 1, 52, 1, 52, 1, 53, 1, 53, 1, 54, 1, 54, 1, 55, 1, 55, 3, 55, 1735, 8, 55, 1, 56, 1, 56, 1, 57, 1, 57, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 3, 59, 1747, 8, 59, 1, 60, 1, 60, 1, 61, 1, 61, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 1759, 8, 63, 1, 64, 1, 64, 5, 64, 1763, 8, 64, 10, 64, 12, 64, 1766, 9, 64, 1, 64, 1, 64, 5, 64, 1770, 8, 64, 10, 64, 12, 64, 1773, 9, 64, 1, 64, 1, 64, 5, 64, 1777, 8, 64, 10, 64, 12, 64, 1780, 9, 64, 1, 64, 1, 64, 5, 64, 1784, 8, 64, 10, 64, 12, 64, 1787, 9, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 3, 65, 1794, 8, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 3, 66, 1814, 8, 66, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1825, 8, 68, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 3, 70, 1840, 8, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 73, 1, 73, 1, 74, 1, 74, 4, 74, 1852, 8, 74, 11, 74, 12, 74, 1853, 1, 75, 1, 75, 5, 75, 1858, 8, 75, 10, 75, 12, 75, 1861, 9, 75, 1, 76, 1, 76, 3, 76, 1865, 8, 76, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 4, 78, 1876, 8, 78, 11, 78, 12, 78, 1877, 1, 78, 3, 78, 1881, 8, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 3, 79, 1890, 8, 79, 1, 80, 5, 80, 1893, 8, 80, 10, 80, 12, 80, 1896, 9, 80, 1, 80, 1, 80, 5, 80, 1900, 8, 80, 10, 80, 12, 80, 1903, 9, 80, 1, 80, 1, 80, 5, 80, 1907, 8, 80, 10, 80, 12, 80, 1910, 9, 80, 1, 80, 1, 80, 5, 80, 1914, 8, 80, 10, 80, 12, 80, 1917, 9, 80, 1, 80, 1, 80, 1, 81, 5, 81, 1922, 8, 81, 10, 81, 12, 81, 1925, 9, 81, 1, 81, 1, 81, 5, 81, 1929, 8, 81, 10, 81, 12, 81, 1932, 9, 81, 1, 81, 1, 81, 5, 81, 1936, 8, 81, 10, 81, 12, 81, 1939, 9, 81, 1, 81, 1, 81, 5, 81, 1943, 8, 81, 10, 81, 12, 81, 1946, 9, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1958, 8, 83, 1, 84, 1, 84, 1, 85, 1, 85, 5, 85, 1964, 8, 85, 10, 85, 12, 85, 1967, 9, 85, 1, 86, 1, 86, 5, 86, 1971, 8, 86, 10, 86, 12, 86, 1974, 9, 86, 1, 87, 1, 87, 1, 88, 1, 88, 1, 89, 1, 89, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 3, 91, 1988, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 2000, 8, 92, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 0, 0, 96, 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, 0, 19, 1, 0, 12, 13, 1, 0, 32, 33, 1, 0, 41, 72, 1, 0, 73, 74, 2, 0, 38, 38, 75, 78, 1, 0, 79, 83, 1, 0, 90, 92, 3, 0, 37, 37, 160, 160, 163, 163, 2, 0, 37, 37, 162, 163, 1, 0, 103, 110, 1, 0, 111, 136, 1, 0, 137, 138, 1, 0, 139, 140, 1, 0, 142, 145, 1, 0, 147, 148, 3, 0, 42, 42, 44, 44, 48, 48, 2, 0, 142, 143, 153, 153, 1, 0, 156, 157, 1, 0, 158, 159, 2220, 0, 192, 1, 0, 0, 0, 2, 197, 1, 0, 0, 0, 4, 239, 1, 0, 0, 0, 6, 261, 1, 0, 0, 0, 8, 285, 1, 0, 0, 0, 10, 314, 1, 0, 0, 0, 12, 343, 1, 0, 0, 0, 14, 369, 1, 0, 0, 0, 16, 424, 1, 0, 0, 0, 18, 462, 1, 0, 0, 0, 20, 498, 1, 0, 0, 0, 22, 534, 1, 0, 0, 0, 24, 576, 1, 0, 0, 0, 26, 612, 1, 0, 0, 0, 28, 648, 1, 0, 0, 0, 30, 680, 1, 0, 0, 0, 32, 723, 1, 0, 0, 0, 34, 728, 1, 0, 0, 0, 36, 779, 1, 0, 0, 0, 38, 830, 1, 0, 0, 0, 40, 888, 1, 0, 0, 0, 42, 939, 1, 0, 0, 0, 44, 976, 1, 0, 0, 0, 46, 1036, 1, 0, 0, 0, 48, 1058, 1, 0, 0, 0, 50, 1107, 1, 0, 0, 0, 52, 1129, 1, 0, 0, 0, 54, 1153, 1, 0, 0, 0, 56, 1176, 1, 0, 0, 0, 58, 1206, 1, 0, 0, 0, 60, 1243, 1, 0, 0, 0, 62, 1273, 1, 0, 0, 0, 64, 1289, 1, 0, 0, 0, 66, 1336, 1, 0, 0, 0, 68, 1378, 1, 0, 0, 0, 70, 1429, 1, 0, 0, 0, 72, 1431, 1, 0, 0, 0, 74, 1468, 1, 0, 0, 0, 76, 1509, 1, 0, 0, 0, 78, 1550, 1, 0, 0, 0, 80, 1592, 1, 0, 0, 0, 82, 1595, 1, 0, 0, 0, 84, 1611, 1, 0, 0, 0, 86, 1628, 1, 0, 0, 0, 88, 1631, 1, 0, 0, 0, 90, 1647, 1, 0, 0, 0, 92, 1663, 1, 0, 0, 0, 94, 1682, 1, 0, 0, 0, 96, 1685, 1, 0, 0, 0, 98, 1700, 1, 0, 0, 0, 100, 1712, 1, 0, 0, 0, 102, 1724, 1, 0, 0, 0, 104, 1726, 1, 0, 0, 0, 106, 1728, 1, 0, 0, 0, 108, 1730, 1, 0, 0, 0, 110, 1734, 1, 0, 0, 0, 112, 1736, 1, 0, 0, 0, 114, 1738, 1, 0, 0, 0, 116, 1740, 1, 0, 0, 0, 118, 1746, 1, 0, 0, 0, 120, 1748, 1, 0, 0, 0, 122, 1750, 1, 0, 0, 0, 124, 1752, 1, 0, 0, 0, 126, 1758, 1, 0, 0, 0, 128, 1760, 1, 0, 0, 0, 130, 1793, 1, 0, 0, 0, 132, 1813, 1, 0, 0, 0, 134, 1815, 1, 0, 0, 0, 136, 1824, 1, 0, 0, 0, 138, 1826, 1, 0, 0, 0, 140, 1839, 1, 0, 0, 0, 142, 1841, 1, 0, 0, 0, 144, 1845, 1, 0, 0, 0, 146, 1847, 1, 0, 0, 0, 148, 1849, 1, 0, 0, 0, 150, 1855, 1, 0, 0, 0, 152, 1864, 1, 0, 0, 0, 154, 1866, 1, 0, 0, 0, 156, 1880, 1, 0, 0, 0, 158, 1889, 1, 0, 0, 0, 160, 1894, 1, 0, 0, 0, 162, 1923, 1, 0, 0, 0, 164, 1949, 1, 0, 0, 0, 166, 1957, 1, 0, 0, 0, 168, 1959, 1, 0, 0, 0, 170, 1961, 1, 0, 0, 0, 172, 1968, 1, 0, 0, 0, 174, 1975, 1, 0, 0, 0, 176, 1977, 1, 0, 0, 0, 178, 1979, 1, 0, 0, 0, 180, 1981, 1, 0, 0, 0, 182, 1987, 1, 0, 0, 0, 184, 1999, 1, 0, 0, 0, 186, 2001, 1, 0, 0, 0, 188, 2004, 1, 0, 0, 0, 190, 2006, 1, 0, 0, 0, 192, 193, 3, 2, 1, 0, 193, 1, 1, 0, 0, 0, 194, 196, 3, 4, 2, 0, 195, 194, 1, 0, 0, 0, 196, 199, 1, 0, 0, 0, 197, 195, 1, 0, 0, 0, 197, 198, 1, 0, 0, 0, 198, 203, 1, 0, 0, 0, 199, 197, 1, 0, 0, 0, 200, 202, 5, 168, 0, 0, 201, 200, 1, 0, 0, 0, 202, 205, 1, 0, 0, 0, 203, 201, 1, 0, 0, 0, 203, 204, 1, 0, 0, 0, 204, 206, 1, 0, 0, 0, 205, 203, 1, 0, 0, 0, 206, 210, 5, 1, 0, 0, 207, 209, 5, 167, 0, 0, 208, 207, 1, 0, 0, 0, 209, 212, 1, 0, 0, 0, 210, 208, 1, 0, 0, 0, 210, 211, 1, 0, 0, 0, 211, 213, 1, 0, 0, 0, 212, 210, 1, 0, 0, 0, 213, 217, 3, 142, 71, 0, 214, 216, 5, 167, 0, 0, 215, 214, 1, 0, 0, 0, 216, 219, 1, 0, 0, 0, 217, 215, 1, 0, 0, 0, 217, 218, 1, 0, 0, 0, 218, 220, 1, 0, 0, 0, 219, 217, 1, 0, 0, 0, 220, 226, 5, 2, 0, 0, 221, 227, 3, 6, 3, 0, 222, 227, 3, 12, 6, 0, 223, 227, 3, 14, 7, 0, 224, 227, 3, 16, 8, 0, 225, 227, 3, 22, 11, 0, 226, 221, 1, 0, 0, 0, 226, 222, 1, 0, 0, 0, 226, 223, 1, 0, 0, 0, 226, 224, 1, 0, 0, 0, 226, 225, 1, 0, 0, 0, 227, 228, 1, 0, 0, 0, 228, 226, 1, 0, 0, 0, 228, 229, 1, 0, 0, 0, 229, 233, 1, 0, 0, 0, 230, 232, 5, 168, 0, 0, 231, 230, 1, 0, 0, 0, 232, 235, 1, 0, 0, 0, 233, 231, 1, 0, 0, 0, 233, 234, 1, 0, 0, 0, 234, 3, 1, 0, 0, 0, 235, 233, 1, 0, 0, 0, 236, 238, 5, 168, 0, 0, 237, 236, 1, 0, 0, 0, 238, 241, 1, 0, 0, 0, 239, 237, 1, 0, 0, 0, 239, 240, 1, 0, 0, 0, 240, 242, 1, 0, 0, 0, 241, 239, 1, 0, 0, 0, 242, 246, 5, 3, 0, 0, 243, 245, 5, 167, 0, 0, 244, 243, 1, 0, 0, 0, 245, 248, 1, 0, 0, 0, 246, 244, 1, 0, 0, 0, 246, 247, 1, 0, 0, 0, 247, 249, 1, 0, 0, 0, 248, 246, 1, 0, 0, 0, 249, 253, 3, 142, 71, 0, 250, 252, 5, 167, 0, 0, 251, 250, 1, 0, 0, 0, 252, 255, 1, 0, 0, 0, 253, 251, 1, 0, 0, 0, 253, 254, 1, 0, 0, 0, 254, 256, 1, 0, 0, 0, 255, 253, 1, 0, 0, 0, 256, 257, 5, 2, 0, 0, 257, 5, 1, 0, 0, 0, 258, 260, 5, 168, 0, 0, 259, 258, 1, 0, 0, 0, 260, 263, 1, 0, 0, 0, 261, 259, 1, 0, 0, 0, 261, 262, 1, 0, 0, 0, 262, 264, 1, 0, 0, 0, 263, 261, 1, 0, 0, 0, 264, 268, 5, 4, 0, 0, 265, 267, 5, 167, 0, 0, 266, 265, 1, 0, 0, 0, 267, 270, 1, 0, 0, 0, 268, 266, 1, 0, 0, 0, 268, 269, 1, 0, 0, 0, 269, 271, 1, 0, 0, 0, 270, 268, 1, 0, 0, 0, 271, 275, 3, 170, 85, 0, 272, 274, 5, 167, 0, 0, 273, 272, 1, 0, 0, 0, 274, 277, 1, 0, 0, 0, 275, 273, 1, 0, 0, 0, 275, 276, 1, 0, 0, 0, 276, 278, 1, 0, 0, 0, 277, 275, 1, 0, 0, 0, 278, 279, 5, 5, 0, 0, 279, 280, 3, 8, 4, 0, 280, 281, 3, 10, 5, 0, 281, 7, 1, 0, 0, 0, 282, 284, 5, 168, 0, 0, 283, 282, 1, 0, 0, 0, 284, 287, 1, 0, 0, 0, 285, 283, 1, 0, 0, 0, 285, 286, 1, 0, 0, 0, 286, 288, 1, 0, 0, 0, 287, 285, 1, 0, 0, 0, 288, 292, 5, 6, 0, 0, 289, 291, 5, 167, 0, 0, 290, 289, 1, 0, 0, 0, 291, 294, 1, 0, 0, 0, 292, 290, 1, 0, 0, 0, 292, 293, 1, 0, 0, 0, 293, 295, 1, 0, 0, 0, 294, 292, 1, 0, 0, 0, 295, 299, 5, 7, 0, 0, 296, 298, 5, 167, 0, 0, 297, 296, 1, 0, 0, 0, 298, 301, 1, 0, 0, 0, 299, 297, 1, 0, 0, 0, 299, 300, 1, 0, 0, 0, 300, 302, 1, 0, 0, 0, 301, 299, 1, 0, 0, 0, 302, 306, 3, 134, 67, 0, 303, 305, 5, 167, 0, 0, 304, 303, 1, 0, 0, 0, 305, 308, 1, 0, 0, 0, 306, 304, 1, 0, 0, 0, 306, 307, 1, 0, 0, 0, 307, 309, 1, 0, 0, 0, 308, 306, 1, 0, 0, 0, 309, 310, 5, 2, 0, 0, 310, 9, 1, 0, 0, 0, 311, 313, 5, 168, 0, 0, 312, 311, 1, 0, 0, 0, 313, 316, 1, 0, 0, 0, 314, 312, 1, 0, 0, 0, 314, 315, 1, 0, 0, 0, 315, 317, 1, 0, 0, 0, 316, 314, 1, 0, 0, 0, 317, 321, 5, 8, 0, 0, 318, 320, 5, 167, 0, 0, 319, 318, 1, 0, 0, 0, 320, 323, 1, 0, 0, 0, 321, 319, 1, 0, 0, 0, 321, 322, 1, 0, 0, 0, 322, 324, 1, 0, 0, 0, 323, 321, 1, 0, 0, 0, 324, 328, 5, 7, 0, 0, 325, 327, 5, 167, 0, 0, 326, 325, 1, 0, 0, 0, 327, 330, 1, 0, 0, 0, 328, 326, 1, 0, 0, 0, 328, 329, 1, 0, 0, 0, 329, 331, 1, 0, 0, 0, 330, 328, 1, 0, 0, 0, 331, 335, 3, 134, 67, 0, 332, 334, 5, 167, 0, 0, 333, 332, 1, 0, 0, 0, 334, 337, 1, 0, 0, 0, 335, 333, 1, 0, 0, 0, 335, 336, 1, 0, 0, 0, 336, 338, 1, 0, 0, 0, 337, 335, 1, 0, 0, 0, 338, 339, 5, 2, 0, 0, 339, 11, 1, 0, 0, 0, 340, 342, 5, 168, 0, 0, 341, 340, 1, 0, 0, 0, 342, 345, 1, 0, 0, 0, 343, 341, 1, 0, 0, 0, 343, 344, 1, 0, 0, 0, 344, 346, 1, 0, 0, 0, 345, 343, 1, 0, 0, 0, 346, 350, 5, 9, 0, 0, 347, 349, 5, 167, 0, 0, 348, 347, 1, 0, 0, 0, 349, 352, 1, 0, 0, 0, 350, 348, 1, 0, 0, 0, 350, 351, 1, 0, 0, 0, 351, 353, 1, 0, 0, 0, 352, 350, 1, 0, 0, 0, 353, 357, 3, 170, 85, 0, 354, 356, 5, 167, 0, 0, 355, 354, 1, 0, 0, 0, 356, 359, 1, 0, 0, 0, 357, 355, 1, 0, 0, 0, 357, 358, 1, 0, 0, 0, 358, 360, 1, 0, 0, 0, 359, 357, 1, 0, 0, 0, 360, 362, 5, 5, 0, 0, 361, 363, 3, 160, 80, 0, 362, 361, 1, 0, 0, 0, 363, 364, 1, 0, 0, 0, 364, 362, 1, 0, 0, 0, 364, 365, 1, 0, 0, 0, 365, 13, 1, 0, 0, 0, 366, 368, 5, 168, 0, 0, 367, 366, 1, 0, 0, 0, 368, 371, 1, 0, 0, 0, 369, 367, 1, 0, 0, 0, 369, 370, 1, 0, 0, 0, 370, 372, 1, 0, 0, 0, 371, 369, 1, 0, 0, 0, 372, 376, 5, 10, 0, 0, 373, 375, 5, 167, 0, 0, 374, 373, 1, 0, 0, 0, 375, 378, 1, 0, 0, 0, 376, 374, 1, 0, 0, 0, 376, 377, 1, 0, 0, 0, 377, 379, 1, 0, 0, 0, 378, 376, 1, 0, 0, 0, 379, 383, 3, 170, 85, 0, 380, 382, 5, 167, 0, 0, 381, 380, 1, 0, 0, 0, 382, 385, 1, 0, 0, 0, 383, 381, 1, 0, 0, 0, 383, 384, 1, 0, 0, 0, 384, 386, 1, 0, 0, 0, 385, 383, 1, 0, 0, 0, 386, 390, 5, 5, 0, 0, 387, 389, 5, 168, 0, 0, 388, 387, 1, 0, 0, 0, 389, 392, 1, 0, 0, 0, 390, 388, 1, 0, 0, 0, 390, 391, 1, 0, 0, 0, 391, 393, 1, 0, 0, 0, 392, 390, 1, 0, 0, 0, 393, 397, 5, 11, 0, 0, 394, 396, 5, 167, 0, 0, 395, 394, 1, 0, 0, 0, 396, 399, 1, 0, 0, 0, 397, 395, 1, 0, 0, 0, 397, 398, 1, 0, 0, 0, 398, 400, 1, 0, 0, 0, 399, 397, 1, 0, 0, 0, 400, 404, 5, 7, 0, 0, 401, 403, 5, 167, 0, 0, 402, 401, 1, 0, 0, 0, 403, 406, 1, 0, 0, 0, 404, 402, 1, 0, 0, 0, 404, 405, 1, 0, 0, 0, 405, 407, 1, 0, 0, 0, 406, 404, 1, 0, 0, 0, 407, 411, 7, 0, 0, 0, 408, 410, 5, 167, 0, 0, 409, 408, 1, 0, 0, 0, 410, 413, 1, 0, 0, 0, 411, 409, 1, 0, 0, 0, 411, 412, 1, 0, 0, 0, 412, 414, 1, 0, 0, 0, 413, 411, 1, 0, 0, 0, 414, 418, 5, 2, 0, 0, 415, 417, 3, 162, 81, 0, 416, 415, 1, 0, 0, 0, 417, 420, 1, 0, 0, 0, 418, 416, 1, 0, 0, 0, 418, 419, 1, 0, 0, 0, 419, 15, 1, 0, 0, 0, 420, 418, 1, 0, 0, 0, 421, 423, 5, 168, 0, 0, 422, 421, 1, 0, 0, 0, 423, 426, 1, 0, 0, 0, 424, 422, 1, 0, 0, 0, 424, 425, 1, 0, 0, 0, 425, 427, 1, 0, 0, 0, 426, 424, 1, 0, 0, 0, 427, 431, 5, 14, 0, 0, 428, 430, 5, 167, 0, 0, 429, 428, 1, 0, 0, 0, 430, 433, 1, 0, 0, 0, 431, 429, 1, 0, 0, 0, 431, 432, 1, 0, 0, 0, 432, 434, 1, 0, 0, 0, 433, 431, 1, 0, 0, 0, 434, 438, 3, 170, 85, 0, 435, 437, 5, 167, 0, 0, 436, 435, 1, 0, 0, 0, 437, 440, 1, 0, 0, 0, 438, 436, 1, 0, 0, 0, 438, 439, 1, 0, 0, 0, 439, 441, 1, 0, 0, 0, 440, 438, 1, 0, 0, 0, 441, 445, 5, 5, 0, 0, 442, 444, 3, 18, 9, 0, 443, 442, 1, 0, 0, 0, 444, 447, 1, 0, 0, 0, 445, 443, 1, 0, 0, 0, 445, 446, 1, 0, 0, 0, 446, 449, 1, 0, 0, 0, 447, 445, 1, 0, 0, 0, 448, 450, 3, 52, 26, 0, 449, 448, 1, 0, 0, 0, 450, 451, 1, 0, 0, 0, 451, 449, 1, 0, 0, 0, 451, 452, 1, 0, 0, 0, 452, 456, 1, 0, 0, 0, 453, 455, 3, 20, 10, 0, 454, 453, 1, 0, 0, 0, 455, 458, 1, 0, 0, 0, 456, 454, 1, 0, 0, 0, 456, 457, 1, 0, 0, 0, 457, 17, 1, 0, 0, 0, 458, 456, 1, 0, 0, 0, 459, 461, 5, 168, 0, 0, 460, 459, 1, 0, 0, 0, 461, 464, 1, 0, 0, 0, 462, 460, 1, 0, 0, 0, 462, 463, 1, 0, 0, 0, 463, 465, 1, 0, 0, 0, 464, 462, 1, 0, 0, 0, 465, 469, 5, 15, 0, 0, 466, 468, 5, 167, 0, 0, 467, 466, 1, 0, 0, 0, 468, 471, 1, 0, 0, 0, 469, 467, 1, 0, 0, 0, 469, 470, 1, 0, 0, 0, 470, 472, 1, 0, 0, 0, 471, 469, 1, 0, 0, 0, 472, 476, 3, 148, 74, 0, 473, 475, 5, 167, 0, 0, 474, 473, 1, 0, 0, 0, 475, 478, 1, 0, 0, 0, 476, 474, 1, 0, 0, 0, 476, 477, 1, 0, 0, 0, 477, 479, 1, 0, 0, 0, 478, 476, 1, 0, 0, 0, 479, 483, 5, 7, 0, 0, 480, 482, 5, 167, 0, 0, 481, 480, 1, 0, 0, 0, 482, 485, 1, 0, 0, 0, 483, 481, 1, 0, 0, 0, 483, 484, 1, 0, 0, 0, 484, 486, 1, 0, 0, 0, 485, 483, 1, 0, 0, 0, 486, 490, 3, 140, 70, 0, 487, 489, 5, 167, 0, 0, 488, 487, 1, 0, 0, 0, 489, 492, 1, 0, 0, 0, 490, 488, 1, 0, 0, 0, 490, 491, 1, 0, 0, 0, 491, 493, 1, 0, 0, 0, 492, 490, 1, 0, 0, 0, 493, 494, 5, 2, 0, 0, 494, 19, 1, 0, 0, 0, 495, 497, 5, 168, 0, 0, 496, 495, 1, 0, 0, 0, 497, 500, 1, 0, 0, 0, 498, 496, 1, 0, 0, 0, 498, 499, 1, 0, 0, 0, 499, 501, 1, 0, 0, 0, 500, 498, 1, 0, 0, 0, 501, 505, 5, 16, 0, 0, 502, 504, 5, 167, 0, 0, 503, 502, 1, 0, 0, 0, 504, 507, 1, 0, 0, 0, 505, 503, 1, 0, 0, 0, 505, 506, 1, 0, 0, 0, 506, 508, 1, 0, 0, 0, 507, 505, 1, 0, 0, 0, 508, 512, 3, 158, 79, 0, 509, 511, 5, 167, 0, 0, 510, 509, 1, 0, 0, 0, 511, 514, 1, 0, 0, 0, 512, 510, 1, 0, 0, 0, 512, 513, 1, 0, 0, 0, 513, 515, 1, 0, 0, 0, 514, 512, 1, 0, 0, 0, 515, 519, 5, 7, 0, 0, 516, 518, 5, 167, 0, 0, 517, 516, 1, 0, 0, 0, 518, 521, 1, 0, 0, 0, 519, 517, 1, 0, 0, 0, 519, 520, 1, 0, 0, 0, 520, 522, 1, 0, 0, 0, 521, 519, 1, 0, 0, 0, 522, 526, 3, 140, 70, 0, 523, 525, 5, 167, 0, 0, 524, 523, 1, 0, 0, 0, 525, 528, 1, 0, 0, 0, 526, 524, 1, 0, 0, 0, 526, 527, 1, 0, 0, 0, 527, 529, 1, 0, 0, 0, 528, 526, 1, 0, 0, 0, 529, 530, 5, 2, 0, 0, 530, 21, 1, 0, 0, 0, 531, 533, 5, 168, 0, 0, 532, 531, 1, 0, 0, 0, 533, 536, 1, 0, 0, 0, 534, 532, 1, 0, 0, 0, 534, 535, 1, 0, 0, 0, 535, 537, 1, 0, 0, 0, 536, 534, 1, 0, 0, 0, 537, 541, 5, 17, 0, 0, 538, 540, 5, 167, 0, 0, 539, 538, 1, 0, 0, 0, 540, 543, 1, 0, 0, 0, 541, 539, 1, 0, 0, 0, 541, 542, 1, 0, 0, 0, 542, 544, 1, 0, 0, 0, 543, 541, 1, 0, 0, 0, 544, 548, 3, 170, 85, 0, 545, 547, 5, 167, 0, 0, 546, 545, 1, 0, 0, 0, 547, 550, 1, 0, 0, 0, 548, 546, 1, 0, 0, 0, 548, 549, 1, 0, 0, 0, 549, 551, 1, 0, 0, 0, 550, 548, 1, 0, 0, 0, 551, 555, 5, 5, 0, 0, 552, 554, 3, 24, 12, 0, 553, 552, 1, 0, 0, 0, 554, 557, 1, 0, 0, 0, 555, 553, 1, 0, 0, 0, 555, 556, 1, 0, 0, 0, 556, 561, 1, 0, 0, 0, 557, 555, 1, 0, 0, 0, 558, 560, 3, 52, 26, 0, 559, 558, 1, 0, 0, 0, 560, 563, 1, 0, 0, 0, 561, 559, 1, 0, 0, 0, 561, 562, 1, 0, 0, 0, 562, 567, 1, 0, 0, 0, 563, 561, 1, 0, 0, 0, 564, 566, 3, 26, 13, 0, 565, 564, 1, 0, 0, 0, 566, 569, 1, 0, 0, 0, 567, 565, 1, 0, 0, 0, 567, 568, 1, 0, 0, 0, 568, 571, 1, 0, 0, 0, 569, 567, 1, 0, 0, 0, 570, 572, 3, 28, 14, 0, 571, 570, 1, 0, 0, 0, 571, 572, 1, 0, 0, 0, 572, 23, 1, 0, 0, 0, 573, 575, 5, 168, 0, 0, 574, 573, 1, 0, 0, 0, 575, 578, 1, 0, 0, 0, 576, 574, 1, 0, 0, 0, 576, 577, 1, 0, 0, 0, 577, 579, 1, 0, 0, 0, 578, 576, 1, 0, 0, 0, 579, 583, 5, 15, 0, 0, 580, 582, 5, 167, 0, 0, 581, 580, 1, 0, 0, 0, 582, 585, 1, 0, 0, 0, 583, 581, 1, 0, 0, 0, 583, 584, 1, 0, 0, 0, 584, 586, 1, 0, 0, 0, 585, 583, 1, 0, 0, 0, 586, 590, 3, 148, 74, 0, 587, 589, 5, 167, 0, 0, 588, 587, 1, 0, 0, 0, 589, 592, 1, 0, 0, 0, 590, 588, 1, 0, 0, 0, 590, 591, 1, 0, 0, 0, 591, 593, 1, 0, 0, 0, 592, 590, 1, 0, 0, 0, 593, 597, 5, 7, 0, 0, 594, 596, 5, 167, 0, 0, 595, 594, 1, 0, 0, 0, 596, 599, 1, 0, 0, 0, 597, 595, 1, 0, 0, 0, 597, 598, 1, 0, 0, 0, 598, 600, 1, 0, 0, 0, 599, 597, 1, 0, 0, 0, 600, 604, 3, 132, 66, 0, 601, 603, 5, 167, 0, 0, 602, 601, 1, 0, 0, 0, 603, 606, 1, 0, 0, 0, 604, 602, 1, 0, 0, 0, 604, 605, 1, 0, 0, 0, 605, 607, 1, 0, 0, 0, 606, 604, 1, 0, 0, 0, 607, 608, 5, 2, 0, 0, 608, 25, 1, 0, 0, 0, 609, 611, 5, 168, 0, 0, 610, 609, 1, 0, 0, 0, 611, 614, 1, 0, 0, 0, 612, 610, 1, 0, 0, 0, 612, 613, 1, 0, 0, 0, 613, 615, 1, 0, 0, 0, 614, 612, 1, 0, 0, 0, 615, 619, 5, 16, 0, 0, 616, 618, 5, 167, 0, 0, 617, 616, 1, 0, 0, 0, 618, 621, 1, 0, 0, 0, 619, 617, 1, 0, 0, 0, 619, 620, 1, 0, 0, 0, 620, 622, 1, 0, 0, 0, 621, 619, 1, 0, 0, 0, 622, 626, 3, 158, 79, 0, 623, 625, 5, 167, 0, 0, 624, 623, 1, 0, 0, 0, 625, 628, 1, 0, 0, 0, 626, 624, 1, 0, 0, 0, 626, 627, 1, 0, 0, 0, 627, 629, 1, 0, 0, 0, 628, 626, 1, 0, 0, 0, 629, 633, 5, 7, 0, 0, 630, 632, 5, 167, 0, 0, 631, 630, 1, 0, 0, 0, 632, 635, 1, 0, 0, 0, 633, 631, 1, 0, 0, 0, 633, 634, 1, 0, 0, 0, 634, 636, 1, 0, 0, 0, 635, 633, 1, 0, 0, 0, 636, 640, 3, 132, 66, 0, 637, 639, 5, 167, 0, 0, 638, 637, 1, 0, 0, 0, 639, 642, 1, 0, 0, 0, 640, 638, 1, 0, 0, 0, 640, 641, 1, 0, 0, 0, 641, 643, 1, 0, 0, 0, 642, 640, 1, 0, 0, 0, 643, 644, 5, 2, 0, 0, 644, 27, 1, 0, 0, 0, 645, 647, 5, 168, 0, 0, 646, 645, 1, 0, 0, 0, 647, 650, 1, 0, 0, 0, 648, 646, 1, 0, 0, 0, 648, 649, 1, 0, 0, 0, 649, 651, 1, 0, 0, 0, 650, 648, 1, 0, 0, 0, 651, 655, 5, 18, 0, 0, 652, 654, 5, 167, 0, 0, 653, 652, 1, 0, 0, 0, 654, 657, 1, 0, 0, 0, 655, 653, 1, 0, 0, 0, 655, 656, 1, 0, 0, 0, 656, 658, 1, 0, 0, 0, 657, 655, 1, 0, 0, 0, 658, 662, 3, 170, 85, 0, 659, 661, 5, 167, 0, 0, 660, 659, 1, 0, 0, 0, 661, 664, 1, 0, 0, 0, 662, 660, 1, 0, 0, 0, 662, 663, 1, 0, 0, 0, 663, 665, 1, 0, 0, 0, 664, 662, 1, 0, 0, 0, 665, 669, 5, 5, 0, 0, 666, 668, 3, 30, 15, 0, 667, 666, 1, 0, 0, 0, 668, 671, 1, 0, 0, 0, 669, 667, 1, 0, 0, 0, 669, 670, 1, 0, 0, 0, 670, 673, 1, 0, 0, 0, 671, 669, 1, 0, 0, 0, 672, 674, 3, 32, 16, 0, 673, 672, 1, 0, 0, 0, 674, 675, 1, 0, 0, 0, 675, 673, 1, 0, 0, 0, 675, 676, 1, 0, 0, 0, 676, 29, 1, 0, 0, 0, 677, 679, 5, 168, 0, 0, 678, 677, 1, 0, 0, 0, 679, 682, 1, 0, 0, 0, 680, 678, 1, 0, 0, 0, 680, 681, 1, 0, 0, 0, 681, 683, 1, 0, 0, 0, 682, 680, 1, 0, 0, 0, 683, 687, 5, 15, 0, 0, 684, 686, 5, 167, 0, 0, 685, 684, 1, 0, 0, 0, 686, 689, 1, 0, 0, 0, 687, 685, 1, 0, 0, 0, 687, 688, 1, 0, 0, 0, 688, 690, 1, 0, 0, 0, 689, 687, 1, 0, 0, 0, 690, 694, 3, 148, 74, 0, 691, 693, 5, 167, 0, 0, 692, 691, 1, 0, 0, 0, 693, 696, 1, 0, 0, 0, 694, 692, 1, 0, 0, 0, 694, 695, 1, 0, 0, 0, 695, 697, 1, 0, 0, 0, 696, 694, 1, 0, 0, 0, 697, 701, 5, 7, 0, 0, 698, 700, 5, 167, 0, 0, 699, 698, 1, 0, 0, 0, 700, 703, 1, 0, 0, 0, 701, 699, 1, 0, 0, 0, 701, 702, 1, 0, 0, 0, 702, 704, 1, 0, 0, 0, 703, 701, 1, 0, 0, 0, 704, 708, 3, 136, 68, 0, 705, 707, 5, 167, 0, 0, 706, 705, 1, 0, 0, 0, 707, 710, 1, 0, 0, 0, 708, 706, 1, 0, 0, 0, 708, 709, 1, 0, 0, 0, 709, 711, 1, 0, 0, 0, 710, 708, 1, 0, 0, 0, 711, 712, 5, 2, 0, 0, 712, 31, 1, 0, 0, 0, 713, 724, 3, 34, 17, 0, 714, 724, 3, 36, 18, 0, 715, 724, 3, 38, 19, 0, 716, 724, 3, 40, 20, 0, 717, 724, 3, 42, 21, 0, 718, 724, 3, 44, 22, 0, 719, 724, 3, 46, 23, 0, 720, 724, 3, 48, 24, 0, 721, 724, 3, 50, 25, 0, 722, 724, 3, 52, 26, 0, 723, 713, 1, 0, 0, 0, 723, 714, 1, 0, 0, 0, 723, 715, 1, 0, 0, 0, 723, 716, 1, 0, 0, 0, 723, 717, 1, 0, 0, 0, 723, 718, 1, 0, 0, 0, 723, 719, 1, 0, 0, 0, 723, 720, 1, 0, 0, 0, 723, 721, 1, 0, 0, 0, 723, 722, 1, 0, 0, 0, 724, 33, 1, 0, 0, 0, 725, 727, 5, 168, 0, 0, 726, 725, 1, 0, 0, 0, 727, 730, 1, 0, 0, 0, 728, 726, 1, 0, 0, 0, 728, 729, 1, 0, 0, 0, 729, 731, 1, 0, 0, 0, 730, 728, 1, 0, 0, 0, 731, 735, 5, 19, 0, 0, 732, 734, 5, 167, 0, 0, 733, 732, 1, 0, 0, 0, 734, 737, 1, 0, 0, 0, 735, 733, 1, 0, 0, 0, 735, 736, 1, 0, 0, 0, 736, 738, 1, 0, 0, 0, 737, 735, 1, 0, 0, 0, 738, 739, 3, 170, 85, 0, 739, 743, 5, 20, 0, 0, 740, 742, 5, 167, 0, 0, 741, 740, 1, 0, 0, 0, 742, 745, 1, 0, 0, 0, 743, 741, 1, 0, 0, 0, 743, 744, 1, 0, 0, 0, 744, 746, 1, 0, 0, 0, 745, 743, 1, 0, 0, 0, 746, 750, 3, 158, 79, 0, 747, 749, 5, 167, 0, 0, 748, 747, 1, 0, 0, 0, 749, 752, 1, 0, 0, 0, 750, 748, 1, 0, 0, 0, 750, 751, 1, 0, 0, 0, 751, 753, 1, 0, 0, 0, 752, 750, 1, 0, 0, 0, 753, 757, 5, 21, 0, 0, 754, 756, 5, 167, 0, 0, 755, 754, 1, 0, 0, 0, 756, 759, 1, 0, 0, 0, 757, 755, 1, 0, 0, 0, 757, 758, 1, 0, 0, 0, 758, 760, 1, 0, 0, 0, 759, 757, 1, 0, 0, 0, 760, 764, 5, 22, 0, 0, 761, 763, 5, 167, 0, 0, 762, 761, 1, 0, 0, 0, 763, 766, 1, 0, 0, 0, 764, 762, 1, 0, 0, 0, 764, 765, 1, 0, 0, 0, 765, 767, 1, 0, 0, 0, 766, 764, 1, 0, 0, 0, 767, 771, 3, 150, 75, 0, 768, 770, 5, 167, 0, 0, 769, 768, 1, 0, 0, 0, 770, 773, 1, 0, 0, 0, 771, 769, 1, 0, 0, 0, 771, 772, 1, 0, 0, 0, 772, 774, 1, 0, 0, 0, 773, 771, 1, 0, 0, 0, 774, 775, 5, 2, 0, 0, 775, 35, 1, 0, 0, 0, 776, 778, 5, 168, 0, 0, 777, 776, 1, 0, 0, 0, 778, 781, 1, 0, 0, 0, 779, 777, 1, 0, 0, 0, 779, 780, 1, 0, 0, 0, 780, 782, 1, 0, 0, 0, 781, 779, 1, 0, 0, 0, 782, 786, 5, 23, 0, 0, 783, 785, 5, 167, 0, 0, 784, 783, 1, 0, 0, 0, 785, 788, 1, 0, 0, 0, 786, 784, 1, 0, 0, 0, 786, 787, 1, 0, 0, 0, 787, 789, 1, 0, 0, 0, 788, 786, 1, 0, 0, 0, 789, 790, 3, 170, 85, 0, 790, 794, 5, 20, 0, 0, 791, 793, 5, 167, 0, 0, 792, 791, 1, 0, 0, 0, 793, 796, 1, 0, 0, 0, 794, 792, 1, 0, 0, 0, 794, 795, 1, 0, 0, 0, 795, 797, 1, 0, 0, 0, 796, 794, 1, 0, 0, 0, 797, 801, 3, 158, 79, 0, 798, 800, 5, 167, 0, 0, 799, 798, 1, 0, 0, 0, 800, 803, 1, 0, 0, 0, 801, 799, 1, 0, 0, 0, 801, 802, 1, 0, 0, 0, 802, 804, 1, 0, 0, 0, 803, 801, 1, 0, 0, 0, 804, 808, 5, 21, 0, 0, 805, 807, 5, 167, 0, 0, 806, 805, 1, 0, 0, 0, 807, 810, 1, 0, 0, 0, 808, 806, 1, 0, 0, 0, 808, 809, 1, 0, 0, 0, 809, 811, 1, 0, 0, 0, 810, 808, 1, 0, 0, 0, 811, 815, 5, 22, 0, 0, 812, 814, 5, 167, 0, 0, 813, 812, 1, 0, 0, 0, 814, 817, 1, 0, 0, 0, 815, 813, 1, 0, 0, 0, 815, 816, 1, 0, 0, 0, 816, 818, 1, 0, 0, 0, 817, 815, 1, 0, 0, 0, 818, 822, 3, 150, 75, 0, 819, 821, 5, 167, 0, 0, 820, 819, 1, 0, 0, 0, 821, 824, 1, 0, 0, 0, 822, 820, 1, 0, 0, 0, 822, 823, 1, 0, 0, 0, 823, 825, 1, 0, 0, 0, 824, 822, 1, 0, 0, 0, 825, 826, 5, 2, 0, 0, 826, 37, 1, 0, 0, 0, 827, 829, 5, 168, 0, 0, 828, 827, 1, 0, 0, 0, 829, 832, 1, 0, 0, 0, 830, 828, 1, 0, 0, 0, 830, 831, 1, 0, 0, 0, 831, 833, 1, 0, 0, 0, 832, 830, 1, 0, 0, 0, 833, 837, 5, 24, 0, 0, 834, 836, 5, 167, 0, 0, 835, 834, 1, 0, 0, 0, 836, 839, 1, 0, 0, 0, 837, 835, 1, 0, 0, 0, 837, 838, 1, 0, 0, 0, 838, 840, 1, 0, 0, 0, 839, 837, 1, 0, 0, 0, 840, 841, 3, 170, 85, 0, 841, 845, 5, 20, 0, 0, 842, 844, 5, 167, 0, 0, 843, 842, 1, 0, 0, 0, 844, 847, 1, 0, 0, 0, 845, 843, 1, 0, 0, 0, 845, 846, 1, 0, 0, 0, 846, 848, 1, 0, 0, 0, 847, 845, 1, 0, 0, 0, 848, 852, 3, 158, 79, 0, 849, 851, 5, 167, 0, 0, 850, 849, 1, 0, 0, 0, 851, 854, 1, 0, 0, 0, 852, 850, 1, 0, 0, 0, 852, 853, 1, 0, 0, 0, 853, 855, 1, 0, 0, 0, 854, 852, 1, 0, 0, 0, 855, 859, 5, 21, 0, 0, 856, 858, 5, 167, 0, 0, 857, 856, 1, 0, 0, 0, 858, 861, 1, 0, 0, 0, 859, 857, 1, 0, 0, 0, 859, 860, 1, 0, 0, 0, 860, 862, 1, 0, 0, 0, 861, 859, 1, 0, 0, 0, 862, 866, 3, 158, 79, 0, 863, 865, 5, 167, 0, 0, 864, 863, 1, 0, 0, 0, 865, 868, 1, 0, 0, 0, 866, 864, 1, 0, 0, 0, 866, 867, 1, 0, 0, 0, 867, 869, 1, 0, 0, 0, 868, 866, 1, 0, 0, 0, 869, 873, 5, 22, 0, 0, 870, 872, 5, 167, 0, 0, 871, 870, 1, 0, 0, 0, 872, 875, 1, 0, 0, 0, 873, 871, 1, 0, 0, 0, 873, 874, 1, 0, 0, 0, 874, 876, 1, 0, 0, 0, 875, 873, 1, 0, 0, 0, 876, 880, 3, 150, 75, 0, 877, 879, 5, 167, 0, 0, 878, 877, 1, 0, 0, 0, 879, 882, 1, 0, 0, 0, 880, 878, 1, 0, 0, 0, 880, 881, 1, 0, 0, 0, 881, 883, 1, 0, 0, 0, 882, 880, 1, 0, 0, 0, 883, 884, 5, 2, 0, 0, 884, 39, 1, 0, 0, 0, 885, 887, 5, 168, 0, 0, 886, 885, 1, 0, 0, 0, 887, 890, 1, 0, 0, 0, 888, 886, 1, 0, 0, 0, 888, 889, 1, 0, 0, 0, 889, 891, 1, 0, 0, 0, 890, 888, 1, 0, 0, 0, 891, 895, 5, 25, 0, 0, 892, 894, 5, 167, 0, 0, 893, 892, 1, 0, 0, 0, 894, 897, 1, 0, 0, 0, 895, 893, 1, 0, 0, 0, 895, 896, 1, 0, 0, 0, 896, 898, 1, 0, 0, 0, 897, 895, 1, 0, 0, 0, 898, 902, 3, 158, 79, 0, 899, 901, 5, 167, 0, 0, 900, 899, 1, 0, 0, 0, 901, 904, 1, 0, 0, 0, 902, 900, 1, 0, 0, 0, 902, 903, 1, 0, 0, 0, 903, 905, 1, 0, 0, 0, 904, 902, 1, 0, 0, 0, 905, 909, 5, 22, 0, 0, 906, 908, 5, 167, 0, 0, 907, 906, 1, 0, 0, 0, 908, 911, 1, 0, 0, 0, 909, 907, 1, 0, 0, 0, 909, 910, 1, 0, 0, 0, 910, 912, 1, 0, 0, 0, 911, 909, 1, 0, 0, 0, 912, 913, 3, 170, 85, 0, 913, 917, 5, 20, 0, 0, 914, 916, 5, 167, 0, 0, 915, 914, 1, 0, 0, 0, 916, 919, 1, 0, 0, 0, 917, 915, 1, 0, 0, 0, 917, 918, 1, 0, 0, 0, 918, 920, 1, 0, 0, 0, 919, 917, 1, 0, 0, 0, 920, 924, 3, 158, 79, 0, 921, 923, 5, 167, 0, 0, 922, 921, 1, 0, 0, 0, 923, 926, 1, 0, 0, 0, 924, 922, 1, 0, 0, 0, 924, 925, 1, 0, 0, 0, 925, 927, 1, 0, 0, 0, 926, 924, 1, 0, 0, 0, 927, 931, 5, 21, 0, 0, 928, 930, 5, 167, 0, 0, 929, 928, 1, 0, 0, 0, 930, 933, 1, 0, 0, 0, 931, 929, 1, 0, 0, 0, 931, 932, 1, 0, 0, 0, 932, 934, 1, 0, 0, 0, 933, 931, 1, 0, 0, 0, 934, 935, 5, 2, 0, 0, 935, 41, 1, 0, 0, 0, 936, 938, 5, 168, 0, 0, 937, 936, 1, 0, 0, 0, 938, 941, 1, 0, 0, 0, 939, 937, 1, 0, 0, 0, 939, 940, 1, 0, 0, 0, 940, 942, 1, 0, 0, 0, 941, 939, 1, 0, 0, 0, 942, 946, 5, 26, 0, 0, 943, 945, 5, 167, 0, 0, 944, 943, 1, 0, 0, 0, 945, 948, 1, 0, 0, 0, 946, 944, 1, 0, 0, 0, 946, 947, 1, 0, 0, 0, 947, 949, 1, 0, 0, 0, 948, 946, 1, 0, 0, 0, 949, 950, 3, 170, 85, 0, 950, 954, 5, 20, 0, 0, 951, 953, 5, 167, 0, 0, 952, 951, 1, 0, 0, 0, 953, 956, 1, 0, 0, 0, 954, 952, 1, 0, 0, 0, 954, 955, 1, 0, 0, 0, 955, 957, 1, 0, 0, 0, 956, 954, 1, 0, 0, 0, 957, 961, 3, 158, 79, 0, 958, 960, 5, 167, 0, 0, 959, 958, 1, 0, 0, 0, 960, 963, 1, 0, 0, 0, 961, 959, 1, 0, 0, 0, 961, 962, 1, 0, 0, 0, 962, 964, 1, 0, 0, 0, 963, 961, 1, 0, 0, 0, 964, 968, 5, 21, 0, 0, 965, 967, 5, 167, 0, 0, 966, 965, 1, 0, 0, 0, 967, 970, 1, 0, 0, 0, 968, 966, 1, 0, 0, 0, 968, 969, 1, 0, 0, 0, 969, 971, 1, 0, 0, 0, 970, 968, 1, 0, 0, 0, 971, 972, 5, 2, 0, 0, 972, 43, 1, 0, 0, 0, 973, 975, 5, 168, 0, 0, 974, 973, 1, 0, 0, 0, 975, 978, 1, 0, 0, 0, 976, 974, 1, 0, 0, 0, 976, 977, 1, 0, 0, 0, 977, 979, 1, 0, 0, 0, 978, 976, 1, 0, 0, 0, 979, 989, 5, 27, 0, 0, 980, 982, 5, 167, 0, 0, 981, 980, 1, 0, 0, 0, 982, 985, 1, 0, 0, 0, 983, 981, 1, 0, 0, 0, 983, 984, 1, 0, 0, 0, 984, 986, 1, 0, 0, 0, 985, 983, 1, 0, 0, 0, 986, 988, 3, 158, 79, 0, 987, 983, 1, 0, 0, 0, 988, 991, 1, 0, 0, 0, 989, 987, 1, 0, 0, 0, 989, 990, 1, 0, 0, 0, 990, 995, 1, 0, 0, 0, 991, 989, 1, 0, 0, 0, 992, 994, 5, 167, 0, 0, 993, 992, 1, 0, 0, 0, 994, 997, 1, 0, 0, 0, 995, 993, 1, 0, 0, 0, 995, 996, 1, 0, 0, 0, 996, 998, 1, 0, 0, 0, 997, 995, 1, 0, 0, 0, 998, 1002, 5, 22, 0, 0, 999, 1001, 5, 167, 0, 0, 1000, 999, 1, 0, 0, 0, 1001, 1004, 1, 0, 0, 0, 1002, 1000, 1, 0, 0, 0, 1002, 1003, 1, 0, 0, 0, 1003, 1005, 1, 0, 0, 0, 1004, 1002, 1, 0, 0, 0, 1005, 1009, 3, 150, 75, 0, 1006, 1008, 5, 167, 0, 0, 1007, 1006, 1, 0, 0, 0, 1008, 1011, 1, 0, 0, 0, 1009, 1007, 1, 0, 0, 0, 1009, 1010, 1, 0, 0, 0, 1010, 1012, 1, 0, 0, 0, 1011, 1009, 1, 0, 0, 0, 1012, 1016, 5, 7, 0, 0, 1013, 1015, 5, 167, 0, 0, 1014, 1013, 1, 0, 0, 0, 1015, 1018, 1, 0, 0, 0, 1016, 1014, 1, 0, 0, 0, 1016, 1017, 1, 0, 0, 0, 1017, 1023, 1, 0, 0, 0, 1018, 1016, 1, 0, 0, 0, 1019, 1024, 3, 118, 59, 0, 1020, 1024, 3, 120, 60, 0, 1021, 1024, 3, 124, 62, 0, 1022, 1024, 3, 122, 61, 0, 1023, 1019, 1, 0, 0, 0, 1023, 1020, 1, 0, 0, 0, 1023, 1021, 1, 0, 0, 0, 1023, 1022, 1, 0, 0, 0, 1024, 1028, 1, 0, 0, 0, 1025, 1027, 5, 167, 0, 0, 1026, 1025, 1, 0, 0, 0, 1027, 1030, 1, 0, 0, 0, 1028, 1026, 1, 0, 0, 0, 1028, 1029, 1, 0, 0, 0, 1029, 1031, 1, 0, 0, 0, 1030, 1028, 1, 0, 0, 0, 1031, 1032, 5, 2, 0, 0, 1032, 45, 1, 0, 0, 0, 1033, 1035, 5, 168, 0, 0, 1034, 1033, 1, 0, 0, 0, 1035, 1038, 1, 0, 0, 0, 1036, 1034, 1, 0, 0, 0, 1036, 1037, 1, 0, 0, 0, 1037, 1039, 1, 0, 0, 0, 1038, 1036, 1, 0, 0, 0, 1039, 1043, 5, 28, 0, 0, 1040, 1042, 5, 167, 0, 0, 1041, 1040, 1, 0, 0, 0, 1042, 1045, 1, 0, 0, 0, 1043, 1041, 1, 0, 0, 0, 1043, 1044, 1, 0, 0, 0, 1044, 1046, 1, 0, 0, 0, 1045, 1043, 1, 0, 0, 0, 1046, 1050, 3, 168, 84, 0, 1047, 1049, 5, 167, 0, 0, 1048, 1047, 1, 0, 0, 0, 1049, 1052, 1, 0, 0, 0, 1050, 1048, 1, 0, 0, 0, 1050, 1051, 1, 0, 0, 0, 1051, 1053, 1, 0, 0, 0, 1052, 1050, 1, 0, 0, 0, 1053, 1054, 5, 2, 0, 0, 1054, 47, 1, 0, 0, 0, 1055, 1057, 5, 168, 0, 0, 1056, 1055, 1, 0, 0, 0, 1057, 1060, 1, 0, 0, 0, 1058, 1056, 1, 0, 0, 0, 1058, 1059, 1, 0, 0, 0, 1059, 1061, 1, 0, 0, 0, 1060, 1058, 1, 0, 0, 0, 1061, 1065, 3, 190, 95, 0, 1062, 1064, 5, 167, 0, 0, 1063, 1062, 1, 0, 0, 0, 1064, 1067, 1, 0, 0, 0, 1065, 1063, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1066, 1071, 1, 0, 0, 0, 1067, 1065, 1, 0, 0, 0, 1068, 1070, 5, 167, 0, 0, 1069, 1068, 1, 0, 0, 0, 1070, 1073, 1, 0, 0, 0, 1071, 1069, 1, 0, 0, 0, 1071, 1072, 1, 0, 0, 0, 1072, 1074, 1, 0, 0, 0, 1073, 1071, 1, 0, 0, 0, 1074, 1078, 3, 158, 79, 0, 1075, 1077, 5, 167, 0, 0, 1076, 1075, 1, 0, 0, 0, 1077, 1080, 1, 0, 0, 0, 1078, 1076, 1, 0, 0, 0, 1078, 1079, 1, 0, 0, 0, 1079, 1081, 1, 0, 0, 0, 1080, 1078, 1, 0, 0, 0, 1081, 1085, 3, 158, 79, 0, 1082, 1084, 5, 167, 0, 0, 1083, 1082, 1, 0, 0, 0, 1084, 1087, 1, 0, 0, 0, 1085, 1083, 1, 0, 0, 0, 1085, 1086, 1, 0, 0, 0, 1086, 1088, 1, 0, 0, 0, 1087, 1085, 1, 0, 0, 0, 1088, 1092, 5, 29, 0, 0, 1089, 1091, 5, 167, 0, 0, 1090, 1089, 1, 0, 0, 0, 1091, 1094, 1, 0, 0, 0, 1092, 1090, 1, 0, 0, 0, 1092, 1093, 1, 0, 0, 0, 1093, 1095, 1, 0, 0, 0, 1094, 1092, 1, 0, 0, 0, 1095, 1099, 3, 168, 84, 0, 1096, 1098, 5, 167, 0, 0, 1097, 1096, 1, 0, 0, 0, 1098, 1101, 1, 0, 0, 0, 1099, 1097, 1, 0, 0, 0, 1099, 1100, 1, 0, 0, 0, 1100, 1102, 1, 0, 0, 0, 1101, 1099, 1, 0, 0, 0, 1102, 1103, 5, 2, 0, 0, 1103, 49, 1, 0, 0, 0, 1104, 1106, 5, 168, 0, 0, 1105, 1104, 1, 0, 0, 0, 1106, 1109, 1, 0, 0, 0, 1107, 1105, 1, 0, 0, 0, 1107, 1108, 1, 0, 0, 0, 1108, 1110, 1, 0, 0, 0, 1109, 1107, 1, 0, 0, 0, 1110, 1114, 5, 30, 0, 0, 1111, 1113, 5, 167, 0, 0, 1112, 1111, 1, 0, 0, 0, 1113, 1116, 1, 0, 0, 0, 1114, 1112, 1, 0, 0, 0, 1114, 1115, 1, 0, 0, 0, 1115, 1117, 1, 0, 0, 0, 1116, 1114, 1, 0, 0, 0, 1117, 1121, 3, 150, 75, 0, 1118, 1120, 5, 167, 0, 0, 1119, 1118, 1, 0, 0, 0, 1120, 1123, 1, 0, 0, 0, 1121, 1119, 1, 0, 0, 0, 1121, 1122, 1, 0, 0, 0, 1122, 1124, 1, 0, 0, 0, 1123, 1121, 1, 0, 0, 0, 1124, 1125, 5, 2, 0, 0, 1125, 51, 1, 0, 0, 0, 1126, 1128, 5, 168, 0, 0, 1127, 1126, 1, 0, 0, 0, 1128, 1131, 1, 0, 0, 0, 1129, 1127, 1, 0, 0, 0, 1129, 1130, 1, 0, 0, 0, 1130, 1143, 1, 0, 0, 0, 1131, 1129, 1, 0, 0, 0, 1132, 1144, 3, 54, 27, 0, 1133, 1144, 3, 56, 28, 0, 1134, 1144, 3, 58, 29, 0, 1135, 1144, 3, 60, 30, 0, 1136, 1144, 3, 62, 31, 0, 1137, 1144, 3, 64, 32, 0, 1138, 1144, 3, 70, 35, 0, 1139, 1144, 3, 72, 36, 0, 1140, 1144, 3, 74, 37, 0, 1141, 1144, 3, 76, 38, 0, 1142, 1144, 3, 78, 39, 0, 1143, 1132, 1, 0, 0, 0, 1143, 1133, 1, 0, 0, 0, 1143, 1134, 1, 0, 0, 0, 1143, 1135, 1, 0, 0, 0, 1143, 1136, 1, 0, 0, 0, 1143, 1137, 1, 0, 0, 0, 1143, 1138, 1, 0, 0, 0, 1143, 1139, 1, 0, 0, 0, 1143, 1140, 1, 0, 0, 0, 1143, 1141, 1, 0, 0, 0, 1143, 1142, 1, 0, 0, 0, 1144, 1148, 1, 0, 0, 0, 1145, 1147, 5, 167, 0, 0, 1146, 1145, 1, 0, 0, 0, 1147, 1150, 1, 0, 0, 0, 1148, 1146, 1, 0, 0, 0, 1148, 1149, 1, 0, 0, 0, 1149, 1151, 1, 0, 0, 0, 1150, 1148, 1, 0, 0, 0, 1151, 1152, 5, 2, 0, 0, 1152, 53, 1, 0, 0, 0, 1153, 1157, 3, 174, 87, 0, 1154, 1156, 5, 167, 0, 0, 1155, 1154, 1, 0, 0, 0, 1156, 1159, 1, 0, 0, 0, 1157, 1155, 1, 0, 0, 0, 1157, 1158, 1, 0, 0, 0, 1158, 1160, 1, 0, 0, 0, 1159, 1157, 1, 0, 0, 0, 1160, 1164, 3, 158, 79, 0, 1161, 1163, 5, 167, 0, 0, 1162, 1161, 1, 0, 0, 0, 1163, 1166, 1, 0, 0, 0, 1164, 1162, 1, 0, 0, 0, 1164, 1165, 1, 0, 0, 0, 1165, 1167, 1, 0, 0, 0, 1166, 1164, 1, 0, 0, 0, 1167, 1171, 5, 22, 0, 0, 1168, 1170, 5, 167, 0, 0, 1169, 1168, 1, 0, 0, 0, 1170, 1173, 1, 0, 0, 0, 1171, 1169, 1, 0, 0, 0, 1171, 1172, 1, 0, 0, 0, 1172, 1174, 1, 0, 0, 0, 1173, 1171, 1, 0, 0, 0, 1174, 1175, 3, 150, 75, 0, 1175, 55, 1, 0, 0, 0, 1176, 1180, 3, 176, 88, 0, 1177, 1179, 5, 167, 0, 0, 1178, 1177, 1, 0, 0, 0, 1179, 1182, 1, 0, 0, 0, 1180, 1178, 1, 0, 0, 0, 1180, 1181, 1, 0, 0, 0, 1181, 1183, 1, 0, 0, 0, 1182, 1180, 1, 0, 0, 0, 1183, 1187, 3, 158, 79, 0, 1184, 1186, 5, 167, 0, 0, 1185, 1184, 1, 0, 0, 0, 1186, 1189, 1, 0, 0, 0, 1187, 1185, 1, 0, 0, 0, 1187, 1188, 1, 0, 0, 0, 1188, 1190, 1, 0, 0, 0, 1189, 1187, 1, 0, 0, 0, 1190, 1194, 3, 158, 79, 0, 1191, 1193, 5, 167, 0, 0, 1192, 1191, 1, 0, 0, 0, 1193, 1196, 1, 0, 0, 0, 1194, 1192, 1, 0, 0, 0, 1194, 1195, 1, 0, 0, 0, 1195, 1197, 1, 0, 0, 0, 1196, 1194, 1, 0, 0, 0, 1197, 1201, 5, 22, 0, 0, 1198, 1200, 5, 167, 0, 0, 1199, 1198, 1, 0, 0, 0, 1200, 1203, 1, 0, 0, 0, 1201, 1199, 1, 0, 0, 0, 1201, 1202, 1, 0, 0, 0, 1202, 1204, 1, 0, 0, 0, 1203, 1201, 1, 0, 0, 0, 1204, 1205, 3, 150, 75, 0, 1205, 57, 1, 0, 0, 0, 1206, 1210, 5, 31, 0, 0, 1207, 1209, 5, 167, 0, 0, 1208, 1207, 1, 0, 0, 0, 1209, 1212, 1, 0, 0, 0, 1210, 1208, 1, 0, 0, 0, 1210, 1211, 1, 0, 0, 0, 1211, 1213, 1, 0, 0, 0, 1212, 1210, 1, 0, 0, 0, 1213, 1217, 3, 158, 79, 0, 1214, 1216, 5, 167, 0, 0, 1215, 1214, 1, 0, 0, 0, 1216, 1219, 1, 0, 0, 0, 1217, 1215, 1, 0, 0, 0, 1217, 1218, 1, 0, 0, 0, 1218, 1220, 1, 0, 0, 0, 1219, 1217, 1, 0, 0, 0, 1220, 1224, 3, 158, 79, 0, 1221, 1223, 5, 167, 0, 0, 1222, 1221, 1, 0, 0, 0, 1223, 1226, 1, 0, 0, 0, 1224, 1222, 1, 0, 0, 0, 1224, 1225, 1, 0, 0, 0, 1225, 1227, 1, 0, 0, 0, 1226, 1224, 1, 0, 0, 0, 1227, 1231, 3, 158, 79, 0, 1228, 1230, 5, 167, 0, 0, 1229, 1228, 1, 0, 0, 0, 1230, 1233, 1, 0, 0, 0, 1231, 1229, 1, 0, 0, 0, 1231, 1232, 1, 0, 0, 0, 1232, 1234, 1, 0, 0, 0, 1233, 1231, 1, 0, 0, 0, 1234, 1238, 5, 22, 0, 0, 1235, 1237, 5, 167, 0, 0, 1236, 1235, 1, 0, 0, 0, 1237, 1240, 1, 0, 0, 0, 1238, 1236, 1, 0, 0, 0, 1238, 1239, 1, 0, 0, 0, 1239, 1241, 1, 0, 0, 0, 1240, 1238, 1, 0, 0, 0, 1241, 1242, 3, 150, 75, 0, 1242, 59, 1, 0, 0, 0, 1243, 1247, 3, 178, 89, 0, 1244, 1246, 5, 167, 0, 0, 1245, 1244, 1, 0, 0, 0, 1246, 1249, 1, 0, 0, 0, 1247, 1245, 1, 0, 0, 0, 1247, 1248, 1, 0, 0, 0, 1248, 1250, 1, 0, 0, 0, 1249, 1247, 1, 0, 0, 0, 1250, 1254, 3, 158, 79, 0, 1251, 1253, 5, 167, 0, 0, 1252, 1251, 1, 0, 0, 0, 1253, 1256, 1, 0, 0, 0, 1254, 1252, 1, 0, 0, 0, 1254, 1255, 1, 0, 0, 0, 1255, 1257, 1, 0, 0, 0, 1256, 1254, 1, 0, 0, 0, 1257, 1261, 3, 158, 79, 0, 1258, 1260, 5, 167, 0, 0, 1259, 1258, 1, 0, 0, 0, 1260, 1263, 1, 0, 0, 0, 1261, 1259, 1, 0, 0, 0, 1261, 1262, 1, 0, 0, 0, 1262, 1264, 1, 0, 0, 0, 1263, 1261, 1, 0, 0, 0, 1264, 1268, 5, 22, 0, 0, 1265, 1267, 5, 167, 0, 0, 1266, 1265, 1, 0, 0, 0, 1267, 1270, 1, 0, 0, 0, 1268, 1266, 1, 0, 0, 0, 1268, 1269, 1, 0, 0, 0, 1269, 1271, 1, 0, 0, 0, 1270, 1268, 1, 0, 0, 0, 1271, 1272, 3, 150, 75, 0, 1272, 61, 1, 0, 0, 0, 1273, 1277, 3, 180, 90, 0, 1274, 1276, 5, 167, 0, 0, 1275, 1274, 1, 0, 0, 0, 1276, 1279, 1, 0, 0, 0, 1277, 1275, 1, 0, 0, 0, 1277, 1278, 1, 0, 0, 0, 1278, 1280, 1, 0, 0, 0, 1279, 1277, 1, 0, 0, 0, 1280, 1284, 3, 158, 79, 0, 1281, 1283, 5, 167, 0, 0, 1282, 1281, 1, 0, 0, 0, 1283, 1286, 1, 0, 0, 0, 1284, 1282, 1, 0, 0, 0, 1284, 1285, 1, 0, 0, 0, 1285, 1287, 1, 0, 0, 0, 1286, 1284, 1, 0, 0, 0, 1287, 1288, 3, 158, 79, 0, 1288, 63, 1, 0, 0, 0, 1289, 1293, 3, 182, 91, 0, 1290, 1292, 5, 167, 0, 0, 1291, 1290, 1, 0, 0, 0, 1292, 1295, 1, 0, 0, 0, 1293, 1291, 1, 0, 0, 0, 1293, 1294, 1, 0, 0, 0, 1294, 1296, 1, 0, 0, 0, 1295, 1293, 1, 0, 0, 0, 1296, 1300, 3, 158, 79, 0, 1297, 1299, 5, 167, 0, 0, 1298, 1297, 1, 0, 0, 0, 1299, 1302, 1, 0, 0, 0, 1300, 1298, 1, 0, 0, 0, 1300, 1301, 1, 0, 0, 0, 1301, 1303, 1, 0, 0, 0, 1302, 1300, 1, 0, 0, 0, 1303, 1307, 3, 158, 79, 0, 1304, 1306, 5, 167, 0, 0, 1305, 1304, 1, 0, 0, 0, 1306, 1309, 1, 0, 0, 0, 1307, 1305, 1, 0, 0, 0, 1307, 1308, 1, 0, 0, 0, 1308, 1310, 1, 0, 0, 0, 1309, 1307, 1, 0, 0, 0, 1310, 1314, 5, 22, 0, 0, 1311, 1313, 5, 167, 0, 0, 1312, 1311, 1, 0, 0, 0, 1313, 1316, 1, 0, 0, 0, 1314, 1312, 1, 0, 0, 0, 1314, 1315, 1, 0, 0, 0, 1315, 1317, 1, 0, 0, 0, 1316, 1314, 1, 0, 0, 0, 1317, 1321, 3, 150, 75, 0, 1318, 1320, 5, 167, 0, 0, 1319, 1318, 1, 0, 0, 0, 1320, 1323, 1, 0, 0, 0, 1321, 1319, 1, 0, 0, 0, 1321, 1322, 1, 0, 0, 0, 1322, 1324, 1, 0, 0, 0, 1323, 1321, 1, 0, 0, 0, 1324, 1328, 5, 7, 0, 0, 1325, 1327, 5, 167, 0, 0, 1326, 1325, 1, 0, 0, 0, 1327, 1330, 1, 0, 0, 0, 1328, 1326, 1, 0, 0, 0, 1328, 1329, 1, 0, 0, 0, 1329, 1334, 1, 0, 0, 0, 1330, 1328, 1, 0, 0, 0, 1331, 1335, 3, 120, 60, 0, 1332, 1335, 3, 112, 56, 0, 1333, 1335, 3, 114, 57, 0, 1334, 1331, 1, 0, 0, 0, 1334, 1332, 1, 0, 0, 0, 1334, 1333, 1, 0, 0, 0, 1335, 65, 1, 0, 0, 0, 1336, 1340, 3, 184, 92, 0, 1337, 1339, 5, 167, 0, 0, 1338, 1337, 1, 0, 0, 0, 1339, 1342, 1, 0, 0, 0, 1340, 1338, 1, 0, 0, 0, 1340, 1341, 1, 0, 0, 0, 1341, 1343, 1, 0, 0, 0, 1342, 1340, 1, 0, 0, 0, 1343, 1347, 3, 158, 79, 0, 1344, 1346, 5, 167, 0, 0, 1345, 1344, 1, 0, 0, 0, 1346, 1349, 1, 0, 0, 0, 1347, 1345, 1, 0, 0, 0, 1347, 1348, 1, 0, 0, 0, 1348, 1350, 1, 0, 0, 0, 1349, 1347, 1, 0, 0, 0, 1350, 1354, 5, 22, 0, 0, 1351, 1353, 5, 167, 0, 0, 1352, 1351, 1, 0, 0, 0, 1353, 1356, 1, 0, 0, 0, 1354, 1352, 1, 0, 0, 0, 1354, 1355, 1, 0, 0, 0, 1355, 1357, 1, 0, 0, 0, 1356, 1354, 1, 0, 0, 0, 1357, 1361, 3, 150, 75, 0, 1358, 1360, 5, 167, 0, 0, 1359, 1358, 1, 0, 0, 0, 1360, 1363, 1, 0, 0, 0, 1361, 1359, 1, 0, 0, 0, 1361, 1362, 1, 0, 0, 0, 1362, 1364, 1, 0, 0, 0, 1363, 1361, 1, 0, 0, 0, 1364, 1368, 5, 7, 0, 0, 1365, 1367, 5, 167, 0, 0, 1366, 1365, 1, 0, 0, 0, 1367, 1370, 1, 0, 0, 0, 1368, 1366, 1, 0, 0, 0, 1368, 1369, 1, 0, 0, 0, 1369, 1376, 1, 0, 0, 0, 1370, 1368, 1, 0, 0, 0, 1371, 1377, 3, 118, 59, 0, 1372, 1377, 3, 120, 60, 0, 1373, 1377, 3, 124, 62, 0, 1374, 1377, 3, 128, 64, 0, 1375, 1377, 3, 170, 85, 0, 1376, 1371, 1, 0, 0, 0, 1376, 1372, 1, 0, 0, 0, 1376, 1373, 1, 0, 0, 0, 1376, 1374, 1, 0, 0, 0, 1376, 1375, 1, 0, 0, 0, 1377, 67, 1, 0, 0, 0, 1378, 1382, 3, 186, 93, 0, 1379, 1381, 5, 167, 0, 0, 1380, 1379, 1, 0, 0, 0, 1381, 1384, 1, 0, 0, 0, 1382, 1380, 1, 0, 0, 0, 1382, 1383, 1, 0, 0, 0, 1383, 1385, 1, 0, 0, 0, 1384, 1382, 1, 0, 0, 0, 1385, 1389, 3, 158, 79, 0, 1386, 1388, 5, 167, 0, 0, 1387, 1386, 1, 0, 0, 0, 1388, 1391, 1, 0, 0, 0, 1389, 1387, 1, 0, 0, 0, 1389, 1390, 1, 0, 0, 0, 1390, 1392, 1, 0, 0, 0, 1391, 1389, 1, 0, 0, 0, 1392, 1396, 3, 158, 79, 0, 1393, 1395, 5, 167, 0, 0, 1394, 1393, 1, 0, 0, 0, 1395, 1398, 1, 0, 0, 0, 1396, 1394, 1, 0, 0, 0, 1396, 1397, 1, 0, 0, 0, 1397, 1399, 1, 0, 0, 0, 1398, 1396, 1, 0, 0, 0, 1399, 1403, 5, 22, 0, 0, 1400, 1402, 5, 167, 0, 0, 1401, 1400, 1, 0, 0, 0, 1402, 1405, 1, 0, 0, 0, 1403, 1401, 1, 0, 0, 0, 1403, 1404, 1, 0, 0, 0, 1404, 1406, 1, 0, 0, 0, 1405, 1403, 1, 0, 0, 0, 1406, 1410, 3, 150, 75, 0, 1407, 1409, 5, 167, 0, 0, 1408, 1407, 1, 0, 0, 0, 1409, 1412, 1, 0, 0, 0, 1410, 1408, 1, 0, 0, 0, 1410, 1411, 1, 0, 0, 0, 1411, 1413, 1, 0, 0, 0, 1412, 1410, 1, 0, 0, 0, 1413, 1417, 5, 7, 0, 0, 1414, 1416, 5, 167, 0, 0, 1415, 1414, 1, 0, 0, 0, 1416, 1419, 1, 0, 0, 0, 1417, 1415, 1, 0, 0, 0, 1417, 1418, 1, 0, 0, 0, 1418, 1425, 1, 0, 0, 0, 1419, 1417, 1, 0, 0, 0, 1420, 1426, 3, 118, 59, 0, 1421, 1426, 3, 120, 60, 0, 1422, 1426, 3, 124, 62, 0, 1423, 1426, 3, 128, 64, 0, 1424, 1426, 3, 170, 85, 0, 1425, 1420, 1, 0, 0, 0, 1425, 1421, 1, 0, 0, 0, 1425, 1422, 1, 0, 0, 0, 1425, 1423, 1, 0, 0, 0, 1425, 1424, 1, 0, 0, 0, 1426, 69, 1, 0, 0, 0, 1427, 1430, 3, 66, 33, 0, 1428, 1430, 3, 68, 34, 0, 1429, 1427, 1, 0, 0, 0, 1429, 1428, 1, 0, 0, 0, 1430, 71, 1, 0, 0, 0, 1431, 1435, 7, 1, 0, 0, 1432, 1434, 5, 167, 0, 0, 1433, 1432, 1, 0, 0, 0, 1434, 1437, 1, 0, 0, 0, 1435, 1433, 1, 0, 0, 0, 1435, 1436, 1, 0, 0, 0, 1436, 1438, 1, 0, 0, 0, 1437, 1435, 1, 0, 0, 0, 1438, 1442, 3, 158, 79, 0, 1439, 1441, 5, 167, 0, 0, 1440, 1439, 1, 0, 0, 0, 1441, 1444, 1, 0, 0, 0, 1442, 1440, 1, 0, 0, 0, 1442, 1443, 1, 0, 0, 0, 1443, 1445, 1, 0, 0, 0, 1444, 1442, 1, 0, 0, 0, 1445, 1449, 3, 158, 79, 0, 1446, 1448, 5, 167, 0, 0, 1447, 1446, 1, 0, 0, 0, 1448, 1451, 1, 0, 0, 0, 1449, 1447, 1, 0, 0, 0, 1449, 1450, 1, 0, 0, 0, 1450, 1452, 1, 0, 0, 0, 1451, 1449, 1, 0, 0, 0, 1452, 1456, 3, 158, 79, 0, 1453, 1455, 5, 167, 0, 0, 1454, 1453, 1, 0, 0, 0, 1455, 1458, 1, 0, 0, 0, 1456, 1454, 1, 0, 0, 0, 1456, 1457, 1, 0, 0, 0, 1457, 1459, 1, 0, 0, 0, 1458, 1456, 1, 0, 0, 0, 1459, 1463, 5, 22, 0, 0, 1460, 1462, 5, 167, 0, 0, 1461, 1460, 1, 0, 0, 0, 1462, 1465, 1, 0, 0, 0, 1463, 1461, 1, 0, 0, 0, 1463, 1464, 1, 0, 0, 0, 1464, 1466, 1, 0, 0, 0, 1465, 1463, 1, 0, 0, 0, 1466, 1467, 3, 150, 75, 0, 1467, 73, 1, 0, 0, 0, 1468, 1476, 3, 188, 94, 0, 1469, 1471, 5, 167, 0, 0, 1470, 1469, 1, 0, 0, 0, 1471, 1474, 1, 0, 0, 0, 1472, 1470, 1, 0, 0, 0, 1472, 1473, 1, 0, 0, 0, 1473, 1475, 1, 0, 0, 0, 1474, 1472, 1, 0, 0, 0, 1475, 1477, 3, 158, 79, 0, 1476, 1472, 1, 0, 0, 0, 1477, 1478, 1, 0, 0, 0, 1478, 1476, 1, 0, 0, 0, 1478, 1479, 1, 0, 0, 0, 1479, 1483, 1, 0, 0, 0, 1480, 1482, 5, 167, 0, 0, 1481, 1480, 1, 0, 0, 0, 1482, 1485, 1, 0, 0, 0, 1483, 1481, 1, 0, 0, 0, 1483, 1484, 1, 0, 0, 0, 1484, 1486, 1, 0, 0, 0, 1485, 1483, 1, 0, 0, 0, 1486, 1490, 5, 22, 0, 0, 1487, 1489, 5, 167, 0, 0, 1488, 1487, 1, 0, 0, 0, 1489, 1492, 1, 0, 0, 0, 1490, 1488, 1, 0, 0, 0, 1490, 1491, 1, 0, 0, 0, 1491, 1493, 1, 0, 0, 0, 1492, 1490, 1, 0, 0, 0, 1493, 1497, 3, 150, 75, 0, 1494, 1496, 5, 167, 0, 0, 1495, 1494, 1, 0, 0, 0, 1496, 1499, 1, 0, 0, 0, 1497, 1495, 1, 0, 0, 0, 1497, 1498, 1, 0, 0, 0, 1498, 1500, 1, 0, 0, 0, 1499, 1497, 1, 0, 0, 0, 1500, 1504, 5, 7, 0, 0, 1501, 1503, 5, 167, 0, 0, 1502, 1501, 1, 0, 0, 0, 1503, 1506, 1, 0, 0, 0, 1504, 1502, 1, 0, 0, 0, 1504, 1505, 1, 0, 0, 0, 1505, 1507, 1, 0, 0, 0, 1506, 1504, 1, 0, 0, 0, 1507, 1508, 3, 166, 83, 0, 1508, 75, 1, 0, 0, 0, 1509, 1513, 5, 34, 0, 0, 1510, 1512, 5, 167, 0, 0, 1511, 1510, 1, 0, 0, 0, 1512, 1515, 1, 0, 0, 0, 1513, 1511, 1, 0, 0, 0, 1513, 1514, 1, 0, 0, 0, 1514, 1518, 1, 0, 0, 0, 1515, 1513, 1, 0, 0, 0, 1516, 1519, 3, 164, 82, 0, 1517, 1519, 3, 170, 85, 0, 1518, 1516, 1, 0, 0, 0, 1518, 1517, 1, 0, 0, 0, 1519, 1529, 1, 0, 0, 0, 1520, 1522, 5, 167, 0, 0, 1521, 1520, 1, 0, 0, 0, 1522, 1525, 1, 0, 0, 0, 1523, 1521, 1, 0, 0, 0, 1523, 1524, 1, 0, 0, 0, 1524, 1526, 1, 0, 0, 0, 1525, 1523, 1, 0, 0, 0, 1526, 1528, 3, 158, 79, 0, 1527, 1523, 1, 0, 0, 0, 1528, 1531, 1, 0, 0, 0, 1529, 1527, 1, 0, 0, 0, 1529, 1530, 1, 0, 0, 0, 1530, 1545, 1, 0, 0, 0, 1531, 1529, 1, 0, 0, 0, 1532, 1534, 5, 167, 0, 0, 1533, 1532, 1, 0, 0, 0, 1534, 1537, 1, 0, 0, 0, 1535, 1533, 1, 0, 0, 0, 1535, 1536, 1, 0, 0, 0, 1536, 1538, 1, 0, 0, 0, 1537, 1535, 1, 0, 0, 0, 1538, 1541, 5, 22, 0, 0, 1539, 1540, 5, 167, 0, 0, 1540, 1542, 3, 150, 75, 0, 1541, 1539, 1, 0, 0, 0, 1542, 1543, 1, 0, 0, 0, 1543, 1541, 1, 0, 0, 0, 1543, 1544, 1, 0, 0, 0, 1544, 1546, 1, 0, 0, 0, 1545, 1535, 1, 0, 0, 0, 1545, 1546, 1, 0, 0, 0, 1546, 77, 1, 0, 0, 0, 1547, 1549, 5, 168, 0, 0, 1548, 1547, 1, 0, 0, 0, 1549, 1552, 1, 0, 0, 0, 1550, 1548, 1, 0, 0, 0, 1550, 1551, 1, 0, 0, 0, 1551, 1553, 1, 0, 0, 0, 1552, 1550, 1, 0, 0, 0, 1553, 1557, 5, 35, 0, 0, 1554, 1556, 5, 167, 0, 0, 1555, 1554, 1, 0, 0, 0, 1556, 1559, 1, 0, 0, 0, 1557, 1555, 1, 0, 0, 0, 1557, 1558, 1, 0, 0, 0, 1558, 1560, 1, 0, 0, 0, 1559, 1557, 1, 0, 0, 0, 1560, 1570, 3, 170, 85, 0, 1561, 1563, 5, 167, 0, 0, 1562, 1561, 1, 0, 0, 0, 1563, 1566, 1, 0, 0, 0, 1564, 1562, 1, 0, 0, 0, 1564, 1565, 1, 0, 0, 0, 1565, 1567, 1, 0, 0, 0, 1566, 1564, 1, 0, 0, 0, 1567, 1569, 3, 158, 79, 0, 1568, 1564, 1, 0, 0, 0, 1569, 1572, 1, 0, 0, 0, 1570, 1568, 1, 0, 0, 0, 1570, 1571, 1, 0, 0, 0, 1571, 1576, 1, 0, 0, 0, 1572, 1570, 1, 0, 0, 0, 1573, 1575, 5, 167, 0, 0, 1574, 1573, 1, 0, 0, 0, 1575, 1578, 1, 0, 0, 0, 1576, 1574, 1, 0, 0, 0, 1576, 1577, 1, 0, 0, 0, 1577, 1579, 1, 0, 0, 0, 1578, 1576, 1, 0, 0, 0, 1579, 1583, 5, 22, 0, 0, 1580, 1582, 5, 167, 0, 0, 1581, 1580, 1, 0, 0, 0, 1582, 1585, 1, 0, 0, 0, 1583, 1581, 1, 0, 0, 0, 1583, 1584, 1, 0, 0, 0, 1584, 1586, 1, 0, 0, 0, 1585, 1583, 1, 0, 0, 0, 1586, 1587, 3, 150, 75, 0, 1587, 79, 1, 0, 0, 0, 1588, 1593, 3, 94, 47, 0, 1589, 1593, 3, 98, 49, 0, 1590, 1593, 3, 100, 50, 0, 1591, 1593, 3, 104, 52, 0, 1592, 1588, 1, 0, 0, 0, 1592, 1589, 1, 0, 0, 0, 1592, 1590, 1, 0, 0, 0, 1592, 1591, 1, 0, 0, 0, 1593, 81, 1, 0, 0, 0, 1594, 1596, 5, 36, 0, 0, 1595, 1594, 1, 0, 0, 0, 1595, 1596, 1, 0, 0, 0, 1596, 1604, 1, 0, 0, 0, 1597, 1601, 5, 163, 0, 0, 1598, 1600, 5, 37, 0, 0, 1599, 1598, 1, 0, 0, 0, 1600, 1603, 1, 0, 0, 0, 1601, 1599, 1, 0, 0, 0, 1601, 1602, 1, 0, 0, 0, 1602, 1605, 1, 0, 0, 0, 1603, 1601, 1, 0, 0, 0, 1604, 1597, 1, 0, 0, 0, 1605, 1606, 1, 0, 0, 0, 1606, 1604, 1, 0, 0, 0, 1606, 1607, 1, 0, 0, 0, 1607, 1608, 1, 0, 0, 0, 1608, 1609, 3, 108, 54, 0, 1609, 83, 1, 0, 0, 0, 1610, 1612, 5, 36, 0, 0, 1611, 1610, 1, 0, 0, 0, 1611, 1612, 1, 0, 0, 0, 1612, 1620, 1, 0, 0, 0, 1613, 1617, 5, 163, 0, 0, 1614, 1616, 5, 37, 0, 0, 1615, 1614, 1, 0, 0, 0, 1616, 1619, 1, 0, 0, 0, 1617, 1615, 1, 0, 0, 0, 1617, 1618, 1, 0, 0, 0, 1618, 1621, 1, 0, 0, 0, 1619, 1617, 1, 0, 0, 0, 1620, 1613, 1, 0, 0, 0, 1621, 1622, 1, 0, 0, 0, 1622, 1620, 1, 0, 0, 0, 1622, 1623, 1, 0, 0, 0, 1623, 1624, 1, 0, 0, 0, 1624, 1625, 3, 106, 53, 0, 1625, 85, 1, 0, 0, 0, 1626, 1629, 3, 82, 41, 0, 1627, 1629, 3, 84, 42, 0, 1628, 1626, 1, 0, 0, 0, 1628, 1627, 1, 0, 0, 0, 1629, 87, 1, 0, 0, 0, 1630, 1632, 5, 36, 0, 0, 1631, 1630, 1, 0, 0, 0, 1631, 1632, 1, 0, 0, 0, 1632, 1640, 1, 0, 0, 0, 1633, 1637, 5, 163, 0, 0, 1634, 1636, 5, 37, 0, 0, 1635, 1634, 1, 0, 0, 0, 1636, 1639, 1, 0, 0, 0, 1637, 1635, 1, 0, 0, 0, 1637, 1638, 1, 0, 0, 0, 1638, 1641, 1, 0, 0, 0, 1639, 1637, 1, 0, 0, 0, 1640, 1633, 1, 0, 0, 0, 1641, 1642, 1, 0, 0, 0, 1642, 1640, 1, 0, 0, 0, 1642, 1643, 1, 0, 0, 0, 1643, 1644, 1, 0, 0, 0, 1644, 1645, 3, 112, 56, 0, 1645, 89, 1, 0, 0, 0, 1646, 1648, 5, 36, 0, 0, 1647, 1646, 1, 0, 0, 0, 1647, 1648, 1, 0, 0, 0, 1648, 1656, 1, 0, 0, 0, 1649, 1653, 5, 163, 0, 0, 1650, 1652, 5, 37, 0, 0, 1651, 1650, 1, 0, 0, 0, 1652, 1655, 1, 0, 0, 0, 1653, 1651, 1, 0, 0, 0, 1653, 1654, 1, 0, 0, 0, 1654, 1657, 1, 0, 0, 0, 1655, 1653, 1, 0, 0, 0, 1656, 1649, 1, 0, 0, 0, 1657, 1658, 1, 0, 0, 0, 1658, 1656, 1, 0, 0, 0, 1658, 1659, 1, 0, 0, 0, 1659, 1660, 1, 0, 0, 0, 1660, 1661, 3, 114, 57, 0, 1661, 91, 1, 0, 0, 0, 1662, 1664, 5, 36, 0, 0, 1663, 1662, 1, 0, 0, 0, 1663, 1664, 1, 0, 0, 0, 1664, 1672, 1, 0, 0, 0, 1665, 1669, 5, 163, 0, 0, 1666, 1668, 5, 37, 0, 0, 1667, 1666, 1, 0, 0, 0, 1668, 1671, 1, 0, 0, 0, 1669, 1667, 1, 0, 0, 0, 1669, 1670, 1, 0, 0, 0, 1670, 1673, 1, 0, 0, 0, 1671, 1669, 1, 0, 0, 0, 1672, 1665, 1, 0, 0, 0, 1673, 1674, 1, 0, 0, 0, 1674, 1672, 1, 0, 0, 0, 1674, 1675, 1, 0, 0, 0, 1675, 1676, 1, 0, 0, 0, 1676, 1677, 3, 116, 58, 0, 1677, 93, 1, 0, 0, 0, 1678, 1683, 3, 86, 43, 0, 1679, 1683, 3, 88, 44, 0, 1680, 1683, 3, 90, 45, 0, 1681, 1683, 3, 92, 46, 0, 1682, 1678, 1, 0, 0, 0, 1682, 1679, 1, 0, 0, 0, 1682, 1680, 1, 0, 0, 0, 1682, 1681, 1, 0, 0, 0, 1683, 95, 1, 0, 0, 0, 1684, 1686, 5, 36, 0, 0, 1685, 1684, 1, 0, 0, 0, 1685, 1686, 1, 0, 0, 0, 1686, 1694, 1, 0, 0, 0, 1687, 1691, 5, 163, 0, 0, 1688, 1690, 5, 37, 0, 0, 1689, 1688, 1, 0, 0, 0, 1690, 1693, 1, 0, 0, 0, 1691, 1689, 1, 0, 0, 0, 1691, 1692, 1, 0, 0, 0, 1692, 1695, 1, 0, 0, 0, 1693, 1691, 1, 0, 0, 0, 1694, 1687, 1, 0, 0, 0, 1695, 1696, 1, 0, 0, 0, 1696, 1694, 1, 0, 0, 0, 1696, 1697, 1, 0, 0, 0, 1697, 1698, 1, 0, 0, 0, 1698, 1699, 5, 38, 0, 0, 1699, 97, 1, 0, 0, 0, 1700, 1708, 5, 39, 0, 0, 1701, 1705, 3, 102, 51, 0, 1702, 1704, 5, 37, 0, 0, 1703, 1702, 1, 0, 0, 0, 1704, 1707, 1, 0, 0, 0, 1705, 1703, 1, 0, 0, 0, 1705, 1706, 1, 0, 0, 0, 1706, 1709, 1, 0, 0, 0, 1707, 1705, 1, 0, 0, 0, 1708, 1701, 1, 0, 0, 0, 1709, 1710, 1, 0, 0, 0, 1710, 1708, 1, 0, 0, 0, 1710, 1711, 1, 0, 0, 0, 1711, 99, 1, 0, 0, 0, 1712, 1720, 5, 40, 0, 0, 1713, 1717, 3, 102, 51, 0, 1714, 1716, 5, 37, 0, 0, 1715, 1714, 1, 0, 0, 0, 1716, 1719, 1, 0, 0, 0, 1717, 1715, 1, 0, 0, 0, 1717, 1718, 1, 0, 0, 0, 1718, 1721, 1, 0, 0, 0, 1719, 1717, 1, 0, 0, 0, 1720, 1713, 1, 0, 0, 0, 1721, 1722, 1, 0, 0, 0, 1722, 1720, 1, 0, 0, 0, 1722, 1723, 1, 0, 0, 0, 1723, 101, 1, 0, 0, 0, 1724, 1725, 7, 2, 0, 0, 1725, 103, 1, 0, 0, 0, 1726, 1727, 7, 3, 0, 0, 1727, 105, 1, 0, 0, 0, 1728, 1729, 7, 4, 0, 0, 1729, 107, 1, 0, 0, 0, 1730, 1731, 7, 5, 0, 0, 1731, 109, 1, 0, 0, 0, 1732, 1735, 3, 106, 53, 0, 1733, 1735, 3, 108, 54, 0, 1734, 1732, 1, 0, 0, 0, 1734, 1733, 1, 0, 0, 0, 1735, 111, 1, 0, 0, 0, 1736, 1737, 5, 84, 0, 0, 1737, 113, 1, 0, 0, 0, 1738, 1739, 5, 85, 0, 0, 1739, 115, 1, 0, 0, 0, 1740, 1741, 5, 86, 0, 0, 1741, 117, 1, 0, 0, 0, 1742, 1747, 3, 110, 55, 0, 1743, 1747, 3, 112, 56, 0, 1744, 1747, 3, 114, 57, 0, 1745, 1747, 3, 116, 58, 0, 1746, 1742, 1, 0, 0, 0, 1746, 1743, 1, 0, 0, 0, 1746, 1744, 1, 0, 0, 0, 1746, 1745, 1, 0, 0, 0, 1747, 119, 1, 0, 0, 0, 1748, 1749, 5, 87, 0, 0, 1749, 121, 1, 0, 0, 0, 1750, 1751, 5, 88, 0, 0, 1751, 123, 1, 0, 0, 0, 1752, 1753, 5, 89, 0, 0, 1753, 125, 1, 0, 0, 0, 1754, 1759, 3, 118, 59, 0, 1755, 1759, 3, 120, 60, 0, 1756, 1759, 3, 124, 62, 0, 1757, 1759, 3, 122, 61, 0, 1758, 1754, 1, 0, 0, 0, 1758, 1755, 1, 0, 0, 0, 1758, 1756, 1, 0, 0, 0, 1758, 1757, 1, 0, 0, 0, 1759, 127, 1, 0, 0, 0, 1760, 1764, 5, 20, 0, 0, 1761, 1763, 5, 167, 0, 0, 1762, 1761, 1, 0, 0, 0, 1763, 1766, 1, 0, 0, 0, 1764, 1762, 1, 0, 0, 0, 1764, 1765, 1, 0, 0, 0, 1765, 1767, 1, 0, 0, 0, 1766, 1764, 1, 0, 0, 0, 1767, 1771, 3, 130, 65, 0, 1768, 1770, 5, 167, 0, 0, 1769, 1768, 1, 0, 0, 0, 1770, 1773, 1, 0, 0, 0, 1771, 1769, 1, 0, 0, 0, 1771, 1772, 1, 0, 0, 0, 1772, 1774, 1, 0, 0, 0, 1773, 1771, 1, 0, 0, 0, 1774, 1778, 5, 2, 0, 0, 1775, 1777, 5, 167, 0, 0, 1776, 1775, 1, 0, 0, 0, 1777, 1780, 1, 0, 0, 0, 1778, 1776, 1, 0, 0, 0, 1778, 1779, 1, 0, 0, 0, 1779, 1781, 1, 0, 0, 0, 1780, 1778, 1, 0, 0, 0, 1781, 1785, 3, 96, 48, 0, 1782, 1784, 5, 167, 0, 0, 1783, 1782, 1, 0, 0, 0, 1784, 1787, 1, 0, 0, 0, 1785, 1783, 1, 0, 0, 0, 1785, 1786, 1, 0, 0, 0, 1786, 1788, 1, 0, 0, 0, 1787, 1785, 1, 0, 0, 0, 1788, 1789, 5, 21, 0, 0, 1789, 129, 1, 0, 0, 0, 1790, 1794, 3, 126, 63, 0, 1791, 1794, 3, 128, 64, 0, 1792, 1794, 3, 170, 85, 0, 1793, 1790, 1, 0, 0, 0, 1793, 1791, 1, 0, 0, 0, 1793, 1792, 1, 0, 0, 0, 1794, 131, 1, 0, 0, 0, 1795, 1796, 3, 130, 65, 0, 1796, 1797, 5, 90, 0, 0, 1797, 1814, 1, 0, 0, 0, 1798, 1799, 3, 130, 65, 0, 1799, 1800, 5, 91, 0, 0, 1800, 1814, 1, 0, 0, 0, 1801, 1802, 3, 130, 65, 0, 1802, 1803, 5, 92, 0, 0, 1803, 1814, 1, 0, 0, 0, 1804, 1805, 3, 170, 85, 0, 1805, 1806, 5, 93, 0, 0, 1806, 1814, 1, 0, 0, 0, 1807, 1808, 3, 164, 82, 0, 1808, 1809, 5, 93, 0, 0, 1809, 1814, 1, 0, 0, 0, 1810, 1811, 3, 164, 82, 0, 1811, 1812, 5, 94, 0, 0, 1812, 1814, 1, 0, 0, 0, 1813, 1795, 1, 0, 0, 0, 1813, 1798, 1, 0, 0, 0, 1813, 1801, 1, 0, 0, 0, 1813, 1804, 1, 0, 0, 0, 1813, 1807, 1, 0, 0, 0, 1813, 1810, 1, 0, 0, 0, 1814, 133, 1, 0, 0, 0, 1815, 1816, 3, 130, 65, 0, 1816, 1817, 5, 91, 0, 0, 1817, 135, 1, 0, 0, 0, 1818, 1819, 3, 130, 65, 0, 1819, 1820, 5, 91, 0, 0, 1820, 1825, 1, 0, 0, 0, 1821, 1822, 3, 164, 82, 0, 1822, 1823, 5, 94, 0, 0, 1823, 1825, 1, 0, 0, 0, 1824, 1818, 1, 0, 0, 0, 1824, 1821, 1, 0, 0, 0, 1825, 137, 1, 0, 0, 0, 1826, 1827, 3, 130, 65, 0, 1827, 1828, 7, 6, 0, 0, 1828, 139, 1, 0, 0, 0, 1829, 1830, 3, 164, 82, 0, 1830, 1831, 5, 94, 0, 0, 1831, 1840, 1, 0, 0, 0, 1832, 1833, 3, 164, 82, 0, 1833, 1834, 5, 93, 0, 0, 1834, 1840, 1, 0, 0, 0, 1835, 1836, 3, 170, 85, 0, 1836, 1837, 5, 93, 0, 0, 1837, 1840, 1, 0, 0, 0, 1838, 1840, 3, 130, 65, 0, 1839, 1829, 1, 0, 0, 0, 1839, 1832, 1, 0, 0, 0, 1839, 1835, 1, 0, 0, 0, 1839, 1838, 1, 0, 0, 0, 1840, 141, 1, 0, 0, 0, 1841, 1842, 3, 144, 72, 0, 1842, 1843, 5, 95, 0, 0, 1843, 1844, 3, 146, 73, 0, 1844, 143, 1, 0, 0, 0, 1845, 1846, 3, 172, 86, 0, 1846, 145, 1, 0, 0, 0, 1847, 1848, 3, 172, 86, 0, 1848, 147, 1, 0, 0, 0, 1849, 1851, 5, 64, 0, 0, 1850, 1852, 5, 163, 0, 0, 1851, 1850, 1, 0, 0, 0, 1852, 1853, 1, 0, 0, 0, 1853, 1851, 1, 0, 0, 0, 1853, 1854, 1, 0, 0, 0, 1854, 149, 1, 0, 0, 0, 1855, 1859, 3, 148, 74, 0, 1856, 1858, 3, 152, 76, 0, 1857, 1856, 1, 0, 0, 0, 1858, 1861, 1, 0, 0, 0, 1859, 1857, 1, 0, 0, 0, 1859, 1860, 1, 0, 0, 0, 1860, 151, 1, 0, 0, 0, 1861, 1859, 1, 0, 0, 0, 1862, 1865, 3, 154, 77, 0, 1863, 1865, 3, 156, 78, 0, 1864, 1862, 1, 0, 0, 0, 1864, 1863, 1, 0, 0, 0, 1865, 153, 1, 0, 0, 0, 1866, 1867, 5, 95, 0, 0, 1867, 1868, 3, 170, 85, 0, 1868, 155, 1, 0, 0, 0, 1869, 1870, 5, 20, 0, 0, 1870, 1871, 3, 96, 48, 0, 1871, 1872, 5, 21, 0, 0, 1872, 1881, 1, 0, 0, 0, 1873, 1875, 5, 20, 0, 0, 1874, 1876, 5, 163, 0, 0, 1875, 1874, 1, 0, 0, 0, 1876, 1877, 1, 0, 0, 0, 1877, 1875, 1, 0, 0, 0, 1877, 1878, 1, 0, 0, 0, 1878, 1879, 1, 0, 0, 0, 1879, 1881, 5, 21, 0, 0, 1880, 1869, 1, 0, 0, 0, 1880, 1873, 1, 0, 0, 0, 1881, 157, 1, 0, 0, 0, 1882, 1890, 3, 80, 40, 0, 1883, 1890, 5, 96, 0, 0, 1884, 1890, 3, 150, 75, 0, 1885, 1890, 3, 142, 71, 0, 1886, 1890, 5, 97, 0, 0, 1887, 1890, 5, 98, 0, 0, 1888, 1890, 5, 99, 0, 0, 1889, 1882, 1, 0, 0, 0, 1889, 1883, 1, 0, 0, 0, 1889, 1884, 1, 0, 0, 0, 1889, 1885, 1, 0, 0, 0, 1889, 1886, 1, 0, 0, 0, 1889, 1887, 1, 0, 0, 0, 1889, 1888, 1, 0, 0, 0, 1890, 159, 1, 0, 0, 0, 1891, 1893, 5, 168, 0, 0, 1892, 1891, 1, 0, 0, 0, 1893, 1896, 1, 0, 0, 0, 1894, 1892, 1, 0, 0, 0, 1894, 1895, 1, 0, 0, 0, 1895, 1897, 1, 0, 0, 0, 1896, 1894, 1, 0, 0, 0, 1897, 1901, 3, 170, 85, 0, 1898, 1900, 5, 167, 0, 0, 1899, 1898, 1, 0, 0, 0, 1900, 1903, 1, 0, 0, 0, 1901, 1899, 1, 0, 0, 0, 1901, 1902, 1, 0, 0, 0, 1902, 1904, 1, 0, 0, 0, 1903, 1901, 1, 0, 0, 0, 1904, 1908, 5, 7, 0, 0, 1905, 1907, 5, 167, 0, 0, 1906, 1905, 1, 0, 0, 0, 1907, 1910, 1, 0, 0, 0, 1908, 1906, 1, 0, 0, 0, 1908, 1909, 1, 0, 0, 0, 1909, 1911, 1, 0, 0, 0, 1910, 1908, 1, 0, 0, 0, 1911, 1915, 3, 130, 65, 0, 1912, 1914, 5, 167, 0, 0, 1913, 1912, 1, 0, 0, 0, 1914, 1917, 1, 0, 0, 0, 1915, 1913, 1, 0, 0, 0, 1915, 1916, 1, 0, 0, 0, 1916, 1918, 1, 0, 0, 0, 1917, 1915, 1, 0, 0, 0, 1918, 1919, 5, 2, 0, 0, 1919, 161, 1, 0, 0, 0, 1920, 1922, 5, 168, 0, 0, 1921, 1920, 1, 0, 0, 0, 1922, 1925, 1, 0, 0, 0, 1923, 1921, 1, 0, 0, 0, 1923, 1924, 1, 0, 0, 0, 1924, 1926, 1, 0, 0, 0, 1925, 1923, 1, 0, 0, 0, 1926, 1930, 3, 170, 85, 0, 1927, 1929, 5, 167, 0, 0, 1928, 1927, 1, 0, 0, 0, 1929, 1932, 1, 0, 0, 0, 1930, 1928, 1, 0, 0, 0, 1930, 1931, 1, 0, 0, 0, 1931, 1933, 1, 0, 0, 0, 1932, 1930, 1, 0, 0, 0, 1933, 1937, 5, 7, 0, 0, 1934, 1936, 5, 167, 0, 0, 1935, 1934, 1, 0, 0, 0, 1936, 1939, 1, 0, 0, 0, 1937, 1935, 1, 0, 0, 0, 1937, 1938, 1, 0, 0, 0, 1938, 1940, 1, 0, 0, 0, 1939, 1937, 1, 0, 0, 0, 1940, 1944, 3, 138, 69, 0, 1941, 1943, 5, 167, 0, 0, 1942, 1941, 1, 0, 0, 0, 1943, 1946, 1, 0, 0, 0, 1944, 1942, 1, 0, 0, 0, 1944, 1945, 1, 0, 0, 0, 1945, 1947, 1, 0, 0, 0, 1946, 1944, 1, 0, 0, 0, 1947, 1948, 5, 2, 0, 0, 1948, 163, 1, 0, 0, 0, 1949, 1950, 3, 142, 71, 0, 1950, 1951, 5, 100, 0, 0, 1951, 1952, 3, 170, 85, 0, 1952, 165, 1, 0, 0, 0, 1953, 1958, 3, 140, 70, 0, 1954, 1958, 3, 164, 82, 0, 1955, 1958, 5, 101, 0, 0, 1956, 1958, 5, 102, 0, 0, 1957, 1953, 1, 0, 0, 0, 1957, 1954, 1, 0, 0, 0, 1957, 1955, 1, 0, 0, 0, 1957, 1956, 1, 0, 0, 0, 1958, 167, 1, 0, 0, 0, 1959, 1960, 3, 170, 85, 0, 1960, 169, 1, 0, 0, 0, 1961, 1965, 5, 160, 0, 0, 1962, 1964, 7, 7, 0, 0, 1963, 1962, 1, 0, 0, 0, 1964, 1967, 1, 0, 0, 0, 1965, 1963, 1, 0, 0, 0, 1965, 1966, 1, 0, 0, 0, 1966, 171, 1, 0, 0, 0, 1967, 1965, 1, 0, 0, 0, 1968, 1972, 5, 162, 0, 0, 1969, 1971, 7, 8, 0, 0, 1970, 1969, 1, 0, 0, 0, 1971, 1974, 1, 0, 0, 0, 1972, 1970, 1, 0, 0, 0, 1972, 1973, 1, 0, 0, 0, 1973, 173, 1, 0, 0, 0, 1974, 1972, 1, 0, 0, 0, 1975, 1976, 7, 9, 0, 0, 1976, 175, 1, 0, 0, 0, 1977, 1978, 7, 10, 0, 0, 1978, 177, 1, 0, 0, 0, 1979, 1980, 7, 11, 0, 0, 1980, 179, 1, 0, 0, 0, 1981, 1982, 7, 12, 0, 0, 1982, 181, 1, 0, 0, 0, 1983, 1984, 5, 141, 0, 0, 1984, 1988, 7, 13, 0, 0, 1985, 1986, 5, 146, 0, 0, 1986, 1988, 7, 14, 0, 0, 1987, 1983, 1, 0, 0, 0, 1987, 1985, 1, 0, 0, 0, 1988, 183, 1, 0, 0, 0, 1989, 1990, 5, 149, 0, 0, 1990, 2000, 7, 13, 0, 0, 1991, 1992, 5, 150, 0, 0, 1992, 2000, 7, 14, 0, 0, 1993, 1994, 5, 151, 0, 0, 1994, 2000, 7, 15, 0, 0, 1995, 1996, 5, 152, 0, 0, 1996, 2000, 7, 16, 0, 0, 1997, 1998, 5, 154, 0, 0, 1998, 2000, 7, 16, 0, 0, 1999, 1989, 1, 0, 0, 0, 1999, 1991, 1, 0, 0, 0, 1999, 1993, 1, 0, 0, 0, 1999, 1995, 1, 0, 0, 0, 1999, 1997, 1, 0, 0, 0, 2000, 185, 1, 0, 0, 0, 2001, 2002, 5, 155, 0, 0, 2002, 2003, 7, 15, 0, 0, 2003, 187, 1, 0, 0, 0, 2004, 2005, 7, 17, 0, 0, 2005, 189, 1, 0, 0, 0, 2006, 2007, 7, 18, 0, 0, 2007, 191, 1, 0, 0, 0, 254, 197, 203, 210, 217, 226, 228, 233, 239, 246, 253, 261, 268, 275, 285, 292, 299, 306, 314, 321, 328, 335, 343, 350, 357, 364, 369, 376, 383, 390, 397, 404, 411, 418, 424, 431, 438, 445, 451, 456, 462, 469, 476, 483, 490, 498, 505, 512, 519, 526, 534, 541, 548, 555, 561, 567, 571, 576, 583, 590, 597, 604, 612, 619, 626, 633, 640, 648, 655, 662, 669, 675, 680, 687, 694, 701, 708, 723, 728, 735, 743, 750, 757, 764, 771, 779, 786, 794, 801, 808, 815, 822, 830, 837, 845, 852, 859, 866, 873, 880, 888, 895, 902, 909, 917, 924, 931, 939, 946, 954, 961, 968, 976, 983, 989, 995, 1002, 1009, 1016, 1023, 1028, 1036, 1043, 1050, 1058, 1065, 1071, 1078, 1085, 1092, 1099, 1107, 1114, 1121, 1129, 1143, 1148, 1157, 1164, 1171, 1180, 1187, 1194, 1201, 1210, 1217, 1224, 1231, 1238, 1247, 1254, 1261, 1268, 1277, 1284, 1293, 1300, 1307, 1314, 1321, 1328, 1334, 1340, 1347, 1354, 1361, 1368, 1376, 1382, 1389, 1396, 1403, 1410, 1417, 1425, 1429, 1435, 1442, 1449, 1456, 1463, 1472, 1478, 1483, 1490, 1497, 1504, 1513, 1518, 1523, 1529, 1535, 1543, 1545, 1550, 1557, 1564, 1570, 1576, 1583, 1592, 1595, 1601, 1606, 1611, 1617, 1622, 1628, 1631, 1637, 1642, 1647, 1653, 1658, 1663, 1669, 1674, 1682, 1685, 1691, 1696, 1705, 1710, 1717, 1722, 1734, 1746, 1758, 1764, 1771, 1778, 1785, 1793, 1813, 1824, 1839, 1853, 1859, 1864, 1877, 1880, 1889, 1894, 1901, 1908, 1915, 1923, 1930, 1937, 1944, 1957, 1965, 1972, 1987, 1999] \ No newline at end of file diff --git a/vanguard/aleo/parser/.antlr/aleo.tokens b/vanguard/aleo/parser/.antlr/aleo.tokens new file mode 100644 index 0000000..2ebee3f --- /dev/null +++ b/vanguard/aleo/parser/.antlr/aleo.tokens @@ -0,0 +1,327 @@ +T__0=1 +T__1=2 +T__2=3 +T__3=4 +T__4=5 +T__5=6 +T__6=7 +T__7=8 +T__8=9 +T__9=10 +T__10=11 +T__11=12 +T__12=13 +T__13=14 +T__14=15 +T__15=16 +T__16=17 +T__17=18 +T__18=19 +T__19=20 +T__20=21 +T__21=22 +T__22=23 +T__23=24 +T__24=25 +T__25=26 +T__26=27 +T__27=28 +T__28=29 +T__29=30 +T__30=31 +T__31=32 +T__32=33 +T__33=34 +T__34=35 +T__35=36 +T__36=37 +T__37=38 +T__38=39 +T__39=40 +T__40=41 +T__41=42 +T__42=43 +T__43=44 +T__44=45 +T__45=46 +T__46=47 +T__47=48 +T__48=49 +T__49=50 +T__50=51 +T__51=52 +T__52=53 +T__53=54 +T__54=55 +T__55=56 +T__56=57 +T__57=58 +T__58=59 +T__59=60 +T__60=61 +T__61=62 +T__62=63 +T__63=64 +T__64=65 +T__65=66 +T__66=67 +T__67=68 +T__68=69 +T__69=70 +T__70=71 +T__71=72 +T__72=73 +T__73=74 +T__74=75 +T__75=76 +T__76=77 +T__77=78 +T__78=79 +T__79=80 +T__80=81 +T__81=82 +T__82=83 +T__83=84 +T__84=85 +T__85=86 +T__86=87 +T__87=88 +T__88=89 +T__89=90 +T__90=91 +T__91=92 +T__92=93 +T__93=94 +T__94=95 +T__95=96 +T__96=97 +T__97=98 +T__98=99 +T__99=100 +T__100=101 +T__101=102 +T__102=103 +T__103=104 +T__104=105 +T__105=106 +T__106=107 +T__107=108 +T__108=109 +T__109=110 +T__110=111 +T__111=112 +T__112=113 +T__113=114 +T__114=115 +T__115=116 +T__116=117 +T__117=118 +T__118=119 +T__119=120 +T__120=121 +T__121=122 +T__122=123 +T__123=124 +T__124=125 +T__125=126 +T__126=127 +T__127=128 +T__128=129 +T__129=130 +T__130=131 +T__131=132 +T__132=133 +T__133=134 +T__134=135 +T__135=136 +T__136=137 +T__137=138 +T__138=139 +T__139=140 +T__140=141 +T__141=142 +T__142=143 +T__143=144 +T__144=145 +T__145=146 +T__146=147 +T__147=148 +T__148=149 +T__149=150 +T__150=151 +T__151=152 +T__152=153 +T__153=154 +T__154=155 +T__155=156 +T__156=157 +T__157=158 +T__158=159 +Letter=160 +UL=161 +LL=162 +DIGIT=163 +COMMENT=164 +BLOCK_COMMENT=165 +LINE_COMMENT=166 +WS=167 +CWS=168 +'program'=1 +';'=2 +'import'=3 +'mapping'=4 +':'=5 +'key'=6 +'as'=7 +'value'=8 +'struct'=9 +'record'=10 +'owner'=11 +'address.public'=12 +'address.private'=13 +'closure'=14 +'input'=15 +'output'=16 +'function'=17 +'finalize'=18 +'contains'=19 +'['=20 +']'=21 +'into'=22 +'get'=23 +'get.or_use'=24 +'set'=25 +'remove'=26 +'rand.chacha'=27 +'position'=28 +'to'=29 +'await'=30 +'ternary'=31 +'sign.verify'=32 +'sign_verify'=33 +'call'=34 +'async'=35 +'-'=36 +'_'=37 +'u32'=38 +'aleo1'=39 +'sign1'=40 +'0'=41 +'2'=42 +'3'=43 +'4'=44 +'5'=45 +'6'=46 +'7'=47 +'8'=48 +'9'=49 +'a'=50 +'c'=51 +'d'=52 +'e'=53 +'f'=54 +'g'=55 +'h'=56 +'j'=57 +'k'=58 +'l'=59 +'m'=60 +'n'=61 +'p'=62 +'q'=63 +'r'=64 +'s'=65 +'t'=66 +'u'=67 +'v'=68 +'w'=69 +'x'=70 +'y'=71 +'z'=72 +'true'=73 +'false'=74 +'u8'=75 +'u16'=76 +'u64'=77 +'u128'=78 +'i8'=79 +'i16'=80 +'i32'=81 +'i64'=82 +'i128'=83 +'field'=84 +'group'=85 +'scalar'=86 +'address'=87 +'boolean'=88 +'signature'=89 +'.constant'=90 +'.public'=91 +'.private'=92 +'.record'=93 +'.future'=94 +'.'=95 +'group::GEN'=96 +'self.signer'=97 +'self.caller'=98 +'block.height'=99 +'/'=100 +'group.x'=101 +'group.y'=102 +'abs'=103 +'abs.w'=104 +'double'=105 +'inv'=106 +'neg'=107 +'not'=108 +'square'=109 +'sqrt'=110 +'add'=111 +'add.w'=112 +'sub'=113 +'sub.w'=114 +'mul'=115 +'mul.w'=116 +'div'=117 +'div.w'=118 +'rem'=119 +'rem.w'=120 +'pow'=121 +'pow.w'=122 +'shl'=123 +'shl.w'=124 +'shr'=125 +'shr.w'=126 +'mod'=127 +'and'=128 +'or'=129 +'xor'=130 +'nand'=131 +'nor'=132 +'gt'=133 +'gte'=134 +'lt'=135 +'lte'=136 +'is.eq'=137 +'is.neq'=138 +'assert.eq'=139 +'assert.neq'=140 +'commit.bhp'=141 +'256'=142 +'512'=143 +'768'=144 +'1024'=145 +'commit.ped'=146 +'64'=147 +'128'=148 +'hash.bhp'=149 +'hash.ped'=150 +'hash.psd'=151 +'hash.keccak'=152 +'384'=153 +'hash.sha3_'=154 +'hash_many.psd'=155 +'cast'=156 +'cast.lossy'=157 +'branch.eq'=158 +'branch.neq'=159 diff --git a/vanguard/aleo/parser/.antlr/aleoParser.java b/vanguard/aleo/parser/.antlr/aleoParser.java new file mode 100644 index 0000000..3f25aed --- /dev/null +++ b/vanguard/aleo/parser/.antlr/aleoParser.java @@ -0,0 +1,10142 @@ +// Generated from /Users/joseph/Desktop/UCSB/24winter/vanguard-aleo/vanguard/aleo/parser/aleo.g4 by ANTLR 4.13.1 +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"}) +public class aleoParser extends Parser { + static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, + T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, + T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, + T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31, + T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38, + T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, T__44=45, + T__45=46, T__46=47, T__47=48, T__48=49, T__49=50, T__50=51, T__51=52, + T__52=53, T__53=54, T__54=55, T__55=56, T__56=57, T__57=58, T__58=59, + T__59=60, T__60=61, T__61=62, T__62=63, T__63=64, T__64=65, T__65=66, + T__66=67, T__67=68, T__68=69, T__69=70, T__70=71, T__71=72, T__72=73, + T__73=74, T__74=75, T__75=76, T__76=77, T__77=78, T__78=79, T__79=80, + T__80=81, T__81=82, T__82=83, T__83=84, T__84=85, T__85=86, T__86=87, + T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, T__92=93, T__93=94, + T__94=95, T__95=96, T__96=97, T__97=98, T__98=99, T__99=100, T__100=101, + T__101=102, T__102=103, T__103=104, T__104=105, T__105=106, T__106=107, + T__107=108, T__108=109, T__109=110, T__110=111, T__111=112, T__112=113, + T__113=114, T__114=115, T__115=116, T__116=117, T__117=118, T__118=119, + T__119=120, T__120=121, T__121=122, T__122=123, T__123=124, T__124=125, + T__125=126, T__126=127, T__127=128, T__128=129, T__129=130, T__130=131, + T__131=132, T__132=133, T__133=134, T__134=135, T__135=136, T__136=137, + T__137=138, T__138=139, T__139=140, T__140=141, T__141=142, T__142=143, + T__143=144, T__144=145, T__145=146, T__146=147, T__147=148, T__148=149, + T__149=150, T__150=151, T__151=152, T__152=153, T__153=154, T__154=155, + T__155=156, T__156=157, T__157=158, T__158=159, Letter=160, UL=161, LL=162, + DIGIT=163, COMMENT=164, BLOCK_COMMENT=165, LINE_COMMENT=166, WS=167, CWS=168; + public static final int + RULE_start = 0, RULE_program = 1, RULE_ximport = 2, RULE_mapping = 3, + RULE_mapping_key = 4, RULE_mapping_value = 5, RULE_struct = 6, RULE_record = 7, + RULE_closure = 8, RULE_closure_input = 9, RULE_closure_output = 10, RULE_function = 11, + RULE_function_input = 12, RULE_function_output = 13, RULE_finalize = 14, + RULE_finalize_input = 15, RULE_command = 16, RULE_contains = 17, RULE_get = 18, + RULE_get_or_use = 19, RULE_set = 20, RULE_remove = 21, RULE_random = 22, + RULE_position = 23, RULE_branch = 24, RULE_xawait = 25, RULE_instruction = 26, + RULE_unary = 27, RULE_binary = 28, RULE_ternary = 29, RULE_is = 30, RULE_assert = 31, + RULE_commit = 32, RULE_hash1 = 33, RULE_hash2 = 34, RULE_hash = 35, RULE_signverify = 36, + RULE_cast = 37, RULE_call = 38, RULE_xasync = 39, RULE_literal = 40, RULE_signed_literal = 41, + RULE_unsigned_literal = 42, RULE_integer_literal = 43, RULE_field_literal = 44, + RULE_group_literal = 45, RULE_scalar_literal = 46, RULE_arithmetic_literal = 47, + RULE_u32_literal = 48, RULE_address_literal = 49, RULE_signature_literal = 50, + RULE_address_or_signature_char = 51, RULE_boolean_literal = 52, RULE_unsigned_type = 53, + RULE_signed_type = 54, RULE_integer_type = 55, RULE_field_type = 56, RULE_group_type = 57, + RULE_scalar_type = 58, RULE_arithmetic_type = 59, RULE_address_type = 60, + RULE_boolean_type = 61, RULE_signature_type = 62, RULE_literal_type = 63, + RULE_array_type = 64, RULE_plaintext_type = 65, RULE_value_type = 66, + RULE_mapping_type = 67, RULE_finalize_type = 68, RULE_entry_type = 69, + RULE_register_type = 70, RULE_program_id = 71, RULE_program_name = 72, + RULE_program_domain = 73, RULE_register = 74, RULE_register_access = 75, + RULE_register_accessor = 76, RULE_access_by_field = 77, RULE_access_by_index = 78, + RULE_operand = 79, RULE_tuple = 80, RULE_entry = 81, RULE_locator = 82, + RULE_cast_destination = 83, RULE_label = 84, RULE_identifier = 85, RULE_lowercase_identifier = 86, + RULE_unary_op = 87, RULE_binary_op = 88, RULE_is_op = 89, RULE_assert_op = 90, + RULE_commit_op = 91, RULE_hash1_op = 92, RULE_hash2_op = 93, RULE_cast_op = 94, + RULE_branch_op = 95; + private static String[] makeRuleNames() { + return new String[] { + "start", "program", "ximport", "mapping", "mapping_key", "mapping_value", + "struct", "record", "closure", "closure_input", "closure_output", "function", + "function_input", "function_output", "finalize", "finalize_input", "command", + "contains", "get", "get_or_use", "set", "remove", "random", "position", + "branch", "xawait", "instruction", "unary", "binary", "ternary", "is", + "assert", "commit", "hash1", "hash2", "hash", "signverify", "cast", "call", + "xasync", "literal", "signed_literal", "unsigned_literal", "integer_literal", + "field_literal", "group_literal", "scalar_literal", "arithmetic_literal", + "u32_literal", "address_literal", "signature_literal", "address_or_signature_char", + "boolean_literal", "unsigned_type", "signed_type", "integer_type", "field_type", + "group_type", "scalar_type", "arithmetic_type", "address_type", "boolean_type", + "signature_type", "literal_type", "array_type", "plaintext_type", "value_type", + "mapping_type", "finalize_type", "entry_type", "register_type", "program_id", + "program_name", "program_domain", "register", "register_access", "register_accessor", + "access_by_field", "access_by_index", "operand", "tuple", "entry", "locator", + "cast_destination", "label", "identifier", "lowercase_identifier", "unary_op", + "binary_op", "is_op", "assert_op", "commit_op", "hash1_op", "hash2_op", + "cast_op", "branch_op" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, "'program'", "';'", "'import'", "'mapping'", "':'", "'key'", "'as'", + "'value'", "'struct'", "'record'", "'owner'", "'address.public'", "'address.private'", + "'closure'", "'input'", "'output'", "'function'", "'finalize'", "'contains'", + "'['", "']'", "'into'", "'get'", "'get.or_use'", "'set'", "'remove'", + "'rand.chacha'", "'position'", "'to'", "'await'", "'ternary'", "'sign.verify'", + "'sign_verify'", "'call'", "'async'", "'-'", "'_'", "'u32'", "'aleo1'", + "'sign1'", "'0'", "'2'", "'3'", "'4'", "'5'", "'6'", "'7'", "'8'", "'9'", + "'a'", "'c'", "'d'", "'e'", "'f'", "'g'", "'h'", "'j'", "'k'", "'l'", + "'m'", "'n'", "'p'", "'q'", "'r'", "'s'", "'t'", "'u'", "'v'", "'w'", + "'x'", "'y'", "'z'", "'true'", "'false'", "'u8'", "'u16'", "'u64'", "'u128'", + "'i8'", "'i16'", "'i32'", "'i64'", "'i128'", "'field'", "'group'", "'scalar'", + "'address'", "'boolean'", "'signature'", "'.constant'", "'.public'", + "'.private'", "'.record'", "'.future'", "'.'", "'group::GEN'", "'self.signer'", + "'self.caller'", "'block.height'", "'/'", "'group.x'", "'group.y'", "'abs'", + "'abs.w'", "'double'", "'inv'", "'neg'", "'not'", "'square'", "'sqrt'", + "'add'", "'add.w'", "'sub'", "'sub.w'", "'mul'", "'mul.w'", "'div'", + "'div.w'", "'rem'", "'rem.w'", "'pow'", "'pow.w'", "'shl'", "'shl.w'", + "'shr'", "'shr.w'", "'mod'", "'and'", "'or'", "'xor'", "'nand'", "'nor'", + "'gt'", "'gte'", "'lt'", "'lte'", "'is.eq'", "'is.neq'", "'assert.eq'", + "'assert.neq'", "'commit.bhp'", "'256'", "'512'", "'768'", "'1024'", + "'commit.ped'", "'64'", "'128'", "'hash.bhp'", "'hash.ped'", "'hash.psd'", + "'hash.keccak'", "'384'", "'hash.sha3_'", "'hash_many.psd'", "'cast'", + "'cast.lossy'", "'branch.eq'", "'branch.neq'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, "Letter", "UL", "LL", "DIGIT", "COMMENT", "BLOCK_COMMENT", + "LINE_COMMENT", "WS", "CWS" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getGrammarFileName() { return "aleo.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public aleoParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @SuppressWarnings("CheckReturnValue") + public static class StartContext extends ParserRuleContext { + public ProgramContext program() { + return getRuleContext(ProgramContext.class,0); + } + public StartContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_start; } + } + + public final StartContext start() throws RecognitionException { + StartContext _localctx = new StartContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_start); + try { + enterOuterAlt(_localctx, 1); + { + setState(192); + program(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ProgramContext extends ParserRuleContext { + public Program_idContext program_id() { + return getRuleContext(Program_idContext.class,0); + } + public List ximport() { + return getRuleContexts(XimportContext.class); + } + public XimportContext ximport(int i) { + return getRuleContext(XimportContext.class,i); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public List mapping() { + return getRuleContexts(MappingContext.class); + } + public MappingContext mapping(int i) { + return getRuleContext(MappingContext.class,i); + } + public List struct() { + return getRuleContexts(StructContext.class); + } + public StructContext struct(int i) { + return getRuleContext(StructContext.class,i); + } + public List record() { + return getRuleContexts(RecordContext.class); + } + public RecordContext record(int i) { + return getRuleContext(RecordContext.class,i); + } + public List closure() { + return getRuleContexts(ClosureContext.class); + } + public ClosureContext closure(int i) { + return getRuleContext(ClosureContext.class,i); + } + public List function() { + return getRuleContexts(FunctionContext.class); + } + public FunctionContext function(int i) { + return getRuleContext(FunctionContext.class,i); + } + public ProgramContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_program; } + } + + public final ProgramContext program() throws RecognitionException { + ProgramContext _localctx = new ProgramContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_program); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(197); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,0,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(194); + ximport(); + } + } + } + setState(199); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,0,_ctx); + } + setState(203); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(200); + match(CWS); + } + } + setState(205); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(206); + match(T__0); + setState(210); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(207); + match(WS); + } + } + setState(212); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(213); + program_id(); + setState(217); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(214); + match(WS); + } + } + setState(219); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(220); + match(T__1); + setState(226); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + setState(226); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) { + case 1: + { + setState(221); + mapping(); + } + break; + case 2: + { + setState(222); + struct(); + } + break; + case 3: + { + setState(223); + record(); + } + break; + case 4: + { + setState(224); + closure(); + } + break; + case 5: + { + setState(225); + function(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(228); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,5,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(233); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(230); + match(CWS); + } + } + setState(235); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class XimportContext extends ParserRuleContext { + public Program_idContext program_id() { + return getRuleContext(Program_idContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public XimportContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ximport; } + } + + public final XimportContext ximport() throws RecognitionException { + XimportContext _localctx = new XimportContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_ximport); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(239); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(236); + match(CWS); + } + } + setState(241); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(242); + match(T__2); + setState(246); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(243); + match(WS); + } + } + setState(248); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(249); + program_id(); + setState(253); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(250); + match(WS); + } + } + setState(255); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(256); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class MappingContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Mapping_keyContext mapping_key() { + return getRuleContext(Mapping_keyContext.class,0); + } + public Mapping_valueContext mapping_value() { + return getRuleContext(Mapping_valueContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public MappingContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_mapping; } + } + + public final MappingContext mapping() throws RecognitionException { + MappingContext _localctx = new MappingContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_mapping); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(261); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(258); + match(CWS); + } + } + setState(263); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(264); + match(T__3); + setState(268); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(265); + match(WS); + } + } + setState(270); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(271); + identifier(); + setState(275); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(272); + match(WS); + } + } + setState(277); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(278); + match(T__4); + setState(279); + mapping_key(); + setState(280); + mapping_value(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Mapping_keyContext extends ParserRuleContext { + public Mapping_typeContext mapping_type() { + return getRuleContext(Mapping_typeContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public Mapping_keyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_mapping_key; } + } + + public final Mapping_keyContext mapping_key() throws RecognitionException { + Mapping_keyContext _localctx = new Mapping_keyContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_mapping_key); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(285); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(282); + match(CWS); + } + } + setState(287); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(288); + match(T__5); + setState(292); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(289); + match(WS); + } + } + setState(294); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(295); + match(T__6); + setState(299); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(296); + match(WS); + } + } + setState(301); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(302); + mapping_type(); + setState(306); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(303); + match(WS); + } + } + setState(308); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(309); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Mapping_valueContext extends ParserRuleContext { + public Mapping_typeContext mapping_type() { + return getRuleContext(Mapping_typeContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public Mapping_valueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_mapping_value; } + } + + public final Mapping_valueContext mapping_value() throws RecognitionException { + Mapping_valueContext _localctx = new Mapping_valueContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_mapping_value); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(314); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(311); + match(CWS); + } + } + setState(316); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(317); + match(T__7); + setState(321); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(318); + match(WS); + } + } + setState(323); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(324); + match(T__6); + setState(328); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(325); + match(WS); + } + } + setState(330); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(331); + mapping_type(); + setState(335); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(332); + match(WS); + } + } + setState(337); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(338); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class StructContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public List tuple() { + return getRuleContexts(TupleContext.class); + } + public TupleContext tuple(int i) { + return getRuleContext(TupleContext.class,i); + } + public StructContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_struct; } + } + + public final StructContext struct() throws RecognitionException { + StructContext _localctx = new StructContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_struct); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(343); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(340); + match(CWS); + } + } + setState(345); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(346); + match(T__8); + setState(350); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(347); + match(WS); + } + } + setState(352); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(353); + identifier(); + setState(357); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(354); + match(WS); + } + } + setState(359); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(360); + match(T__4); + setState(362); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(361); + tuple(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(364); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,24,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RecordContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public List entry() { + return getRuleContexts(EntryContext.class); + } + public EntryContext entry(int i) { + return getRuleContext(EntryContext.class,i); + } + public RecordContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_record; } + } + + public final RecordContext record() throws RecognitionException { + RecordContext _localctx = new RecordContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_record); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(369); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(366); + match(CWS); + } + } + setState(371); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(372); + match(T__9); + setState(376); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(373); + match(WS); + } + } + setState(378); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(379); + identifier(); + setState(383); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(380); + match(WS); + } + } + setState(385); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(386); + match(T__4); + setState(390); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(387); + match(CWS); + } + } + setState(392); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(393); + match(T__10); + setState(397); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(394); + match(WS); + } + } + setState(399); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(400); + match(T__6); + setState(404); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(401); + match(WS); + } + } + setState(406); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(407); + _la = _input.LA(1); + if ( !(_la==T__11 || _la==T__12) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(411); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(408); + match(WS); + } + } + setState(413); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(414); + match(T__1); + setState(418); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,32,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(415); + entry(); + } + } + } + setState(420); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,32,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ClosureContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public List closure_input() { + return getRuleContexts(Closure_inputContext.class); + } + public Closure_inputContext closure_input(int i) { + return getRuleContext(Closure_inputContext.class,i); + } + public List instruction() { + return getRuleContexts(InstructionContext.class); + } + public InstructionContext instruction(int i) { + return getRuleContext(InstructionContext.class,i); + } + public List closure_output() { + return getRuleContexts(Closure_outputContext.class); + } + public Closure_outputContext closure_output(int i) { + return getRuleContext(Closure_outputContext.class,i); + } + public ClosureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_closure; } + } + + public final ClosureContext closure() throws RecognitionException { + ClosureContext _localctx = new ClosureContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_closure); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(424); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(421); + match(CWS); + } + } + setState(426); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(427); + match(T__13); + setState(431); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(428); + match(WS); + } + } + setState(433); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(434); + identifier(); + setState(438); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(435); + match(WS); + } + } + setState(440); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(441); + match(T__4); + setState(445); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,36,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(442); + closure_input(); + } + } + } + setState(447); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,36,_ctx); + } + setState(449); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(448); + instruction(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(451); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,37,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(456); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,38,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(453); + closure_output(); + } + } + } + setState(458); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,38,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Closure_inputContext extends ParserRuleContext { + public RegisterContext register() { + return getRuleContext(RegisterContext.class,0); + } + public Register_typeContext register_type() { + return getRuleContext(Register_typeContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public Closure_inputContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_closure_input; } + } + + public final Closure_inputContext closure_input() throws RecognitionException { + Closure_inputContext _localctx = new Closure_inputContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_closure_input); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(462); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(459); + match(CWS); + } + } + setState(464); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(465); + match(T__14); + setState(469); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(466); + match(WS); + } + } + setState(471); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(472); + register(); + setState(476); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(473); + match(WS); + } + } + setState(478); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(479); + match(T__6); + setState(483); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(480); + match(WS); + } + } + setState(485); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(486); + register_type(); + setState(490); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(487); + match(WS); + } + } + setState(492); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(493); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Closure_outputContext extends ParserRuleContext { + public OperandContext operand() { + return getRuleContext(OperandContext.class,0); + } + public Register_typeContext register_type() { + return getRuleContext(Register_typeContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public Closure_outputContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_closure_output; } + } + + public final Closure_outputContext closure_output() throws RecognitionException { + Closure_outputContext _localctx = new Closure_outputContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_closure_output); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(498); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(495); + match(CWS); + } + } + setState(500); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(501); + match(T__15); + setState(505); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(502); + match(WS); + } + } + setState(507); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(508); + operand(); + setState(512); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(509); + match(WS); + } + } + setState(514); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(515); + match(T__6); + setState(519); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(516); + match(WS); + } + } + setState(521); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(522); + register_type(); + setState(526); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(523); + match(WS); + } + } + setState(528); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(529); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FunctionContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public List function_input() { + return getRuleContexts(Function_inputContext.class); + } + public Function_inputContext function_input(int i) { + return getRuleContext(Function_inputContext.class,i); + } + public List instruction() { + return getRuleContexts(InstructionContext.class); + } + public InstructionContext instruction(int i) { + return getRuleContext(InstructionContext.class,i); + } + public List function_output() { + return getRuleContexts(Function_outputContext.class); + } + public Function_outputContext function_output(int i) { + return getRuleContext(Function_outputContext.class,i); + } + public FinalizeContext finalize() { + return getRuleContext(FinalizeContext.class,0); + } + public FunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_function; } + } + + public final FunctionContext function() throws RecognitionException { + FunctionContext _localctx = new FunctionContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_function); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(534); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(531); + match(CWS); + } + } + setState(536); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(537); + match(T__16); + setState(541); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(538); + match(WS); + } + } + setState(543); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(544); + identifier(); + setState(548); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(545); + match(WS); + } + } + setState(550); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(551); + match(T__4); + setState(555); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,52,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(552); + function_input(); + } + } + } + setState(557); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,52,_ctx); + } + setState(561); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,53,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(558); + instruction(); + } + } + } + setState(563); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,53,_ctx); + } + setState(567); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,54,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(564); + function_output(); + } + } + } + setState(569); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,54,_ctx); + } + setState(571); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { + case 1: + { + setState(570); + finalize(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Function_inputContext extends ParserRuleContext { + public RegisterContext register() { + return getRuleContext(RegisterContext.class,0); + } + public Value_typeContext value_type() { + return getRuleContext(Value_typeContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public Function_inputContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_function_input; } + } + + public final Function_inputContext function_input() throws RecognitionException { + Function_inputContext _localctx = new Function_inputContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_function_input); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(576); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(573); + match(CWS); + } + } + setState(578); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(579); + match(T__14); + setState(583); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(580); + match(WS); + } + } + setState(585); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(586); + register(); + setState(590); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(587); + match(WS); + } + } + setState(592); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(593); + match(T__6); + setState(597); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(594); + match(WS); + } + } + setState(599); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(600); + value_type(); + setState(604); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(601); + match(WS); + } + } + setState(606); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(607); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Function_outputContext extends ParserRuleContext { + public OperandContext operand() { + return getRuleContext(OperandContext.class,0); + } + public Value_typeContext value_type() { + return getRuleContext(Value_typeContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public Function_outputContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_function_output; } + } + + public final Function_outputContext function_output() throws RecognitionException { + Function_outputContext _localctx = new Function_outputContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_function_output); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(612); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(609); + match(CWS); + } + } + setState(614); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(615); + match(T__15); + setState(619); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(616); + match(WS); + } + } + setState(621); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(622); + operand(); + setState(626); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(623); + match(WS); + } + } + setState(628); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(629); + match(T__6); + setState(633); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(630); + match(WS); + } + } + setState(635); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(636); + value_type(); + setState(640); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(637); + match(WS); + } + } + setState(642); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(643); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class FinalizeContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public List finalize_input() { + return getRuleContexts(Finalize_inputContext.class); + } + public Finalize_inputContext finalize_input(int i) { + return getRuleContext(Finalize_inputContext.class,i); + } + public List command() { + return getRuleContexts(CommandContext.class); + } + public CommandContext command(int i) { + return getRuleContext(CommandContext.class,i); + } + public FinalizeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_finalize; } + } + + public final FinalizeContext finalize() throws RecognitionException { + FinalizeContext _localctx = new FinalizeContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_finalize); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(648); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(645); + match(CWS); + } + } + setState(650); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(651); + match(T__17); + setState(655); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(652); + match(WS); + } + } + setState(657); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(658); + identifier(); + setState(662); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(659); + match(WS); + } + } + setState(664); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(665); + match(T__4); + setState(669); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,69,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(666); + finalize_input(); + } + } + } + setState(671); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,69,_ctx); + } + setState(673); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(672); + command(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(675); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,70,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Finalize_inputContext extends ParserRuleContext { + public RegisterContext register() { + return getRuleContext(RegisterContext.class,0); + } + public Finalize_typeContext finalize_type() { + return getRuleContext(Finalize_typeContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public Finalize_inputContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_finalize_input; } + } + + public final Finalize_inputContext finalize_input() throws RecognitionException { + Finalize_inputContext _localctx = new Finalize_inputContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_finalize_input); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(680); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(677); + match(CWS); + } + } + setState(682); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(683); + match(T__14); + setState(687); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(684); + match(WS); + } + } + setState(689); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(690); + register(); + setState(694); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(691); + match(WS); + } + } + setState(696); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(697); + match(T__6); + setState(701); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(698); + match(WS); + } + } + setState(703); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(704); + finalize_type(); + setState(708); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(705); + match(WS); + } + } + setState(710); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(711); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CommandContext extends ParserRuleContext { + public ContainsContext contains() { + return getRuleContext(ContainsContext.class,0); + } + public GetContext get() { + return getRuleContext(GetContext.class,0); + } + public Get_or_useContext get_or_use() { + return getRuleContext(Get_or_useContext.class,0); + } + public SetContext set() { + return getRuleContext(SetContext.class,0); + } + public RemoveContext remove() { + return getRuleContext(RemoveContext.class,0); + } + public RandomContext random() { + return getRuleContext(RandomContext.class,0); + } + public PositionContext position() { + return getRuleContext(PositionContext.class,0); + } + public BranchContext branch() { + return getRuleContext(BranchContext.class,0); + } + public XawaitContext xawait() { + return getRuleContext(XawaitContext.class,0); + } + public InstructionContext instruction() { + return getRuleContext(InstructionContext.class,0); + } + public CommandContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_command; } + } + + public final CommandContext command() throws RecognitionException { + CommandContext _localctx = new CommandContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_command); + try { + setState(723); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(713); + contains(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(714); + get(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(715); + get_or_use(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(716); + set(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(717); + remove(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(718); + random(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(719); + position(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(720); + branch(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(721); + xawait(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(722); + instruction(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ContainsContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public OperandContext operand() { + return getRuleContext(OperandContext.class,0); + } + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public ContainsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_contains; } + } + + public final ContainsContext contains() throws RecognitionException { + ContainsContext _localctx = new ContainsContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_contains); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(728); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(725); + match(CWS); + } + } + setState(730); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(731); + match(T__18); + setState(735); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(732); + match(WS); + } + } + setState(737); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(738); + identifier(); + setState(739); + match(T__19); + setState(743); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(740); + match(WS); + } + } + setState(745); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(746); + operand(); + setState(750); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(747); + match(WS); + } + } + setState(752); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(753); + match(T__20); + setState(757); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(754); + match(WS); + } + } + setState(759); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(760); + match(T__21); + setState(764); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(761); + match(WS); + } + } + setState(766); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(767); + register_access(); + setState(771); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(768); + match(WS); + } + } + setState(773); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(774); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class GetContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public OperandContext operand() { + return getRuleContext(OperandContext.class,0); + } + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public GetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_get; } + } + + public final GetContext get() throws RecognitionException { + GetContext _localctx = new GetContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_get); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(779); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(776); + match(CWS); + } + } + setState(781); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(782); + match(T__22); + setState(786); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(783); + match(WS); + } + } + setState(788); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(789); + identifier(); + setState(790); + match(T__19); + setState(794); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(791); + match(WS); + } + } + setState(796); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(797); + operand(); + setState(801); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(798); + match(WS); + } + } + setState(803); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(804); + match(T__20); + setState(808); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(805); + match(WS); + } + } + setState(810); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(811); + match(T__21); + setState(815); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(812); + match(WS); + } + } + setState(817); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(818); + register_access(); + setState(822); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(819); + match(WS); + } + } + setState(824); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(825); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Get_or_useContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List operand() { + return getRuleContexts(OperandContext.class); + } + public OperandContext operand(int i) { + return getRuleContext(OperandContext.class,i); + } + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public Get_or_useContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_get_or_use; } + } + + public final Get_or_useContext get_or_use() throws RecognitionException { + Get_or_useContext _localctx = new Get_or_useContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_get_or_use); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(830); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(827); + match(CWS); + } + } + setState(832); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(833); + match(T__23); + setState(837); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(834); + match(WS); + } + } + setState(839); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(840); + identifier(); + setState(841); + match(T__19); + setState(845); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(842); + match(WS); + } + } + setState(847); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(848); + operand(); + setState(852); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(849); + match(WS); + } + } + setState(854); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(855); + match(T__20); + setState(859); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(856); + match(WS); + } + } + setState(861); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(862); + operand(); + setState(866); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(863); + match(WS); + } + } + setState(868); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(869); + match(T__21); + setState(873); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(870); + match(WS); + } + } + setState(875); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(876); + register_access(); + setState(880); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(877); + match(WS); + } + } + setState(882); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(883); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SetContext extends ParserRuleContext { + public List operand() { + return getRuleContexts(OperandContext.class); + } + public OperandContext operand(int i) { + return getRuleContext(OperandContext.class,i); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public SetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_set; } + } + + public final SetContext set() throws RecognitionException { + SetContext _localctx = new SetContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_set); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(888); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(885); + match(CWS); + } + } + setState(890); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(891); + match(T__24); + setState(895); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(892); + match(WS); + } + } + setState(897); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(898); + operand(); + setState(902); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(899); + match(WS); + } + } + setState(904); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(905); + match(T__21); + setState(909); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(906); + match(WS); + } + } + setState(911); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(912); + identifier(); + setState(913); + match(T__19); + setState(917); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(914); + match(WS); + } + } + setState(919); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(920); + operand(); + setState(924); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(921); + match(WS); + } + } + setState(926); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(927); + match(T__20); + setState(931); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(928); + match(WS); + } + } + setState(933); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(934); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RemoveContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public OperandContext operand() { + return getRuleContext(OperandContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public RemoveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_remove; } + } + + public final RemoveContext remove() throws RecognitionException { + RemoveContext _localctx = new RemoveContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_remove); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(939); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(936); + match(CWS); + } + } + setState(941); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(942); + match(T__25); + setState(946); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(943); + match(WS); + } + } + setState(948); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(949); + identifier(); + setState(950); + match(T__19); + setState(954); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(951); + match(WS); + } + } + setState(956); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(957); + operand(); + setState(961); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(958); + match(WS); + } + } + setState(963); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(964); + match(T__20); + setState(968); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(965); + match(WS); + } + } + setState(970); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(971); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RandomContext extends ParserRuleContext { + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public Arithmetic_typeContext arithmetic_type() { + return getRuleContext(Arithmetic_typeContext.class,0); + } + public Address_typeContext address_type() { + return getRuleContext(Address_typeContext.class,0); + } + public Signature_typeContext signature_type() { + return getRuleContext(Signature_typeContext.class,0); + } + public Boolean_typeContext boolean_type() { + return getRuleContext(Boolean_typeContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List operand() { + return getRuleContexts(OperandContext.class); + } + public OperandContext operand(int i) { + return getRuleContext(OperandContext.class,i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public RandomContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_random; } + } + + public final RandomContext random() throws RecognitionException { + RandomContext _localctx = new RandomContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_random); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(976); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(973); + match(CWS); + } + } + setState(978); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(979); + match(T__26); + setState(989); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,113,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(983); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(980); + match(WS); + } + } + setState(985); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(986); + operand(); + } + } + } + setState(991); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,113,_ctx); + } + setState(995); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(992); + match(WS); + } + } + setState(997); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(998); + match(T__21); + setState(1002); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(999); + match(WS); + } + } + setState(1004); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1005); + register_access(); + setState(1009); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1006); + match(WS); + } + } + setState(1011); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1012); + match(T__6); + setState(1016); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1013); + match(WS); + } + } + setState(1018); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1023); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__37: + case T__74: + case T__75: + case T__76: + case T__77: + case T__78: + case T__79: + case T__80: + case T__81: + case T__82: + case T__83: + case T__84: + case T__85: + { + setState(1019); + arithmetic_type(); + } + break; + case T__86: + { + setState(1020); + address_type(); + } + break; + case T__88: + { + setState(1021); + signature_type(); + } + break; + case T__87: + { + setState(1022); + boolean_type(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1028); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1025); + match(WS); + } + } + setState(1030); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1031); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class PositionContext extends ParserRuleContext { + public LabelContext label() { + return getRuleContext(LabelContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public PositionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_position; } + } + + public final PositionContext position() throws RecognitionException { + PositionContext _localctx = new PositionContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_position); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1036); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(1033); + match(CWS); + } + } + setState(1038); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1039); + match(T__27); + setState(1043); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1040); + match(WS); + } + } + setState(1045); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1046); + label(); + setState(1050); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1047); + match(WS); + } + } + setState(1052); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1053); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BranchContext extends ParserRuleContext { + public Branch_opContext branch_op() { + return getRuleContext(Branch_opContext.class,0); + } + public List operand() { + return getRuleContexts(OperandContext.class); + } + public OperandContext operand(int i) { + return getRuleContext(OperandContext.class,i); + } + public LabelContext label() { + return getRuleContext(LabelContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public BranchContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_branch; } + } + + public final BranchContext branch() throws RecognitionException { + BranchContext _localctx = new BranchContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_branch); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1058); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(1055); + match(CWS); + } + } + setState(1060); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1061); + branch_op(); + setState(1065); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,124,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1062); + match(WS); + } + } + } + setState(1067); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,124,_ctx); + } + setState(1071); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1068); + match(WS); + } + } + setState(1073); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1074); + operand(); + setState(1078); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1075); + match(WS); + } + } + setState(1080); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1081); + operand(); + setState(1085); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1082); + match(WS); + } + } + setState(1087); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1088); + match(T__28); + setState(1092); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1089); + match(WS); + } + } + setState(1094); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1095); + label(); + setState(1099); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1096); + match(WS); + } + } + setState(1101); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1102); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class XawaitContext extends ParserRuleContext { + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public XawaitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xawait; } + } + + public final XawaitContext xawait() throws RecognitionException { + XawaitContext _localctx = new XawaitContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_xawait); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1107); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(1104); + match(CWS); + } + } + setState(1109); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1110); + match(T__29); + setState(1114); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1111); + match(WS); + } + } + setState(1116); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1117); + register_access(); + setState(1121); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1118); + match(WS); + } + } + setState(1123); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1124); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class InstructionContext extends ParserRuleContext { + public UnaryContext unary() { + return getRuleContext(UnaryContext.class,0); + } + public BinaryContext binary() { + return getRuleContext(BinaryContext.class,0); + } + public TernaryContext ternary() { + return getRuleContext(TernaryContext.class,0); + } + public IsContext is() { + return getRuleContext(IsContext.class,0); + } + public AssertContext assert_() { + return getRuleContext(AssertContext.class,0); + } + public CommitContext commit() { + return getRuleContext(CommitContext.class,0); + } + public HashContext hash() { + return getRuleContext(HashContext.class,0); + } + public SignverifyContext signverify() { + return getRuleContext(SignverifyContext.class,0); + } + public CastContext cast() { + return getRuleContext(CastContext.class,0); + } + public CallContext call() { + return getRuleContext(CallContext.class,0); + } + public XasyncContext xasync() { + return getRuleContext(XasyncContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public InstructionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_instruction; } + } + + public final InstructionContext instruction() throws RecognitionException { + InstructionContext _localctx = new InstructionContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_instruction); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1129); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,133,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1126); + match(CWS); + } + } + } + setState(1131); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,133,_ctx); + } + setState(1143); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__102: + case T__103: + case T__104: + case T__105: + case T__106: + case T__107: + case T__108: + case T__109: + { + setState(1132); + unary(); + } + break; + case T__110: + case T__111: + case T__112: + case T__113: + case T__114: + case T__115: + case T__116: + case T__117: + case T__118: + case T__119: + case T__120: + case T__121: + case T__122: + case T__123: + case T__124: + case T__125: + case T__126: + case T__127: + case T__128: + case T__129: + case T__130: + case T__131: + case T__132: + case T__133: + case T__134: + case T__135: + { + setState(1133); + binary(); + } + break; + case T__30: + { + setState(1134); + ternary(); + } + break; + case T__136: + case T__137: + { + setState(1135); + is(); + } + break; + case T__138: + case T__139: + { + setState(1136); + assert_(); + } + break; + case T__140: + case T__145: + { + setState(1137); + commit(); + } + break; + case T__148: + case T__149: + case T__150: + case T__151: + case T__153: + case T__154: + { + setState(1138); + hash(); + } + break; + case T__31: + case T__32: + { + setState(1139); + signverify(); + } + break; + case T__155: + case T__156: + { + setState(1140); + cast(); + } + break; + case T__33: + { + setState(1141); + call(); + } + break; + case T__34: + case CWS: + { + setState(1142); + xasync(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1148); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1145); + match(WS); + } + } + setState(1150); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1151); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class UnaryContext extends ParserRuleContext { + public Unary_opContext unary_op() { + return getRuleContext(Unary_opContext.class,0); + } + public OperandContext operand() { + return getRuleContext(OperandContext.class,0); + } + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public UnaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unary; } + } + + public final UnaryContext unary() throws RecognitionException { + UnaryContext _localctx = new UnaryContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_unary); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1153); + unary_op(); + setState(1157); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1154); + match(WS); + } + } + setState(1159); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1160); + operand(); + setState(1164); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1161); + match(WS); + } + } + setState(1166); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1167); + match(T__21); + setState(1171); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1168); + match(WS); + } + } + setState(1173); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1174); + register_access(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class BinaryContext extends ParserRuleContext { + public Binary_opContext binary_op() { + return getRuleContext(Binary_opContext.class,0); + } + public List operand() { + return getRuleContexts(OperandContext.class); + } + public OperandContext operand(int i) { + return getRuleContext(OperandContext.class,i); + } + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public BinaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_binary; } + } + + public final BinaryContext binary() throws RecognitionException { + BinaryContext _localctx = new BinaryContext(_ctx, getState()); + enterRule(_localctx, 56, RULE_binary); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1176); + binary_op(); + setState(1180); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1177); + match(WS); + } + } + setState(1182); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1183); + operand(); + setState(1187); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1184); + match(WS); + } + } + setState(1189); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1190); + operand(); + setState(1194); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1191); + match(WS); + } + } + setState(1196); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1197); + match(T__21); + setState(1201); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1198); + match(WS); + } + } + setState(1203); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1204); + register_access(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TernaryContext extends ParserRuleContext { + public List operand() { + return getRuleContexts(OperandContext.class); + } + public OperandContext operand(int i) { + return getRuleContext(OperandContext.class,i); + } + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public TernaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ternary; } + } + + public final TernaryContext ternary() throws RecognitionException { + TernaryContext _localctx = new TernaryContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_ternary); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1206); + match(T__30); + setState(1210); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1207); + match(WS); + } + } + setState(1212); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1213); + operand(); + setState(1217); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1214); + match(WS); + } + } + setState(1219); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1220); + operand(); + setState(1224); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1221); + match(WS); + } + } + setState(1226); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1227); + operand(); + setState(1231); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1228); + match(WS); + } + } + setState(1233); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1234); + match(T__21); + setState(1238); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1235); + match(WS); + } + } + setState(1240); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1241); + register_access(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IsContext extends ParserRuleContext { + public Is_opContext is_op() { + return getRuleContext(Is_opContext.class,0); + } + public List operand() { + return getRuleContexts(OperandContext.class); + } + public OperandContext operand(int i) { + return getRuleContext(OperandContext.class,i); + } + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public IsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_is; } + } + + public final IsContext is() throws RecognitionException { + IsContext _localctx = new IsContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_is); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1243); + is_op(); + setState(1247); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1244); + match(WS); + } + } + setState(1249); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1250); + operand(); + setState(1254); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1251); + match(WS); + } + } + setState(1256); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1257); + operand(); + setState(1261); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1258); + match(WS); + } + } + setState(1263); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1264); + match(T__21); + setState(1268); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1265); + match(WS); + } + } + setState(1270); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1271); + register_access(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class AssertContext extends ParserRuleContext { + public Assert_opContext assert_op() { + return getRuleContext(Assert_opContext.class,0); + } + public List operand() { + return getRuleContexts(OperandContext.class); + } + public OperandContext operand(int i) { + return getRuleContext(OperandContext.class,i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public AssertContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assert; } + } + + public final AssertContext assert_() throws RecognitionException { + AssertContext _localctx = new AssertContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_assert); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1273); + assert_op(); + setState(1277); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1274); + match(WS); + } + } + setState(1279); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1280); + operand(); + setState(1284); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1281); + match(WS); + } + } + setState(1286); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1287); + operand(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CommitContext extends ParserRuleContext { + public Commit_opContext commit_op() { + return getRuleContext(Commit_opContext.class,0); + } + public List operand() { + return getRuleContexts(OperandContext.class); + } + public OperandContext operand(int i) { + return getRuleContext(OperandContext.class,i); + } + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public Address_typeContext address_type() { + return getRuleContext(Address_typeContext.class,0); + } + public Field_typeContext field_type() { + return getRuleContext(Field_typeContext.class,0); + } + public Group_typeContext group_type() { + return getRuleContext(Group_typeContext.class,0); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public CommitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_commit; } + } + + public final CommitContext commit() throws RecognitionException { + CommitContext _localctx = new CommitContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_commit); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1289); + commit_op(); + setState(1293); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1290); + match(WS); + } + } + setState(1295); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1296); + operand(); + setState(1300); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1297); + match(WS); + } + } + setState(1302); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1303); + operand(); + setState(1307); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1304); + match(WS); + } + } + setState(1309); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1310); + match(T__21); + setState(1314); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1311); + match(WS); + } + } + setState(1316); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1317); + register_access(); + setState(1321); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1318); + match(WS); + } + } + setState(1323); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1324); + match(T__6); + setState(1328); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1325); + match(WS); + } + } + setState(1330); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1334); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__86: + { + setState(1331); + address_type(); + } + break; + case T__83: + { + setState(1332); + field_type(); + } + break; + case T__84: + { + setState(1333); + group_type(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Hash1Context extends ParserRuleContext { + public Hash1_opContext hash1_op() { + return getRuleContext(Hash1_opContext.class,0); + } + public OperandContext operand() { + return getRuleContext(OperandContext.class,0); + } + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public Arithmetic_typeContext arithmetic_type() { + return getRuleContext(Arithmetic_typeContext.class,0); + } + public Address_typeContext address_type() { + return getRuleContext(Address_typeContext.class,0); + } + public Signature_typeContext signature_type() { + return getRuleContext(Signature_typeContext.class,0); + } + public Array_typeContext array_type() { + return getRuleContext(Array_typeContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public Hash1Context(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_hash1; } + } + + public final Hash1Context hash1() throws RecognitionException { + Hash1Context _localctx = new Hash1Context(_ctx, getState()); + enterRule(_localctx, 66, RULE_hash1); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1336); + hash1_op(); + setState(1340); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1337); + match(WS); + } + } + setState(1342); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1343); + operand(); + setState(1347); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1344); + match(WS); + } + } + setState(1349); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1350); + match(T__21); + setState(1354); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1351); + match(WS); + } + } + setState(1356); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1357); + register_access(); + setState(1361); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1358); + match(WS); + } + } + setState(1363); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1364); + match(T__6); + setState(1368); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1365); + match(WS); + } + } + setState(1370); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1376); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__37: + case T__74: + case T__75: + case T__76: + case T__77: + case T__78: + case T__79: + case T__80: + case T__81: + case T__82: + case T__83: + case T__84: + case T__85: + { + setState(1371); + arithmetic_type(); + } + break; + case T__86: + { + setState(1372); + address_type(); + } + break; + case T__88: + { + setState(1373); + signature_type(); + } + break; + case T__19: + { + setState(1374); + array_type(); + } + break; + case Letter: + { + setState(1375); + identifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Hash2Context extends ParserRuleContext { + public Hash2_opContext hash2_op() { + return getRuleContext(Hash2_opContext.class,0); + } + public List operand() { + return getRuleContexts(OperandContext.class); + } + public OperandContext operand(int i) { + return getRuleContext(OperandContext.class,i); + } + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public Arithmetic_typeContext arithmetic_type() { + return getRuleContext(Arithmetic_typeContext.class,0); + } + public Address_typeContext address_type() { + return getRuleContext(Address_typeContext.class,0); + } + public Signature_typeContext signature_type() { + return getRuleContext(Signature_typeContext.class,0); + } + public Array_typeContext array_type() { + return getRuleContext(Array_typeContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public Hash2Context(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_hash2; } + } + + public final Hash2Context hash2() throws RecognitionException { + Hash2Context _localctx = new Hash2Context(_ctx, getState()); + enterRule(_localctx, 68, RULE_hash2); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1378); + hash2_op(); + setState(1382); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1379); + match(WS); + } + } + setState(1384); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1385); + operand(); + setState(1389); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1386); + match(WS); + } + } + setState(1391); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1392); + operand(); + setState(1396); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1393); + match(WS); + } + } + setState(1398); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1399); + match(T__21); + setState(1403); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1400); + match(WS); + } + } + setState(1405); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1406); + register_access(); + setState(1410); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1407); + match(WS); + } + } + setState(1412); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1413); + match(T__6); + setState(1417); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1414); + match(WS); + } + } + setState(1419); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1425); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__37: + case T__74: + case T__75: + case T__76: + case T__77: + case T__78: + case T__79: + case T__80: + case T__81: + case T__82: + case T__83: + case T__84: + case T__85: + { + setState(1420); + arithmetic_type(); + } + break; + case T__86: + { + setState(1421); + address_type(); + } + break; + case T__88: + { + setState(1422); + signature_type(); + } + break; + case T__19: + { + setState(1423); + array_type(); + } + break; + case Letter: + { + setState(1424); + identifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class HashContext extends ParserRuleContext { + public Hash1Context hash1() { + return getRuleContext(Hash1Context.class,0); + } + public Hash2Context hash2() { + return getRuleContext(Hash2Context.class,0); + } + public HashContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_hash; } + } + + public final HashContext hash() throws RecognitionException { + HashContext _localctx = new HashContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_hash); + try { + setState(1429); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__148: + case T__149: + case T__150: + case T__151: + case T__153: + enterOuterAlt(_localctx, 1); + { + setState(1427); + hash1(); + } + break; + case T__154: + enterOuterAlt(_localctx, 2); + { + setState(1428); + hash2(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class SignverifyContext extends ParserRuleContext { + public List operand() { + return getRuleContexts(OperandContext.class); + } + public OperandContext operand(int i) { + return getRuleContext(OperandContext.class,i); + } + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public SignverifyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_signverify; } + } + + public final SignverifyContext signverify() throws RecognitionException { + SignverifyContext _localctx = new SignverifyContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_signverify); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1431); + _la = _input.LA(1); + if ( !(_la==T__31 || _la==T__32) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1435); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1432); + match(WS); + } + } + setState(1437); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1438); + operand(); + setState(1442); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1439); + match(WS); + } + } + setState(1444); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1445); + operand(); + setState(1449); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1446); + match(WS); + } + } + setState(1451); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1452); + operand(); + setState(1456); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1453); + match(WS); + } + } + setState(1458); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1459); + match(T__21); + setState(1463); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1460); + match(WS); + } + } + setState(1465); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1466); + register_access(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CastContext extends ParserRuleContext { + public Cast_opContext cast_op() { + return getRuleContext(Cast_opContext.class,0); + } + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public Cast_destinationContext cast_destination() { + return getRuleContext(Cast_destinationContext.class,0); + } + public List operand() { + return getRuleContexts(OperandContext.class); + } + public OperandContext operand(int i) { + return getRuleContext(OperandContext.class,i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public CastContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cast; } + } + + public final CastContext cast() throws RecognitionException { + CastContext _localctx = new CastContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_cast); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1468); + cast_op(); + setState(1476); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1472); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1469); + match(WS); + } + } + setState(1474); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1475); + operand(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1478); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,181,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(1483); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1480); + match(WS); + } + } + setState(1485); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1486); + match(T__21); + setState(1490); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1487); + match(WS); + } + } + setState(1492); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1493); + register_access(); + setState(1497); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1494); + match(WS); + } + } + setState(1499); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1500); + match(T__6); + setState(1504); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1501); + match(WS); + } + } + setState(1506); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1507); + cast_destination(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class CallContext extends ParserRuleContext { + public LocatorContext locator() { + return getRuleContext(LocatorContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public List operand() { + return getRuleContexts(OperandContext.class); + } + public OperandContext operand(int i) { + return getRuleContext(OperandContext.class,i); + } + public List register_access() { + return getRuleContexts(Register_accessContext.class); + } + public Register_accessContext register_access(int i) { + return getRuleContext(Register_accessContext.class,i); + } + public CallContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_call; } + } + + public final CallContext call() throws RecognitionException { + CallContext _localctx = new CallContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_call); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1509); + match(T__33); + setState(1513); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1510); + match(WS); + } + } + setState(1515); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1518); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LL: + { + setState(1516); + locator(); + } + break; + case Letter: + { + setState(1517); + identifier(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1529); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,189,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1523); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1520); + match(WS); + } + } + setState(1525); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1526); + operand(); + } + } + } + setState(1531); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,189,_ctx); + } + setState(1545); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) { + case 1: + { + setState(1535); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1532); + match(WS); + } + } + setState(1537); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1538); + match(T__21); + setState(1541); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1539); + match(WS); + setState(1540); + register_access(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1543); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,191,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class XasyncContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public List operand() { + return getRuleContexts(OperandContext.class); + } + public OperandContext operand(int i) { + return getRuleContext(OperandContext.class,i); + } + public XasyncContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xasync; } + } + + public final XasyncContext xasync() throws RecognitionException { + XasyncContext _localctx = new XasyncContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_xasync); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1550); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(1547); + match(CWS); + } + } + setState(1552); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1553); + match(T__34); + setState(1557); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1554); + match(WS); + } + } + setState(1559); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1560); + identifier(); + setState(1570); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,196,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1564); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1561); + match(WS); + } + } + setState(1566); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1567); + operand(); + } + } + } + setState(1572); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,196,_ctx); + } + setState(1576); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1573); + match(WS); + } + } + setState(1578); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1579); + match(T__21); + setState(1583); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1580); + match(WS); + } + } + setState(1585); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1586); + register_access(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LiteralContext extends ParserRuleContext { + public Arithmetic_literalContext arithmetic_literal() { + return getRuleContext(Arithmetic_literalContext.class,0); + } + public Address_literalContext address_literal() { + return getRuleContext(Address_literalContext.class,0); + } + public Signature_literalContext signature_literal() { + return getRuleContext(Signature_literalContext.class,0); + } + public Boolean_literalContext boolean_literal() { + return getRuleContext(Boolean_literalContext.class,0); + } + public LiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_literal; } + } + + public final LiteralContext literal() throws RecognitionException { + LiteralContext _localctx = new LiteralContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_literal); + try { + setState(1592); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__35: + case DIGIT: + enterOuterAlt(_localctx, 1); + { + setState(1588); + arithmetic_literal(); + } + break; + case T__38: + enterOuterAlt(_localctx, 2); + { + setState(1589); + address_literal(); + } + break; + case T__39: + enterOuterAlt(_localctx, 3); + { + setState(1590); + signature_literal(); + } + break; + case T__72: + case T__73: + enterOuterAlt(_localctx, 4); + { + setState(1591); + boolean_literal(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Signed_literalContext extends ParserRuleContext { + public Signed_typeContext signed_type() { + return getRuleContext(Signed_typeContext.class,0); + } + public List DIGIT() { return getTokens(aleoParser.DIGIT); } + public TerminalNode DIGIT(int i) { + return getToken(aleoParser.DIGIT, i); + } + public Signed_literalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_signed_literal; } + } + + public final Signed_literalContext signed_literal() throws RecognitionException { + Signed_literalContext _localctx = new Signed_literalContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_signed_literal); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1595); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__35) { + { + setState(1594); + match(T__35); + } + } + + setState(1604); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1597); + match(DIGIT); + setState(1601); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__36) { + { + { + setState(1598); + match(T__36); + } + } + setState(1603); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + setState(1606); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==DIGIT ); + setState(1608); + signed_type(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Unsigned_literalContext extends ParserRuleContext { + public Unsigned_typeContext unsigned_type() { + return getRuleContext(Unsigned_typeContext.class,0); + } + public List DIGIT() { return getTokens(aleoParser.DIGIT); } + public TerminalNode DIGIT(int i) { + return getToken(aleoParser.DIGIT, i); + } + public Unsigned_literalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unsigned_literal; } + } + + public final Unsigned_literalContext unsigned_literal() throws RecognitionException { + Unsigned_literalContext _localctx = new Unsigned_literalContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_unsigned_literal); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1611); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__35) { + { + setState(1610); + match(T__35); + } + } + + setState(1620); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1613); + match(DIGIT); + setState(1617); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__36) { + { + { + setState(1614); + match(T__36); + } + } + setState(1619); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + setState(1622); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==DIGIT ); + setState(1624); + unsigned_type(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Integer_literalContext extends ParserRuleContext { + public Signed_literalContext signed_literal() { + return getRuleContext(Signed_literalContext.class,0); + } + public Unsigned_literalContext unsigned_literal() { + return getRuleContext(Unsigned_literalContext.class,0); + } + public Integer_literalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_integer_literal; } + } + + public final Integer_literalContext integer_literal() throws RecognitionException { + Integer_literalContext _localctx = new Integer_literalContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_integer_literal); + try { + setState(1628); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1626); + signed_literal(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1627); + unsigned_literal(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Field_literalContext extends ParserRuleContext { + public Field_typeContext field_type() { + return getRuleContext(Field_typeContext.class,0); + } + public List DIGIT() { return getTokens(aleoParser.DIGIT); } + public TerminalNode DIGIT(int i) { + return getToken(aleoParser.DIGIT, i); + } + public Field_literalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_field_literal; } + } + + public final Field_literalContext field_literal() throws RecognitionException { + Field_literalContext _localctx = new Field_literalContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_field_literal); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1631); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__35) { + { + setState(1630); + match(T__35); + } + } + + setState(1640); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1633); + match(DIGIT); + setState(1637); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__36) { + { + { + setState(1634); + match(T__36); + } + } + setState(1639); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + setState(1642); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==DIGIT ); + setState(1644); + field_type(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Group_literalContext extends ParserRuleContext { + public Group_typeContext group_type() { + return getRuleContext(Group_typeContext.class,0); + } + public List DIGIT() { return getTokens(aleoParser.DIGIT); } + public TerminalNode DIGIT(int i) { + return getToken(aleoParser.DIGIT, i); + } + public Group_literalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_group_literal; } + } + + public final Group_literalContext group_literal() throws RecognitionException { + Group_literalContext _localctx = new Group_literalContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_group_literal); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1647); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__35) { + { + setState(1646); + match(T__35); + } + } + + setState(1656); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1649); + match(DIGIT); + setState(1653); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__36) { + { + { + setState(1650); + match(T__36); + } + } + setState(1655); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + setState(1658); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==DIGIT ); + setState(1660); + group_type(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Scalar_literalContext extends ParserRuleContext { + public Scalar_typeContext scalar_type() { + return getRuleContext(Scalar_typeContext.class,0); + } + public List DIGIT() { return getTokens(aleoParser.DIGIT); } + public TerminalNode DIGIT(int i) { + return getToken(aleoParser.DIGIT, i); + } + public Scalar_literalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_scalar_literal; } + } + + public final Scalar_literalContext scalar_literal() throws RecognitionException { + Scalar_literalContext _localctx = new Scalar_literalContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_scalar_literal); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1663); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__35) { + { + setState(1662); + match(T__35); + } + } + + setState(1672); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1665); + match(DIGIT); + setState(1669); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__36) { + { + { + setState(1666); + match(T__36); + } + } + setState(1671); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + setState(1674); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==DIGIT ); + setState(1676); + scalar_type(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Arithmetic_literalContext extends ParserRuleContext { + public Integer_literalContext integer_literal() { + return getRuleContext(Integer_literalContext.class,0); + } + public Field_literalContext field_literal() { + return getRuleContext(Field_literalContext.class,0); + } + public Group_literalContext group_literal() { + return getRuleContext(Group_literalContext.class,0); + } + public Scalar_literalContext scalar_literal() { + return getRuleContext(Scalar_literalContext.class,0); + } + public Arithmetic_literalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arithmetic_literal; } + } + + public final Arithmetic_literalContext arithmetic_literal() throws RecognitionException { + Arithmetic_literalContext _localctx = new Arithmetic_literalContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_arithmetic_literal); + try { + setState(1682); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,216,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1678); + integer_literal(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1679); + field_literal(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1680); + group_literal(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1681); + scalar_literal(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class U32_literalContext extends ParserRuleContext { + public List DIGIT() { return getTokens(aleoParser.DIGIT); } + public TerminalNode DIGIT(int i) { + return getToken(aleoParser.DIGIT, i); + } + public U32_literalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_u32_literal; } + } + + public final U32_literalContext u32_literal() throws RecognitionException { + U32_literalContext _localctx = new U32_literalContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_u32_literal); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1685); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==T__35) { + { + setState(1684); + match(T__35); + } + } + + setState(1694); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1687); + match(DIGIT); + setState(1691); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__36) { + { + { + setState(1688); + match(T__36); + } + } + setState(1693); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + setState(1696); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==DIGIT ); + setState(1698); + match(T__37); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Address_literalContext extends ParserRuleContext { + public List address_or_signature_char() { + return getRuleContexts(Address_or_signature_charContext.class); + } + public Address_or_signature_charContext address_or_signature_char(int i) { + return getRuleContext(Address_or_signature_charContext.class,i); + } + public Address_literalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_address_literal; } + } + + public final Address_literalContext address_literal() throws RecognitionException { + Address_literalContext _localctx = new Address_literalContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_address_literal); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1700); + match(T__38); + setState(1708); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1701); + address_or_signature_char(); + setState(1705); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__36) { + { + { + setState(1702); + match(T__36); + } + } + setState(1707); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1710); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,221,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Signature_literalContext extends ParserRuleContext { + public List address_or_signature_char() { + return getRuleContexts(Address_or_signature_charContext.class); + } + public Address_or_signature_charContext address_or_signature_char(int i) { + return getRuleContext(Address_or_signature_charContext.class,i); + } + public Signature_literalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_signature_literal; } + } + + public final Signature_literalContext signature_literal() throws RecognitionException { + Signature_literalContext _localctx = new Signature_literalContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_signature_literal); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1712); + match(T__39); + setState(1720); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1713); + address_or_signature_char(); + setState(1717); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__36) { + { + { + setState(1714); + match(T__36); + } + } + setState(1719); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1722); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,223,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Address_or_signature_charContext extends ParserRuleContext { + public Address_or_signature_charContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_address_or_signature_char; } + } + + public final Address_or_signature_charContext address_or_signature_char() throws RecognitionException { + Address_or_signature_charContext _localctx = new Address_or_signature_charContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_address_or_signature_char); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1724); + _la = _input.LA(1); + if ( !(((((_la - 41)) & ~0x3f) == 0 && ((1L << (_la - 41)) & 4294967295L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Boolean_literalContext extends ParserRuleContext { + public Boolean_literalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_boolean_literal; } + } + + public final Boolean_literalContext boolean_literal() throws RecognitionException { + Boolean_literalContext _localctx = new Boolean_literalContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_boolean_literal); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1726); + _la = _input.LA(1); + if ( !(_la==T__72 || _la==T__73) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Unsigned_typeContext extends ParserRuleContext { + public Unsigned_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unsigned_type; } + } + + public final Unsigned_typeContext unsigned_type() throws RecognitionException { + Unsigned_typeContext _localctx = new Unsigned_typeContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_unsigned_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1728); + _la = _input.LA(1); + if ( !(((((_la - 38)) & ~0x3f) == 0 && ((1L << (_la - 38)) & 2061584302081L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Signed_typeContext extends ParserRuleContext { + public Signed_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_signed_type; } + } + + public final Signed_typeContext signed_type() throws RecognitionException { + Signed_typeContext _localctx = new Signed_typeContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_signed_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1730); + _la = _input.LA(1); + if ( !(((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & 31L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Integer_typeContext extends ParserRuleContext { + public Unsigned_typeContext unsigned_type() { + return getRuleContext(Unsigned_typeContext.class,0); + } + public Signed_typeContext signed_type() { + return getRuleContext(Signed_typeContext.class,0); + } + public Integer_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_integer_type; } + } + + public final Integer_typeContext integer_type() throws RecognitionException { + Integer_typeContext _localctx = new Integer_typeContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_integer_type); + try { + setState(1734); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__37: + case T__74: + case T__75: + case T__76: + case T__77: + enterOuterAlt(_localctx, 1); + { + setState(1732); + unsigned_type(); + } + break; + case T__78: + case T__79: + case T__80: + case T__81: + case T__82: + enterOuterAlt(_localctx, 2); + { + setState(1733); + signed_type(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Field_typeContext extends ParserRuleContext { + public Field_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_field_type; } + } + + public final Field_typeContext field_type() throws RecognitionException { + Field_typeContext _localctx = new Field_typeContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_field_type); + try { + enterOuterAlt(_localctx, 1); + { + setState(1736); + match(T__83); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Group_typeContext extends ParserRuleContext { + public Group_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_group_type; } + } + + public final Group_typeContext group_type() throws RecognitionException { + Group_typeContext _localctx = new Group_typeContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_group_type); + try { + enterOuterAlt(_localctx, 1); + { + setState(1738); + match(T__84); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Scalar_typeContext extends ParserRuleContext { + public Scalar_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_scalar_type; } + } + + public final Scalar_typeContext scalar_type() throws RecognitionException { + Scalar_typeContext _localctx = new Scalar_typeContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_scalar_type); + try { + enterOuterAlt(_localctx, 1); + { + setState(1740); + match(T__85); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Arithmetic_typeContext extends ParserRuleContext { + public Integer_typeContext integer_type() { + return getRuleContext(Integer_typeContext.class,0); + } + public Field_typeContext field_type() { + return getRuleContext(Field_typeContext.class,0); + } + public Group_typeContext group_type() { + return getRuleContext(Group_typeContext.class,0); + } + public Scalar_typeContext scalar_type() { + return getRuleContext(Scalar_typeContext.class,0); + } + public Arithmetic_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arithmetic_type; } + } + + public final Arithmetic_typeContext arithmetic_type() throws RecognitionException { + Arithmetic_typeContext _localctx = new Arithmetic_typeContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_arithmetic_type); + try { + setState(1746); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__37: + case T__74: + case T__75: + case T__76: + case T__77: + case T__78: + case T__79: + case T__80: + case T__81: + case T__82: + enterOuterAlt(_localctx, 1); + { + setState(1742); + integer_type(); + } + break; + case T__83: + enterOuterAlt(_localctx, 2); + { + setState(1743); + field_type(); + } + break; + case T__84: + enterOuterAlt(_localctx, 3); + { + setState(1744); + group_type(); + } + break; + case T__85: + enterOuterAlt(_localctx, 4); + { + setState(1745); + scalar_type(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Address_typeContext extends ParserRuleContext { + public Address_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_address_type; } + } + + public final Address_typeContext address_type() throws RecognitionException { + Address_typeContext _localctx = new Address_typeContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_address_type); + try { + enterOuterAlt(_localctx, 1); + { + setState(1748); + match(T__86); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Boolean_typeContext extends ParserRuleContext { + public Boolean_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_boolean_type; } + } + + public final Boolean_typeContext boolean_type() throws RecognitionException { + Boolean_typeContext _localctx = new Boolean_typeContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_boolean_type); + try { + enterOuterAlt(_localctx, 1); + { + setState(1750); + match(T__87); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Signature_typeContext extends ParserRuleContext { + public Signature_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_signature_type; } + } + + public final Signature_typeContext signature_type() throws RecognitionException { + Signature_typeContext _localctx = new Signature_typeContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_signature_type); + try { + enterOuterAlt(_localctx, 1); + { + setState(1752); + match(T__88); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Literal_typeContext extends ParserRuleContext { + public Arithmetic_typeContext arithmetic_type() { + return getRuleContext(Arithmetic_typeContext.class,0); + } + public Address_typeContext address_type() { + return getRuleContext(Address_typeContext.class,0); + } + public Signature_typeContext signature_type() { + return getRuleContext(Signature_typeContext.class,0); + } + public Boolean_typeContext boolean_type() { + return getRuleContext(Boolean_typeContext.class,0); + } + public Literal_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_literal_type; } + } + + public final Literal_typeContext literal_type() throws RecognitionException { + Literal_typeContext _localctx = new Literal_typeContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_literal_type); + try { + setState(1758); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__37: + case T__74: + case T__75: + case T__76: + case T__77: + case T__78: + case T__79: + case T__80: + case T__81: + case T__82: + case T__83: + case T__84: + case T__85: + enterOuterAlt(_localctx, 1); + { + setState(1754); + arithmetic_type(); + } + break; + case T__86: + enterOuterAlt(_localctx, 2); + { + setState(1755); + address_type(); + } + break; + case T__88: + enterOuterAlt(_localctx, 3); + { + setState(1756); + signature_type(); + } + break; + case T__87: + enterOuterAlt(_localctx, 4); + { + setState(1757); + boolean_type(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Array_typeContext extends ParserRuleContext { + public Plaintext_typeContext plaintext_type() { + return getRuleContext(Plaintext_typeContext.class,0); + } + public U32_literalContext u32_literal() { + return getRuleContext(U32_literalContext.class,0); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public Array_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_array_type; } + } + + public final Array_typeContext array_type() throws RecognitionException { + Array_typeContext _localctx = new Array_typeContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_array_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1760); + match(T__19); + setState(1764); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1761); + match(WS); + } + } + setState(1766); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1767); + plaintext_type(); + setState(1771); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1768); + match(WS); + } + } + setState(1773); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1774); + match(T__1); + setState(1778); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1775); + match(WS); + } + } + setState(1780); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1781); + u32_literal(); + setState(1785); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1782); + match(WS); + } + } + setState(1787); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1788); + match(T__20); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Plaintext_typeContext extends ParserRuleContext { + public Literal_typeContext literal_type() { + return getRuleContext(Literal_typeContext.class,0); + } + public Array_typeContext array_type() { + return getRuleContext(Array_typeContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Plaintext_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_plaintext_type; } + } + + public final Plaintext_typeContext plaintext_type() throws RecognitionException { + Plaintext_typeContext _localctx = new Plaintext_typeContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_plaintext_type); + try { + setState(1793); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__37: + case T__74: + case T__75: + case T__76: + case T__77: + case T__78: + case T__79: + case T__80: + case T__81: + case T__82: + case T__83: + case T__84: + case T__85: + case T__86: + case T__87: + case T__88: + enterOuterAlt(_localctx, 1); + { + setState(1790); + literal_type(); + } + break; + case T__19: + enterOuterAlt(_localctx, 2); + { + setState(1791); + array_type(); + } + break; + case Letter: + enterOuterAlt(_localctx, 3); + { + setState(1792); + identifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Value_typeContext extends ParserRuleContext { + public Plaintext_typeContext plaintext_type() { + return getRuleContext(Plaintext_typeContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public LocatorContext locator() { + return getRuleContext(LocatorContext.class,0); + } + public Value_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_value_type; } + } + + public final Value_typeContext value_type() throws RecognitionException { + Value_typeContext _localctx = new Value_typeContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_value_type); + try { + setState(1813); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,232,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1795); + plaintext_type(); + setState(1796); + match(T__89); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1798); + plaintext_type(); + setState(1799); + match(T__90); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1801); + plaintext_type(); + setState(1802); + match(T__91); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1804); + identifier(); + setState(1805); + match(T__92); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1807); + locator(); + setState(1808); + match(T__92); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1810); + locator(); + setState(1811); + match(T__93); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Mapping_typeContext extends ParserRuleContext { + public Plaintext_typeContext plaintext_type() { + return getRuleContext(Plaintext_typeContext.class,0); + } + public Mapping_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_mapping_type; } + } + + public final Mapping_typeContext mapping_type() throws RecognitionException { + Mapping_typeContext _localctx = new Mapping_typeContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_mapping_type); + try { + enterOuterAlt(_localctx, 1); + { + setState(1815); + plaintext_type(); + setState(1816); + match(T__90); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Finalize_typeContext extends ParserRuleContext { + public Plaintext_typeContext plaintext_type() { + return getRuleContext(Plaintext_typeContext.class,0); + } + public LocatorContext locator() { + return getRuleContext(LocatorContext.class,0); + } + public Finalize_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_finalize_type; } + } + + public final Finalize_typeContext finalize_type() throws RecognitionException { + Finalize_typeContext _localctx = new Finalize_typeContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_finalize_type); + try { + setState(1824); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__19: + case T__37: + case T__74: + case T__75: + case T__76: + case T__77: + case T__78: + case T__79: + case T__80: + case T__81: + case T__82: + case T__83: + case T__84: + case T__85: + case T__86: + case T__87: + case T__88: + case Letter: + enterOuterAlt(_localctx, 1); + { + setState(1818); + plaintext_type(); + setState(1819); + match(T__90); + } + break; + case LL: + enterOuterAlt(_localctx, 2); + { + setState(1821); + locator(); + setState(1822); + match(T__93); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Entry_typeContext extends ParserRuleContext { + public Plaintext_typeContext plaintext_type() { + return getRuleContext(Plaintext_typeContext.class,0); + } + public Entry_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_entry_type; } + } + + public final Entry_typeContext entry_type() throws RecognitionException { + Entry_typeContext _localctx = new Entry_typeContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_entry_type); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1826); + plaintext_type(); + setState(1827); + _la = _input.LA(1); + if ( !(((((_la - 90)) & ~0x3f) == 0 && ((1L << (_la - 90)) & 7L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Register_typeContext extends ParserRuleContext { + public LocatorContext locator() { + return getRuleContext(LocatorContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Plaintext_typeContext plaintext_type() { + return getRuleContext(Plaintext_typeContext.class,0); + } + public Register_typeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_register_type; } + } + + public final Register_typeContext register_type() throws RecognitionException { + Register_typeContext _localctx = new Register_typeContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_register_type); + try { + setState(1839); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,234,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1829); + locator(); + setState(1830); + match(T__93); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1832); + locator(); + setState(1833); + match(T__92); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1835); + identifier(); + setState(1836); + match(T__92); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1838); + plaintext_type(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Program_idContext extends ParserRuleContext { + public Program_nameContext program_name() { + return getRuleContext(Program_nameContext.class,0); + } + public Program_domainContext program_domain() { + return getRuleContext(Program_domainContext.class,0); + } + public Program_idContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_program_id; } + } + + public final Program_idContext program_id() throws RecognitionException { + Program_idContext _localctx = new Program_idContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_program_id); + try { + enterOuterAlt(_localctx, 1); + { + setState(1841); + program_name(); + setState(1842); + match(T__94); + setState(1843); + program_domain(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Program_nameContext extends ParserRuleContext { + public Lowercase_identifierContext lowercase_identifier() { + return getRuleContext(Lowercase_identifierContext.class,0); + } + public Program_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_program_name; } + } + + public final Program_nameContext program_name() throws RecognitionException { + Program_nameContext _localctx = new Program_nameContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_program_name); + try { + enterOuterAlt(_localctx, 1); + { + setState(1845); + lowercase_identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Program_domainContext extends ParserRuleContext { + public Lowercase_identifierContext lowercase_identifier() { + return getRuleContext(Lowercase_identifierContext.class,0); + } + public Program_domainContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_program_domain; } + } + + public final Program_domainContext program_domain() throws RecognitionException { + Program_domainContext _localctx = new Program_domainContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_program_domain); + try { + enterOuterAlt(_localctx, 1); + { + setState(1847); + lowercase_identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class RegisterContext extends ParserRuleContext { + public List DIGIT() { return getTokens(aleoParser.DIGIT); } + public TerminalNode DIGIT(int i) { + return getToken(aleoParser.DIGIT, i); + } + public RegisterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_register; } + } + + public final RegisterContext register() throws RecognitionException { + RegisterContext _localctx = new RegisterContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_register); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1849); + match(T__63); + setState(1851); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1850); + match(DIGIT); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1853); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,235,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Register_accessContext extends ParserRuleContext { + public RegisterContext register() { + return getRuleContext(RegisterContext.class,0); + } + public List register_accessor() { + return getRuleContexts(Register_accessorContext.class); + } + public Register_accessorContext register_accessor(int i) { + return getRuleContext(Register_accessorContext.class,i); + } + public Register_accessContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_register_access; } + } + + public final Register_accessContext register_access() throws RecognitionException { + Register_accessContext _localctx = new Register_accessContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_register_access); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1855); + register(); + setState(1859); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==T__19 || _la==T__94) { + { + { + setState(1856); + register_accessor(); + } + } + setState(1861); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Register_accessorContext extends ParserRuleContext { + public Access_by_fieldContext access_by_field() { + return getRuleContext(Access_by_fieldContext.class,0); + } + public Access_by_indexContext access_by_index() { + return getRuleContext(Access_by_indexContext.class,0); + } + public Register_accessorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_register_accessor; } + } + + public final Register_accessorContext register_accessor() throws RecognitionException { + Register_accessorContext _localctx = new Register_accessorContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_register_accessor); + try { + setState(1864); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__94: + enterOuterAlt(_localctx, 1); + { + setState(1862); + access_by_field(); + } + break; + case T__19: + enterOuterAlt(_localctx, 2); + { + setState(1863); + access_by_index(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Access_by_fieldContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Access_by_fieldContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_access_by_field; } + } + + public final Access_by_fieldContext access_by_field() throws RecognitionException { + Access_by_fieldContext _localctx = new Access_by_fieldContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_access_by_field); + try { + enterOuterAlt(_localctx, 1); + { + setState(1866); + match(T__94); + setState(1867); + identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Access_by_indexContext extends ParserRuleContext { + public U32_literalContext u32_literal() { + return getRuleContext(U32_literalContext.class,0); + } + public List DIGIT() { return getTokens(aleoParser.DIGIT); } + public TerminalNode DIGIT(int i) { + return getToken(aleoParser.DIGIT, i); + } + public Access_by_indexContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_access_by_index; } + } + + public final Access_by_indexContext access_by_index() throws RecognitionException { + Access_by_indexContext _localctx = new Access_by_indexContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_access_by_index); + int _la; + try { + setState(1880); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,239,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1869); + match(T__19); + setState(1870); + u32_literal(); + setState(1871); + match(T__20); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1873); + match(T__19); + setState(1875); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1874); + match(DIGIT); + } + } + setState(1877); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==DIGIT ); + setState(1879); + match(T__20); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class OperandContext extends ParserRuleContext { + public LiteralContext literal() { + return getRuleContext(LiteralContext.class,0); + } + public Register_accessContext register_access() { + return getRuleContext(Register_accessContext.class,0); + } + public Program_idContext program_id() { + return getRuleContext(Program_idContext.class,0); + } + public OperandContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_operand; } + } + + public final OperandContext operand() throws RecognitionException { + OperandContext _localctx = new OperandContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_operand); + try { + setState(1889); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__35: + case T__38: + case T__39: + case T__72: + case T__73: + case DIGIT: + enterOuterAlt(_localctx, 1); + { + setState(1882); + literal(); + } + break; + case T__95: + enterOuterAlt(_localctx, 2); + { + setState(1883); + match(T__95); + } + break; + case T__63: + enterOuterAlt(_localctx, 3); + { + setState(1884); + register_access(); + } + break; + case LL: + enterOuterAlt(_localctx, 4); + { + setState(1885); + program_id(); + } + break; + case T__96: + enterOuterAlt(_localctx, 5); + { + setState(1886); + match(T__96); + } + break; + case T__97: + enterOuterAlt(_localctx, 6); + { + setState(1887); + match(T__97); + } + break; + case T__98: + enterOuterAlt(_localctx, 7); + { + setState(1888); + match(T__98); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class TupleContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Plaintext_typeContext plaintext_type() { + return getRuleContext(Plaintext_typeContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public TupleContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tuple; } + } + + public final TupleContext tuple() throws RecognitionException { + TupleContext _localctx = new TupleContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_tuple); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1894); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(1891); + match(CWS); + } + } + setState(1896); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1897); + identifier(); + setState(1901); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1898); + match(WS); + } + } + setState(1903); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1904); + match(T__6); + setState(1908); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1905); + match(WS); + } + } + setState(1910); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1911); + plaintext_type(); + setState(1915); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1912); + match(WS); + } + } + setState(1917); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1918); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class EntryContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Entry_typeContext entry_type() { + return getRuleContext(Entry_typeContext.class,0); + } + public List CWS() { return getTokens(aleoParser.CWS); } + public TerminalNode CWS(int i) { + return getToken(aleoParser.CWS, i); + } + public List WS() { return getTokens(aleoParser.WS); } + public TerminalNode WS(int i) { + return getToken(aleoParser.WS, i); + } + public EntryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_entry; } + } + + public final EntryContext entry() throws RecognitionException { + EntryContext _localctx = new EntryContext(_ctx, getState()); + enterRule(_localctx, 162, RULE_entry); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1923); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CWS) { + { + { + setState(1920); + match(CWS); + } + } + setState(1925); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1926); + identifier(); + setState(1930); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1927); + match(WS); + } + } + setState(1932); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1933); + match(T__6); + setState(1937); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1934); + match(WS); + } + } + setState(1939); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1940); + entry_type(); + setState(1944); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==WS) { + { + { + setState(1941); + match(WS); + } + } + setState(1946); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1947); + match(T__1); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LocatorContext extends ParserRuleContext { + public Program_idContext program_id() { + return getRuleContext(Program_idContext.class,0); + } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public LocatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_locator; } + } + + public final LocatorContext locator() throws RecognitionException { + LocatorContext _localctx = new LocatorContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_locator); + try { + enterOuterAlt(_localctx, 1); + { + setState(1949); + program_id(); + setState(1950); + match(T__99); + setState(1951); + identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Cast_destinationContext extends ParserRuleContext { + public Register_typeContext register_type() { + return getRuleContext(Register_typeContext.class,0); + } + public LocatorContext locator() { + return getRuleContext(LocatorContext.class,0); + } + public Cast_destinationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cast_destination; } + } + + public final Cast_destinationContext cast_destination() throws RecognitionException { + Cast_destinationContext _localctx = new Cast_destinationContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_cast_destination); + try { + setState(1957); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,249,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1953); + register_type(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1954); + locator(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1955); + match(T__100); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1956); + match(T__101); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class LabelContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public LabelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_label; } + } + + public final LabelContext label() throws RecognitionException { + LabelContext _localctx = new LabelContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_label); + try { + enterOuterAlt(_localctx, 1); + { + setState(1959); + identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class IdentifierContext extends ParserRuleContext { + public List Letter() { return getTokens(aleoParser.Letter); } + public TerminalNode Letter(int i) { + return getToken(aleoParser.Letter, i); + } + public List DIGIT() { return getTokens(aleoParser.DIGIT); } + public TerminalNode DIGIT(int i) { + return getToken(aleoParser.DIGIT, i); + } + public IdentifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_identifier; } + } + + public final IdentifierContext identifier() throws RecognitionException { + IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_identifier); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1961); + match(Letter); + setState(1965); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,250,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1962); + _la = _input.LA(1); + if ( !(_la==T__36 || _la==Letter || _la==DIGIT) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + } + setState(1967); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,250,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Lowercase_identifierContext extends ParserRuleContext { + public List LL() { return getTokens(aleoParser.LL); } + public TerminalNode LL(int i) { + return getToken(aleoParser.LL, i); + } + public List DIGIT() { return getTokens(aleoParser.DIGIT); } + public TerminalNode DIGIT(int i) { + return getToken(aleoParser.DIGIT, i); + } + public Lowercase_identifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lowercase_identifier; } + } + + public final Lowercase_identifierContext lowercase_identifier() throws RecognitionException { + Lowercase_identifierContext _localctx = new Lowercase_identifierContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_lowercase_identifier); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1968); + match(LL); + setState(1972); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,251,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1969); + _la = _input.LA(1); + if ( !(_la==T__36 || _la==LL || _la==DIGIT) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + } + setState(1974); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,251,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Unary_opContext extends ParserRuleContext { + public Unary_opContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unary_op; } + } + + public final Unary_opContext unary_op() throws RecognitionException { + Unary_opContext _localctx = new Unary_opContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_unary_op); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1975); + _la = _input.LA(1); + if ( !(((((_la - 103)) & ~0x3f) == 0 && ((1L << (_la - 103)) & 255L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Binary_opContext extends ParserRuleContext { + public Binary_opContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_binary_op; } + } + + public final Binary_opContext binary_op() throws RecognitionException { + Binary_opContext _localctx = new Binary_opContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_binary_op); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1977); + _la = _input.LA(1); + if ( !(((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & 67108863L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Is_opContext extends ParserRuleContext { + public Is_opContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_is_op; } + } + + public final Is_opContext is_op() throws RecognitionException { + Is_opContext _localctx = new Is_opContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_is_op); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1979); + _la = _input.LA(1); + if ( !(_la==T__136 || _la==T__137) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Assert_opContext extends ParserRuleContext { + public Assert_opContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assert_op; } + } + + public final Assert_opContext assert_op() throws RecognitionException { + Assert_opContext _localctx = new Assert_opContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_assert_op); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1981); + _la = _input.LA(1); + if ( !(_la==T__138 || _la==T__139) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Commit_opContext extends ParserRuleContext { + public Commit_opContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_commit_op; } + } + + public final Commit_opContext commit_op() throws RecognitionException { + Commit_opContext _localctx = new Commit_opContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_commit_op); + int _la; + try { + setState(1987); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__140: + enterOuterAlt(_localctx, 1); + { + setState(1983); + match(T__140); + setState(1984); + _la = _input.LA(1); + if ( !(((((_la - 142)) & ~0x3f) == 0 && ((1L << (_la - 142)) & 15L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case T__145: + enterOuterAlt(_localctx, 2); + { + setState(1985); + match(T__145); + setState(1986); + _la = _input.LA(1); + if ( !(_la==T__146 || _la==T__147) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Hash1_opContext extends ParserRuleContext { + public Hash1_opContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_hash1_op; } + } + + public final Hash1_opContext hash1_op() throws RecognitionException { + Hash1_opContext _localctx = new Hash1_opContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_hash1_op); + int _la; + try { + setState(1999); + _errHandler.sync(this); + switch (_input.LA(1)) { + case T__148: + enterOuterAlt(_localctx, 1); + { + setState(1989); + match(T__148); + setState(1990); + _la = _input.LA(1); + if ( !(((((_la - 142)) & ~0x3f) == 0 && ((1L << (_la - 142)) & 15L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case T__149: + enterOuterAlt(_localctx, 2); + { + setState(1991); + match(T__149); + setState(1992); + _la = _input.LA(1); + if ( !(_la==T__146 || _la==T__147) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case T__150: + enterOuterAlt(_localctx, 3); + { + setState(1993); + match(T__150); + setState(1994); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 303465209266176L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case T__151: + enterOuterAlt(_localctx, 4); + { + setState(1995); + match(T__151); + setState(1996); + _la = _input.LA(1); + if ( !(((((_la - 142)) & ~0x3f) == 0 && ((1L << (_la - 142)) & 2051L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case T__153: + enterOuterAlt(_localctx, 5); + { + setState(1997); + match(T__153); + setState(1998); + _la = _input.LA(1); + if ( !(((((_la - 142)) & ~0x3f) == 0 && ((1L << (_la - 142)) & 2051L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Hash2_opContext extends ParserRuleContext { + public Hash2_opContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_hash2_op; } + } + + public final Hash2_opContext hash2_op() throws RecognitionException { + Hash2_opContext _localctx = new Hash2_opContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_hash2_op); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2001); + match(T__154); + setState(2002); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 303465209266176L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Cast_opContext extends ParserRuleContext { + public Cast_opContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cast_op; } + } + + public final Cast_opContext cast_op() throws RecognitionException { + Cast_opContext _localctx = new Cast_opContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_cast_op); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2004); + _la = _input.LA(1); + if ( !(_la==T__155 || _la==T__156) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Branch_opContext extends ParserRuleContext { + public Branch_opContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_branch_op; } + } + + public final Branch_opContext branch_op() throws RecognitionException { + Branch_opContext _localctx = new Branch_opContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_branch_op); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2006); + _la = _input.LA(1); + if ( !(_la==T__157 || _la==T__158) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static final String _serializedATN = + "\u0004\u0001\u00a8\u07d9\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+ + "\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+ + "\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+ + "\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+ + "\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007"+ + "\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007"+ + "\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007"+ + "\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007"+ + "\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007"+ + "\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007"+ + "\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007"+ + "\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007"+ + "\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007"+ + ",\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u0007"+ + "1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007"+ + "6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007"+ + ";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007"+ + "@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007"+ + "E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007"+ + "J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007"+ + "O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007"+ + "T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007"+ + "Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007"+ + "^\u0002_\u0007_\u0001\u0000\u0001\u0000\u0001\u0001\u0005\u0001\u00c4"+ + "\b\u0001\n\u0001\f\u0001\u00c7\t\u0001\u0001\u0001\u0005\u0001\u00ca\b"+ + "\u0001\n\u0001\f\u0001\u00cd\t\u0001\u0001\u0001\u0001\u0001\u0005\u0001"+ + "\u00d1\b\u0001\n\u0001\f\u0001\u00d4\t\u0001\u0001\u0001\u0001\u0001\u0005"+ + "\u0001\u00d8\b\u0001\n\u0001\f\u0001\u00db\t\u0001\u0001\u0001\u0001\u0001"+ + "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0004\u0001\u00e3\b\u0001"+ + "\u000b\u0001\f\u0001\u00e4\u0001\u0001\u0005\u0001\u00e8\b\u0001\n\u0001"+ + "\f\u0001\u00eb\t\u0001\u0001\u0002\u0005\u0002\u00ee\b\u0002\n\u0002\f"+ + "\u0002\u00f1\t\u0002\u0001\u0002\u0001\u0002\u0005\u0002\u00f5\b\u0002"+ + "\n\u0002\f\u0002\u00f8\t\u0002\u0001\u0002\u0001\u0002\u0005\u0002\u00fc"+ + "\b\u0002\n\u0002\f\u0002\u00ff\t\u0002\u0001\u0002\u0001\u0002\u0001\u0003"+ + "\u0005\u0003\u0104\b\u0003\n\u0003\f\u0003\u0107\t\u0003\u0001\u0003\u0001"+ + "\u0003\u0005\u0003\u010b\b\u0003\n\u0003\f\u0003\u010e\t\u0003\u0001\u0003"+ + "\u0001\u0003\u0005\u0003\u0112\b\u0003\n\u0003\f\u0003\u0115\t\u0003\u0001"+ + "\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0004\u0005\u0004\u011c"+ + "\b\u0004\n\u0004\f\u0004\u011f\t\u0004\u0001\u0004\u0001\u0004\u0005\u0004"+ + "\u0123\b\u0004\n\u0004\f\u0004\u0126\t\u0004\u0001\u0004\u0001\u0004\u0005"+ + "\u0004\u012a\b\u0004\n\u0004\f\u0004\u012d\t\u0004\u0001\u0004\u0001\u0004"+ + "\u0005\u0004\u0131\b\u0004\n\u0004\f\u0004\u0134\t\u0004\u0001\u0004\u0001"+ + "\u0004\u0001\u0005\u0005\u0005\u0139\b\u0005\n\u0005\f\u0005\u013c\t\u0005"+ + "\u0001\u0005\u0001\u0005\u0005\u0005\u0140\b\u0005\n\u0005\f\u0005\u0143"+ + "\t\u0005\u0001\u0005\u0001\u0005\u0005\u0005\u0147\b\u0005\n\u0005\f\u0005"+ + "\u014a\t\u0005\u0001\u0005\u0001\u0005\u0005\u0005\u014e\b\u0005\n\u0005"+ + "\f\u0005\u0151\t\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0005\u0006"+ + "\u0156\b\u0006\n\u0006\f\u0006\u0159\t\u0006\u0001\u0006\u0001\u0006\u0005"+ + "\u0006\u015d\b\u0006\n\u0006\f\u0006\u0160\t\u0006\u0001\u0006\u0001\u0006"+ + "\u0005\u0006\u0164\b\u0006\n\u0006\f\u0006\u0167\t\u0006\u0001\u0006\u0001"+ + "\u0006\u0004\u0006\u016b\b\u0006\u000b\u0006\f\u0006\u016c\u0001\u0007"+ + "\u0005\u0007\u0170\b\u0007\n\u0007\f\u0007\u0173\t\u0007\u0001\u0007\u0001"+ + "\u0007\u0005\u0007\u0177\b\u0007\n\u0007\f\u0007\u017a\t\u0007\u0001\u0007"+ + "\u0001\u0007\u0005\u0007\u017e\b\u0007\n\u0007\f\u0007\u0181\t\u0007\u0001"+ + "\u0007\u0001\u0007\u0005\u0007\u0185\b\u0007\n\u0007\f\u0007\u0188\t\u0007"+ + "\u0001\u0007\u0001\u0007\u0005\u0007\u018c\b\u0007\n\u0007\f\u0007\u018f"+ + "\t\u0007\u0001\u0007\u0001\u0007\u0005\u0007\u0193\b\u0007\n\u0007\f\u0007"+ + "\u0196\t\u0007\u0001\u0007\u0001\u0007\u0005\u0007\u019a\b\u0007\n\u0007"+ + "\f\u0007\u019d\t\u0007\u0001\u0007\u0001\u0007\u0005\u0007\u01a1\b\u0007"+ + "\n\u0007\f\u0007\u01a4\t\u0007\u0001\b\u0005\b\u01a7\b\b\n\b\f\b\u01aa"+ + "\t\b\u0001\b\u0001\b\u0005\b\u01ae\b\b\n\b\f\b\u01b1\t\b\u0001\b\u0001"+ + "\b\u0005\b\u01b5\b\b\n\b\f\b\u01b8\t\b\u0001\b\u0001\b\u0005\b\u01bc\b"+ + "\b\n\b\f\b\u01bf\t\b\u0001\b\u0004\b\u01c2\b\b\u000b\b\f\b\u01c3\u0001"+ + "\b\u0005\b\u01c7\b\b\n\b\f\b\u01ca\t\b\u0001\t\u0005\t\u01cd\b\t\n\t\f"+ + "\t\u01d0\t\t\u0001\t\u0001\t\u0005\t\u01d4\b\t\n\t\f\t\u01d7\t\t\u0001"+ + "\t\u0001\t\u0005\t\u01db\b\t\n\t\f\t\u01de\t\t\u0001\t\u0001\t\u0005\t"+ + "\u01e2\b\t\n\t\f\t\u01e5\t\t\u0001\t\u0001\t\u0005\t\u01e9\b\t\n\t\f\t"+ + "\u01ec\t\t\u0001\t\u0001\t\u0001\n\u0005\n\u01f1\b\n\n\n\f\n\u01f4\t\n"+ + "\u0001\n\u0001\n\u0005\n\u01f8\b\n\n\n\f\n\u01fb\t\n\u0001\n\u0001\n\u0005"+ + "\n\u01ff\b\n\n\n\f\n\u0202\t\n\u0001\n\u0001\n\u0005\n\u0206\b\n\n\n\f"+ + "\n\u0209\t\n\u0001\n\u0001\n\u0005\n\u020d\b\n\n\n\f\n\u0210\t\n\u0001"+ + "\n\u0001\n\u0001\u000b\u0005\u000b\u0215\b\u000b\n\u000b\f\u000b\u0218"+ + "\t\u000b\u0001\u000b\u0001\u000b\u0005\u000b\u021c\b\u000b\n\u000b\f\u000b"+ + "\u021f\t\u000b\u0001\u000b\u0001\u000b\u0005\u000b\u0223\b\u000b\n\u000b"+ + "\f\u000b\u0226\t\u000b\u0001\u000b\u0001\u000b\u0005\u000b\u022a\b\u000b"+ + "\n\u000b\f\u000b\u022d\t\u000b\u0001\u000b\u0005\u000b\u0230\b\u000b\n"+ + "\u000b\f\u000b\u0233\t\u000b\u0001\u000b\u0005\u000b\u0236\b\u000b\n\u000b"+ + "\f\u000b\u0239\t\u000b\u0001\u000b\u0003\u000b\u023c\b\u000b\u0001\f\u0005"+ + "\f\u023f\b\f\n\f\f\f\u0242\t\f\u0001\f\u0001\f\u0005\f\u0246\b\f\n\f\f"+ + "\f\u0249\t\f\u0001\f\u0001\f\u0005\f\u024d\b\f\n\f\f\f\u0250\t\f\u0001"+ + "\f\u0001\f\u0005\f\u0254\b\f\n\f\f\f\u0257\t\f\u0001\f\u0001\f\u0005\f"+ + "\u025b\b\f\n\f\f\f\u025e\t\f\u0001\f\u0001\f\u0001\r\u0005\r\u0263\b\r"+ + "\n\r\f\r\u0266\t\r\u0001\r\u0001\r\u0005\r\u026a\b\r\n\r\f\r\u026d\t\r"+ + "\u0001\r\u0001\r\u0005\r\u0271\b\r\n\r\f\r\u0274\t\r\u0001\r\u0001\r\u0005"+ + "\r\u0278\b\r\n\r\f\r\u027b\t\r\u0001\r\u0001\r\u0005\r\u027f\b\r\n\r\f"+ + "\r\u0282\t\r\u0001\r\u0001\r\u0001\u000e\u0005\u000e\u0287\b\u000e\n\u000e"+ + "\f\u000e\u028a\t\u000e\u0001\u000e\u0001\u000e\u0005\u000e\u028e\b\u000e"+ + "\n\u000e\f\u000e\u0291\t\u000e\u0001\u000e\u0001\u000e\u0005\u000e\u0295"+ + "\b\u000e\n\u000e\f\u000e\u0298\t\u000e\u0001\u000e\u0001\u000e\u0005\u000e"+ + "\u029c\b\u000e\n\u000e\f\u000e\u029f\t\u000e\u0001\u000e\u0004\u000e\u02a2"+ + "\b\u000e\u000b\u000e\f\u000e\u02a3\u0001\u000f\u0005\u000f\u02a7\b\u000f"+ + "\n\u000f\f\u000f\u02aa\t\u000f\u0001\u000f\u0001\u000f\u0005\u000f\u02ae"+ + "\b\u000f\n\u000f\f\u000f\u02b1\t\u000f\u0001\u000f\u0001\u000f\u0005\u000f"+ + "\u02b5\b\u000f\n\u000f\f\u000f\u02b8\t\u000f\u0001\u000f\u0001\u000f\u0005"+ + "\u000f\u02bc\b\u000f\n\u000f\f\u000f\u02bf\t\u000f\u0001\u000f\u0001\u000f"+ + "\u0005\u000f\u02c3\b\u000f\n\u000f\f\u000f\u02c6\t\u000f\u0001\u000f\u0001"+ + "\u000f\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001"+ + "\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0003\u0010\u02d4"+ + "\b\u0010\u0001\u0011\u0005\u0011\u02d7\b\u0011\n\u0011\f\u0011\u02da\t"+ + "\u0011\u0001\u0011\u0001\u0011\u0005\u0011\u02de\b\u0011\n\u0011\f\u0011"+ + "\u02e1\t\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0005\u0011\u02e6\b"+ + "\u0011\n\u0011\f\u0011\u02e9\t\u0011\u0001\u0011\u0001\u0011\u0005\u0011"+ + "\u02ed\b\u0011\n\u0011\f\u0011\u02f0\t\u0011\u0001\u0011\u0001\u0011\u0005"+ + "\u0011\u02f4\b\u0011\n\u0011\f\u0011\u02f7\t\u0011\u0001\u0011\u0001\u0011"+ + "\u0005\u0011\u02fb\b\u0011\n\u0011\f\u0011\u02fe\t\u0011\u0001\u0011\u0001"+ + "\u0011\u0005\u0011\u0302\b\u0011\n\u0011\f\u0011\u0305\t\u0011\u0001\u0011"+ + "\u0001\u0011\u0001\u0012\u0005\u0012\u030a\b\u0012\n\u0012\f\u0012\u030d"+ + "\t\u0012\u0001\u0012\u0001\u0012\u0005\u0012\u0311\b\u0012\n\u0012\f\u0012"+ + "\u0314\t\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0005\u0012\u0319\b"+ + "\u0012\n\u0012\f\u0012\u031c\t\u0012\u0001\u0012\u0001\u0012\u0005\u0012"+ + "\u0320\b\u0012\n\u0012\f\u0012\u0323\t\u0012\u0001\u0012\u0001\u0012\u0005"+ + "\u0012\u0327\b\u0012\n\u0012\f\u0012\u032a\t\u0012\u0001\u0012\u0001\u0012"+ + "\u0005\u0012\u032e\b\u0012\n\u0012\f\u0012\u0331\t\u0012\u0001\u0012\u0001"+ + "\u0012\u0005\u0012\u0335\b\u0012\n\u0012\f\u0012\u0338\t\u0012\u0001\u0012"+ + "\u0001\u0012\u0001\u0013\u0005\u0013\u033d\b\u0013\n\u0013\f\u0013\u0340"+ + "\t\u0013\u0001\u0013\u0001\u0013\u0005\u0013\u0344\b\u0013\n\u0013\f\u0013"+ + "\u0347\t\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0005\u0013\u034c\b"+ + "\u0013\n\u0013\f\u0013\u034f\t\u0013\u0001\u0013\u0001\u0013\u0005\u0013"+ + "\u0353\b\u0013\n\u0013\f\u0013\u0356\t\u0013\u0001\u0013\u0001\u0013\u0005"+ + "\u0013\u035a\b\u0013\n\u0013\f\u0013\u035d\t\u0013\u0001\u0013\u0001\u0013"+ + "\u0005\u0013\u0361\b\u0013\n\u0013\f\u0013\u0364\t\u0013\u0001\u0013\u0001"+ + "\u0013\u0005\u0013\u0368\b\u0013\n\u0013\f\u0013\u036b\t\u0013\u0001\u0013"+ + "\u0001\u0013\u0005\u0013\u036f\b\u0013\n\u0013\f\u0013\u0372\t\u0013\u0001"+ + "\u0013\u0001\u0013\u0001\u0014\u0005\u0014\u0377\b\u0014\n\u0014\f\u0014"+ + "\u037a\t\u0014\u0001\u0014\u0001\u0014\u0005\u0014\u037e\b\u0014\n\u0014"+ + "\f\u0014\u0381\t\u0014\u0001\u0014\u0001\u0014\u0005\u0014\u0385\b\u0014"+ + "\n\u0014\f\u0014\u0388\t\u0014\u0001\u0014\u0001\u0014\u0005\u0014\u038c"+ + "\b\u0014\n\u0014\f\u0014\u038f\t\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+ + "\u0005\u0014\u0394\b\u0014\n\u0014\f\u0014\u0397\t\u0014\u0001\u0014\u0001"+ + "\u0014\u0005\u0014\u039b\b\u0014\n\u0014\f\u0014\u039e\t\u0014\u0001\u0014"+ + "\u0001\u0014\u0005\u0014\u03a2\b\u0014\n\u0014\f\u0014\u03a5\t\u0014\u0001"+ + "\u0014\u0001\u0014\u0001\u0015\u0005\u0015\u03aa\b\u0015\n\u0015\f\u0015"+ + "\u03ad\t\u0015\u0001\u0015\u0001\u0015\u0005\u0015\u03b1\b\u0015\n\u0015"+ + "\f\u0015\u03b4\t\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0005\u0015"+ + "\u03b9\b\u0015\n\u0015\f\u0015\u03bc\t\u0015\u0001\u0015\u0001\u0015\u0005"+ + "\u0015\u03c0\b\u0015\n\u0015\f\u0015\u03c3\t\u0015\u0001\u0015\u0001\u0015"+ + "\u0005\u0015\u03c7\b\u0015\n\u0015\f\u0015\u03ca\t\u0015\u0001\u0015\u0001"+ + "\u0015\u0001\u0016\u0005\u0016\u03cf\b\u0016\n\u0016\f\u0016\u03d2\t\u0016"+ + "\u0001\u0016\u0001\u0016\u0005\u0016\u03d6\b\u0016\n\u0016\f\u0016\u03d9"+ + "\t\u0016\u0001\u0016\u0005\u0016\u03dc\b\u0016\n\u0016\f\u0016\u03df\t"+ + "\u0016\u0001\u0016\u0005\u0016\u03e2\b\u0016\n\u0016\f\u0016\u03e5\t\u0016"+ + "\u0001\u0016\u0001\u0016\u0005\u0016\u03e9\b\u0016\n\u0016\f\u0016\u03ec"+ + "\t\u0016\u0001\u0016\u0001\u0016\u0005\u0016\u03f0\b\u0016\n\u0016\f\u0016"+ + "\u03f3\t\u0016\u0001\u0016\u0001\u0016\u0005\u0016\u03f7\b\u0016\n\u0016"+ + "\f\u0016\u03fa\t\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016"+ + "\u0003\u0016\u0400\b\u0016\u0001\u0016\u0005\u0016\u0403\b\u0016\n\u0016"+ + "\f\u0016\u0406\t\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0005\u0017"+ + "\u040b\b\u0017\n\u0017\f\u0017\u040e\t\u0017\u0001\u0017\u0001\u0017\u0005"+ + "\u0017\u0412\b\u0017\n\u0017\f\u0017\u0415\t\u0017\u0001\u0017\u0001\u0017"+ + "\u0005\u0017\u0419\b\u0017\n\u0017\f\u0017\u041c\t\u0017\u0001\u0017\u0001"+ + "\u0017\u0001\u0018\u0005\u0018\u0421\b\u0018\n\u0018\f\u0018\u0424\t\u0018"+ + "\u0001\u0018\u0001\u0018\u0005\u0018\u0428\b\u0018\n\u0018\f\u0018\u042b"+ + "\t\u0018\u0001\u0018\u0005\u0018\u042e\b\u0018\n\u0018\f\u0018\u0431\t"+ + "\u0018\u0001\u0018\u0001\u0018\u0005\u0018\u0435\b\u0018\n\u0018\f\u0018"+ + "\u0438\t\u0018\u0001\u0018\u0001\u0018\u0005\u0018\u043c\b\u0018\n\u0018"+ + "\f\u0018\u043f\t\u0018\u0001\u0018\u0001\u0018\u0005\u0018\u0443\b\u0018"+ + "\n\u0018\f\u0018\u0446\t\u0018\u0001\u0018\u0001\u0018\u0005\u0018\u044a"+ + "\b\u0018\n\u0018\f\u0018\u044d\t\u0018\u0001\u0018\u0001\u0018\u0001\u0019"+ + "\u0005\u0019\u0452\b\u0019\n\u0019\f\u0019\u0455\t\u0019\u0001\u0019\u0001"+ + "\u0019\u0005\u0019\u0459\b\u0019\n\u0019\f\u0019\u045c\t\u0019\u0001\u0019"+ + "\u0001\u0019\u0005\u0019\u0460\b\u0019\n\u0019\f\u0019\u0463\t\u0019\u0001"+ + "\u0019\u0001\u0019\u0001\u001a\u0005\u001a\u0468\b\u001a\n\u001a\f\u001a"+ + "\u046b\t\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+ + "\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+ + "\u0003\u001a\u0478\b\u001a\u0001\u001a\u0005\u001a\u047b\b\u001a\n\u001a"+ + "\f\u001a\u047e\t\u001a\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b"+ + "\u0005\u001b\u0484\b\u001b\n\u001b\f\u001b\u0487\t\u001b\u0001\u001b\u0001"+ + "\u001b\u0005\u001b\u048b\b\u001b\n\u001b\f\u001b\u048e\t\u001b\u0001\u001b"+ + "\u0001\u001b\u0005\u001b\u0492\b\u001b\n\u001b\f\u001b\u0495\t\u001b\u0001"+ + "\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0005\u001c\u049b\b\u001c\n"+ + "\u001c\f\u001c\u049e\t\u001c\u0001\u001c\u0001\u001c\u0005\u001c\u04a2"+ + "\b\u001c\n\u001c\f\u001c\u04a5\t\u001c\u0001\u001c\u0001\u001c\u0005\u001c"+ + "\u04a9\b\u001c\n\u001c\f\u001c\u04ac\t\u001c\u0001\u001c\u0001\u001c\u0005"+ + "\u001c\u04b0\b\u001c\n\u001c\f\u001c\u04b3\t\u001c\u0001\u001c\u0001\u001c"+ + "\u0001\u001d\u0001\u001d\u0005\u001d\u04b9\b\u001d\n\u001d\f\u001d\u04bc"+ + "\t\u001d\u0001\u001d\u0001\u001d\u0005\u001d\u04c0\b\u001d\n\u001d\f\u001d"+ + "\u04c3\t\u001d\u0001\u001d\u0001\u001d\u0005\u001d\u04c7\b\u001d\n\u001d"+ + "\f\u001d\u04ca\t\u001d\u0001\u001d\u0001\u001d\u0005\u001d\u04ce\b\u001d"+ + "\n\u001d\f\u001d\u04d1\t\u001d\u0001\u001d\u0001\u001d\u0005\u001d\u04d5"+ + "\b\u001d\n\u001d\f\u001d\u04d8\t\u001d\u0001\u001d\u0001\u001d\u0001\u001e"+ + "\u0001\u001e\u0005\u001e\u04de\b\u001e\n\u001e\f\u001e\u04e1\t\u001e\u0001"+ + "\u001e\u0001\u001e\u0005\u001e\u04e5\b\u001e\n\u001e\f\u001e\u04e8\t\u001e"+ + "\u0001\u001e\u0001\u001e\u0005\u001e\u04ec\b\u001e\n\u001e\f\u001e\u04ef"+ + "\t\u001e\u0001\u001e\u0001\u001e\u0005\u001e\u04f3\b\u001e\n\u001e\f\u001e"+ + "\u04f6\t\u001e\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0005\u001f"+ + "\u04fc\b\u001f\n\u001f\f\u001f\u04ff\t\u001f\u0001\u001f\u0001\u001f\u0005"+ + "\u001f\u0503\b\u001f\n\u001f\f\u001f\u0506\t\u001f\u0001\u001f\u0001\u001f"+ + "\u0001 \u0001 \u0005 \u050c\b \n \f \u050f\t \u0001 \u0001 \u0005 \u0513"+ + "\b \n \f \u0516\t \u0001 \u0001 \u0005 \u051a\b \n \f \u051d\t \u0001"+ + " \u0001 \u0005 \u0521\b \n \f \u0524\t \u0001 \u0001 \u0005 \u0528\b "+ + "\n \f \u052b\t \u0001 \u0001 \u0005 \u052f\b \n \f \u0532\t \u0001 \u0001"+ + " \u0001 \u0003 \u0537\b \u0001!\u0001!\u0005!\u053b\b!\n!\f!\u053e\t!"+ + "\u0001!\u0001!\u0005!\u0542\b!\n!\f!\u0545\t!\u0001!\u0001!\u0005!\u0549"+ + "\b!\n!\f!\u054c\t!\u0001!\u0001!\u0005!\u0550\b!\n!\f!\u0553\t!\u0001"+ + "!\u0001!\u0005!\u0557\b!\n!\f!\u055a\t!\u0001!\u0001!\u0001!\u0001!\u0001"+ + "!\u0003!\u0561\b!\u0001\"\u0001\"\u0005\"\u0565\b\"\n\"\f\"\u0568\t\""+ + "\u0001\"\u0001\"\u0005\"\u056c\b\"\n\"\f\"\u056f\t\"\u0001\"\u0001\"\u0005"+ + "\"\u0573\b\"\n\"\f\"\u0576\t\"\u0001\"\u0001\"\u0005\"\u057a\b\"\n\"\f"+ + "\"\u057d\t\"\u0001\"\u0001\"\u0005\"\u0581\b\"\n\"\f\"\u0584\t\"\u0001"+ + "\"\u0001\"\u0005\"\u0588\b\"\n\"\f\"\u058b\t\"\u0001\"\u0001\"\u0001\""+ + "\u0001\"\u0001\"\u0003\"\u0592\b\"\u0001#\u0001#\u0003#\u0596\b#\u0001"+ + "$\u0001$\u0005$\u059a\b$\n$\f$\u059d\t$\u0001$\u0001$\u0005$\u05a1\b$"+ + "\n$\f$\u05a4\t$\u0001$\u0001$\u0005$\u05a8\b$\n$\f$\u05ab\t$\u0001$\u0001"+ + "$\u0005$\u05af\b$\n$\f$\u05b2\t$\u0001$\u0001$\u0005$\u05b6\b$\n$\f$\u05b9"+ + "\t$\u0001$\u0001$\u0001%\u0001%\u0005%\u05bf\b%\n%\f%\u05c2\t%\u0001%"+ + "\u0004%\u05c5\b%\u000b%\f%\u05c6\u0001%\u0005%\u05ca\b%\n%\f%\u05cd\t"+ + "%\u0001%\u0001%\u0005%\u05d1\b%\n%\f%\u05d4\t%\u0001%\u0001%\u0005%\u05d8"+ + "\b%\n%\f%\u05db\t%\u0001%\u0001%\u0005%\u05df\b%\n%\f%\u05e2\t%\u0001"+ + "%\u0001%\u0001&\u0001&\u0005&\u05e8\b&\n&\f&\u05eb\t&\u0001&\u0001&\u0003"+ + "&\u05ef\b&\u0001&\u0005&\u05f2\b&\n&\f&\u05f5\t&\u0001&\u0005&\u05f8\b"+ + "&\n&\f&\u05fb\t&\u0001&\u0005&\u05fe\b&\n&\f&\u0601\t&\u0001&\u0001&\u0001"+ + "&\u0004&\u0606\b&\u000b&\f&\u0607\u0003&\u060a\b&\u0001\'\u0005\'\u060d"+ + "\b\'\n\'\f\'\u0610\t\'\u0001\'\u0001\'\u0005\'\u0614\b\'\n\'\f\'\u0617"+ + "\t\'\u0001\'\u0001\'\u0005\'\u061b\b\'\n\'\f\'\u061e\t\'\u0001\'\u0005"+ + "\'\u0621\b\'\n\'\f\'\u0624\t\'\u0001\'\u0005\'\u0627\b\'\n\'\f\'\u062a"+ + "\t\'\u0001\'\u0001\'\u0005\'\u062e\b\'\n\'\f\'\u0631\t\'\u0001\'\u0001"+ + "\'\u0001(\u0001(\u0001(\u0001(\u0003(\u0639\b(\u0001)\u0003)\u063c\b)"+ + "\u0001)\u0001)\u0005)\u0640\b)\n)\f)\u0643\t)\u0004)\u0645\b)\u000b)\f"+ + ")\u0646\u0001)\u0001)\u0001*\u0003*\u064c\b*\u0001*\u0001*\u0005*\u0650"+ + "\b*\n*\f*\u0653\t*\u0004*\u0655\b*\u000b*\f*\u0656\u0001*\u0001*\u0001"+ + "+\u0001+\u0003+\u065d\b+\u0001,\u0003,\u0660\b,\u0001,\u0001,\u0005,\u0664"+ + "\b,\n,\f,\u0667\t,\u0004,\u0669\b,\u000b,\f,\u066a\u0001,\u0001,\u0001"+ + "-\u0003-\u0670\b-\u0001-\u0001-\u0005-\u0674\b-\n-\f-\u0677\t-\u0004-"+ + "\u0679\b-\u000b-\f-\u067a\u0001-\u0001-\u0001.\u0003.\u0680\b.\u0001."+ + "\u0001.\u0005.\u0684\b.\n.\f.\u0687\t.\u0004.\u0689\b.\u000b.\f.\u068a"+ + "\u0001.\u0001.\u0001/\u0001/\u0001/\u0001/\u0003/\u0693\b/\u00010\u0003"+ + "0\u0696\b0\u00010\u00010\u00050\u069a\b0\n0\f0\u069d\t0\u00040\u069f\b"+ + "0\u000b0\f0\u06a0\u00010\u00010\u00011\u00011\u00011\u00051\u06a8\b1\n"+ + "1\f1\u06ab\t1\u00041\u06ad\b1\u000b1\f1\u06ae\u00012\u00012\u00012\u0005"+ + "2\u06b4\b2\n2\f2\u06b7\t2\u00042\u06b9\b2\u000b2\f2\u06ba\u00013\u0001"+ + "3\u00014\u00014\u00015\u00015\u00016\u00016\u00017\u00017\u00037\u06c7"+ + "\b7\u00018\u00018\u00019\u00019\u0001:\u0001:\u0001;\u0001;\u0001;\u0001"+ + ";\u0003;\u06d3\b;\u0001<\u0001<\u0001=\u0001=\u0001>\u0001>\u0001?\u0001"+ + "?\u0001?\u0001?\u0003?\u06df\b?\u0001@\u0001@\u0005@\u06e3\b@\n@\f@\u06e6"+ + "\t@\u0001@\u0001@\u0005@\u06ea\b@\n@\f@\u06ed\t@\u0001@\u0001@\u0005@"+ + "\u06f1\b@\n@\f@\u06f4\t@\u0001@\u0001@\u0005@\u06f8\b@\n@\f@\u06fb\t@"+ + "\u0001@\u0001@\u0001A\u0001A\u0001A\u0003A\u0702\bA\u0001B\u0001B\u0001"+ + "B\u0001B\u0001B\u0001B\u0001B\u0001B\u0001B\u0001B\u0001B\u0001B\u0001"+ + "B\u0001B\u0001B\u0001B\u0001B\u0001B\u0003B\u0716\bB\u0001C\u0001C\u0001"+ + "C\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0003D\u0721\bD\u0001E\u0001"+ + "E\u0001E\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+ + "F\u0001F\u0003F\u0730\bF\u0001G\u0001G\u0001G\u0001G\u0001H\u0001H\u0001"+ + "I\u0001I\u0001J\u0001J\u0004J\u073c\bJ\u000bJ\fJ\u073d\u0001K\u0001K\u0005"+ + "K\u0742\bK\nK\fK\u0745\tK\u0001L\u0001L\u0003L\u0749\bL\u0001M\u0001M"+ + "\u0001M\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0004N\u0754\bN\u000b"+ + "N\fN\u0755\u0001N\u0003N\u0759\bN\u0001O\u0001O\u0001O\u0001O\u0001O\u0001"+ + "O\u0001O\u0003O\u0762\bO\u0001P\u0005P\u0765\bP\nP\fP\u0768\tP\u0001P"+ + "\u0001P\u0005P\u076c\bP\nP\fP\u076f\tP\u0001P\u0001P\u0005P\u0773\bP\n"+ + "P\fP\u0776\tP\u0001P\u0001P\u0005P\u077a\bP\nP\fP\u077d\tP\u0001P\u0001"+ + "P\u0001Q\u0005Q\u0782\bQ\nQ\fQ\u0785\tQ\u0001Q\u0001Q\u0005Q\u0789\bQ"+ + "\nQ\fQ\u078c\tQ\u0001Q\u0001Q\u0005Q\u0790\bQ\nQ\fQ\u0793\tQ\u0001Q\u0001"+ + "Q\u0005Q\u0797\bQ\nQ\fQ\u079a\tQ\u0001Q\u0001Q\u0001R\u0001R\u0001R\u0001"+ + "R\u0001S\u0001S\u0001S\u0001S\u0003S\u07a6\bS\u0001T\u0001T\u0001U\u0001"+ + "U\u0005U\u07ac\bU\nU\fU\u07af\tU\u0001V\u0001V\u0005V\u07b3\bV\nV\fV\u07b6"+ + "\tV\u0001W\u0001W\u0001X\u0001X\u0001Y\u0001Y\u0001Z\u0001Z\u0001[\u0001"+ + "[\u0001[\u0001[\u0003[\u07c4\b[\u0001\\\u0001\\\u0001\\\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0003\\\u07d0\b\\\u0001]\u0001"+ + "]\u0001]\u0001^\u0001^\u0001_\u0001_\u0001_\u0000\u0000`\u0000\u0002\u0004"+ + "\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e \""+ + "$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086"+ + "\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e"+ + "\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6"+ + "\u00b8\u00ba\u00bc\u00be\u0000\u0013\u0001\u0000\f\r\u0001\u0000 !\u0001"+ + "\u0000)H\u0001\u0000IJ\u0002\u0000&&KN\u0001\u0000OS\u0001\u0000Z\\\u0003"+ + "\u0000%%\u00a0\u00a0\u00a3\u00a3\u0002\u0000%%\u00a2\u00a3\u0001\u0000"+ + "gn\u0001\u0000o\u0088\u0001\u0000\u0089\u008a\u0001\u0000\u008b\u008c"+ + "\u0001\u0000\u008e\u0091\u0001\u0000\u0093\u0094\u0003\u0000**,,00\u0002"+ + "\u0000\u008e\u008f\u0099\u0099\u0001\u0000\u009c\u009d\u0001\u0000\u009e"+ + "\u009f\u08ac\u0000\u00c0\u0001\u0000\u0000\u0000\u0002\u00c5\u0001\u0000"+ + "\u0000\u0000\u0004\u00ef\u0001\u0000\u0000\u0000\u0006\u0105\u0001\u0000"+ + "\u0000\u0000\b\u011d\u0001\u0000\u0000\u0000\n\u013a\u0001\u0000\u0000"+ + "\u0000\f\u0157\u0001\u0000\u0000\u0000\u000e\u0171\u0001\u0000\u0000\u0000"+ + "\u0010\u01a8\u0001\u0000\u0000\u0000\u0012\u01ce\u0001\u0000\u0000\u0000"+ + "\u0014\u01f2\u0001\u0000\u0000\u0000\u0016\u0216\u0001\u0000\u0000\u0000"+ + "\u0018\u0240\u0001\u0000\u0000\u0000\u001a\u0264\u0001\u0000\u0000\u0000"+ + "\u001c\u0288\u0001\u0000\u0000\u0000\u001e\u02a8\u0001\u0000\u0000\u0000"+ + " \u02d3\u0001\u0000\u0000\u0000\"\u02d8\u0001\u0000\u0000\u0000$\u030b"+ + "\u0001\u0000\u0000\u0000&\u033e\u0001\u0000\u0000\u0000(\u0378\u0001\u0000"+ + "\u0000\u0000*\u03ab\u0001\u0000\u0000\u0000,\u03d0\u0001\u0000\u0000\u0000"+ + ".\u040c\u0001\u0000\u0000\u00000\u0422\u0001\u0000\u0000\u00002\u0453"+ + "\u0001\u0000\u0000\u00004\u0469\u0001\u0000\u0000\u00006\u0481\u0001\u0000"+ + "\u0000\u00008\u0498\u0001\u0000\u0000\u0000:\u04b6\u0001\u0000\u0000\u0000"+ + "<\u04db\u0001\u0000\u0000\u0000>\u04f9\u0001\u0000\u0000\u0000@\u0509"+ + "\u0001\u0000\u0000\u0000B\u0538\u0001\u0000\u0000\u0000D\u0562\u0001\u0000"+ + "\u0000\u0000F\u0595\u0001\u0000\u0000\u0000H\u0597\u0001\u0000\u0000\u0000"+ + "J\u05bc\u0001\u0000\u0000\u0000L\u05e5\u0001\u0000\u0000\u0000N\u060e"+ + "\u0001\u0000\u0000\u0000P\u0638\u0001\u0000\u0000\u0000R\u063b\u0001\u0000"+ + "\u0000\u0000T\u064b\u0001\u0000\u0000\u0000V\u065c\u0001\u0000\u0000\u0000"+ + "X\u065f\u0001\u0000\u0000\u0000Z\u066f\u0001\u0000\u0000\u0000\\\u067f"+ + "\u0001\u0000\u0000\u0000^\u0692\u0001\u0000\u0000\u0000`\u0695\u0001\u0000"+ + "\u0000\u0000b\u06a4\u0001\u0000\u0000\u0000d\u06b0\u0001\u0000\u0000\u0000"+ + "f\u06bc\u0001\u0000\u0000\u0000h\u06be\u0001\u0000\u0000\u0000j\u06c0"+ + "\u0001\u0000\u0000\u0000l\u06c2\u0001\u0000\u0000\u0000n\u06c6\u0001\u0000"+ + "\u0000\u0000p\u06c8\u0001\u0000\u0000\u0000r\u06ca\u0001\u0000\u0000\u0000"+ + "t\u06cc\u0001\u0000\u0000\u0000v\u06d2\u0001\u0000\u0000\u0000x\u06d4"+ + "\u0001\u0000\u0000\u0000z\u06d6\u0001\u0000\u0000\u0000|\u06d8\u0001\u0000"+ + "\u0000\u0000~\u06de\u0001\u0000\u0000\u0000\u0080\u06e0\u0001\u0000\u0000"+ + "\u0000\u0082\u0701\u0001\u0000\u0000\u0000\u0084\u0715\u0001\u0000\u0000"+ + "\u0000\u0086\u0717\u0001\u0000\u0000\u0000\u0088\u0720\u0001\u0000\u0000"+ + "\u0000\u008a\u0722\u0001\u0000\u0000\u0000\u008c\u072f\u0001\u0000\u0000"+ + "\u0000\u008e\u0731\u0001\u0000\u0000\u0000\u0090\u0735\u0001\u0000\u0000"+ + "\u0000\u0092\u0737\u0001\u0000\u0000\u0000\u0094\u0739\u0001\u0000\u0000"+ + "\u0000\u0096\u073f\u0001\u0000\u0000\u0000\u0098\u0748\u0001\u0000\u0000"+ + "\u0000\u009a\u074a\u0001\u0000\u0000\u0000\u009c\u0758\u0001\u0000\u0000"+ + "\u0000\u009e\u0761\u0001\u0000\u0000\u0000\u00a0\u0766\u0001\u0000\u0000"+ + "\u0000\u00a2\u0783\u0001\u0000\u0000\u0000\u00a4\u079d\u0001\u0000\u0000"+ + "\u0000\u00a6\u07a5\u0001\u0000\u0000\u0000\u00a8\u07a7\u0001\u0000\u0000"+ + "\u0000\u00aa\u07a9\u0001\u0000\u0000\u0000\u00ac\u07b0\u0001\u0000\u0000"+ + "\u0000\u00ae\u07b7\u0001\u0000\u0000\u0000\u00b0\u07b9\u0001\u0000\u0000"+ + "\u0000\u00b2\u07bb\u0001\u0000\u0000\u0000\u00b4\u07bd\u0001\u0000\u0000"+ + "\u0000\u00b6\u07c3\u0001\u0000\u0000\u0000\u00b8\u07cf\u0001\u0000\u0000"+ + "\u0000\u00ba\u07d1\u0001\u0000\u0000\u0000\u00bc\u07d4\u0001\u0000\u0000"+ + "\u0000\u00be\u07d6\u0001\u0000\u0000\u0000\u00c0\u00c1\u0003\u0002\u0001"+ + "\u0000\u00c1\u0001\u0001\u0000\u0000\u0000\u00c2\u00c4\u0003\u0004\u0002"+ + "\u0000\u00c3\u00c2\u0001\u0000\u0000\u0000\u00c4\u00c7\u0001\u0000\u0000"+ + "\u0000\u00c5\u00c3\u0001\u0000\u0000\u0000\u00c5\u00c6\u0001\u0000\u0000"+ + "\u0000\u00c6\u00cb\u0001\u0000\u0000\u0000\u00c7\u00c5\u0001\u0000\u0000"+ + "\u0000\u00c8\u00ca\u0005\u00a8\u0000\u0000\u00c9\u00c8\u0001\u0000\u0000"+ + "\u0000\u00ca\u00cd\u0001\u0000\u0000\u0000\u00cb\u00c9\u0001\u0000\u0000"+ + "\u0000\u00cb\u00cc\u0001\u0000\u0000\u0000\u00cc\u00ce\u0001\u0000\u0000"+ + "\u0000\u00cd\u00cb\u0001\u0000\u0000\u0000\u00ce\u00d2\u0005\u0001\u0000"+ + "\u0000\u00cf\u00d1\u0005\u00a7\u0000\u0000\u00d0\u00cf\u0001\u0000\u0000"+ + "\u0000\u00d1\u00d4\u0001\u0000\u0000\u0000\u00d2\u00d0\u0001\u0000\u0000"+ + "\u0000\u00d2\u00d3\u0001\u0000\u0000\u0000\u00d3\u00d5\u0001\u0000\u0000"+ + "\u0000\u00d4\u00d2\u0001\u0000\u0000\u0000\u00d5\u00d9\u0003\u008eG\u0000"+ + "\u00d6\u00d8\u0005\u00a7\u0000\u0000\u00d7\u00d6\u0001\u0000\u0000\u0000"+ + "\u00d8\u00db\u0001\u0000\u0000\u0000\u00d9\u00d7\u0001\u0000\u0000\u0000"+ + "\u00d9\u00da\u0001\u0000\u0000\u0000\u00da\u00dc\u0001\u0000\u0000\u0000"+ + "\u00db\u00d9\u0001\u0000\u0000\u0000\u00dc\u00e2\u0005\u0002\u0000\u0000"+ + "\u00dd\u00e3\u0003\u0006\u0003\u0000\u00de\u00e3\u0003\f\u0006\u0000\u00df"+ + "\u00e3\u0003\u000e\u0007\u0000\u00e0\u00e3\u0003\u0010\b\u0000\u00e1\u00e3"+ + "\u0003\u0016\u000b\u0000\u00e2\u00dd\u0001\u0000\u0000\u0000\u00e2\u00de"+ + "\u0001\u0000\u0000\u0000\u00e2\u00df\u0001\u0000\u0000\u0000\u00e2\u00e0"+ + "\u0001\u0000\u0000\u0000\u00e2\u00e1\u0001\u0000\u0000\u0000\u00e3\u00e4"+ + "\u0001\u0000\u0000\u0000\u00e4\u00e2\u0001\u0000\u0000\u0000\u00e4\u00e5"+ + "\u0001\u0000\u0000\u0000\u00e5\u00e9\u0001\u0000\u0000\u0000\u00e6\u00e8"+ + "\u0005\u00a8\u0000\u0000\u00e7\u00e6\u0001\u0000\u0000\u0000\u00e8\u00eb"+ + "\u0001\u0000\u0000\u0000\u00e9\u00e7\u0001\u0000\u0000\u0000\u00e9\u00ea"+ + "\u0001\u0000\u0000\u0000\u00ea\u0003\u0001\u0000\u0000\u0000\u00eb\u00e9"+ + "\u0001\u0000\u0000\u0000\u00ec\u00ee\u0005\u00a8\u0000\u0000\u00ed\u00ec"+ + "\u0001\u0000\u0000\u0000\u00ee\u00f1\u0001\u0000\u0000\u0000\u00ef\u00ed"+ + "\u0001\u0000\u0000\u0000\u00ef\u00f0\u0001\u0000\u0000\u0000\u00f0\u00f2"+ + "\u0001\u0000\u0000\u0000\u00f1\u00ef\u0001\u0000\u0000\u0000\u00f2\u00f6"+ + "\u0005\u0003\u0000\u0000\u00f3\u00f5\u0005\u00a7\u0000\u0000\u00f4\u00f3"+ + "\u0001\u0000\u0000\u0000\u00f5\u00f8\u0001\u0000\u0000\u0000\u00f6\u00f4"+ + "\u0001\u0000\u0000\u0000\u00f6\u00f7\u0001\u0000\u0000\u0000\u00f7\u00f9"+ + "\u0001\u0000\u0000\u0000\u00f8\u00f6\u0001\u0000\u0000\u0000\u00f9\u00fd"+ + "\u0003\u008eG\u0000\u00fa\u00fc\u0005\u00a7\u0000\u0000\u00fb\u00fa\u0001"+ + "\u0000\u0000\u0000\u00fc\u00ff\u0001\u0000\u0000\u0000\u00fd\u00fb\u0001"+ + "\u0000\u0000\u0000\u00fd\u00fe\u0001\u0000\u0000\u0000\u00fe\u0100\u0001"+ + "\u0000\u0000\u0000\u00ff\u00fd\u0001\u0000\u0000\u0000\u0100\u0101\u0005"+ + "\u0002\u0000\u0000\u0101\u0005\u0001\u0000\u0000\u0000\u0102\u0104\u0005"+ + "\u00a8\u0000\u0000\u0103\u0102\u0001\u0000\u0000\u0000\u0104\u0107\u0001"+ + "\u0000\u0000\u0000\u0105\u0103\u0001\u0000\u0000\u0000\u0105\u0106\u0001"+ + "\u0000\u0000\u0000\u0106\u0108\u0001\u0000\u0000\u0000\u0107\u0105\u0001"+ + "\u0000\u0000\u0000\u0108\u010c\u0005\u0004\u0000\u0000\u0109\u010b\u0005"+ + "\u00a7\u0000\u0000\u010a\u0109\u0001\u0000\u0000\u0000\u010b\u010e\u0001"+ + "\u0000\u0000\u0000\u010c\u010a\u0001\u0000\u0000\u0000\u010c\u010d\u0001"+ + "\u0000\u0000\u0000\u010d\u010f\u0001\u0000\u0000\u0000\u010e\u010c\u0001"+ + "\u0000\u0000\u0000\u010f\u0113\u0003\u00aaU\u0000\u0110\u0112\u0005\u00a7"+ + "\u0000\u0000\u0111\u0110\u0001\u0000\u0000\u0000\u0112\u0115\u0001\u0000"+ + "\u0000\u0000\u0113\u0111\u0001\u0000\u0000\u0000\u0113\u0114\u0001\u0000"+ + "\u0000\u0000\u0114\u0116\u0001\u0000\u0000\u0000\u0115\u0113\u0001\u0000"+ + "\u0000\u0000\u0116\u0117\u0005\u0005\u0000\u0000\u0117\u0118\u0003\b\u0004"+ + "\u0000\u0118\u0119\u0003\n\u0005\u0000\u0119\u0007\u0001\u0000\u0000\u0000"+ + "\u011a\u011c\u0005\u00a8\u0000\u0000\u011b\u011a\u0001\u0000\u0000\u0000"+ + "\u011c\u011f\u0001\u0000\u0000\u0000\u011d\u011b\u0001\u0000\u0000\u0000"+ + "\u011d\u011e\u0001\u0000\u0000\u0000\u011e\u0120\u0001\u0000\u0000\u0000"+ + "\u011f\u011d\u0001\u0000\u0000\u0000\u0120\u0124\u0005\u0006\u0000\u0000"+ + "\u0121\u0123\u0005\u00a7\u0000\u0000\u0122\u0121\u0001\u0000\u0000\u0000"+ + "\u0123\u0126\u0001\u0000\u0000\u0000\u0124\u0122\u0001\u0000\u0000\u0000"+ + "\u0124\u0125\u0001\u0000\u0000\u0000\u0125\u0127\u0001\u0000\u0000\u0000"+ + "\u0126\u0124\u0001\u0000\u0000\u0000\u0127\u012b\u0005\u0007\u0000\u0000"+ + "\u0128\u012a\u0005\u00a7\u0000\u0000\u0129\u0128\u0001\u0000\u0000\u0000"+ + "\u012a\u012d\u0001\u0000\u0000\u0000\u012b\u0129\u0001\u0000\u0000\u0000"+ + "\u012b\u012c\u0001\u0000\u0000\u0000\u012c\u012e\u0001\u0000\u0000\u0000"+ + "\u012d\u012b\u0001\u0000\u0000\u0000\u012e\u0132\u0003\u0086C\u0000\u012f"+ + "\u0131\u0005\u00a7\u0000\u0000\u0130\u012f\u0001\u0000\u0000\u0000\u0131"+ + "\u0134\u0001\u0000\u0000\u0000\u0132\u0130\u0001\u0000\u0000\u0000\u0132"+ + "\u0133\u0001\u0000\u0000\u0000\u0133\u0135\u0001\u0000\u0000\u0000\u0134"+ + "\u0132\u0001\u0000\u0000\u0000\u0135\u0136\u0005\u0002\u0000\u0000\u0136"+ + "\t\u0001\u0000\u0000\u0000\u0137\u0139\u0005\u00a8\u0000\u0000\u0138\u0137"+ + "\u0001\u0000\u0000\u0000\u0139\u013c\u0001\u0000\u0000\u0000\u013a\u0138"+ + "\u0001\u0000\u0000\u0000\u013a\u013b\u0001\u0000\u0000\u0000\u013b\u013d"+ + "\u0001\u0000\u0000\u0000\u013c\u013a\u0001\u0000\u0000\u0000\u013d\u0141"+ + "\u0005\b\u0000\u0000\u013e\u0140\u0005\u00a7\u0000\u0000\u013f\u013e\u0001"+ + "\u0000\u0000\u0000\u0140\u0143\u0001\u0000\u0000\u0000\u0141\u013f\u0001"+ + "\u0000\u0000\u0000\u0141\u0142\u0001\u0000\u0000\u0000\u0142\u0144\u0001"+ + "\u0000\u0000\u0000\u0143\u0141\u0001\u0000\u0000\u0000\u0144\u0148\u0005"+ + "\u0007\u0000\u0000\u0145\u0147\u0005\u00a7\u0000\u0000\u0146\u0145\u0001"+ + "\u0000\u0000\u0000\u0147\u014a\u0001\u0000\u0000\u0000\u0148\u0146\u0001"+ + "\u0000\u0000\u0000\u0148\u0149\u0001\u0000\u0000\u0000\u0149\u014b\u0001"+ + "\u0000\u0000\u0000\u014a\u0148\u0001\u0000\u0000\u0000\u014b\u014f\u0003"+ + "\u0086C\u0000\u014c\u014e\u0005\u00a7\u0000\u0000\u014d\u014c\u0001\u0000"+ + "\u0000\u0000\u014e\u0151\u0001\u0000\u0000\u0000\u014f\u014d\u0001\u0000"+ + "\u0000\u0000\u014f\u0150\u0001\u0000\u0000\u0000\u0150\u0152\u0001\u0000"+ + "\u0000\u0000\u0151\u014f\u0001\u0000\u0000\u0000\u0152\u0153\u0005\u0002"+ + "\u0000\u0000\u0153\u000b\u0001\u0000\u0000\u0000\u0154\u0156\u0005\u00a8"+ + "\u0000\u0000\u0155\u0154\u0001\u0000\u0000\u0000\u0156\u0159\u0001\u0000"+ + "\u0000\u0000\u0157\u0155\u0001\u0000\u0000\u0000\u0157\u0158\u0001\u0000"+ + "\u0000\u0000\u0158\u015a\u0001\u0000\u0000\u0000\u0159\u0157\u0001\u0000"+ + "\u0000\u0000\u015a\u015e\u0005\t\u0000\u0000\u015b\u015d\u0005\u00a7\u0000"+ + "\u0000\u015c\u015b\u0001\u0000\u0000\u0000\u015d\u0160\u0001\u0000\u0000"+ + "\u0000\u015e\u015c\u0001\u0000\u0000\u0000\u015e\u015f\u0001\u0000\u0000"+ + "\u0000\u015f\u0161\u0001\u0000\u0000\u0000\u0160\u015e\u0001\u0000\u0000"+ + "\u0000\u0161\u0165\u0003\u00aaU\u0000\u0162\u0164\u0005\u00a7\u0000\u0000"+ + "\u0163\u0162\u0001\u0000\u0000\u0000\u0164\u0167\u0001\u0000\u0000\u0000"+ + "\u0165\u0163\u0001\u0000\u0000\u0000\u0165\u0166\u0001\u0000\u0000\u0000"+ + "\u0166\u0168\u0001\u0000\u0000\u0000\u0167\u0165\u0001\u0000\u0000\u0000"+ + "\u0168\u016a\u0005\u0005\u0000\u0000\u0169\u016b\u0003\u00a0P\u0000\u016a"+ + "\u0169\u0001\u0000\u0000\u0000\u016b\u016c\u0001\u0000\u0000\u0000\u016c"+ + "\u016a\u0001\u0000\u0000\u0000\u016c\u016d\u0001\u0000\u0000\u0000\u016d"+ + "\r\u0001\u0000\u0000\u0000\u016e\u0170\u0005\u00a8\u0000\u0000\u016f\u016e"+ + "\u0001\u0000\u0000\u0000\u0170\u0173\u0001\u0000\u0000\u0000\u0171\u016f"+ + "\u0001\u0000\u0000\u0000\u0171\u0172\u0001\u0000\u0000\u0000\u0172\u0174"+ + "\u0001\u0000\u0000\u0000\u0173\u0171\u0001\u0000\u0000\u0000\u0174\u0178"+ + "\u0005\n\u0000\u0000\u0175\u0177\u0005\u00a7\u0000\u0000\u0176\u0175\u0001"+ + "\u0000\u0000\u0000\u0177\u017a\u0001\u0000\u0000\u0000\u0178\u0176\u0001"+ + "\u0000\u0000\u0000\u0178\u0179\u0001\u0000\u0000\u0000\u0179\u017b\u0001"+ + "\u0000\u0000\u0000\u017a\u0178\u0001\u0000\u0000\u0000\u017b\u017f\u0003"+ + "\u00aaU\u0000\u017c\u017e\u0005\u00a7\u0000\u0000\u017d\u017c\u0001\u0000"+ + "\u0000\u0000\u017e\u0181\u0001\u0000\u0000\u0000\u017f\u017d\u0001\u0000"+ + "\u0000\u0000\u017f\u0180\u0001\u0000\u0000\u0000\u0180\u0182\u0001\u0000"+ + "\u0000\u0000\u0181\u017f\u0001\u0000\u0000\u0000\u0182\u0186\u0005\u0005"+ + "\u0000\u0000\u0183\u0185\u0005\u00a8\u0000\u0000\u0184\u0183\u0001\u0000"+ + "\u0000\u0000\u0185\u0188\u0001\u0000\u0000\u0000\u0186\u0184\u0001\u0000"+ + "\u0000\u0000\u0186\u0187\u0001\u0000\u0000\u0000\u0187\u0189\u0001\u0000"+ + "\u0000\u0000\u0188\u0186\u0001\u0000\u0000\u0000\u0189\u018d\u0005\u000b"+ + "\u0000\u0000\u018a\u018c\u0005\u00a7\u0000\u0000\u018b\u018a\u0001\u0000"+ + "\u0000\u0000\u018c\u018f\u0001\u0000\u0000\u0000\u018d\u018b\u0001\u0000"+ + "\u0000\u0000\u018d\u018e\u0001\u0000\u0000\u0000\u018e\u0190\u0001\u0000"+ + "\u0000\u0000\u018f\u018d\u0001\u0000\u0000\u0000\u0190\u0194\u0005\u0007"+ + "\u0000\u0000\u0191\u0193\u0005\u00a7\u0000\u0000\u0192\u0191\u0001\u0000"+ + "\u0000\u0000\u0193\u0196\u0001\u0000\u0000\u0000\u0194\u0192\u0001\u0000"+ + "\u0000\u0000\u0194\u0195\u0001\u0000\u0000\u0000\u0195\u0197\u0001\u0000"+ + "\u0000\u0000\u0196\u0194\u0001\u0000\u0000\u0000\u0197\u019b\u0007\u0000"+ + "\u0000\u0000\u0198\u019a\u0005\u00a7\u0000\u0000\u0199\u0198\u0001\u0000"+ + "\u0000\u0000\u019a\u019d\u0001\u0000\u0000\u0000\u019b\u0199\u0001\u0000"+ + "\u0000\u0000\u019b\u019c\u0001\u0000\u0000\u0000\u019c\u019e\u0001\u0000"+ + "\u0000\u0000\u019d\u019b\u0001\u0000\u0000\u0000\u019e\u01a2\u0005\u0002"+ + "\u0000\u0000\u019f\u01a1\u0003\u00a2Q\u0000\u01a0\u019f\u0001\u0000\u0000"+ + "\u0000\u01a1\u01a4\u0001\u0000\u0000\u0000\u01a2\u01a0\u0001\u0000\u0000"+ + "\u0000\u01a2\u01a3\u0001\u0000\u0000\u0000\u01a3\u000f\u0001\u0000\u0000"+ + "\u0000\u01a4\u01a2\u0001\u0000\u0000\u0000\u01a5\u01a7\u0005\u00a8\u0000"+ + "\u0000\u01a6\u01a5\u0001\u0000\u0000\u0000\u01a7\u01aa\u0001\u0000\u0000"+ + "\u0000\u01a8\u01a6\u0001\u0000\u0000\u0000\u01a8\u01a9\u0001\u0000\u0000"+ + "\u0000\u01a9\u01ab\u0001\u0000\u0000\u0000\u01aa\u01a8\u0001\u0000\u0000"+ + "\u0000\u01ab\u01af\u0005\u000e\u0000\u0000\u01ac\u01ae\u0005\u00a7\u0000"+ + "\u0000\u01ad\u01ac\u0001\u0000\u0000\u0000\u01ae\u01b1\u0001\u0000\u0000"+ + "\u0000\u01af\u01ad\u0001\u0000\u0000\u0000\u01af\u01b0\u0001\u0000\u0000"+ + "\u0000\u01b0\u01b2\u0001\u0000\u0000\u0000\u01b1\u01af\u0001\u0000\u0000"+ + "\u0000\u01b2\u01b6\u0003\u00aaU\u0000\u01b3\u01b5\u0005\u00a7\u0000\u0000"+ + "\u01b4\u01b3\u0001\u0000\u0000\u0000\u01b5\u01b8\u0001\u0000\u0000\u0000"+ + "\u01b6\u01b4\u0001\u0000\u0000\u0000\u01b6\u01b7\u0001\u0000\u0000\u0000"+ + "\u01b7\u01b9\u0001\u0000\u0000\u0000\u01b8\u01b6\u0001\u0000\u0000\u0000"+ + "\u01b9\u01bd\u0005\u0005\u0000\u0000\u01ba\u01bc\u0003\u0012\t\u0000\u01bb"+ + "\u01ba\u0001\u0000\u0000\u0000\u01bc\u01bf\u0001\u0000\u0000\u0000\u01bd"+ + "\u01bb\u0001\u0000\u0000\u0000\u01bd\u01be\u0001\u0000\u0000\u0000\u01be"+ + "\u01c1\u0001\u0000\u0000\u0000\u01bf\u01bd\u0001\u0000\u0000\u0000\u01c0"+ + "\u01c2\u00034\u001a\u0000\u01c1\u01c0\u0001\u0000\u0000\u0000\u01c2\u01c3"+ + "\u0001\u0000\u0000\u0000\u01c3\u01c1\u0001\u0000\u0000\u0000\u01c3\u01c4"+ + "\u0001\u0000\u0000\u0000\u01c4\u01c8\u0001\u0000\u0000\u0000\u01c5\u01c7"+ + "\u0003\u0014\n\u0000\u01c6\u01c5\u0001\u0000\u0000\u0000\u01c7\u01ca\u0001"+ + "\u0000\u0000\u0000\u01c8\u01c6\u0001\u0000\u0000\u0000\u01c8\u01c9\u0001"+ + "\u0000\u0000\u0000\u01c9\u0011\u0001\u0000\u0000\u0000\u01ca\u01c8\u0001"+ + "\u0000\u0000\u0000\u01cb\u01cd\u0005\u00a8\u0000\u0000\u01cc\u01cb\u0001"+ + "\u0000\u0000\u0000\u01cd\u01d0\u0001\u0000\u0000\u0000\u01ce\u01cc\u0001"+ + "\u0000\u0000\u0000\u01ce\u01cf\u0001\u0000\u0000\u0000\u01cf\u01d1\u0001"+ + "\u0000\u0000\u0000\u01d0\u01ce\u0001\u0000\u0000\u0000\u01d1\u01d5\u0005"+ + "\u000f\u0000\u0000\u01d2\u01d4\u0005\u00a7\u0000\u0000\u01d3\u01d2\u0001"+ + "\u0000\u0000\u0000\u01d4\u01d7\u0001\u0000\u0000\u0000\u01d5\u01d3\u0001"+ + "\u0000\u0000\u0000\u01d5\u01d6\u0001\u0000\u0000\u0000\u01d6\u01d8\u0001"+ + "\u0000\u0000\u0000\u01d7\u01d5\u0001\u0000\u0000\u0000\u01d8\u01dc\u0003"+ + "\u0094J\u0000\u01d9\u01db\u0005\u00a7\u0000\u0000\u01da\u01d9\u0001\u0000"+ + "\u0000\u0000\u01db\u01de\u0001\u0000\u0000\u0000\u01dc\u01da\u0001\u0000"+ + "\u0000\u0000\u01dc\u01dd\u0001\u0000\u0000\u0000\u01dd\u01df\u0001\u0000"+ + "\u0000\u0000\u01de\u01dc\u0001\u0000\u0000\u0000\u01df\u01e3\u0005\u0007"+ + "\u0000\u0000\u01e0\u01e2\u0005\u00a7\u0000\u0000\u01e1\u01e0\u0001\u0000"+ + "\u0000\u0000\u01e2\u01e5\u0001\u0000\u0000\u0000\u01e3\u01e1\u0001\u0000"+ + "\u0000\u0000\u01e3\u01e4\u0001\u0000\u0000\u0000\u01e4\u01e6\u0001\u0000"+ + "\u0000\u0000\u01e5\u01e3\u0001\u0000\u0000\u0000\u01e6\u01ea\u0003\u008c"+ + "F\u0000\u01e7\u01e9\u0005\u00a7\u0000\u0000\u01e8\u01e7\u0001\u0000\u0000"+ + "\u0000\u01e9\u01ec\u0001\u0000\u0000\u0000\u01ea\u01e8\u0001\u0000\u0000"+ + "\u0000\u01ea\u01eb\u0001\u0000\u0000\u0000\u01eb\u01ed\u0001\u0000\u0000"+ + "\u0000\u01ec\u01ea\u0001\u0000\u0000\u0000\u01ed\u01ee\u0005\u0002\u0000"+ + "\u0000\u01ee\u0013\u0001\u0000\u0000\u0000\u01ef\u01f1\u0005\u00a8\u0000"+ + "\u0000\u01f0\u01ef\u0001\u0000\u0000\u0000\u01f1\u01f4\u0001\u0000\u0000"+ + "\u0000\u01f2\u01f0\u0001\u0000\u0000\u0000\u01f2\u01f3\u0001\u0000\u0000"+ + "\u0000\u01f3\u01f5\u0001\u0000\u0000\u0000\u01f4\u01f2\u0001\u0000\u0000"+ + "\u0000\u01f5\u01f9\u0005\u0010\u0000\u0000\u01f6\u01f8\u0005\u00a7\u0000"+ + "\u0000\u01f7\u01f6\u0001\u0000\u0000\u0000\u01f8\u01fb\u0001\u0000\u0000"+ + "\u0000\u01f9\u01f7\u0001\u0000\u0000\u0000\u01f9\u01fa\u0001\u0000\u0000"+ + "\u0000\u01fa\u01fc\u0001\u0000\u0000\u0000\u01fb\u01f9\u0001\u0000\u0000"+ + "\u0000\u01fc\u0200\u0003\u009eO\u0000\u01fd\u01ff\u0005\u00a7\u0000\u0000"+ + "\u01fe\u01fd\u0001\u0000\u0000\u0000\u01ff\u0202\u0001\u0000\u0000\u0000"+ + "\u0200\u01fe\u0001\u0000\u0000\u0000\u0200\u0201\u0001\u0000\u0000\u0000"+ + "\u0201\u0203\u0001\u0000\u0000\u0000\u0202\u0200\u0001\u0000\u0000\u0000"+ + "\u0203\u0207\u0005\u0007\u0000\u0000\u0204\u0206\u0005\u00a7\u0000\u0000"+ + "\u0205\u0204\u0001\u0000\u0000\u0000\u0206\u0209\u0001\u0000\u0000\u0000"+ + "\u0207\u0205\u0001\u0000\u0000\u0000\u0207\u0208\u0001\u0000\u0000\u0000"+ + "\u0208\u020a\u0001\u0000\u0000\u0000\u0209\u0207\u0001\u0000\u0000\u0000"+ + "\u020a\u020e\u0003\u008cF\u0000\u020b\u020d\u0005\u00a7\u0000\u0000\u020c"+ + "\u020b\u0001\u0000\u0000\u0000\u020d\u0210\u0001\u0000\u0000\u0000\u020e"+ + "\u020c\u0001\u0000\u0000\u0000\u020e\u020f\u0001\u0000\u0000\u0000\u020f"+ + "\u0211\u0001\u0000\u0000\u0000\u0210\u020e\u0001\u0000\u0000\u0000\u0211"+ + "\u0212\u0005\u0002\u0000\u0000\u0212\u0015\u0001\u0000\u0000\u0000\u0213"+ + "\u0215\u0005\u00a8\u0000\u0000\u0214\u0213\u0001\u0000\u0000\u0000\u0215"+ + "\u0218\u0001\u0000\u0000\u0000\u0216\u0214\u0001\u0000\u0000\u0000\u0216"+ + "\u0217\u0001\u0000\u0000\u0000\u0217\u0219\u0001\u0000\u0000\u0000\u0218"+ + "\u0216\u0001\u0000\u0000\u0000\u0219\u021d\u0005\u0011\u0000\u0000\u021a"+ + "\u021c\u0005\u00a7\u0000\u0000\u021b\u021a\u0001\u0000\u0000\u0000\u021c"+ + "\u021f\u0001\u0000\u0000\u0000\u021d\u021b\u0001\u0000\u0000\u0000\u021d"+ + "\u021e\u0001\u0000\u0000\u0000\u021e\u0220\u0001\u0000\u0000\u0000\u021f"+ + "\u021d\u0001\u0000\u0000\u0000\u0220\u0224\u0003\u00aaU\u0000\u0221\u0223"+ + "\u0005\u00a7\u0000\u0000\u0222\u0221\u0001\u0000\u0000\u0000\u0223\u0226"+ + "\u0001\u0000\u0000\u0000\u0224\u0222\u0001\u0000\u0000\u0000\u0224\u0225"+ + "\u0001\u0000\u0000\u0000\u0225\u0227\u0001\u0000\u0000\u0000\u0226\u0224"+ + "\u0001\u0000\u0000\u0000\u0227\u022b\u0005\u0005\u0000\u0000\u0228\u022a"+ + "\u0003\u0018\f\u0000\u0229\u0228\u0001\u0000\u0000\u0000\u022a\u022d\u0001"+ + "\u0000\u0000\u0000\u022b\u0229\u0001\u0000\u0000\u0000\u022b\u022c\u0001"+ + "\u0000\u0000\u0000\u022c\u0231\u0001\u0000\u0000\u0000\u022d\u022b\u0001"+ + "\u0000\u0000\u0000\u022e\u0230\u00034\u001a\u0000\u022f\u022e\u0001\u0000"+ + "\u0000\u0000\u0230\u0233\u0001\u0000\u0000\u0000\u0231\u022f\u0001\u0000"+ + "\u0000\u0000\u0231\u0232\u0001\u0000\u0000\u0000\u0232\u0237\u0001\u0000"+ + "\u0000\u0000\u0233\u0231\u0001\u0000\u0000\u0000\u0234\u0236\u0003\u001a"+ + "\r\u0000\u0235\u0234\u0001\u0000\u0000\u0000\u0236\u0239\u0001\u0000\u0000"+ + "\u0000\u0237\u0235\u0001\u0000\u0000\u0000\u0237\u0238\u0001\u0000\u0000"+ + "\u0000\u0238\u023b\u0001\u0000\u0000\u0000\u0239\u0237\u0001\u0000\u0000"+ + "\u0000\u023a\u023c\u0003\u001c\u000e\u0000\u023b\u023a\u0001\u0000\u0000"+ + "\u0000\u023b\u023c\u0001\u0000\u0000\u0000\u023c\u0017\u0001\u0000\u0000"+ + "\u0000\u023d\u023f\u0005\u00a8\u0000\u0000\u023e\u023d\u0001\u0000\u0000"+ + "\u0000\u023f\u0242\u0001\u0000\u0000\u0000\u0240\u023e\u0001\u0000\u0000"+ + "\u0000\u0240\u0241\u0001\u0000\u0000\u0000\u0241\u0243\u0001\u0000\u0000"+ + "\u0000\u0242\u0240\u0001\u0000\u0000\u0000\u0243\u0247\u0005\u000f\u0000"+ + "\u0000\u0244\u0246\u0005\u00a7\u0000\u0000\u0245\u0244\u0001\u0000\u0000"+ + "\u0000\u0246\u0249\u0001\u0000\u0000\u0000\u0247\u0245\u0001\u0000\u0000"+ + "\u0000\u0247\u0248\u0001\u0000\u0000\u0000\u0248\u024a\u0001\u0000\u0000"+ + "\u0000\u0249\u0247\u0001\u0000\u0000\u0000\u024a\u024e\u0003\u0094J\u0000"+ + "\u024b\u024d\u0005\u00a7\u0000\u0000\u024c\u024b\u0001\u0000\u0000\u0000"+ + "\u024d\u0250\u0001\u0000\u0000\u0000\u024e\u024c\u0001\u0000\u0000\u0000"+ + "\u024e\u024f\u0001\u0000\u0000\u0000\u024f\u0251\u0001\u0000\u0000\u0000"+ + "\u0250\u024e\u0001\u0000\u0000\u0000\u0251\u0255\u0005\u0007\u0000\u0000"+ + "\u0252\u0254\u0005\u00a7\u0000\u0000\u0253\u0252\u0001\u0000\u0000\u0000"+ + "\u0254\u0257\u0001\u0000\u0000\u0000\u0255\u0253\u0001\u0000\u0000\u0000"+ + "\u0255\u0256\u0001\u0000\u0000\u0000\u0256\u0258\u0001\u0000\u0000\u0000"+ + "\u0257\u0255\u0001\u0000\u0000\u0000\u0258\u025c\u0003\u0084B\u0000\u0259"+ + "\u025b\u0005\u00a7\u0000\u0000\u025a\u0259\u0001\u0000\u0000\u0000\u025b"+ + "\u025e\u0001\u0000\u0000\u0000\u025c\u025a\u0001\u0000\u0000\u0000\u025c"+ + "\u025d\u0001\u0000\u0000\u0000\u025d\u025f\u0001\u0000\u0000\u0000\u025e"+ + "\u025c\u0001\u0000\u0000\u0000\u025f\u0260\u0005\u0002\u0000\u0000\u0260"+ + "\u0019\u0001\u0000\u0000\u0000\u0261\u0263\u0005\u00a8\u0000\u0000\u0262"+ + "\u0261\u0001\u0000\u0000\u0000\u0263\u0266\u0001\u0000\u0000\u0000\u0264"+ + "\u0262\u0001\u0000\u0000\u0000\u0264\u0265\u0001\u0000\u0000\u0000\u0265"+ + "\u0267\u0001\u0000\u0000\u0000\u0266\u0264\u0001\u0000\u0000\u0000\u0267"+ + "\u026b\u0005\u0010\u0000\u0000\u0268\u026a\u0005\u00a7\u0000\u0000\u0269"+ + "\u0268\u0001\u0000\u0000\u0000\u026a\u026d\u0001\u0000\u0000\u0000\u026b"+ + "\u0269\u0001\u0000\u0000\u0000\u026b\u026c\u0001\u0000\u0000\u0000\u026c"+ + "\u026e\u0001\u0000\u0000\u0000\u026d\u026b\u0001\u0000\u0000\u0000\u026e"+ + "\u0272\u0003\u009eO\u0000\u026f\u0271\u0005\u00a7\u0000\u0000\u0270\u026f"+ + "\u0001\u0000\u0000\u0000\u0271\u0274\u0001\u0000\u0000\u0000\u0272\u0270"+ + "\u0001\u0000\u0000\u0000\u0272\u0273\u0001\u0000\u0000\u0000\u0273\u0275"+ + "\u0001\u0000\u0000\u0000\u0274\u0272\u0001\u0000\u0000\u0000\u0275\u0279"+ + "\u0005\u0007\u0000\u0000\u0276\u0278\u0005\u00a7\u0000\u0000\u0277\u0276"+ + "\u0001\u0000\u0000\u0000\u0278\u027b\u0001\u0000\u0000\u0000\u0279\u0277"+ + "\u0001\u0000\u0000\u0000\u0279\u027a\u0001\u0000\u0000\u0000\u027a\u027c"+ + "\u0001\u0000\u0000\u0000\u027b\u0279\u0001\u0000\u0000\u0000\u027c\u0280"+ + "\u0003\u0084B\u0000\u027d\u027f\u0005\u00a7\u0000\u0000\u027e\u027d\u0001"+ + "\u0000\u0000\u0000\u027f\u0282\u0001\u0000\u0000\u0000\u0280\u027e\u0001"+ + "\u0000\u0000\u0000\u0280\u0281\u0001\u0000\u0000\u0000\u0281\u0283\u0001"+ + "\u0000\u0000\u0000\u0282\u0280\u0001\u0000\u0000\u0000\u0283\u0284\u0005"+ + "\u0002\u0000\u0000\u0284\u001b\u0001\u0000\u0000\u0000\u0285\u0287\u0005"+ + "\u00a8\u0000\u0000\u0286\u0285\u0001\u0000\u0000\u0000\u0287\u028a\u0001"+ + "\u0000\u0000\u0000\u0288\u0286\u0001\u0000\u0000\u0000\u0288\u0289\u0001"+ + "\u0000\u0000\u0000\u0289\u028b\u0001\u0000\u0000\u0000\u028a\u0288\u0001"+ + "\u0000\u0000\u0000\u028b\u028f\u0005\u0012\u0000\u0000\u028c\u028e\u0005"+ + "\u00a7\u0000\u0000\u028d\u028c\u0001\u0000\u0000\u0000\u028e\u0291\u0001"+ + "\u0000\u0000\u0000\u028f\u028d\u0001\u0000\u0000\u0000\u028f\u0290\u0001"+ + "\u0000\u0000\u0000\u0290\u0292\u0001\u0000\u0000\u0000\u0291\u028f\u0001"+ + "\u0000\u0000\u0000\u0292\u0296\u0003\u00aaU\u0000\u0293\u0295\u0005\u00a7"+ + "\u0000\u0000\u0294\u0293\u0001\u0000\u0000\u0000\u0295\u0298\u0001\u0000"+ + "\u0000\u0000\u0296\u0294\u0001\u0000\u0000\u0000\u0296\u0297\u0001\u0000"+ + "\u0000\u0000\u0297\u0299\u0001\u0000\u0000\u0000\u0298\u0296\u0001\u0000"+ + "\u0000\u0000\u0299\u029d\u0005\u0005\u0000\u0000\u029a\u029c\u0003\u001e"+ + "\u000f\u0000\u029b\u029a\u0001\u0000\u0000\u0000\u029c\u029f\u0001\u0000"+ + "\u0000\u0000\u029d\u029b\u0001\u0000\u0000\u0000\u029d\u029e\u0001\u0000"+ + "\u0000\u0000\u029e\u02a1\u0001\u0000\u0000\u0000\u029f\u029d\u0001\u0000"+ + "\u0000\u0000\u02a0\u02a2\u0003 \u0010\u0000\u02a1\u02a0\u0001\u0000\u0000"+ + "\u0000\u02a2\u02a3\u0001\u0000\u0000\u0000\u02a3\u02a1\u0001\u0000\u0000"+ + "\u0000\u02a3\u02a4\u0001\u0000\u0000\u0000\u02a4\u001d\u0001\u0000\u0000"+ + "\u0000\u02a5\u02a7\u0005\u00a8\u0000\u0000\u02a6\u02a5\u0001\u0000\u0000"+ + "\u0000\u02a7\u02aa\u0001\u0000\u0000\u0000\u02a8\u02a6\u0001\u0000\u0000"+ + "\u0000\u02a8\u02a9\u0001\u0000\u0000\u0000\u02a9\u02ab\u0001\u0000\u0000"+ + "\u0000\u02aa\u02a8\u0001\u0000\u0000\u0000\u02ab\u02af\u0005\u000f\u0000"+ + "\u0000\u02ac\u02ae\u0005\u00a7\u0000\u0000\u02ad\u02ac\u0001\u0000\u0000"+ + "\u0000\u02ae\u02b1\u0001\u0000\u0000\u0000\u02af\u02ad\u0001\u0000\u0000"+ + "\u0000\u02af\u02b0\u0001\u0000\u0000\u0000\u02b0\u02b2\u0001\u0000\u0000"+ + "\u0000\u02b1\u02af\u0001\u0000\u0000\u0000\u02b2\u02b6\u0003\u0094J\u0000"+ + "\u02b3\u02b5\u0005\u00a7\u0000\u0000\u02b4\u02b3\u0001\u0000\u0000\u0000"+ + "\u02b5\u02b8\u0001\u0000\u0000\u0000\u02b6\u02b4\u0001\u0000\u0000\u0000"+ + "\u02b6\u02b7\u0001\u0000\u0000\u0000\u02b7\u02b9\u0001\u0000\u0000\u0000"+ + "\u02b8\u02b6\u0001\u0000\u0000\u0000\u02b9\u02bd\u0005\u0007\u0000\u0000"+ + "\u02ba\u02bc\u0005\u00a7\u0000\u0000\u02bb\u02ba\u0001\u0000\u0000\u0000"+ + "\u02bc\u02bf\u0001\u0000\u0000\u0000\u02bd\u02bb\u0001\u0000\u0000\u0000"+ + "\u02bd\u02be\u0001\u0000\u0000\u0000\u02be\u02c0\u0001\u0000\u0000\u0000"+ + "\u02bf\u02bd\u0001\u0000\u0000\u0000\u02c0\u02c4\u0003\u0088D\u0000\u02c1"+ + "\u02c3\u0005\u00a7\u0000\u0000\u02c2\u02c1\u0001\u0000\u0000\u0000\u02c3"+ + "\u02c6\u0001\u0000\u0000\u0000\u02c4\u02c2\u0001\u0000\u0000\u0000\u02c4"+ + "\u02c5\u0001\u0000\u0000\u0000\u02c5\u02c7\u0001\u0000\u0000\u0000\u02c6"+ + "\u02c4\u0001\u0000\u0000\u0000\u02c7\u02c8\u0005\u0002\u0000\u0000\u02c8"+ + "\u001f\u0001\u0000\u0000\u0000\u02c9\u02d4\u0003\"\u0011\u0000\u02ca\u02d4"+ + "\u0003$\u0012\u0000\u02cb\u02d4\u0003&\u0013\u0000\u02cc\u02d4\u0003("+ + "\u0014\u0000\u02cd\u02d4\u0003*\u0015\u0000\u02ce\u02d4\u0003,\u0016\u0000"+ + "\u02cf\u02d4\u0003.\u0017\u0000\u02d0\u02d4\u00030\u0018\u0000\u02d1\u02d4"+ + "\u00032\u0019\u0000\u02d2\u02d4\u00034\u001a\u0000\u02d3\u02c9\u0001\u0000"+ + "\u0000\u0000\u02d3\u02ca\u0001\u0000\u0000\u0000\u02d3\u02cb\u0001\u0000"+ + "\u0000\u0000\u02d3\u02cc\u0001\u0000\u0000\u0000\u02d3\u02cd\u0001\u0000"+ + "\u0000\u0000\u02d3\u02ce\u0001\u0000\u0000\u0000\u02d3\u02cf\u0001\u0000"+ + "\u0000\u0000\u02d3\u02d0\u0001\u0000\u0000\u0000\u02d3\u02d1\u0001\u0000"+ + "\u0000\u0000\u02d3\u02d2\u0001\u0000\u0000\u0000\u02d4!\u0001\u0000\u0000"+ + "\u0000\u02d5\u02d7\u0005\u00a8\u0000\u0000\u02d6\u02d5\u0001\u0000\u0000"+ + "\u0000\u02d7\u02da\u0001\u0000\u0000\u0000\u02d8\u02d6\u0001\u0000\u0000"+ + "\u0000\u02d8\u02d9\u0001\u0000\u0000\u0000\u02d9\u02db\u0001\u0000\u0000"+ + "\u0000\u02da\u02d8\u0001\u0000\u0000\u0000\u02db\u02df\u0005\u0013\u0000"+ + "\u0000\u02dc\u02de\u0005\u00a7\u0000\u0000\u02dd\u02dc\u0001\u0000\u0000"+ + "\u0000\u02de\u02e1\u0001\u0000\u0000\u0000\u02df\u02dd\u0001\u0000\u0000"+ + "\u0000\u02df\u02e0\u0001\u0000\u0000\u0000\u02e0\u02e2\u0001\u0000\u0000"+ + "\u0000\u02e1\u02df\u0001\u0000\u0000\u0000\u02e2\u02e3\u0003\u00aaU\u0000"+ + "\u02e3\u02e7\u0005\u0014\u0000\u0000\u02e4\u02e6\u0005\u00a7\u0000\u0000"+ + "\u02e5\u02e4\u0001\u0000\u0000\u0000\u02e6\u02e9\u0001\u0000\u0000\u0000"+ + "\u02e7\u02e5\u0001\u0000\u0000\u0000\u02e7\u02e8\u0001\u0000\u0000\u0000"+ + "\u02e8\u02ea\u0001\u0000\u0000\u0000\u02e9\u02e7\u0001\u0000\u0000\u0000"+ + "\u02ea\u02ee\u0003\u009eO\u0000\u02eb\u02ed\u0005\u00a7\u0000\u0000\u02ec"+ + "\u02eb\u0001\u0000\u0000\u0000\u02ed\u02f0\u0001\u0000\u0000\u0000\u02ee"+ + "\u02ec\u0001\u0000\u0000\u0000\u02ee\u02ef\u0001\u0000\u0000\u0000\u02ef"+ + "\u02f1\u0001\u0000\u0000\u0000\u02f0\u02ee\u0001\u0000\u0000\u0000\u02f1"+ + "\u02f5\u0005\u0015\u0000\u0000\u02f2\u02f4\u0005\u00a7\u0000\u0000\u02f3"+ + "\u02f2\u0001\u0000\u0000\u0000\u02f4\u02f7\u0001\u0000\u0000\u0000\u02f5"+ + "\u02f3\u0001\u0000\u0000\u0000\u02f5\u02f6\u0001\u0000\u0000\u0000\u02f6"+ + "\u02f8\u0001\u0000\u0000\u0000\u02f7\u02f5\u0001\u0000\u0000\u0000\u02f8"+ + "\u02fc\u0005\u0016\u0000\u0000\u02f9\u02fb\u0005\u00a7\u0000\u0000\u02fa"+ + "\u02f9\u0001\u0000\u0000\u0000\u02fb\u02fe\u0001\u0000\u0000\u0000\u02fc"+ + "\u02fa\u0001\u0000\u0000\u0000\u02fc\u02fd\u0001\u0000\u0000\u0000\u02fd"+ + "\u02ff\u0001\u0000\u0000\u0000\u02fe\u02fc\u0001\u0000\u0000\u0000\u02ff"+ + "\u0303\u0003\u0096K\u0000\u0300\u0302\u0005\u00a7\u0000\u0000\u0301\u0300"+ + "\u0001\u0000\u0000\u0000\u0302\u0305\u0001\u0000\u0000\u0000\u0303\u0301"+ + "\u0001\u0000\u0000\u0000\u0303\u0304\u0001\u0000\u0000\u0000\u0304\u0306"+ + "\u0001\u0000\u0000\u0000\u0305\u0303\u0001\u0000\u0000\u0000\u0306\u0307"+ + "\u0005\u0002\u0000\u0000\u0307#\u0001\u0000\u0000\u0000\u0308\u030a\u0005"+ + "\u00a8\u0000\u0000\u0309\u0308\u0001\u0000\u0000\u0000\u030a\u030d\u0001"+ + "\u0000\u0000\u0000\u030b\u0309\u0001\u0000\u0000\u0000\u030b\u030c\u0001"+ + "\u0000\u0000\u0000\u030c\u030e\u0001\u0000\u0000\u0000\u030d\u030b\u0001"+ + "\u0000\u0000\u0000\u030e\u0312\u0005\u0017\u0000\u0000\u030f\u0311\u0005"+ + "\u00a7\u0000\u0000\u0310\u030f\u0001\u0000\u0000\u0000\u0311\u0314\u0001"+ + "\u0000\u0000\u0000\u0312\u0310\u0001\u0000\u0000\u0000\u0312\u0313\u0001"+ + "\u0000\u0000\u0000\u0313\u0315\u0001\u0000\u0000\u0000\u0314\u0312\u0001"+ + "\u0000\u0000\u0000\u0315\u0316\u0003\u00aaU\u0000\u0316\u031a\u0005\u0014"+ + "\u0000\u0000\u0317\u0319\u0005\u00a7\u0000\u0000\u0318\u0317\u0001\u0000"+ + "\u0000\u0000\u0319\u031c\u0001\u0000\u0000\u0000\u031a\u0318\u0001\u0000"+ + "\u0000\u0000\u031a\u031b\u0001\u0000\u0000\u0000\u031b\u031d\u0001\u0000"+ + "\u0000\u0000\u031c\u031a\u0001\u0000\u0000\u0000\u031d\u0321\u0003\u009e"+ + "O\u0000\u031e\u0320\u0005\u00a7\u0000\u0000\u031f\u031e\u0001\u0000\u0000"+ + "\u0000\u0320\u0323\u0001\u0000\u0000\u0000\u0321\u031f\u0001\u0000\u0000"+ + "\u0000\u0321\u0322\u0001\u0000\u0000\u0000\u0322\u0324\u0001\u0000\u0000"+ + "\u0000\u0323\u0321\u0001\u0000\u0000\u0000\u0324\u0328\u0005\u0015\u0000"+ + "\u0000\u0325\u0327\u0005\u00a7\u0000\u0000\u0326\u0325\u0001\u0000\u0000"+ + "\u0000\u0327\u032a\u0001\u0000\u0000\u0000\u0328\u0326\u0001\u0000\u0000"+ + "\u0000\u0328\u0329\u0001\u0000\u0000\u0000\u0329\u032b\u0001\u0000\u0000"+ + "\u0000\u032a\u0328\u0001\u0000\u0000\u0000\u032b\u032f\u0005\u0016\u0000"+ + "\u0000\u032c\u032e\u0005\u00a7\u0000\u0000\u032d\u032c\u0001\u0000\u0000"+ + "\u0000\u032e\u0331\u0001\u0000\u0000\u0000\u032f\u032d\u0001\u0000\u0000"+ + "\u0000\u032f\u0330\u0001\u0000\u0000\u0000\u0330\u0332\u0001\u0000\u0000"+ + "\u0000\u0331\u032f\u0001\u0000\u0000\u0000\u0332\u0336\u0003\u0096K\u0000"+ + "\u0333\u0335\u0005\u00a7\u0000\u0000\u0334\u0333\u0001\u0000\u0000\u0000"+ + "\u0335\u0338\u0001\u0000\u0000\u0000\u0336\u0334\u0001\u0000\u0000\u0000"+ + "\u0336\u0337\u0001\u0000\u0000\u0000\u0337\u0339\u0001\u0000\u0000\u0000"+ + "\u0338\u0336\u0001\u0000\u0000\u0000\u0339\u033a\u0005\u0002\u0000\u0000"+ + "\u033a%\u0001\u0000\u0000\u0000\u033b\u033d\u0005\u00a8\u0000\u0000\u033c"+ + "\u033b\u0001\u0000\u0000\u0000\u033d\u0340\u0001\u0000\u0000\u0000\u033e"+ + "\u033c\u0001\u0000\u0000\u0000\u033e\u033f\u0001\u0000\u0000\u0000\u033f"+ + "\u0341\u0001\u0000\u0000\u0000\u0340\u033e\u0001\u0000\u0000\u0000\u0341"+ + "\u0345\u0005\u0018\u0000\u0000\u0342\u0344\u0005\u00a7\u0000\u0000\u0343"+ + "\u0342\u0001\u0000\u0000\u0000\u0344\u0347\u0001\u0000\u0000\u0000\u0345"+ + "\u0343\u0001\u0000\u0000\u0000\u0345\u0346\u0001\u0000\u0000\u0000\u0346"+ + "\u0348\u0001\u0000\u0000\u0000\u0347\u0345\u0001\u0000\u0000\u0000\u0348"+ + "\u0349\u0003\u00aaU\u0000\u0349\u034d\u0005\u0014\u0000\u0000\u034a\u034c"+ + "\u0005\u00a7\u0000\u0000\u034b\u034a\u0001\u0000\u0000\u0000\u034c\u034f"+ + "\u0001\u0000\u0000\u0000\u034d\u034b\u0001\u0000\u0000\u0000\u034d\u034e"+ + "\u0001\u0000\u0000\u0000\u034e\u0350\u0001\u0000\u0000\u0000\u034f\u034d"+ + "\u0001\u0000\u0000\u0000\u0350\u0354\u0003\u009eO\u0000\u0351\u0353\u0005"+ + "\u00a7\u0000\u0000\u0352\u0351\u0001\u0000\u0000\u0000\u0353\u0356\u0001"+ + "\u0000\u0000\u0000\u0354\u0352\u0001\u0000\u0000\u0000\u0354\u0355\u0001"+ + "\u0000\u0000\u0000\u0355\u0357\u0001\u0000\u0000\u0000\u0356\u0354\u0001"+ + "\u0000\u0000\u0000\u0357\u035b\u0005\u0015\u0000\u0000\u0358\u035a\u0005"+ + "\u00a7\u0000\u0000\u0359\u0358\u0001\u0000\u0000\u0000\u035a\u035d\u0001"+ + "\u0000\u0000\u0000\u035b\u0359\u0001\u0000\u0000\u0000\u035b\u035c\u0001"+ + "\u0000\u0000\u0000\u035c\u035e\u0001\u0000\u0000\u0000\u035d\u035b\u0001"+ + "\u0000\u0000\u0000\u035e\u0362\u0003\u009eO\u0000\u035f\u0361\u0005\u00a7"+ + "\u0000\u0000\u0360\u035f\u0001\u0000\u0000\u0000\u0361\u0364\u0001\u0000"+ + "\u0000\u0000\u0362\u0360\u0001\u0000\u0000\u0000\u0362\u0363\u0001\u0000"+ + "\u0000\u0000\u0363\u0365\u0001\u0000\u0000\u0000\u0364\u0362\u0001\u0000"+ + "\u0000\u0000\u0365\u0369\u0005\u0016\u0000\u0000\u0366\u0368\u0005\u00a7"+ + "\u0000\u0000\u0367\u0366\u0001\u0000\u0000\u0000\u0368\u036b\u0001\u0000"+ + "\u0000\u0000\u0369\u0367\u0001\u0000\u0000\u0000\u0369\u036a\u0001\u0000"+ + "\u0000\u0000\u036a\u036c\u0001\u0000\u0000\u0000\u036b\u0369\u0001\u0000"+ + "\u0000\u0000\u036c\u0370\u0003\u0096K\u0000\u036d\u036f\u0005\u00a7\u0000"+ + "\u0000\u036e\u036d\u0001\u0000\u0000\u0000\u036f\u0372\u0001\u0000\u0000"+ + "\u0000\u0370\u036e\u0001\u0000\u0000\u0000\u0370\u0371\u0001\u0000\u0000"+ + "\u0000\u0371\u0373\u0001\u0000\u0000\u0000\u0372\u0370\u0001\u0000\u0000"+ + "\u0000\u0373\u0374\u0005\u0002\u0000\u0000\u0374\'\u0001\u0000\u0000\u0000"+ + "\u0375\u0377\u0005\u00a8\u0000\u0000\u0376\u0375\u0001\u0000\u0000\u0000"+ + "\u0377\u037a\u0001\u0000\u0000\u0000\u0378\u0376\u0001\u0000\u0000\u0000"+ + "\u0378\u0379\u0001\u0000\u0000\u0000\u0379\u037b\u0001\u0000\u0000\u0000"+ + "\u037a\u0378\u0001\u0000\u0000\u0000\u037b\u037f\u0005\u0019\u0000\u0000"+ + "\u037c\u037e\u0005\u00a7\u0000\u0000\u037d\u037c\u0001\u0000\u0000\u0000"+ + "\u037e\u0381\u0001\u0000\u0000\u0000\u037f\u037d\u0001\u0000\u0000\u0000"+ + "\u037f\u0380\u0001\u0000\u0000\u0000\u0380\u0382\u0001\u0000\u0000\u0000"+ + "\u0381\u037f\u0001\u0000\u0000\u0000\u0382\u0386\u0003\u009eO\u0000\u0383"+ + "\u0385\u0005\u00a7\u0000\u0000\u0384\u0383\u0001\u0000\u0000\u0000\u0385"+ + "\u0388\u0001\u0000\u0000\u0000\u0386\u0384\u0001\u0000\u0000\u0000\u0386"+ + "\u0387\u0001\u0000\u0000\u0000\u0387\u0389\u0001\u0000\u0000\u0000\u0388"+ + "\u0386\u0001\u0000\u0000\u0000\u0389\u038d\u0005\u0016\u0000\u0000\u038a"+ + "\u038c\u0005\u00a7\u0000\u0000\u038b\u038a\u0001\u0000\u0000\u0000\u038c"+ + "\u038f\u0001\u0000\u0000\u0000\u038d\u038b\u0001\u0000\u0000\u0000\u038d"+ + "\u038e\u0001\u0000\u0000\u0000\u038e\u0390\u0001\u0000\u0000\u0000\u038f"+ + "\u038d\u0001\u0000\u0000\u0000\u0390\u0391\u0003\u00aaU\u0000\u0391\u0395"+ + "\u0005\u0014\u0000\u0000\u0392\u0394\u0005\u00a7\u0000\u0000\u0393\u0392"+ + "\u0001\u0000\u0000\u0000\u0394\u0397\u0001\u0000\u0000\u0000\u0395\u0393"+ + "\u0001\u0000\u0000\u0000\u0395\u0396\u0001\u0000\u0000\u0000\u0396\u0398"+ + "\u0001\u0000\u0000\u0000\u0397\u0395\u0001\u0000\u0000\u0000\u0398\u039c"+ + "\u0003\u009eO\u0000\u0399\u039b\u0005\u00a7\u0000\u0000\u039a\u0399\u0001"+ + "\u0000\u0000\u0000\u039b\u039e\u0001\u0000\u0000\u0000\u039c\u039a\u0001"+ + "\u0000\u0000\u0000\u039c\u039d\u0001\u0000\u0000\u0000\u039d\u039f\u0001"+ + "\u0000\u0000\u0000\u039e\u039c\u0001\u0000\u0000\u0000\u039f\u03a3\u0005"+ + "\u0015\u0000\u0000\u03a0\u03a2\u0005\u00a7\u0000\u0000\u03a1\u03a0\u0001"+ + "\u0000\u0000\u0000\u03a2\u03a5\u0001\u0000\u0000\u0000\u03a3\u03a1\u0001"+ + "\u0000\u0000\u0000\u03a3\u03a4\u0001\u0000\u0000\u0000\u03a4\u03a6\u0001"+ + "\u0000\u0000\u0000\u03a5\u03a3\u0001\u0000\u0000\u0000\u03a6\u03a7\u0005"+ + "\u0002\u0000\u0000\u03a7)\u0001\u0000\u0000\u0000\u03a8\u03aa\u0005\u00a8"+ + "\u0000\u0000\u03a9\u03a8\u0001\u0000\u0000\u0000\u03aa\u03ad\u0001\u0000"+ + "\u0000\u0000\u03ab\u03a9\u0001\u0000\u0000\u0000\u03ab\u03ac\u0001\u0000"+ + "\u0000\u0000\u03ac\u03ae\u0001\u0000\u0000\u0000\u03ad\u03ab\u0001\u0000"+ + "\u0000\u0000\u03ae\u03b2\u0005\u001a\u0000\u0000\u03af\u03b1\u0005\u00a7"+ + "\u0000\u0000\u03b0\u03af\u0001\u0000\u0000\u0000\u03b1\u03b4\u0001\u0000"+ + "\u0000\u0000\u03b2\u03b0\u0001\u0000\u0000\u0000\u03b2\u03b3\u0001\u0000"+ + "\u0000\u0000\u03b3\u03b5\u0001\u0000\u0000\u0000\u03b4\u03b2\u0001\u0000"+ + "\u0000\u0000\u03b5\u03b6\u0003\u00aaU\u0000\u03b6\u03ba\u0005\u0014\u0000"+ + "\u0000\u03b7\u03b9\u0005\u00a7\u0000\u0000\u03b8\u03b7\u0001\u0000\u0000"+ + "\u0000\u03b9\u03bc\u0001\u0000\u0000\u0000\u03ba\u03b8\u0001\u0000\u0000"+ + "\u0000\u03ba\u03bb\u0001\u0000\u0000\u0000\u03bb\u03bd\u0001\u0000\u0000"+ + "\u0000\u03bc\u03ba\u0001\u0000\u0000\u0000\u03bd\u03c1\u0003\u009eO\u0000"+ + "\u03be\u03c0\u0005\u00a7\u0000\u0000\u03bf\u03be\u0001\u0000\u0000\u0000"+ + "\u03c0\u03c3\u0001\u0000\u0000\u0000\u03c1\u03bf\u0001\u0000\u0000\u0000"+ + "\u03c1\u03c2\u0001\u0000\u0000\u0000\u03c2\u03c4\u0001\u0000\u0000\u0000"+ + "\u03c3\u03c1\u0001\u0000\u0000\u0000\u03c4\u03c8\u0005\u0015\u0000\u0000"+ + "\u03c5\u03c7\u0005\u00a7\u0000\u0000\u03c6\u03c5\u0001\u0000\u0000\u0000"+ + "\u03c7\u03ca\u0001\u0000\u0000\u0000\u03c8\u03c6\u0001\u0000\u0000\u0000"+ + "\u03c8\u03c9\u0001\u0000\u0000\u0000\u03c9\u03cb\u0001\u0000\u0000\u0000"+ + "\u03ca\u03c8\u0001\u0000\u0000\u0000\u03cb\u03cc\u0005\u0002\u0000\u0000"+ + "\u03cc+\u0001\u0000\u0000\u0000\u03cd\u03cf\u0005\u00a8\u0000\u0000\u03ce"+ + "\u03cd\u0001\u0000\u0000\u0000\u03cf\u03d2\u0001\u0000\u0000\u0000\u03d0"+ + "\u03ce\u0001\u0000\u0000\u0000\u03d0\u03d1\u0001\u0000\u0000\u0000\u03d1"+ + "\u03d3\u0001\u0000\u0000\u0000\u03d2\u03d0\u0001\u0000\u0000\u0000\u03d3"+ + "\u03dd\u0005\u001b\u0000\u0000\u03d4\u03d6\u0005\u00a7\u0000\u0000\u03d5"+ + "\u03d4\u0001\u0000\u0000\u0000\u03d6\u03d9\u0001\u0000\u0000\u0000\u03d7"+ + "\u03d5\u0001\u0000\u0000\u0000\u03d7\u03d8\u0001\u0000\u0000\u0000\u03d8"+ + "\u03da\u0001\u0000\u0000\u0000\u03d9\u03d7\u0001\u0000\u0000\u0000\u03da"+ + "\u03dc\u0003\u009eO\u0000\u03db\u03d7\u0001\u0000\u0000\u0000\u03dc\u03df"+ + "\u0001\u0000\u0000\u0000\u03dd\u03db\u0001\u0000\u0000\u0000\u03dd\u03de"+ + "\u0001\u0000\u0000\u0000\u03de\u03e3\u0001\u0000\u0000\u0000\u03df\u03dd"+ + "\u0001\u0000\u0000\u0000\u03e0\u03e2\u0005\u00a7\u0000\u0000\u03e1\u03e0"+ + "\u0001\u0000\u0000\u0000\u03e2\u03e5\u0001\u0000\u0000\u0000\u03e3\u03e1"+ + "\u0001\u0000\u0000\u0000\u03e3\u03e4\u0001\u0000\u0000\u0000\u03e4\u03e6"+ + "\u0001\u0000\u0000\u0000\u03e5\u03e3\u0001\u0000\u0000\u0000\u03e6\u03ea"+ + "\u0005\u0016\u0000\u0000\u03e7\u03e9\u0005\u00a7\u0000\u0000\u03e8\u03e7"+ + "\u0001\u0000\u0000\u0000\u03e9\u03ec\u0001\u0000\u0000\u0000\u03ea\u03e8"+ + "\u0001\u0000\u0000\u0000\u03ea\u03eb\u0001\u0000\u0000\u0000\u03eb\u03ed"+ + "\u0001\u0000\u0000\u0000\u03ec\u03ea\u0001\u0000\u0000\u0000\u03ed\u03f1"+ + "\u0003\u0096K\u0000\u03ee\u03f0\u0005\u00a7\u0000\u0000\u03ef\u03ee\u0001"+ + "\u0000\u0000\u0000\u03f0\u03f3\u0001\u0000\u0000\u0000\u03f1\u03ef\u0001"+ + "\u0000\u0000\u0000\u03f1\u03f2\u0001\u0000\u0000\u0000\u03f2\u03f4\u0001"+ + "\u0000\u0000\u0000\u03f3\u03f1\u0001\u0000\u0000\u0000\u03f4\u03f8\u0005"+ + "\u0007\u0000\u0000\u03f5\u03f7\u0005\u00a7\u0000\u0000\u03f6\u03f5\u0001"+ + "\u0000\u0000\u0000\u03f7\u03fa\u0001\u0000\u0000\u0000\u03f8\u03f6\u0001"+ + "\u0000\u0000\u0000\u03f8\u03f9\u0001\u0000\u0000\u0000\u03f9\u03ff\u0001"+ + "\u0000\u0000\u0000\u03fa\u03f8\u0001\u0000\u0000\u0000\u03fb\u0400\u0003"+ + "v;\u0000\u03fc\u0400\u0003x<\u0000\u03fd\u0400\u0003|>\u0000\u03fe\u0400"+ + "\u0003z=\u0000\u03ff\u03fb\u0001\u0000\u0000\u0000\u03ff\u03fc\u0001\u0000"+ + "\u0000\u0000\u03ff\u03fd\u0001\u0000\u0000\u0000\u03ff\u03fe\u0001\u0000"+ + "\u0000\u0000\u0400\u0404\u0001\u0000\u0000\u0000\u0401\u0403\u0005\u00a7"+ + "\u0000\u0000\u0402\u0401\u0001\u0000\u0000\u0000\u0403\u0406\u0001\u0000"+ + "\u0000\u0000\u0404\u0402\u0001\u0000\u0000\u0000\u0404\u0405\u0001\u0000"+ + "\u0000\u0000\u0405\u0407\u0001\u0000\u0000\u0000\u0406\u0404\u0001\u0000"+ + "\u0000\u0000\u0407\u0408\u0005\u0002\u0000\u0000\u0408-\u0001\u0000\u0000"+ + "\u0000\u0409\u040b\u0005\u00a8\u0000\u0000\u040a\u0409\u0001\u0000\u0000"+ + "\u0000\u040b\u040e\u0001\u0000\u0000\u0000\u040c\u040a\u0001\u0000\u0000"+ + "\u0000\u040c\u040d\u0001\u0000\u0000\u0000\u040d\u040f\u0001\u0000\u0000"+ + "\u0000\u040e\u040c\u0001\u0000\u0000\u0000\u040f\u0413\u0005\u001c\u0000"+ + "\u0000\u0410\u0412\u0005\u00a7\u0000\u0000\u0411\u0410\u0001\u0000\u0000"+ + "\u0000\u0412\u0415\u0001\u0000\u0000\u0000\u0413\u0411\u0001\u0000\u0000"+ + "\u0000\u0413\u0414\u0001\u0000\u0000\u0000\u0414\u0416\u0001\u0000\u0000"+ + "\u0000\u0415\u0413\u0001\u0000\u0000\u0000\u0416\u041a\u0003\u00a8T\u0000"+ + "\u0417\u0419\u0005\u00a7\u0000\u0000\u0418\u0417\u0001\u0000\u0000\u0000"+ + "\u0419\u041c\u0001\u0000\u0000\u0000\u041a\u0418\u0001\u0000\u0000\u0000"+ + "\u041a\u041b\u0001\u0000\u0000\u0000\u041b\u041d\u0001\u0000\u0000\u0000"+ + "\u041c\u041a\u0001\u0000\u0000\u0000\u041d\u041e\u0005\u0002\u0000\u0000"+ + "\u041e/\u0001\u0000\u0000\u0000\u041f\u0421\u0005\u00a8\u0000\u0000\u0420"+ + "\u041f\u0001\u0000\u0000\u0000\u0421\u0424\u0001\u0000\u0000\u0000\u0422"+ + "\u0420\u0001\u0000\u0000\u0000\u0422\u0423\u0001\u0000\u0000\u0000\u0423"+ + "\u0425\u0001\u0000\u0000\u0000\u0424\u0422\u0001\u0000\u0000\u0000\u0425"+ + "\u0429\u0003\u00be_\u0000\u0426\u0428\u0005\u00a7\u0000\u0000\u0427\u0426"+ + "\u0001\u0000\u0000\u0000\u0428\u042b\u0001\u0000\u0000\u0000\u0429\u0427"+ + "\u0001\u0000\u0000\u0000\u0429\u042a\u0001\u0000\u0000\u0000\u042a\u042f"+ + "\u0001\u0000\u0000\u0000\u042b\u0429\u0001\u0000\u0000\u0000\u042c\u042e"+ + "\u0005\u00a7\u0000\u0000\u042d\u042c\u0001\u0000\u0000\u0000\u042e\u0431"+ + "\u0001\u0000\u0000\u0000\u042f\u042d\u0001\u0000\u0000\u0000\u042f\u0430"+ + "\u0001\u0000\u0000\u0000\u0430\u0432\u0001\u0000\u0000\u0000\u0431\u042f"+ + "\u0001\u0000\u0000\u0000\u0432\u0436\u0003\u009eO\u0000\u0433\u0435\u0005"+ + "\u00a7\u0000\u0000\u0434\u0433\u0001\u0000\u0000\u0000\u0435\u0438\u0001"+ + "\u0000\u0000\u0000\u0436\u0434\u0001\u0000\u0000\u0000\u0436\u0437\u0001"+ + "\u0000\u0000\u0000\u0437\u0439\u0001\u0000\u0000\u0000\u0438\u0436\u0001"+ + "\u0000\u0000\u0000\u0439\u043d\u0003\u009eO\u0000\u043a\u043c\u0005\u00a7"+ + "\u0000\u0000\u043b\u043a\u0001\u0000\u0000\u0000\u043c\u043f\u0001\u0000"+ + "\u0000\u0000\u043d\u043b\u0001\u0000\u0000\u0000\u043d\u043e\u0001\u0000"+ + "\u0000\u0000\u043e\u0440\u0001\u0000\u0000\u0000\u043f\u043d\u0001\u0000"+ + "\u0000\u0000\u0440\u0444\u0005\u001d\u0000\u0000\u0441\u0443\u0005\u00a7"+ + "\u0000\u0000\u0442\u0441\u0001\u0000\u0000\u0000\u0443\u0446\u0001\u0000"+ + "\u0000\u0000\u0444\u0442\u0001\u0000\u0000\u0000\u0444\u0445\u0001\u0000"+ + "\u0000\u0000\u0445\u0447\u0001\u0000\u0000\u0000\u0446\u0444\u0001\u0000"+ + "\u0000\u0000\u0447\u044b\u0003\u00a8T\u0000\u0448\u044a\u0005\u00a7\u0000"+ + "\u0000\u0449\u0448\u0001\u0000\u0000\u0000\u044a\u044d\u0001\u0000\u0000"+ + "\u0000\u044b\u0449\u0001\u0000\u0000\u0000\u044b\u044c\u0001\u0000\u0000"+ + "\u0000\u044c\u044e\u0001\u0000\u0000\u0000\u044d\u044b\u0001\u0000\u0000"+ + "\u0000\u044e\u044f\u0005\u0002\u0000\u0000\u044f1\u0001\u0000\u0000\u0000"+ + "\u0450\u0452\u0005\u00a8\u0000\u0000\u0451\u0450\u0001\u0000\u0000\u0000"+ + "\u0452\u0455\u0001\u0000\u0000\u0000\u0453\u0451\u0001\u0000\u0000\u0000"+ + "\u0453\u0454\u0001\u0000\u0000\u0000\u0454\u0456\u0001\u0000\u0000\u0000"+ + "\u0455\u0453\u0001\u0000\u0000\u0000\u0456\u045a\u0005\u001e\u0000\u0000"+ + "\u0457\u0459\u0005\u00a7\u0000\u0000\u0458\u0457\u0001\u0000\u0000\u0000"+ + "\u0459\u045c\u0001\u0000\u0000\u0000\u045a\u0458\u0001\u0000\u0000\u0000"+ + "\u045a\u045b\u0001\u0000\u0000\u0000\u045b\u045d\u0001\u0000\u0000\u0000"+ + "\u045c\u045a\u0001\u0000\u0000\u0000\u045d\u0461\u0003\u0096K\u0000\u045e"+ + "\u0460\u0005\u00a7\u0000\u0000\u045f\u045e\u0001\u0000\u0000\u0000\u0460"+ + "\u0463\u0001\u0000\u0000\u0000\u0461\u045f\u0001\u0000\u0000\u0000\u0461"+ + "\u0462\u0001\u0000\u0000\u0000\u0462\u0464\u0001\u0000\u0000\u0000\u0463"+ + "\u0461\u0001\u0000\u0000\u0000\u0464\u0465\u0005\u0002\u0000\u0000\u0465"+ + "3\u0001\u0000\u0000\u0000\u0466\u0468\u0005\u00a8\u0000\u0000\u0467\u0466"+ + "\u0001\u0000\u0000\u0000\u0468\u046b\u0001\u0000\u0000\u0000\u0469\u0467"+ + "\u0001\u0000\u0000\u0000\u0469\u046a\u0001\u0000\u0000\u0000\u046a\u0477"+ + "\u0001\u0000\u0000\u0000\u046b\u0469\u0001\u0000\u0000\u0000\u046c\u0478"+ + "\u00036\u001b\u0000\u046d\u0478\u00038\u001c\u0000\u046e\u0478\u0003:"+ + "\u001d\u0000\u046f\u0478\u0003<\u001e\u0000\u0470\u0478\u0003>\u001f\u0000"+ + "\u0471\u0478\u0003@ \u0000\u0472\u0478\u0003F#\u0000\u0473\u0478\u0003"+ + "H$\u0000\u0474\u0478\u0003J%\u0000\u0475\u0478\u0003L&\u0000\u0476\u0478"+ + "\u0003N\'\u0000\u0477\u046c\u0001\u0000\u0000\u0000\u0477\u046d\u0001"+ + "\u0000\u0000\u0000\u0477\u046e\u0001\u0000\u0000\u0000\u0477\u046f\u0001"+ + "\u0000\u0000\u0000\u0477\u0470\u0001\u0000\u0000\u0000\u0477\u0471\u0001"+ + "\u0000\u0000\u0000\u0477\u0472\u0001\u0000\u0000\u0000\u0477\u0473\u0001"+ + "\u0000\u0000\u0000\u0477\u0474\u0001\u0000\u0000\u0000\u0477\u0475\u0001"+ + "\u0000\u0000\u0000\u0477\u0476\u0001\u0000\u0000\u0000\u0478\u047c\u0001"+ + "\u0000\u0000\u0000\u0479\u047b\u0005\u00a7\u0000\u0000\u047a\u0479\u0001"+ + "\u0000\u0000\u0000\u047b\u047e\u0001\u0000\u0000\u0000\u047c\u047a\u0001"+ + "\u0000\u0000\u0000\u047c\u047d\u0001\u0000\u0000\u0000\u047d\u047f\u0001"+ + "\u0000\u0000\u0000\u047e\u047c\u0001\u0000\u0000\u0000\u047f\u0480\u0005"+ + "\u0002\u0000\u0000\u04805\u0001\u0000\u0000\u0000\u0481\u0485\u0003\u00ae"+ + "W\u0000\u0482\u0484\u0005\u00a7\u0000\u0000\u0483\u0482\u0001\u0000\u0000"+ + "\u0000\u0484\u0487\u0001\u0000\u0000\u0000\u0485\u0483\u0001\u0000\u0000"+ + "\u0000\u0485\u0486\u0001\u0000\u0000\u0000\u0486\u0488\u0001\u0000\u0000"+ + "\u0000\u0487\u0485\u0001\u0000\u0000\u0000\u0488\u048c\u0003\u009eO\u0000"+ + "\u0489\u048b\u0005\u00a7\u0000\u0000\u048a\u0489\u0001\u0000\u0000\u0000"+ + "\u048b\u048e\u0001\u0000\u0000\u0000\u048c\u048a\u0001\u0000\u0000\u0000"+ + "\u048c\u048d\u0001\u0000\u0000\u0000\u048d\u048f\u0001\u0000\u0000\u0000"+ + "\u048e\u048c\u0001\u0000\u0000\u0000\u048f\u0493\u0005\u0016\u0000\u0000"+ + "\u0490\u0492\u0005\u00a7\u0000\u0000\u0491\u0490\u0001\u0000\u0000\u0000"+ + "\u0492\u0495\u0001\u0000\u0000\u0000\u0493\u0491\u0001\u0000\u0000\u0000"+ + "\u0493\u0494\u0001\u0000\u0000\u0000\u0494\u0496\u0001\u0000\u0000\u0000"+ + "\u0495\u0493\u0001\u0000\u0000\u0000\u0496\u0497\u0003\u0096K\u0000\u0497"+ + "7\u0001\u0000\u0000\u0000\u0498\u049c\u0003\u00b0X\u0000\u0499\u049b\u0005"+ + "\u00a7\u0000\u0000\u049a\u0499\u0001\u0000\u0000\u0000\u049b\u049e\u0001"+ + "\u0000\u0000\u0000\u049c\u049a\u0001\u0000\u0000\u0000\u049c\u049d\u0001"+ + "\u0000\u0000\u0000\u049d\u049f\u0001\u0000\u0000\u0000\u049e\u049c\u0001"+ + "\u0000\u0000\u0000\u049f\u04a3\u0003\u009eO\u0000\u04a0\u04a2\u0005\u00a7"+ + "\u0000\u0000\u04a1\u04a0\u0001\u0000\u0000\u0000\u04a2\u04a5\u0001\u0000"+ + "\u0000\u0000\u04a3\u04a1\u0001\u0000\u0000\u0000\u04a3\u04a4\u0001\u0000"+ + "\u0000\u0000\u04a4\u04a6\u0001\u0000\u0000\u0000\u04a5\u04a3\u0001\u0000"+ + "\u0000\u0000\u04a6\u04aa\u0003\u009eO\u0000\u04a7\u04a9\u0005\u00a7\u0000"+ + "\u0000\u04a8\u04a7\u0001\u0000\u0000\u0000\u04a9\u04ac\u0001\u0000\u0000"+ + "\u0000\u04aa\u04a8\u0001\u0000\u0000\u0000\u04aa\u04ab\u0001\u0000\u0000"+ + "\u0000\u04ab\u04ad\u0001\u0000\u0000\u0000\u04ac\u04aa\u0001\u0000\u0000"+ + "\u0000\u04ad\u04b1\u0005\u0016\u0000\u0000\u04ae\u04b0\u0005\u00a7\u0000"+ + "\u0000\u04af\u04ae\u0001\u0000\u0000\u0000\u04b0\u04b3\u0001\u0000\u0000"+ + "\u0000\u04b1\u04af\u0001\u0000\u0000\u0000\u04b1\u04b2\u0001\u0000\u0000"+ + "\u0000\u04b2\u04b4\u0001\u0000\u0000\u0000\u04b3\u04b1\u0001\u0000\u0000"+ + "\u0000\u04b4\u04b5\u0003\u0096K\u0000\u04b59\u0001\u0000\u0000\u0000\u04b6"+ + "\u04ba\u0005\u001f\u0000\u0000\u04b7\u04b9\u0005\u00a7\u0000\u0000\u04b8"+ + "\u04b7\u0001\u0000\u0000\u0000\u04b9\u04bc\u0001\u0000\u0000\u0000\u04ba"+ + "\u04b8\u0001\u0000\u0000\u0000\u04ba\u04bb\u0001\u0000\u0000\u0000\u04bb"+ + "\u04bd\u0001\u0000\u0000\u0000\u04bc\u04ba\u0001\u0000\u0000\u0000\u04bd"+ + "\u04c1\u0003\u009eO\u0000\u04be\u04c0\u0005\u00a7\u0000\u0000\u04bf\u04be"+ + "\u0001\u0000\u0000\u0000\u04c0\u04c3\u0001\u0000\u0000\u0000\u04c1\u04bf"+ + "\u0001\u0000\u0000\u0000\u04c1\u04c2\u0001\u0000\u0000\u0000\u04c2\u04c4"+ + "\u0001\u0000\u0000\u0000\u04c3\u04c1\u0001\u0000\u0000\u0000\u04c4\u04c8"+ + "\u0003\u009eO\u0000\u04c5\u04c7\u0005\u00a7\u0000\u0000\u04c6\u04c5\u0001"+ + "\u0000\u0000\u0000\u04c7\u04ca\u0001\u0000\u0000\u0000\u04c8\u04c6\u0001"+ + "\u0000\u0000\u0000\u04c8\u04c9\u0001\u0000\u0000\u0000\u04c9\u04cb\u0001"+ + "\u0000\u0000\u0000\u04ca\u04c8\u0001\u0000\u0000\u0000\u04cb\u04cf\u0003"+ + "\u009eO\u0000\u04cc\u04ce\u0005\u00a7\u0000\u0000\u04cd\u04cc\u0001\u0000"+ + "\u0000\u0000\u04ce\u04d1\u0001\u0000\u0000\u0000\u04cf\u04cd\u0001\u0000"+ + "\u0000\u0000\u04cf\u04d0\u0001\u0000\u0000\u0000\u04d0\u04d2\u0001\u0000"+ + "\u0000\u0000\u04d1\u04cf\u0001\u0000\u0000\u0000\u04d2\u04d6\u0005\u0016"+ + "\u0000\u0000\u04d3\u04d5\u0005\u00a7\u0000\u0000\u04d4\u04d3\u0001\u0000"+ + "\u0000\u0000\u04d5\u04d8\u0001\u0000\u0000\u0000\u04d6\u04d4\u0001\u0000"+ + "\u0000\u0000\u04d6\u04d7\u0001\u0000\u0000\u0000\u04d7\u04d9\u0001\u0000"+ + "\u0000\u0000\u04d8\u04d6\u0001\u0000\u0000\u0000\u04d9\u04da\u0003\u0096"+ + "K\u0000\u04da;\u0001\u0000\u0000\u0000\u04db\u04df\u0003\u00b2Y\u0000"+ + "\u04dc\u04de\u0005\u00a7\u0000\u0000\u04dd\u04dc\u0001\u0000\u0000\u0000"+ + "\u04de\u04e1\u0001\u0000\u0000\u0000\u04df\u04dd\u0001\u0000\u0000\u0000"+ + "\u04df\u04e0\u0001\u0000\u0000\u0000\u04e0\u04e2\u0001\u0000\u0000\u0000"+ + "\u04e1\u04df\u0001\u0000\u0000\u0000\u04e2\u04e6\u0003\u009eO\u0000\u04e3"+ + "\u04e5\u0005\u00a7\u0000\u0000\u04e4\u04e3\u0001\u0000\u0000\u0000\u04e5"+ + "\u04e8\u0001\u0000\u0000\u0000\u04e6\u04e4\u0001\u0000\u0000\u0000\u04e6"+ + "\u04e7\u0001\u0000\u0000\u0000\u04e7\u04e9\u0001\u0000\u0000\u0000\u04e8"+ + "\u04e6\u0001\u0000\u0000\u0000\u04e9\u04ed\u0003\u009eO\u0000\u04ea\u04ec"+ + "\u0005\u00a7\u0000\u0000\u04eb\u04ea\u0001\u0000\u0000\u0000\u04ec\u04ef"+ + "\u0001\u0000\u0000\u0000\u04ed\u04eb\u0001\u0000\u0000\u0000\u04ed\u04ee"+ + "\u0001\u0000\u0000\u0000\u04ee\u04f0\u0001\u0000\u0000\u0000\u04ef\u04ed"+ + "\u0001\u0000\u0000\u0000\u04f0\u04f4\u0005\u0016\u0000\u0000\u04f1\u04f3"+ + "\u0005\u00a7\u0000\u0000\u04f2\u04f1\u0001\u0000\u0000\u0000\u04f3\u04f6"+ + "\u0001\u0000\u0000\u0000\u04f4\u04f2\u0001\u0000\u0000\u0000\u04f4\u04f5"+ + "\u0001\u0000\u0000\u0000\u04f5\u04f7\u0001\u0000\u0000\u0000\u04f6\u04f4"+ + "\u0001\u0000\u0000\u0000\u04f7\u04f8\u0003\u0096K\u0000\u04f8=\u0001\u0000"+ + "\u0000\u0000\u04f9\u04fd\u0003\u00b4Z\u0000\u04fa\u04fc\u0005\u00a7\u0000"+ + "\u0000\u04fb\u04fa\u0001\u0000\u0000\u0000\u04fc\u04ff\u0001\u0000\u0000"+ + "\u0000\u04fd\u04fb\u0001\u0000\u0000\u0000\u04fd\u04fe\u0001\u0000\u0000"+ + "\u0000\u04fe\u0500\u0001\u0000\u0000\u0000\u04ff\u04fd\u0001\u0000\u0000"+ + "\u0000\u0500\u0504\u0003\u009eO\u0000\u0501\u0503\u0005\u00a7\u0000\u0000"+ + "\u0502\u0501\u0001\u0000\u0000\u0000\u0503\u0506\u0001\u0000\u0000\u0000"+ + "\u0504\u0502\u0001\u0000\u0000\u0000\u0504\u0505\u0001\u0000\u0000\u0000"+ + "\u0505\u0507\u0001\u0000\u0000\u0000\u0506\u0504\u0001\u0000\u0000\u0000"+ + "\u0507\u0508\u0003\u009eO\u0000\u0508?\u0001\u0000\u0000\u0000\u0509\u050d"+ + "\u0003\u00b6[\u0000\u050a\u050c\u0005\u00a7\u0000\u0000\u050b\u050a\u0001"+ + "\u0000\u0000\u0000\u050c\u050f\u0001\u0000\u0000\u0000\u050d\u050b\u0001"+ + "\u0000\u0000\u0000\u050d\u050e\u0001\u0000\u0000\u0000\u050e\u0510\u0001"+ + "\u0000\u0000\u0000\u050f\u050d\u0001\u0000\u0000\u0000\u0510\u0514\u0003"+ + "\u009eO\u0000\u0511\u0513\u0005\u00a7\u0000\u0000\u0512\u0511\u0001\u0000"+ + "\u0000\u0000\u0513\u0516\u0001\u0000\u0000\u0000\u0514\u0512\u0001\u0000"+ + "\u0000\u0000\u0514\u0515\u0001\u0000\u0000\u0000\u0515\u0517\u0001\u0000"+ + "\u0000\u0000\u0516\u0514\u0001\u0000\u0000\u0000\u0517\u051b\u0003\u009e"+ + "O\u0000\u0518\u051a\u0005\u00a7\u0000\u0000\u0519\u0518\u0001\u0000\u0000"+ + "\u0000\u051a\u051d\u0001\u0000\u0000\u0000\u051b\u0519\u0001\u0000\u0000"+ + "\u0000\u051b\u051c\u0001\u0000\u0000\u0000\u051c\u051e\u0001\u0000\u0000"+ + "\u0000\u051d\u051b\u0001\u0000\u0000\u0000\u051e\u0522\u0005\u0016\u0000"+ + "\u0000\u051f\u0521\u0005\u00a7\u0000\u0000\u0520\u051f\u0001\u0000\u0000"+ + "\u0000\u0521\u0524\u0001\u0000\u0000\u0000\u0522\u0520\u0001\u0000\u0000"+ + "\u0000\u0522\u0523\u0001\u0000\u0000\u0000\u0523\u0525\u0001\u0000\u0000"+ + "\u0000\u0524\u0522\u0001\u0000\u0000\u0000\u0525\u0529\u0003\u0096K\u0000"+ + "\u0526\u0528\u0005\u00a7\u0000\u0000\u0527\u0526\u0001\u0000\u0000\u0000"+ + "\u0528\u052b\u0001\u0000\u0000\u0000\u0529\u0527\u0001\u0000\u0000\u0000"+ + "\u0529\u052a\u0001\u0000\u0000\u0000\u052a\u052c\u0001\u0000\u0000\u0000"+ + "\u052b\u0529\u0001\u0000\u0000\u0000\u052c\u0530\u0005\u0007\u0000\u0000"+ + "\u052d\u052f\u0005\u00a7\u0000\u0000\u052e\u052d\u0001\u0000\u0000\u0000"+ + "\u052f\u0532\u0001\u0000\u0000\u0000\u0530\u052e\u0001\u0000\u0000\u0000"+ + "\u0530\u0531\u0001\u0000\u0000\u0000\u0531\u0536\u0001\u0000\u0000\u0000"+ + "\u0532\u0530\u0001\u0000\u0000\u0000\u0533\u0537\u0003x<\u0000\u0534\u0537"+ + "\u0003p8\u0000\u0535\u0537\u0003r9\u0000\u0536\u0533\u0001\u0000\u0000"+ + "\u0000\u0536\u0534\u0001\u0000\u0000\u0000\u0536\u0535\u0001\u0000\u0000"+ + "\u0000\u0537A\u0001\u0000\u0000\u0000\u0538\u053c\u0003\u00b8\\\u0000"+ + "\u0539\u053b\u0005\u00a7\u0000\u0000\u053a\u0539\u0001\u0000\u0000\u0000"+ + "\u053b\u053e\u0001\u0000\u0000\u0000\u053c\u053a\u0001\u0000\u0000\u0000"+ + "\u053c\u053d\u0001\u0000\u0000\u0000\u053d\u053f\u0001\u0000\u0000\u0000"+ + "\u053e\u053c\u0001\u0000\u0000\u0000\u053f\u0543\u0003\u009eO\u0000\u0540"+ + "\u0542\u0005\u00a7\u0000\u0000\u0541\u0540\u0001\u0000\u0000\u0000\u0542"+ + "\u0545\u0001\u0000\u0000\u0000\u0543\u0541\u0001\u0000\u0000\u0000\u0543"+ + "\u0544\u0001\u0000\u0000\u0000\u0544\u0546\u0001\u0000\u0000\u0000\u0545"+ + "\u0543\u0001\u0000\u0000\u0000\u0546\u054a\u0005\u0016\u0000\u0000\u0547"+ + "\u0549\u0005\u00a7\u0000\u0000\u0548\u0547\u0001\u0000\u0000\u0000\u0549"+ + "\u054c\u0001\u0000\u0000\u0000\u054a\u0548\u0001\u0000\u0000\u0000\u054a"+ + "\u054b\u0001\u0000\u0000\u0000\u054b\u054d\u0001\u0000\u0000\u0000\u054c"+ + "\u054a\u0001\u0000\u0000\u0000\u054d\u0551\u0003\u0096K\u0000\u054e\u0550"+ + "\u0005\u00a7\u0000\u0000\u054f\u054e\u0001\u0000\u0000\u0000\u0550\u0553"+ + "\u0001\u0000\u0000\u0000\u0551\u054f\u0001\u0000\u0000\u0000\u0551\u0552"+ + "\u0001\u0000\u0000\u0000\u0552\u0554\u0001\u0000\u0000\u0000\u0553\u0551"+ + "\u0001\u0000\u0000\u0000\u0554\u0558\u0005\u0007\u0000\u0000\u0555\u0557"+ + "\u0005\u00a7\u0000\u0000\u0556\u0555\u0001\u0000\u0000\u0000\u0557\u055a"+ + "\u0001\u0000\u0000\u0000\u0558\u0556\u0001\u0000\u0000\u0000\u0558\u0559"+ + "\u0001\u0000\u0000\u0000\u0559\u0560\u0001\u0000\u0000\u0000\u055a\u0558"+ + "\u0001\u0000\u0000\u0000\u055b\u0561\u0003v;\u0000\u055c\u0561\u0003x"+ + "<\u0000\u055d\u0561\u0003|>\u0000\u055e\u0561\u0003\u0080@\u0000\u055f"+ + "\u0561\u0003\u00aaU\u0000\u0560\u055b\u0001\u0000\u0000\u0000\u0560\u055c"+ + "\u0001\u0000\u0000\u0000\u0560\u055d\u0001\u0000\u0000\u0000\u0560\u055e"+ + "\u0001\u0000\u0000\u0000\u0560\u055f\u0001\u0000\u0000\u0000\u0561C\u0001"+ + "\u0000\u0000\u0000\u0562\u0566\u0003\u00ba]\u0000\u0563\u0565\u0005\u00a7"+ + "\u0000\u0000\u0564\u0563\u0001\u0000\u0000\u0000\u0565\u0568\u0001\u0000"+ + "\u0000\u0000\u0566\u0564\u0001\u0000\u0000\u0000\u0566\u0567\u0001\u0000"+ + "\u0000\u0000\u0567\u0569\u0001\u0000\u0000\u0000\u0568\u0566\u0001\u0000"+ + "\u0000\u0000\u0569\u056d\u0003\u009eO\u0000\u056a\u056c\u0005\u00a7\u0000"+ + "\u0000\u056b\u056a\u0001\u0000\u0000\u0000\u056c\u056f\u0001\u0000\u0000"+ + "\u0000\u056d\u056b\u0001\u0000\u0000\u0000\u056d\u056e\u0001\u0000\u0000"+ + "\u0000\u056e\u0570\u0001\u0000\u0000\u0000\u056f\u056d\u0001\u0000\u0000"+ + "\u0000\u0570\u0574\u0003\u009eO\u0000\u0571\u0573\u0005\u00a7\u0000\u0000"+ + "\u0572\u0571\u0001\u0000\u0000\u0000\u0573\u0576\u0001\u0000\u0000\u0000"+ + "\u0574\u0572\u0001\u0000\u0000\u0000\u0574\u0575\u0001\u0000\u0000\u0000"+ + "\u0575\u0577\u0001\u0000\u0000\u0000\u0576\u0574\u0001\u0000\u0000\u0000"+ + "\u0577\u057b\u0005\u0016\u0000\u0000\u0578\u057a\u0005\u00a7\u0000\u0000"+ + "\u0579\u0578\u0001\u0000\u0000\u0000\u057a\u057d\u0001\u0000\u0000\u0000"+ + "\u057b\u0579\u0001\u0000\u0000\u0000\u057b\u057c\u0001\u0000\u0000\u0000"+ + "\u057c\u057e\u0001\u0000\u0000\u0000\u057d\u057b\u0001\u0000\u0000\u0000"+ + "\u057e\u0582\u0003\u0096K\u0000\u057f\u0581\u0005\u00a7\u0000\u0000\u0580"+ + "\u057f\u0001\u0000\u0000\u0000\u0581\u0584\u0001\u0000\u0000\u0000\u0582"+ + "\u0580\u0001\u0000\u0000\u0000\u0582\u0583\u0001\u0000\u0000\u0000\u0583"+ + "\u0585\u0001\u0000\u0000\u0000\u0584\u0582\u0001\u0000\u0000\u0000\u0585"+ + "\u0589\u0005\u0007\u0000\u0000\u0586\u0588\u0005\u00a7\u0000\u0000\u0587"+ + "\u0586\u0001\u0000\u0000\u0000\u0588\u058b\u0001\u0000\u0000\u0000\u0589"+ + "\u0587\u0001\u0000\u0000\u0000\u0589\u058a\u0001\u0000\u0000\u0000\u058a"+ + "\u0591\u0001\u0000\u0000\u0000\u058b\u0589\u0001\u0000\u0000\u0000\u058c"+ + "\u0592\u0003v;\u0000\u058d\u0592\u0003x<\u0000\u058e\u0592\u0003|>\u0000"+ + "\u058f\u0592\u0003\u0080@\u0000\u0590\u0592\u0003\u00aaU\u0000\u0591\u058c"+ + "\u0001\u0000\u0000\u0000\u0591\u058d\u0001\u0000\u0000\u0000\u0591\u058e"+ + "\u0001\u0000\u0000\u0000\u0591\u058f\u0001\u0000\u0000\u0000\u0591\u0590"+ + "\u0001\u0000\u0000\u0000\u0592E\u0001\u0000\u0000\u0000\u0593\u0596\u0003"+ + "B!\u0000\u0594\u0596\u0003D\"\u0000\u0595\u0593\u0001\u0000\u0000\u0000"+ + "\u0595\u0594\u0001\u0000\u0000\u0000\u0596G\u0001\u0000\u0000\u0000\u0597"+ + "\u059b\u0007\u0001\u0000\u0000\u0598\u059a\u0005\u00a7\u0000\u0000\u0599"+ + "\u0598\u0001\u0000\u0000\u0000\u059a\u059d\u0001\u0000\u0000\u0000\u059b"+ + "\u0599\u0001\u0000\u0000\u0000\u059b\u059c\u0001\u0000\u0000\u0000\u059c"+ + "\u059e\u0001\u0000\u0000\u0000\u059d\u059b\u0001\u0000\u0000\u0000\u059e"+ + "\u05a2\u0003\u009eO\u0000\u059f\u05a1\u0005\u00a7\u0000\u0000\u05a0\u059f"+ + "\u0001\u0000\u0000\u0000\u05a1\u05a4\u0001\u0000\u0000\u0000\u05a2\u05a0"+ + "\u0001\u0000\u0000\u0000\u05a2\u05a3\u0001\u0000\u0000\u0000\u05a3\u05a5"+ + "\u0001\u0000\u0000\u0000\u05a4\u05a2\u0001\u0000\u0000\u0000\u05a5\u05a9"+ + "\u0003\u009eO\u0000\u05a6\u05a8\u0005\u00a7\u0000\u0000\u05a7\u05a6\u0001"+ + "\u0000\u0000\u0000\u05a8\u05ab\u0001\u0000\u0000\u0000\u05a9\u05a7\u0001"+ + "\u0000\u0000\u0000\u05a9\u05aa\u0001\u0000\u0000\u0000\u05aa\u05ac\u0001"+ + "\u0000\u0000\u0000\u05ab\u05a9\u0001\u0000\u0000\u0000\u05ac\u05b0\u0003"+ + "\u009eO\u0000\u05ad\u05af\u0005\u00a7\u0000\u0000\u05ae\u05ad\u0001\u0000"+ + "\u0000\u0000\u05af\u05b2\u0001\u0000\u0000\u0000\u05b0\u05ae\u0001\u0000"+ + "\u0000\u0000\u05b0\u05b1\u0001\u0000\u0000\u0000\u05b1\u05b3\u0001\u0000"+ + "\u0000\u0000\u05b2\u05b0\u0001\u0000\u0000\u0000\u05b3\u05b7\u0005\u0016"+ + "\u0000\u0000\u05b4\u05b6\u0005\u00a7\u0000\u0000\u05b5\u05b4\u0001\u0000"+ + "\u0000\u0000\u05b6\u05b9\u0001\u0000\u0000\u0000\u05b7\u05b5\u0001\u0000"+ + "\u0000\u0000\u05b7\u05b8\u0001\u0000\u0000\u0000\u05b8\u05ba\u0001\u0000"+ + "\u0000\u0000\u05b9\u05b7\u0001\u0000\u0000\u0000\u05ba\u05bb\u0003\u0096"+ + "K\u0000\u05bbI\u0001\u0000\u0000\u0000\u05bc\u05c4\u0003\u00bc^\u0000"+ + "\u05bd\u05bf\u0005\u00a7\u0000\u0000\u05be\u05bd\u0001\u0000\u0000\u0000"+ + "\u05bf\u05c2\u0001\u0000\u0000\u0000\u05c0\u05be\u0001\u0000\u0000\u0000"+ + "\u05c0\u05c1\u0001\u0000\u0000\u0000\u05c1\u05c3\u0001\u0000\u0000\u0000"+ + "\u05c2\u05c0\u0001\u0000\u0000\u0000\u05c3\u05c5\u0003\u009eO\u0000\u05c4"+ + "\u05c0\u0001\u0000\u0000\u0000\u05c5\u05c6\u0001\u0000\u0000\u0000\u05c6"+ + "\u05c4\u0001\u0000\u0000\u0000\u05c6\u05c7\u0001\u0000\u0000\u0000\u05c7"+ + "\u05cb\u0001\u0000\u0000\u0000\u05c8\u05ca\u0005\u00a7\u0000\u0000\u05c9"+ + "\u05c8\u0001\u0000\u0000\u0000\u05ca\u05cd\u0001\u0000\u0000\u0000\u05cb"+ + "\u05c9\u0001\u0000\u0000\u0000\u05cb\u05cc\u0001\u0000\u0000\u0000\u05cc"+ + "\u05ce\u0001\u0000\u0000\u0000\u05cd\u05cb\u0001\u0000\u0000\u0000\u05ce"+ + "\u05d2\u0005\u0016\u0000\u0000\u05cf\u05d1\u0005\u00a7\u0000\u0000\u05d0"+ + "\u05cf\u0001\u0000\u0000\u0000\u05d1\u05d4\u0001\u0000\u0000\u0000\u05d2"+ + "\u05d0\u0001\u0000\u0000\u0000\u05d2\u05d3\u0001\u0000\u0000\u0000\u05d3"+ + "\u05d5\u0001\u0000\u0000\u0000\u05d4\u05d2\u0001\u0000\u0000\u0000\u05d5"+ + "\u05d9\u0003\u0096K\u0000\u05d6\u05d8\u0005\u00a7\u0000\u0000\u05d7\u05d6"+ + "\u0001\u0000\u0000\u0000\u05d8\u05db\u0001\u0000\u0000\u0000\u05d9\u05d7"+ + "\u0001\u0000\u0000\u0000\u05d9\u05da\u0001\u0000\u0000\u0000\u05da\u05dc"+ + "\u0001\u0000\u0000\u0000\u05db\u05d9\u0001\u0000\u0000\u0000\u05dc\u05e0"+ + "\u0005\u0007\u0000\u0000\u05dd\u05df\u0005\u00a7\u0000\u0000\u05de\u05dd"+ + "\u0001\u0000\u0000\u0000\u05df\u05e2\u0001\u0000\u0000\u0000\u05e0\u05de"+ + "\u0001\u0000\u0000\u0000\u05e0\u05e1\u0001\u0000\u0000\u0000\u05e1\u05e3"+ + "\u0001\u0000\u0000\u0000\u05e2\u05e0\u0001\u0000\u0000\u0000\u05e3\u05e4"+ + "\u0003\u00a6S\u0000\u05e4K\u0001\u0000\u0000\u0000\u05e5\u05e9\u0005\""+ + "\u0000\u0000\u05e6\u05e8\u0005\u00a7\u0000\u0000\u05e7\u05e6\u0001\u0000"+ + "\u0000\u0000\u05e8\u05eb\u0001\u0000\u0000\u0000\u05e9\u05e7\u0001\u0000"+ + "\u0000\u0000\u05e9\u05ea\u0001\u0000\u0000\u0000\u05ea\u05ee\u0001\u0000"+ + "\u0000\u0000\u05eb\u05e9\u0001\u0000\u0000\u0000\u05ec\u05ef\u0003\u00a4"+ + "R\u0000\u05ed\u05ef\u0003\u00aaU\u0000\u05ee\u05ec\u0001\u0000\u0000\u0000"+ + "\u05ee\u05ed\u0001\u0000\u0000\u0000\u05ef\u05f9\u0001\u0000\u0000\u0000"+ + "\u05f0\u05f2\u0005\u00a7\u0000\u0000\u05f1\u05f0\u0001\u0000\u0000\u0000"+ + "\u05f2\u05f5\u0001\u0000\u0000\u0000\u05f3\u05f1\u0001\u0000\u0000\u0000"+ + "\u05f3\u05f4\u0001\u0000\u0000\u0000\u05f4\u05f6\u0001\u0000\u0000\u0000"+ + "\u05f5\u05f3\u0001\u0000\u0000\u0000\u05f6\u05f8\u0003\u009eO\u0000\u05f7"+ + "\u05f3\u0001\u0000\u0000\u0000\u05f8\u05fb\u0001\u0000\u0000\u0000\u05f9"+ + "\u05f7\u0001\u0000\u0000\u0000\u05f9\u05fa\u0001\u0000\u0000\u0000\u05fa"+ + "\u0609\u0001\u0000\u0000\u0000\u05fb\u05f9\u0001\u0000\u0000\u0000\u05fc"+ + "\u05fe\u0005\u00a7\u0000\u0000\u05fd\u05fc\u0001\u0000\u0000\u0000\u05fe"+ + "\u0601\u0001\u0000\u0000\u0000\u05ff\u05fd\u0001\u0000\u0000\u0000\u05ff"+ + "\u0600\u0001\u0000\u0000\u0000\u0600\u0602\u0001\u0000\u0000\u0000\u0601"+ + "\u05ff\u0001\u0000\u0000\u0000\u0602\u0605\u0005\u0016\u0000\u0000\u0603"+ + "\u0604\u0005\u00a7\u0000\u0000\u0604\u0606\u0003\u0096K\u0000\u0605\u0603"+ + "\u0001\u0000\u0000\u0000\u0606\u0607\u0001\u0000\u0000\u0000\u0607\u0605"+ + "\u0001\u0000\u0000\u0000\u0607\u0608\u0001\u0000\u0000\u0000\u0608\u060a"+ + "\u0001\u0000\u0000\u0000\u0609\u05ff\u0001\u0000\u0000\u0000\u0609\u060a"+ + "\u0001\u0000\u0000\u0000\u060aM\u0001\u0000\u0000\u0000\u060b\u060d\u0005"+ + "\u00a8\u0000\u0000\u060c\u060b\u0001\u0000\u0000\u0000\u060d\u0610\u0001"+ + "\u0000\u0000\u0000\u060e\u060c\u0001\u0000\u0000\u0000\u060e\u060f\u0001"+ + "\u0000\u0000\u0000\u060f\u0611\u0001\u0000\u0000\u0000\u0610\u060e\u0001"+ + "\u0000\u0000\u0000\u0611\u0615\u0005#\u0000\u0000\u0612\u0614\u0005\u00a7"+ + "\u0000\u0000\u0613\u0612\u0001\u0000\u0000\u0000\u0614\u0617\u0001\u0000"+ + "\u0000\u0000\u0615\u0613\u0001\u0000\u0000\u0000\u0615\u0616\u0001\u0000"+ + "\u0000\u0000\u0616\u0618\u0001\u0000\u0000\u0000\u0617\u0615\u0001\u0000"+ + "\u0000\u0000\u0618\u0622\u0003\u00aaU\u0000\u0619\u061b\u0005\u00a7\u0000"+ + "\u0000\u061a\u0619\u0001\u0000\u0000\u0000\u061b\u061e\u0001\u0000\u0000"+ + "\u0000\u061c\u061a\u0001\u0000\u0000\u0000\u061c\u061d\u0001\u0000\u0000"+ + "\u0000\u061d\u061f\u0001\u0000\u0000\u0000\u061e\u061c\u0001\u0000\u0000"+ + "\u0000\u061f\u0621\u0003\u009eO\u0000\u0620\u061c\u0001\u0000\u0000\u0000"+ + "\u0621\u0624\u0001\u0000\u0000\u0000\u0622\u0620\u0001\u0000\u0000\u0000"+ + "\u0622\u0623\u0001\u0000\u0000\u0000\u0623\u0628\u0001\u0000\u0000\u0000"+ + "\u0624\u0622\u0001\u0000\u0000\u0000\u0625\u0627\u0005\u00a7\u0000\u0000"+ + "\u0626\u0625\u0001\u0000\u0000\u0000\u0627\u062a\u0001\u0000\u0000\u0000"+ + "\u0628\u0626\u0001\u0000\u0000\u0000\u0628\u0629\u0001\u0000\u0000\u0000"+ + "\u0629\u062b\u0001\u0000\u0000\u0000\u062a\u0628\u0001\u0000\u0000\u0000"+ + "\u062b\u062f\u0005\u0016\u0000\u0000\u062c\u062e\u0005\u00a7\u0000\u0000"+ + "\u062d\u062c\u0001\u0000\u0000\u0000\u062e\u0631\u0001\u0000\u0000\u0000"+ + "\u062f\u062d\u0001\u0000\u0000\u0000\u062f\u0630\u0001\u0000\u0000\u0000"+ + "\u0630\u0632\u0001\u0000\u0000\u0000\u0631\u062f\u0001\u0000\u0000\u0000"+ + "\u0632\u0633\u0003\u0096K\u0000\u0633O\u0001\u0000\u0000\u0000\u0634\u0639"+ + "\u0003^/\u0000\u0635\u0639\u0003b1\u0000\u0636\u0639\u0003d2\u0000\u0637"+ + "\u0639\u0003h4\u0000\u0638\u0634\u0001\u0000\u0000\u0000\u0638\u0635\u0001"+ + "\u0000\u0000\u0000\u0638\u0636\u0001\u0000\u0000\u0000\u0638\u0637\u0001"+ + "\u0000\u0000\u0000\u0639Q\u0001\u0000\u0000\u0000\u063a\u063c\u0005$\u0000"+ + "\u0000\u063b\u063a\u0001\u0000\u0000\u0000\u063b\u063c\u0001\u0000\u0000"+ + "\u0000\u063c\u0644\u0001\u0000\u0000\u0000\u063d\u0641\u0005\u00a3\u0000"+ + "\u0000\u063e\u0640\u0005%\u0000\u0000\u063f\u063e\u0001\u0000\u0000\u0000"+ + "\u0640\u0643\u0001\u0000\u0000\u0000\u0641\u063f\u0001\u0000\u0000\u0000"+ + "\u0641\u0642\u0001\u0000\u0000\u0000\u0642\u0645\u0001\u0000\u0000\u0000"+ + "\u0643\u0641\u0001\u0000\u0000\u0000\u0644\u063d\u0001\u0000\u0000\u0000"+ + "\u0645\u0646\u0001\u0000\u0000\u0000\u0646\u0644\u0001\u0000\u0000\u0000"+ + "\u0646\u0647\u0001\u0000\u0000\u0000\u0647\u0648\u0001\u0000\u0000\u0000"+ + "\u0648\u0649\u0003l6\u0000\u0649S\u0001\u0000\u0000\u0000\u064a\u064c"+ + "\u0005$\u0000\u0000\u064b\u064a\u0001\u0000\u0000\u0000\u064b\u064c\u0001"+ + "\u0000\u0000\u0000\u064c\u0654\u0001\u0000\u0000\u0000\u064d\u0651\u0005"+ + "\u00a3\u0000\u0000\u064e\u0650\u0005%\u0000\u0000\u064f\u064e\u0001\u0000"+ + "\u0000\u0000\u0650\u0653\u0001\u0000\u0000\u0000\u0651\u064f\u0001\u0000"+ + "\u0000\u0000\u0651\u0652\u0001\u0000\u0000\u0000\u0652\u0655\u0001\u0000"+ + "\u0000\u0000\u0653\u0651\u0001\u0000\u0000\u0000\u0654\u064d\u0001\u0000"+ + "\u0000\u0000\u0655\u0656\u0001\u0000\u0000\u0000\u0656\u0654\u0001\u0000"+ + "\u0000\u0000\u0656\u0657\u0001\u0000\u0000\u0000\u0657\u0658\u0001\u0000"+ + "\u0000\u0000\u0658\u0659\u0003j5\u0000\u0659U\u0001\u0000\u0000\u0000"+ + "\u065a\u065d\u0003R)\u0000\u065b\u065d\u0003T*\u0000\u065c\u065a\u0001"+ + "\u0000\u0000\u0000\u065c\u065b\u0001\u0000\u0000\u0000\u065dW\u0001\u0000"+ + "\u0000\u0000\u065e\u0660\u0005$\u0000\u0000\u065f\u065e\u0001\u0000\u0000"+ + "\u0000\u065f\u0660\u0001\u0000\u0000\u0000\u0660\u0668\u0001\u0000\u0000"+ + "\u0000\u0661\u0665\u0005\u00a3\u0000\u0000\u0662\u0664\u0005%\u0000\u0000"+ + "\u0663\u0662\u0001\u0000\u0000\u0000\u0664\u0667\u0001\u0000\u0000\u0000"+ + "\u0665\u0663\u0001\u0000\u0000\u0000\u0665\u0666\u0001\u0000\u0000\u0000"+ + "\u0666\u0669\u0001\u0000\u0000\u0000\u0667\u0665\u0001\u0000\u0000\u0000"+ + "\u0668\u0661\u0001\u0000\u0000\u0000\u0669\u066a\u0001\u0000\u0000\u0000"+ + "\u066a\u0668\u0001\u0000\u0000\u0000\u066a\u066b\u0001\u0000\u0000\u0000"+ + "\u066b\u066c\u0001\u0000\u0000\u0000\u066c\u066d\u0003p8\u0000\u066dY"+ + "\u0001\u0000\u0000\u0000\u066e\u0670\u0005$\u0000\u0000\u066f\u066e\u0001"+ + "\u0000\u0000\u0000\u066f\u0670\u0001\u0000\u0000\u0000\u0670\u0678\u0001"+ + "\u0000\u0000\u0000\u0671\u0675\u0005\u00a3\u0000\u0000\u0672\u0674\u0005"+ + "%\u0000\u0000\u0673\u0672\u0001\u0000\u0000\u0000\u0674\u0677\u0001\u0000"+ + "\u0000\u0000\u0675\u0673\u0001\u0000\u0000\u0000\u0675\u0676\u0001\u0000"+ + "\u0000\u0000\u0676\u0679\u0001\u0000\u0000\u0000\u0677\u0675\u0001\u0000"+ + "\u0000\u0000\u0678\u0671\u0001\u0000\u0000\u0000\u0679\u067a\u0001\u0000"+ + "\u0000\u0000\u067a\u0678\u0001\u0000\u0000\u0000\u067a\u067b\u0001\u0000"+ + "\u0000\u0000\u067b\u067c\u0001\u0000\u0000\u0000\u067c\u067d\u0003r9\u0000"+ + "\u067d[\u0001\u0000\u0000\u0000\u067e\u0680\u0005$\u0000\u0000\u067f\u067e"+ + "\u0001\u0000\u0000\u0000\u067f\u0680\u0001\u0000\u0000\u0000\u0680\u0688"+ + "\u0001\u0000\u0000\u0000\u0681\u0685\u0005\u00a3\u0000\u0000\u0682\u0684"+ + "\u0005%\u0000\u0000\u0683\u0682\u0001\u0000\u0000\u0000\u0684\u0687\u0001"+ + "\u0000\u0000\u0000\u0685\u0683\u0001\u0000\u0000\u0000\u0685\u0686\u0001"+ + "\u0000\u0000\u0000\u0686\u0689\u0001\u0000\u0000\u0000\u0687\u0685\u0001"+ + "\u0000\u0000\u0000\u0688\u0681\u0001\u0000\u0000\u0000\u0689\u068a\u0001"+ + "\u0000\u0000\u0000\u068a\u0688\u0001\u0000\u0000\u0000\u068a\u068b\u0001"+ + "\u0000\u0000\u0000\u068b\u068c\u0001\u0000\u0000\u0000\u068c\u068d\u0003"+ + "t:\u0000\u068d]\u0001\u0000\u0000\u0000\u068e\u0693\u0003V+\u0000\u068f"+ + "\u0693\u0003X,\u0000\u0690\u0693\u0003Z-\u0000\u0691\u0693\u0003\\.\u0000"+ + "\u0692\u068e\u0001\u0000\u0000\u0000\u0692\u068f\u0001\u0000\u0000\u0000"+ + "\u0692\u0690\u0001\u0000\u0000\u0000\u0692\u0691\u0001\u0000\u0000\u0000"+ + "\u0693_\u0001\u0000\u0000\u0000\u0694\u0696\u0005$\u0000\u0000\u0695\u0694"+ + "\u0001\u0000\u0000\u0000\u0695\u0696\u0001\u0000\u0000\u0000\u0696\u069e"+ + "\u0001\u0000\u0000\u0000\u0697\u069b\u0005\u00a3\u0000\u0000\u0698\u069a"+ + "\u0005%\u0000\u0000\u0699\u0698\u0001\u0000\u0000\u0000\u069a\u069d\u0001"+ + "\u0000\u0000\u0000\u069b\u0699\u0001\u0000\u0000\u0000\u069b\u069c\u0001"+ + "\u0000\u0000\u0000\u069c\u069f\u0001\u0000\u0000\u0000\u069d\u069b\u0001"+ + "\u0000\u0000\u0000\u069e\u0697\u0001\u0000\u0000\u0000\u069f\u06a0\u0001"+ + "\u0000\u0000\u0000\u06a0\u069e\u0001\u0000\u0000\u0000\u06a0\u06a1\u0001"+ + "\u0000\u0000\u0000\u06a1\u06a2\u0001\u0000\u0000\u0000\u06a2\u06a3\u0005"+ + "&\u0000\u0000\u06a3a\u0001\u0000\u0000\u0000\u06a4\u06ac\u0005\'\u0000"+ + "\u0000\u06a5\u06a9\u0003f3\u0000\u06a6\u06a8\u0005%\u0000\u0000\u06a7"+ + "\u06a6\u0001\u0000\u0000\u0000\u06a8\u06ab\u0001\u0000\u0000\u0000\u06a9"+ + "\u06a7\u0001\u0000\u0000\u0000\u06a9\u06aa\u0001\u0000\u0000\u0000\u06aa"+ + "\u06ad\u0001\u0000\u0000\u0000\u06ab\u06a9\u0001\u0000\u0000\u0000\u06ac"+ + "\u06a5\u0001\u0000\u0000\u0000\u06ad\u06ae\u0001\u0000\u0000\u0000\u06ae"+ + "\u06ac\u0001\u0000\u0000\u0000\u06ae\u06af\u0001\u0000\u0000\u0000\u06af"+ + "c\u0001\u0000\u0000\u0000\u06b0\u06b8\u0005(\u0000\u0000\u06b1\u06b5\u0003"+ + "f3\u0000\u06b2\u06b4\u0005%\u0000\u0000\u06b3\u06b2\u0001\u0000\u0000"+ + "\u0000\u06b4\u06b7\u0001\u0000\u0000\u0000\u06b5\u06b3\u0001\u0000\u0000"+ + "\u0000\u06b5\u06b6\u0001\u0000\u0000\u0000\u06b6\u06b9\u0001\u0000\u0000"+ + "\u0000\u06b7\u06b5\u0001\u0000\u0000\u0000\u06b8\u06b1\u0001\u0000\u0000"+ + "\u0000\u06b9\u06ba\u0001\u0000\u0000\u0000\u06ba\u06b8\u0001\u0000\u0000"+ + "\u0000\u06ba\u06bb\u0001\u0000\u0000\u0000\u06bbe\u0001\u0000\u0000\u0000"+ + "\u06bc\u06bd\u0007\u0002\u0000\u0000\u06bdg\u0001\u0000\u0000\u0000\u06be"+ + "\u06bf\u0007\u0003\u0000\u0000\u06bfi\u0001\u0000\u0000\u0000\u06c0\u06c1"+ + "\u0007\u0004\u0000\u0000\u06c1k\u0001\u0000\u0000\u0000\u06c2\u06c3\u0007"+ + "\u0005\u0000\u0000\u06c3m\u0001\u0000\u0000\u0000\u06c4\u06c7\u0003j5"+ + "\u0000\u06c5\u06c7\u0003l6\u0000\u06c6\u06c4\u0001\u0000\u0000\u0000\u06c6"+ + "\u06c5\u0001\u0000\u0000\u0000\u06c7o\u0001\u0000\u0000\u0000\u06c8\u06c9"+ + "\u0005T\u0000\u0000\u06c9q\u0001\u0000\u0000\u0000\u06ca\u06cb\u0005U"+ + "\u0000\u0000\u06cbs\u0001\u0000\u0000\u0000\u06cc\u06cd\u0005V\u0000\u0000"+ + "\u06cdu\u0001\u0000\u0000\u0000\u06ce\u06d3\u0003n7\u0000\u06cf\u06d3"+ + "\u0003p8\u0000\u06d0\u06d3\u0003r9\u0000\u06d1\u06d3\u0003t:\u0000\u06d2"+ + "\u06ce\u0001\u0000\u0000\u0000\u06d2\u06cf\u0001\u0000\u0000\u0000\u06d2"+ + "\u06d0\u0001\u0000\u0000\u0000\u06d2\u06d1\u0001\u0000\u0000\u0000\u06d3"+ + "w\u0001\u0000\u0000\u0000\u06d4\u06d5\u0005W\u0000\u0000\u06d5y\u0001"+ + "\u0000\u0000\u0000\u06d6\u06d7\u0005X\u0000\u0000\u06d7{\u0001\u0000\u0000"+ + "\u0000\u06d8\u06d9\u0005Y\u0000\u0000\u06d9}\u0001\u0000\u0000\u0000\u06da"+ + "\u06df\u0003v;\u0000\u06db\u06df\u0003x<\u0000\u06dc\u06df\u0003|>\u0000"+ + "\u06dd\u06df\u0003z=\u0000\u06de\u06da\u0001\u0000\u0000\u0000\u06de\u06db"+ + "\u0001\u0000\u0000\u0000\u06de\u06dc\u0001\u0000\u0000\u0000\u06de\u06dd"+ + "\u0001\u0000\u0000\u0000\u06df\u007f\u0001\u0000\u0000\u0000\u06e0\u06e4"+ + "\u0005\u0014\u0000\u0000\u06e1\u06e3\u0005\u00a7\u0000\u0000\u06e2\u06e1"+ + "\u0001\u0000\u0000\u0000\u06e3\u06e6\u0001\u0000\u0000\u0000\u06e4\u06e2"+ + "\u0001\u0000\u0000\u0000\u06e4\u06e5\u0001\u0000\u0000\u0000\u06e5\u06e7"+ + "\u0001\u0000\u0000\u0000\u06e6\u06e4\u0001\u0000\u0000\u0000\u06e7\u06eb"+ + "\u0003\u0082A\u0000\u06e8\u06ea\u0005\u00a7\u0000\u0000\u06e9\u06e8\u0001"+ + "\u0000\u0000\u0000\u06ea\u06ed\u0001\u0000\u0000\u0000\u06eb\u06e9\u0001"+ + "\u0000\u0000\u0000\u06eb\u06ec\u0001\u0000\u0000\u0000\u06ec\u06ee\u0001"+ + "\u0000\u0000\u0000\u06ed\u06eb\u0001\u0000\u0000\u0000\u06ee\u06f2\u0005"+ + "\u0002\u0000\u0000\u06ef\u06f1\u0005\u00a7\u0000\u0000\u06f0\u06ef\u0001"+ + "\u0000\u0000\u0000\u06f1\u06f4\u0001\u0000\u0000\u0000\u06f2\u06f0\u0001"+ + "\u0000\u0000\u0000\u06f2\u06f3\u0001\u0000\u0000\u0000\u06f3\u06f5\u0001"+ + "\u0000\u0000\u0000\u06f4\u06f2\u0001\u0000\u0000\u0000\u06f5\u06f9\u0003"+ + "`0\u0000\u06f6\u06f8\u0005\u00a7\u0000\u0000\u06f7\u06f6\u0001\u0000\u0000"+ + "\u0000\u06f8\u06fb\u0001\u0000\u0000\u0000\u06f9\u06f7\u0001\u0000\u0000"+ + "\u0000\u06f9\u06fa\u0001\u0000\u0000\u0000\u06fa\u06fc\u0001\u0000\u0000"+ + "\u0000\u06fb\u06f9\u0001\u0000\u0000\u0000\u06fc\u06fd\u0005\u0015\u0000"+ + "\u0000\u06fd\u0081\u0001\u0000\u0000\u0000\u06fe\u0702\u0003~?\u0000\u06ff"+ + "\u0702\u0003\u0080@\u0000\u0700\u0702\u0003\u00aaU\u0000\u0701\u06fe\u0001"+ + "\u0000\u0000\u0000\u0701\u06ff\u0001\u0000\u0000\u0000\u0701\u0700\u0001"+ + "\u0000\u0000\u0000\u0702\u0083\u0001\u0000\u0000\u0000\u0703\u0704\u0003"+ + "\u0082A\u0000\u0704\u0705\u0005Z\u0000\u0000\u0705\u0716\u0001\u0000\u0000"+ + "\u0000\u0706\u0707\u0003\u0082A\u0000\u0707\u0708\u0005[\u0000\u0000\u0708"+ + "\u0716\u0001\u0000\u0000\u0000\u0709\u070a\u0003\u0082A\u0000\u070a\u070b"+ + "\u0005\\\u0000\u0000\u070b\u0716\u0001\u0000\u0000\u0000\u070c\u070d\u0003"+ + "\u00aaU\u0000\u070d\u070e\u0005]\u0000\u0000\u070e\u0716\u0001\u0000\u0000"+ + "\u0000\u070f\u0710\u0003\u00a4R\u0000\u0710\u0711\u0005]\u0000\u0000\u0711"+ + "\u0716\u0001\u0000\u0000\u0000\u0712\u0713\u0003\u00a4R\u0000\u0713\u0714"+ + "\u0005^\u0000\u0000\u0714\u0716\u0001\u0000\u0000\u0000\u0715\u0703\u0001"+ + "\u0000\u0000\u0000\u0715\u0706\u0001\u0000\u0000\u0000\u0715\u0709\u0001"+ + "\u0000\u0000\u0000\u0715\u070c\u0001\u0000\u0000\u0000\u0715\u070f\u0001"+ + "\u0000\u0000\u0000\u0715\u0712\u0001\u0000\u0000\u0000\u0716\u0085\u0001"+ + "\u0000\u0000\u0000\u0717\u0718\u0003\u0082A\u0000\u0718\u0719\u0005[\u0000"+ + "\u0000\u0719\u0087\u0001\u0000\u0000\u0000\u071a\u071b\u0003\u0082A\u0000"+ + "\u071b\u071c\u0005[\u0000\u0000\u071c\u0721\u0001\u0000\u0000\u0000\u071d"+ + "\u071e\u0003\u00a4R\u0000\u071e\u071f\u0005^\u0000\u0000\u071f\u0721\u0001"+ + "\u0000\u0000\u0000\u0720\u071a\u0001\u0000\u0000\u0000\u0720\u071d\u0001"+ + "\u0000\u0000\u0000\u0721\u0089\u0001\u0000\u0000\u0000\u0722\u0723\u0003"+ + "\u0082A\u0000\u0723\u0724\u0007\u0006\u0000\u0000\u0724\u008b\u0001\u0000"+ + "\u0000\u0000\u0725\u0726\u0003\u00a4R\u0000\u0726\u0727\u0005^\u0000\u0000"+ + "\u0727\u0730\u0001\u0000\u0000\u0000\u0728\u0729\u0003\u00a4R\u0000\u0729"+ + "\u072a\u0005]\u0000\u0000\u072a\u0730\u0001\u0000\u0000\u0000\u072b\u072c"+ + "\u0003\u00aaU\u0000\u072c\u072d\u0005]\u0000\u0000\u072d\u0730\u0001\u0000"+ + "\u0000\u0000\u072e\u0730\u0003\u0082A\u0000\u072f\u0725\u0001\u0000\u0000"+ + "\u0000\u072f\u0728\u0001\u0000\u0000\u0000\u072f\u072b\u0001\u0000\u0000"+ + "\u0000\u072f\u072e\u0001\u0000\u0000\u0000\u0730\u008d\u0001\u0000\u0000"+ + "\u0000\u0731\u0732\u0003\u0090H\u0000\u0732\u0733\u0005_\u0000\u0000\u0733"+ + "\u0734\u0003\u0092I\u0000\u0734\u008f\u0001\u0000\u0000\u0000\u0735\u0736"+ + "\u0003\u00acV\u0000\u0736\u0091\u0001\u0000\u0000\u0000\u0737\u0738\u0003"+ + "\u00acV\u0000\u0738\u0093\u0001\u0000\u0000\u0000\u0739\u073b\u0005@\u0000"+ + "\u0000\u073a\u073c\u0005\u00a3\u0000\u0000\u073b\u073a\u0001\u0000\u0000"+ + "\u0000\u073c\u073d\u0001\u0000\u0000\u0000\u073d\u073b\u0001\u0000\u0000"+ + "\u0000\u073d\u073e\u0001\u0000\u0000\u0000\u073e\u0095\u0001\u0000\u0000"+ + "\u0000\u073f\u0743\u0003\u0094J\u0000\u0740\u0742\u0003\u0098L\u0000\u0741"+ + "\u0740\u0001\u0000\u0000\u0000\u0742\u0745\u0001\u0000\u0000\u0000\u0743"+ + "\u0741\u0001\u0000\u0000\u0000\u0743\u0744\u0001\u0000\u0000\u0000\u0744"+ + "\u0097\u0001\u0000\u0000\u0000\u0745\u0743\u0001\u0000\u0000\u0000\u0746"+ + "\u0749\u0003\u009aM\u0000\u0747\u0749\u0003\u009cN\u0000\u0748\u0746\u0001"+ + "\u0000\u0000\u0000\u0748\u0747\u0001\u0000\u0000\u0000\u0749\u0099\u0001"+ + "\u0000\u0000\u0000\u074a\u074b\u0005_\u0000\u0000\u074b\u074c\u0003\u00aa"+ + "U\u0000\u074c\u009b\u0001\u0000\u0000\u0000\u074d\u074e\u0005\u0014\u0000"+ + "\u0000\u074e\u074f\u0003`0\u0000\u074f\u0750\u0005\u0015\u0000\u0000\u0750"+ + "\u0759\u0001\u0000\u0000\u0000\u0751\u0753\u0005\u0014\u0000\u0000\u0752"+ + "\u0754\u0005\u00a3\u0000\u0000\u0753\u0752\u0001\u0000\u0000\u0000\u0754"+ + "\u0755\u0001\u0000\u0000\u0000\u0755\u0753\u0001\u0000\u0000\u0000\u0755"+ + "\u0756\u0001\u0000\u0000\u0000\u0756\u0757\u0001\u0000\u0000\u0000\u0757"+ + "\u0759\u0005\u0015\u0000\u0000\u0758\u074d\u0001\u0000\u0000\u0000\u0758"+ + "\u0751\u0001\u0000\u0000\u0000\u0759\u009d\u0001\u0000\u0000\u0000\u075a"+ + "\u0762\u0003P(\u0000\u075b\u0762\u0005`\u0000\u0000\u075c\u0762\u0003"+ + "\u0096K\u0000\u075d\u0762\u0003\u008eG\u0000\u075e\u0762\u0005a\u0000"+ + "\u0000\u075f\u0762\u0005b\u0000\u0000\u0760\u0762\u0005c\u0000\u0000\u0761"+ + "\u075a\u0001\u0000\u0000\u0000\u0761\u075b\u0001\u0000\u0000\u0000\u0761"+ + "\u075c\u0001\u0000\u0000\u0000\u0761\u075d\u0001\u0000\u0000\u0000\u0761"+ + "\u075e\u0001\u0000\u0000\u0000\u0761\u075f\u0001\u0000\u0000\u0000\u0761"+ + "\u0760\u0001\u0000\u0000\u0000\u0762\u009f\u0001\u0000\u0000\u0000\u0763"+ + "\u0765\u0005\u00a8\u0000\u0000\u0764\u0763\u0001\u0000\u0000\u0000\u0765"+ + "\u0768\u0001\u0000\u0000\u0000\u0766\u0764\u0001\u0000\u0000\u0000\u0766"+ + "\u0767\u0001\u0000\u0000\u0000\u0767\u0769\u0001\u0000\u0000\u0000\u0768"+ + "\u0766\u0001\u0000\u0000\u0000\u0769\u076d\u0003\u00aaU\u0000\u076a\u076c"+ + "\u0005\u00a7\u0000\u0000\u076b\u076a\u0001\u0000\u0000\u0000\u076c\u076f"+ + "\u0001\u0000\u0000\u0000\u076d\u076b\u0001\u0000\u0000\u0000\u076d\u076e"+ + "\u0001\u0000\u0000\u0000\u076e\u0770\u0001\u0000\u0000\u0000\u076f\u076d"+ + "\u0001\u0000\u0000\u0000\u0770\u0774\u0005\u0007\u0000\u0000\u0771\u0773"+ + "\u0005\u00a7\u0000\u0000\u0772\u0771\u0001\u0000\u0000\u0000\u0773\u0776"+ + "\u0001\u0000\u0000\u0000\u0774\u0772\u0001\u0000\u0000\u0000\u0774\u0775"+ + "\u0001\u0000\u0000\u0000\u0775\u0777\u0001\u0000\u0000\u0000\u0776\u0774"+ + "\u0001\u0000\u0000\u0000\u0777\u077b\u0003\u0082A\u0000\u0778\u077a\u0005"+ + "\u00a7\u0000\u0000\u0779\u0778\u0001\u0000\u0000\u0000\u077a\u077d\u0001"+ + "\u0000\u0000\u0000\u077b\u0779\u0001\u0000\u0000\u0000\u077b\u077c\u0001"+ + "\u0000\u0000\u0000\u077c\u077e\u0001\u0000\u0000\u0000\u077d\u077b\u0001"+ + "\u0000\u0000\u0000\u077e\u077f\u0005\u0002\u0000\u0000\u077f\u00a1\u0001"+ + "\u0000\u0000\u0000\u0780\u0782\u0005\u00a8\u0000\u0000\u0781\u0780\u0001"+ + "\u0000\u0000\u0000\u0782\u0785\u0001\u0000\u0000\u0000\u0783\u0781\u0001"+ + "\u0000\u0000\u0000\u0783\u0784\u0001\u0000\u0000\u0000\u0784\u0786\u0001"+ + "\u0000\u0000\u0000\u0785\u0783\u0001\u0000\u0000\u0000\u0786\u078a\u0003"+ + "\u00aaU\u0000\u0787\u0789\u0005\u00a7\u0000\u0000\u0788\u0787\u0001\u0000"+ + "\u0000\u0000\u0789\u078c\u0001\u0000\u0000\u0000\u078a\u0788\u0001\u0000"+ + "\u0000\u0000\u078a\u078b\u0001\u0000\u0000\u0000\u078b\u078d\u0001\u0000"+ + "\u0000\u0000\u078c\u078a\u0001\u0000\u0000\u0000\u078d\u0791\u0005\u0007"+ + "\u0000\u0000\u078e\u0790\u0005\u00a7\u0000\u0000\u078f\u078e\u0001\u0000"+ + "\u0000\u0000\u0790\u0793\u0001\u0000\u0000\u0000\u0791\u078f\u0001\u0000"+ + "\u0000\u0000\u0791\u0792\u0001\u0000\u0000\u0000\u0792\u0794\u0001\u0000"+ + "\u0000\u0000\u0793\u0791\u0001\u0000\u0000\u0000\u0794\u0798\u0003\u008a"+ + "E\u0000\u0795\u0797\u0005\u00a7\u0000\u0000\u0796\u0795\u0001\u0000\u0000"+ + "\u0000\u0797\u079a\u0001\u0000\u0000\u0000\u0798\u0796\u0001\u0000\u0000"+ + "\u0000\u0798\u0799\u0001\u0000\u0000\u0000\u0799\u079b\u0001\u0000\u0000"+ + "\u0000\u079a\u0798\u0001\u0000\u0000\u0000\u079b\u079c\u0005\u0002\u0000"+ + "\u0000\u079c\u00a3\u0001\u0000\u0000\u0000\u079d\u079e\u0003\u008eG\u0000"+ + "\u079e\u079f\u0005d\u0000\u0000\u079f\u07a0\u0003\u00aaU\u0000\u07a0\u00a5"+ + "\u0001\u0000\u0000\u0000\u07a1\u07a6\u0003\u008cF\u0000\u07a2\u07a6\u0003"+ + "\u00a4R\u0000\u07a3\u07a6\u0005e\u0000\u0000\u07a4\u07a6\u0005f\u0000"+ + "\u0000\u07a5\u07a1\u0001\u0000\u0000\u0000\u07a5\u07a2\u0001\u0000\u0000"+ + "\u0000\u07a5\u07a3\u0001\u0000\u0000\u0000\u07a5\u07a4\u0001\u0000\u0000"+ + "\u0000\u07a6\u00a7\u0001\u0000\u0000\u0000\u07a7\u07a8\u0003\u00aaU\u0000"+ + "\u07a8\u00a9\u0001\u0000\u0000\u0000\u07a9\u07ad\u0005\u00a0\u0000\u0000"+ + "\u07aa\u07ac\u0007\u0007\u0000\u0000\u07ab\u07aa\u0001\u0000\u0000\u0000"+ + "\u07ac\u07af\u0001\u0000\u0000\u0000\u07ad\u07ab\u0001\u0000\u0000\u0000"+ + "\u07ad\u07ae\u0001\u0000\u0000\u0000\u07ae\u00ab\u0001\u0000\u0000\u0000"+ + "\u07af\u07ad\u0001\u0000\u0000\u0000\u07b0\u07b4\u0005\u00a2\u0000\u0000"+ + "\u07b1\u07b3\u0007\b\u0000\u0000\u07b2\u07b1\u0001\u0000\u0000\u0000\u07b3"+ + "\u07b6\u0001\u0000\u0000\u0000\u07b4\u07b2\u0001\u0000\u0000\u0000\u07b4"+ + "\u07b5\u0001\u0000\u0000\u0000\u07b5\u00ad\u0001\u0000\u0000\u0000\u07b6"+ + "\u07b4\u0001\u0000\u0000\u0000\u07b7\u07b8\u0007\t\u0000\u0000\u07b8\u00af"+ + "\u0001\u0000\u0000\u0000\u07b9\u07ba\u0007\n\u0000\u0000\u07ba\u00b1\u0001"+ + "\u0000\u0000\u0000\u07bb\u07bc\u0007\u000b\u0000\u0000\u07bc\u00b3\u0001"+ + "\u0000\u0000\u0000\u07bd\u07be\u0007\f\u0000\u0000\u07be\u00b5\u0001\u0000"+ + "\u0000\u0000\u07bf\u07c0\u0005\u008d\u0000\u0000\u07c0\u07c4\u0007\r\u0000"+ + "\u0000\u07c1\u07c2\u0005\u0092\u0000\u0000\u07c2\u07c4\u0007\u000e\u0000"+ + "\u0000\u07c3\u07bf\u0001\u0000\u0000\u0000\u07c3\u07c1\u0001\u0000\u0000"+ + "\u0000\u07c4\u00b7\u0001\u0000\u0000\u0000\u07c5\u07c6\u0005\u0095\u0000"+ + "\u0000\u07c6\u07d0\u0007\r\u0000\u0000\u07c7\u07c8\u0005\u0096\u0000\u0000"+ + "\u07c8\u07d0\u0007\u000e\u0000\u0000\u07c9\u07ca\u0005\u0097\u0000\u0000"+ + "\u07ca\u07d0\u0007\u000f\u0000\u0000\u07cb\u07cc\u0005\u0098\u0000\u0000"+ + "\u07cc\u07d0\u0007\u0010\u0000\u0000\u07cd\u07ce\u0005\u009a\u0000\u0000"+ + "\u07ce\u07d0\u0007\u0010\u0000\u0000\u07cf\u07c5\u0001\u0000\u0000\u0000"+ + "\u07cf\u07c7\u0001\u0000\u0000\u0000\u07cf\u07c9\u0001\u0000\u0000\u0000"+ + "\u07cf\u07cb\u0001\u0000\u0000\u0000\u07cf\u07cd\u0001\u0000\u0000\u0000"+ + "\u07d0\u00b9\u0001\u0000\u0000\u0000\u07d1\u07d2\u0005\u009b\u0000\u0000"+ + "\u07d2\u07d3\u0007\u000f\u0000\u0000\u07d3\u00bb\u0001\u0000\u0000\u0000"+ + "\u07d4\u07d5\u0007\u0011\u0000\u0000\u07d5\u00bd\u0001\u0000\u0000\u0000"+ + "\u07d6\u07d7\u0007\u0012\u0000\u0000\u07d7\u00bf\u0001\u0000\u0000\u0000"+ + "\u00fe\u00c5\u00cb\u00d2\u00d9\u00e2\u00e4\u00e9\u00ef\u00f6\u00fd\u0105"+ + "\u010c\u0113\u011d\u0124\u012b\u0132\u013a\u0141\u0148\u014f\u0157\u015e"+ + "\u0165\u016c\u0171\u0178\u017f\u0186\u018d\u0194\u019b\u01a2\u01a8\u01af"+ + "\u01b6\u01bd\u01c3\u01c8\u01ce\u01d5\u01dc\u01e3\u01ea\u01f2\u01f9\u0200"+ + "\u0207\u020e\u0216\u021d\u0224\u022b\u0231\u0237\u023b\u0240\u0247\u024e"+ + "\u0255\u025c\u0264\u026b\u0272\u0279\u0280\u0288\u028f\u0296\u029d\u02a3"+ + "\u02a8\u02af\u02b6\u02bd\u02c4\u02d3\u02d8\u02df\u02e7\u02ee\u02f5\u02fc"+ + "\u0303\u030b\u0312\u031a\u0321\u0328\u032f\u0336\u033e\u0345\u034d\u0354"+ + "\u035b\u0362\u0369\u0370\u0378\u037f\u0386\u038d\u0395\u039c\u03a3\u03ab"+ + "\u03b2\u03ba\u03c1\u03c8\u03d0\u03d7\u03dd\u03e3\u03ea\u03f1\u03f8\u03ff"+ + "\u0404\u040c\u0413\u041a\u0422\u0429\u042f\u0436\u043d\u0444\u044b\u0453"+ + "\u045a\u0461\u0469\u0477\u047c\u0485\u048c\u0493\u049c\u04a3\u04aa\u04b1"+ + "\u04ba\u04c1\u04c8\u04cf\u04d6\u04df\u04e6\u04ed\u04f4\u04fd\u0504\u050d"+ + "\u0514\u051b\u0522\u0529\u0530\u0536\u053c\u0543\u054a\u0551\u0558\u0560"+ + "\u0566\u056d\u0574\u057b\u0582\u0589\u0591\u0595\u059b\u05a2\u05a9\u05b0"+ + "\u05b7\u05c0\u05c6\u05cb\u05d2\u05d9\u05e0\u05e9\u05ee\u05f3\u05f9\u05ff"+ + "\u0607\u0609\u060e\u0615\u061c\u0622\u0628\u062f\u0638\u063b\u0641\u0646"+ + "\u064b\u0651\u0656\u065c\u065f\u0665\u066a\u066f\u0675\u067a\u067f\u0685"+ + "\u068a\u0692\u0695\u069b\u06a0\u06a9\u06ae\u06b5\u06ba\u06c6\u06d2\u06de"+ + "\u06e4\u06eb\u06f2\u06f9\u0701\u0715\u0720\u072f\u073d\u0743\u0748\u0755"+ + "\u0758\u0761\u0766\u076d\u0774\u077b\u0783\u078a\u0791\u0798\u07a5\u07ad"+ + "\u07b4\u07c3\u07cf"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/vanguard/aleo/parser/Aleo.g4 b/vanguard/aleo/parser/Aleo.g4 new file mode 100644 index 0000000..228c91a --- /dev/null +++ b/vanguard/aleo/parser/Aleo.g4 @@ -0,0 +1,150 @@ +// adapted from: https://github.com/AleoHQ/grammars/blob/master/aleo.abnf +// this is a compatible grammar that adapts to older versions of Aleo grammar + +// =============================================== // +// ==== parser rules and implicit lexer rules ==== // +// =============================================== // +grammar Aleo ; +start: program ; +program : ximport* 'program' program_id ';' ( mapping | struct | record | closure | function )+ ; + +// blocks +ximport : 'import' program_id ';' ; +mapping : 'mapping' identifier ':' mapping_key mapping_value ; +mapping_key : 'key' 'as' mapping_type ';' ; +mapping_value : 'value' 'as' mapping_type ';' ; +struct : 'struct' identifier ':' tuple+ ; +record : 'record' identifier ':' entry* ; +closure : 'closure' identifier ':' closure_input* instruction+ closure_output* ; +closure_input : 'input' register 'as' register_type ';' ; +closure_output : 'output' operand 'as' register_type ';' ; +function : 'function' identifier ':' function_input* instruction* function_output* finalize? ; +function_input : 'input' register 'as' value_type ';' ; +function_output : 'output' operand 'as' value_type ';' ; +finalize : 'finalize' identifier ':' finalize_input* command+ ; +finalize_input : 'input' register 'as' finalize_type ';' ; + +// instructions +command : contains | get | get_or_use | set | remove | random | position | branch | xawait | instruction ; +contains : 'contains' identifier '[' operand ']' 'into' register_access ';' ; +get : 'get' identifier '[' operand ']' 'into' register_access ';' ; +get_or_use : 'get.or_use' identifier '[' operand ']' operand 'into' register_access ';' ; +set : 'set' operand 'into' identifier '[' operand ']' ';' ; +remove : 'remove' identifier '[' operand ']' ';' ; +random : 'rand.chacha' operand* 'into' register_access 'as' ( arithmetic_type | address_type | signature_type | boolean_type ) ';' ; +position : 'position' label ';' ; +branch : branch_op operand operand 'to' label ';' ; +xawait : 'await' register_access ';' ; +instruction : unary | binary | ternary | is | assert | commit | hash | signverify | cast | call | xasync ; +unary : unary_op operand 'into' register_access ';' ; +binary : binary_op operand operand 'into' register_access ';' ; +ternary : 'ternary' operand operand operand 'into' register_access ';' ; +is : is_op operand operand 'into' register_access ';' ; +assert : assert_op operand operand ';' ; +commit : commit_op operand operand 'into' register_access 'as' ( address_type | field_type | group_type ) ';' ; +hash1 : hash1_op operand 'into' register_access 'as' ( arithmetic_type | address_type | signature_type | array_type | identifier ) ';' ; +hash2 : hash2_op operand operand 'into' register_access 'as' ( arithmetic_type | address_type | signature_type | array_type | identifier ) ';' ; +hash : hash1 | hash2 ; +signverify : ( 'sign.verify' | 'sign_verify' ) operand operand operand 'into' register_access ';' ; +cast : cast_op operand+ 'into' register_access 'as' cast_destination ';' ; +call : 'call' ( locator | identifier ) operand* ('into' register_access+)? ';' ; +xasync : 'async' identifier operand* 'into' register_access ';' ; + +// literals +literal : arithmetic_literal | address_literal | signature_literal | boolean_literal ; +signed_literal : '-'? ( DIGIT '_'* )+ signed_type ; +unsigned_literal : '-'? ( DIGIT '_'* )+ unsigned_type ; +integer_literal : signed_literal | unsigned_literal ; +field_literal : '-'? ( DIGIT '_'* )+ field_type ; +group_literal : '-'? ( DIGIT '_'* )+ group_type ; +scalar_literal : '-'? ( DIGIT '_'* )+ scalar_type ; +arithmetic_literal : integer_literal | field_literal | group_literal | scalar_literal ; +u32_literal : '-'? ( DIGIT '_'* )+ 'u32' ; +address_literal : ADDRESS_LITERAL ; +signature_literal : SIGNATURE_LITERAL ; +boolean_literal : 'true' | 'false' ; + +// types +unsigned_type : 'u8' | 'u16' | 'u32' | 'u64' | 'u128' ; +signed_type : 'i8' | 'i16' | 'i32' | 'i64' | 'i128' ; +integer_type : unsigned_type | signed_type ; +field_type : 'field' ; +group_type : 'group' ; +scalar_type : 'scalar' ; +arithmetic_type : integer_type | field_type | group_type | scalar_type ; +address_type : 'address' ; +boolean_type : 'boolean' ; +signature_type : 'signature' ; +literal_type : arithmetic_type | address_type | signature_type | boolean_type ; +array_type : '[' plaintext_type ';' u32_literal ']' ; +plaintext_type : literal_type | array_type | identifier ; +value_type : plaintext_type '.constant' | plaintext_type '.public' | plaintext_type '.private' + | identifier '.record' | locator '.record' | locator '.future' ; +mapping_type : plaintext_type '.public' ; +finalize_type : plaintext_type '.public' | locator '.future' ; +entry_type : plaintext_type ( '.constant' | '.public' | '.private' ) ; +register_type : locator '.future' | locator '.record' | identifier '.record' | plaintext_type ; + +// misc +program_id : program_name '.' program_domain ; +program_name : identifier ; +program_domain : identifier ; +register : REGISTER ; +register_access : register register_accessor* ; +register_accessor : access_by_field | access_by_index ; +access_by_field : '.' identifier ; +access_by_index : '[' u32_literal ']' | '[' DIGIT+ ']' ; + +operand : literal | 'group::GEN' | register_access | program_id | 'self.signer' | 'self.caller' | 'block.height' ; +tuple : identifier 'as' plaintext_type ';' ; +entry : identifier 'as' entry_type ';' ; +locator : program_id '/' identifier ; +cast_destination : register_type | locator | 'group.x' | 'group.y' ; + +unary_op : 'abs' | 'abs.w' | 'double' | 'inv' | 'neg' | 'not' | 'square' | 'sqrt' ; +binary_op : 'add' | 'add.w' | 'sub' | 'sub.w' | 'mul' | 'mul.w' | 'div' | 'div.w' | 'rem' | 'rem.w' + | 'pow' | 'pow.w' | 'shl' | 'shl.w' | 'shr' | 'shr.w' | 'mod' | 'and' | 'or' | 'xor' + | 'nand' | 'nor' | 'gt' | 'gte' | 'lt' | 'lte' ; +is_op : 'is.eq' | 'is.neq' ; +assert_op : 'assert.eq' | 'assert.neq' ; +commit_op : 'commit.bhp256' | 'commit.bhp512' | 'commit.bhp768' | 'commit.bhp1024' + | 'commit.ped64' | 'commit.ped128' ; +hash1_op : 'hash.bhp256' | 'hash.bhp512' | 'hash.bhp768' | 'hash.bhp1024' + | 'hash.ped64' | 'hash.ped128' + | 'hash.psd2' | 'hash.psd4' | 'hash.psd8' + | 'hash.keccak256' | 'hash.keccak384' | 'hash.keccak512' + | 'hash.sha3_256' | 'hash.sha3_384' | 'hash.sha3_512' ; +hash2_op : 'hash_many.psd2' | 'hash_many.psd4' | 'hash_many.psd8' ; +cast_op : 'cast.lossy' | 'cast' ; +branch_op : 'branch.eq' | 'branch.neq' ; + +label : identifier ; +identifier : IDENTIFIER ; // lexer rule to parser rule + +// ============================== // +// ==== explicit lexer rules ==== // +// ============================== // + +// literals +ADDRESS_LITERAL : 'aleo1' ( ADDRESS_OR_SIGNATURE_CHAR '_'* )+ ; +SIGNATURE_LITERAL : 'sign1' ( ADDRESS_OR_SIGNATURE_CHAR '_'* )+ ; +fragment ADDRESS_OR_SIGNATURE_CHAR : ADDRESS_OR_SIGNATURE_LOWERCASE_LETTER | ADDRESS_OR_SIGNATURE_DIGIT ; + +// identifiers +REGISTER : 'r' DIGIT+ ; +IDENTIFIER : LETTER ( LETTER | DIGIT | '_' )* ; +fragment LETTER : LOWERCASE_LETTER | UPPERCASE_LETTER ; +fragment LOWERCASE_LETTER : ADDRESS_OR_SIGNATURE_LOWERCASE_LETTER | OTHER_LOWERCASE_LETTER ; +fragment ADDRESS_OR_SIGNATURE_LOWERCASE_LETTER : 'a' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'j' | 'k' + | 'l' | 'm' | 'n' | 'p' | 'q' | 'r' | 's' | 't' | 'u' + | 'v' | 'w' | 'x' | 'y' | 'z' ; +fragment OTHER_LOWERCASE_LETTER : 'b' | 'i' | 'o' ; +fragment UPPERCASE_LETTER : [A-Z] ; +DIGIT : ADDRESS_OR_SIGNATURE_DIGIT | OTHER_DIGIT ; +fragment ADDRESS_OR_SIGNATURE_DIGIT : '0' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' ; +fragment OTHER_DIGIT : '1' ; + +// misc +WS : [ \t\r\n\u000C]+ -> skip ; +COMMENT : '/*' .*? '*/' -> channel(HIDDEN) ; +LINE_COMMENT : '//' ~[\r\n]* -> channel(HIDDEN) ; \ No newline at end of file diff --git a/vanguard/aleo/parser/Aleo.interp b/vanguard/aleo/parser/Aleo.interp new file mode 100644 index 0000000..5051e8f --- /dev/null +++ b/vanguard/aleo/parser/Aleo.interp @@ -0,0 +1,383 @@ +token literal names: +null +'program' +';' +'import' +'mapping' +':' +'key' +'as' +'value' +'struct' +'record' +'closure' +'input' +'output' +'function' +'finalize' +'contains' +'[' +']' +'into' +'get' +'get.or_use' +'set' +'remove' +'rand.chacha' +'position' +'to' +'await' +'ternary' +'sign.verify' +'sign_verify' +'call' +'async' +'-' +'_' +'u32' +'true' +'false' +'u8' +'u16' +'u64' +'u128' +'i8' +'i16' +'i32' +'i64' +'i128' +'field' +'group' +'scalar' +'address' +'boolean' +'signature' +'.constant' +'.public' +'.private' +'.record' +'.future' +'.' +'group::GEN' +'self.signer' +'self.caller' +'block.height' +'/' +'group.x' +'group.y' +'abs' +'abs.w' +'double' +'inv' +'neg' +'not' +'square' +'sqrt' +'add' +'add.w' +'sub' +'sub.w' +'mul' +'mul.w' +'div' +'div.w' +'rem' +'rem.w' +'pow' +'pow.w' +'shl' +'shl.w' +'shr' +'shr.w' +'mod' +'and' +'or' +'xor' +'nand' +'nor' +'gt' +'gte' +'lt' +'lte' +'is.eq' +'is.neq' +'assert.eq' +'assert.neq' +'commit.bhp256' +'commit.bhp512' +'commit.bhp768' +'commit.bhp1024' +'commit.ped64' +'commit.ped128' +'hash.bhp256' +'hash.bhp512' +'hash.bhp768' +'hash.bhp1024' +'hash.ped64' +'hash.ped128' +'hash.psd2' +'hash.psd4' +'hash.psd8' +'hash.keccak256' +'hash.keccak384' +'hash.keccak512' +'hash.sha3_256' +'hash.sha3_384' +'hash.sha3_512' +'hash_many.psd2' +'hash_many.psd4' +'hash_many.psd8' +'cast.lossy' +'cast' +'branch.eq' +'branch.neq' +null +null +null +null +null +null +null +null + +token symbolic names: +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +ADDRESS_LITERAL +SIGNATURE_LITERAL +REGISTER +IDENTIFIER +DIGIT +WS +COMMENT +LINE_COMMENT + +rule names: +start +program +ximport +mapping +mapping_key +mapping_value +struct +record +closure +closure_input +closure_output +function +function_input +function_output +finalize +finalize_input +command +contains +get +get_or_use +set +remove +random +position +branch +xawait +instruction +unary +binary +ternary +is +assert +commit +hash1 +hash2 +hash +signverify +cast +call +xasync +literal +signed_literal +unsigned_literal +integer_literal +field_literal +group_literal +scalar_literal +arithmetic_literal +u32_literal +address_literal +signature_literal +boolean_literal +unsigned_type +signed_type +integer_type +field_type +group_type +scalar_type +arithmetic_type +address_type +boolean_type +signature_type +literal_type +array_type +plaintext_type +value_type +mapping_type +finalize_type +entry_type +register_type +program_id +program_name +program_domain +register +register_access +register_accessor +access_by_field +access_by_index +operand +tuple +entry +locator +cast_destination +unary_op +binary_op +is_op +assert_op +commit_op +hash1_op +hash2_op +cast_op +branch_op +label +identifier + + +atn: +[4, 1, 139, 863, 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, 1, 0, 1, 0, 1, 1, 5, 1, 192, 8, 1, 10, 1, 12, 1, 195, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 205, 8, 1, 11, 1, 12, 1, 206, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 4, 6, 233, 8, 6, 11, 6, 12, 6, 234, 1, 7, 1, 7, 1, 7, 1, 7, 5, 7, 241, 8, 7, 10, 7, 12, 7, 244, 9, 7, 1, 8, 1, 8, 1, 8, 1, 8, 5, 8, 250, 8, 8, 10, 8, 12, 8, 253, 9, 8, 1, 8, 4, 8, 256, 8, 8, 11, 8, 12, 8, 257, 1, 8, 5, 8, 261, 8, 8, 10, 8, 12, 8, 264, 9, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 5, 11, 282, 8, 11, 10, 11, 12, 11, 285, 9, 11, 1, 11, 5, 11, 288, 8, 11, 10, 11, 12, 11, 291, 9, 11, 1, 11, 5, 11, 294, 8, 11, 10, 11, 12, 11, 297, 9, 11, 1, 11, 3, 11, 300, 8, 11, 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, 14, 1, 14, 1, 14, 1, 14, 5, 14, 318, 8, 14, 10, 14, 12, 14, 321, 9, 14, 1, 14, 4, 14, 324, 8, 14, 11, 14, 12, 14, 325, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 344, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 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, 5, 22, 392, 8, 22, 10, 22, 12, 22, 395, 9, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 404, 8, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 434, 8, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 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, 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, 3, 32, 478, 8, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 492, 8, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 507, 8, 34, 1, 34, 1, 34, 1, 35, 1, 35, 3, 35, 513, 8, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 4, 37, 525, 8, 37, 11, 37, 12, 37, 526, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 3, 38, 538, 8, 38, 1, 38, 5, 38, 541, 8, 38, 10, 38, 12, 38, 544, 9, 38, 1, 38, 1, 38, 4, 38, 548, 8, 38, 11, 38, 12, 38, 549, 3, 38, 552, 8, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 5, 39, 559, 8, 39, 10, 39, 12, 39, 562, 9, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 572, 8, 40, 1, 41, 3, 41, 575, 8, 41, 1, 41, 1, 41, 5, 41, 579, 8, 41, 10, 41, 12, 41, 582, 9, 41, 4, 41, 584, 8, 41, 11, 41, 12, 41, 585, 1, 41, 1, 41, 1, 42, 3, 42, 591, 8, 42, 1, 42, 1, 42, 5, 42, 595, 8, 42, 10, 42, 12, 42, 598, 9, 42, 4, 42, 600, 8, 42, 11, 42, 12, 42, 601, 1, 42, 1, 42, 1, 43, 1, 43, 3, 43, 608, 8, 43, 1, 44, 3, 44, 611, 8, 44, 1, 44, 1, 44, 5, 44, 615, 8, 44, 10, 44, 12, 44, 618, 9, 44, 4, 44, 620, 8, 44, 11, 44, 12, 44, 621, 1, 44, 1, 44, 1, 45, 3, 45, 627, 8, 45, 1, 45, 1, 45, 5, 45, 631, 8, 45, 10, 45, 12, 45, 634, 9, 45, 4, 45, 636, 8, 45, 11, 45, 12, 45, 637, 1, 45, 1, 45, 1, 46, 3, 46, 643, 8, 46, 1, 46, 1, 46, 5, 46, 647, 8, 46, 10, 46, 12, 46, 650, 9, 46, 4, 46, 652, 8, 46, 11, 46, 12, 46, 653, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 662, 8, 47, 1, 48, 3, 48, 665, 8, 48, 1, 48, 1, 48, 5, 48, 669, 8, 48, 10, 48, 12, 48, 672, 9, 48, 4, 48, 674, 8, 48, 11, 48, 12, 48, 675, 1, 48, 1, 48, 1, 49, 1, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, 52, 1, 52, 1, 53, 1, 53, 1, 54, 1, 54, 3, 54, 692, 8, 54, 1, 55, 1, 55, 1, 56, 1, 56, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 704, 8, 58, 1, 59, 1, 59, 1, 60, 1, 60, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 716, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 3, 64, 727, 8, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 747, 8, 65, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 3, 67, 758, 8, 67, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 773, 8, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 72, 1, 72, 1, 73, 1, 73, 1, 74, 1, 74, 5, 74, 787, 8, 74, 10, 74, 12, 74, 790, 9, 74, 1, 75, 1, 75, 3, 75, 794, 8, 75, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 4, 77, 805, 8, 77, 11, 77, 12, 77, 806, 1, 77, 3, 77, 810, 8, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 819, 8, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 839, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 85, 1, 85, 1, 86, 1, 86, 1, 87, 1, 87, 1, 88, 1, 88, 1, 89, 1, 89, 1, 90, 1, 90, 1, 91, 1, 91, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 0, 0, 94, 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, 0, 14, 1, 0, 29, 30, 1, 0, 36, 37, 2, 0, 35, 35, 38, 41, 1, 0, 42, 46, 1, 0, 53, 55, 1, 0, 66, 73, 1, 0, 74, 99, 1, 0, 100, 101, 1, 0, 102, 103, 1, 0, 104, 109, 1, 0, 110, 124, 1, 0, 125, 127, 1, 0, 128, 129, 1, 0, 130, 131, 881, 0, 188, 1, 0, 0, 0, 2, 193, 1, 0, 0, 0, 4, 208, 1, 0, 0, 0, 6, 212, 1, 0, 0, 0, 8, 218, 1, 0, 0, 0, 10, 223, 1, 0, 0, 0, 12, 228, 1, 0, 0, 0, 14, 236, 1, 0, 0, 0, 16, 245, 1, 0, 0, 0, 18, 265, 1, 0, 0, 0, 20, 271, 1, 0, 0, 0, 22, 277, 1, 0, 0, 0, 24, 301, 1, 0, 0, 0, 26, 307, 1, 0, 0, 0, 28, 313, 1, 0, 0, 0, 30, 327, 1, 0, 0, 0, 32, 343, 1, 0, 0, 0, 34, 345, 1, 0, 0, 0, 36, 354, 1, 0, 0, 0, 38, 363, 1, 0, 0, 0, 40, 373, 1, 0, 0, 0, 42, 382, 1, 0, 0, 0, 44, 389, 1, 0, 0, 0, 46, 407, 1, 0, 0, 0, 48, 411, 1, 0, 0, 0, 50, 418, 1, 0, 0, 0, 52, 433, 1, 0, 0, 0, 54, 435, 1, 0, 0, 0, 56, 441, 1, 0, 0, 0, 58, 448, 1, 0, 0, 0, 60, 456, 1, 0, 0, 0, 62, 463, 1, 0, 0, 0, 64, 468, 1, 0, 0, 0, 66, 481, 1, 0, 0, 0, 68, 495, 1, 0, 0, 0, 70, 512, 1, 0, 0, 0, 72, 514, 1, 0, 0, 0, 74, 522, 1, 0, 0, 0, 76, 534, 1, 0, 0, 0, 78, 555, 1, 0, 0, 0, 80, 571, 1, 0, 0, 0, 82, 574, 1, 0, 0, 0, 84, 590, 1, 0, 0, 0, 86, 607, 1, 0, 0, 0, 88, 610, 1, 0, 0, 0, 90, 626, 1, 0, 0, 0, 92, 642, 1, 0, 0, 0, 94, 661, 1, 0, 0, 0, 96, 664, 1, 0, 0, 0, 98, 679, 1, 0, 0, 0, 100, 681, 1, 0, 0, 0, 102, 683, 1, 0, 0, 0, 104, 685, 1, 0, 0, 0, 106, 687, 1, 0, 0, 0, 108, 691, 1, 0, 0, 0, 110, 693, 1, 0, 0, 0, 112, 695, 1, 0, 0, 0, 114, 697, 1, 0, 0, 0, 116, 703, 1, 0, 0, 0, 118, 705, 1, 0, 0, 0, 120, 707, 1, 0, 0, 0, 122, 709, 1, 0, 0, 0, 124, 715, 1, 0, 0, 0, 126, 717, 1, 0, 0, 0, 128, 726, 1, 0, 0, 0, 130, 746, 1, 0, 0, 0, 132, 748, 1, 0, 0, 0, 134, 757, 1, 0, 0, 0, 136, 759, 1, 0, 0, 0, 138, 772, 1, 0, 0, 0, 140, 774, 1, 0, 0, 0, 142, 778, 1, 0, 0, 0, 144, 780, 1, 0, 0, 0, 146, 782, 1, 0, 0, 0, 148, 784, 1, 0, 0, 0, 150, 793, 1, 0, 0, 0, 152, 795, 1, 0, 0, 0, 154, 809, 1, 0, 0, 0, 156, 818, 1, 0, 0, 0, 158, 820, 1, 0, 0, 0, 160, 825, 1, 0, 0, 0, 162, 830, 1, 0, 0, 0, 164, 838, 1, 0, 0, 0, 166, 840, 1, 0, 0, 0, 168, 842, 1, 0, 0, 0, 170, 844, 1, 0, 0, 0, 172, 846, 1, 0, 0, 0, 174, 848, 1, 0, 0, 0, 176, 850, 1, 0, 0, 0, 178, 852, 1, 0, 0, 0, 180, 854, 1, 0, 0, 0, 182, 856, 1, 0, 0, 0, 184, 858, 1, 0, 0, 0, 186, 860, 1, 0, 0, 0, 188, 189, 3, 2, 1, 0, 189, 1, 1, 0, 0, 0, 190, 192, 3, 4, 2, 0, 191, 190, 1, 0, 0, 0, 192, 195, 1, 0, 0, 0, 193, 191, 1, 0, 0, 0, 193, 194, 1, 0, 0, 0, 194, 196, 1, 0, 0, 0, 195, 193, 1, 0, 0, 0, 196, 197, 5, 1, 0, 0, 197, 198, 3, 140, 70, 0, 198, 204, 5, 2, 0, 0, 199, 205, 3, 6, 3, 0, 200, 205, 3, 12, 6, 0, 201, 205, 3, 14, 7, 0, 202, 205, 3, 16, 8, 0, 203, 205, 3, 22, 11, 0, 204, 199, 1, 0, 0, 0, 204, 200, 1, 0, 0, 0, 204, 201, 1, 0, 0, 0, 204, 202, 1, 0, 0, 0, 204, 203, 1, 0, 0, 0, 205, 206, 1, 0, 0, 0, 206, 204, 1, 0, 0, 0, 206, 207, 1, 0, 0, 0, 207, 3, 1, 0, 0, 0, 208, 209, 5, 3, 0, 0, 209, 210, 3, 140, 70, 0, 210, 211, 5, 2, 0, 0, 211, 5, 1, 0, 0, 0, 212, 213, 5, 4, 0, 0, 213, 214, 3, 186, 93, 0, 214, 215, 5, 5, 0, 0, 215, 216, 3, 8, 4, 0, 216, 217, 3, 10, 5, 0, 217, 7, 1, 0, 0, 0, 218, 219, 5, 6, 0, 0, 219, 220, 5, 7, 0, 0, 220, 221, 3, 132, 66, 0, 221, 222, 5, 2, 0, 0, 222, 9, 1, 0, 0, 0, 223, 224, 5, 8, 0, 0, 224, 225, 5, 7, 0, 0, 225, 226, 3, 132, 66, 0, 226, 227, 5, 2, 0, 0, 227, 11, 1, 0, 0, 0, 228, 229, 5, 9, 0, 0, 229, 230, 3, 186, 93, 0, 230, 232, 5, 5, 0, 0, 231, 233, 3, 158, 79, 0, 232, 231, 1, 0, 0, 0, 233, 234, 1, 0, 0, 0, 234, 232, 1, 0, 0, 0, 234, 235, 1, 0, 0, 0, 235, 13, 1, 0, 0, 0, 236, 237, 5, 10, 0, 0, 237, 238, 3, 186, 93, 0, 238, 242, 5, 5, 0, 0, 239, 241, 3, 160, 80, 0, 240, 239, 1, 0, 0, 0, 241, 244, 1, 0, 0, 0, 242, 240, 1, 0, 0, 0, 242, 243, 1, 0, 0, 0, 243, 15, 1, 0, 0, 0, 244, 242, 1, 0, 0, 0, 245, 246, 5, 11, 0, 0, 246, 247, 3, 186, 93, 0, 247, 251, 5, 5, 0, 0, 248, 250, 3, 18, 9, 0, 249, 248, 1, 0, 0, 0, 250, 253, 1, 0, 0, 0, 251, 249, 1, 0, 0, 0, 251, 252, 1, 0, 0, 0, 252, 255, 1, 0, 0, 0, 253, 251, 1, 0, 0, 0, 254, 256, 3, 52, 26, 0, 255, 254, 1, 0, 0, 0, 256, 257, 1, 0, 0, 0, 257, 255, 1, 0, 0, 0, 257, 258, 1, 0, 0, 0, 258, 262, 1, 0, 0, 0, 259, 261, 3, 20, 10, 0, 260, 259, 1, 0, 0, 0, 261, 264, 1, 0, 0, 0, 262, 260, 1, 0, 0, 0, 262, 263, 1, 0, 0, 0, 263, 17, 1, 0, 0, 0, 264, 262, 1, 0, 0, 0, 265, 266, 5, 12, 0, 0, 266, 267, 3, 146, 73, 0, 267, 268, 5, 7, 0, 0, 268, 269, 3, 138, 69, 0, 269, 270, 5, 2, 0, 0, 270, 19, 1, 0, 0, 0, 271, 272, 5, 13, 0, 0, 272, 273, 3, 156, 78, 0, 273, 274, 5, 7, 0, 0, 274, 275, 3, 138, 69, 0, 275, 276, 5, 2, 0, 0, 276, 21, 1, 0, 0, 0, 277, 278, 5, 14, 0, 0, 278, 279, 3, 186, 93, 0, 279, 283, 5, 5, 0, 0, 280, 282, 3, 24, 12, 0, 281, 280, 1, 0, 0, 0, 282, 285, 1, 0, 0, 0, 283, 281, 1, 0, 0, 0, 283, 284, 1, 0, 0, 0, 284, 289, 1, 0, 0, 0, 285, 283, 1, 0, 0, 0, 286, 288, 3, 52, 26, 0, 287, 286, 1, 0, 0, 0, 288, 291, 1, 0, 0, 0, 289, 287, 1, 0, 0, 0, 289, 290, 1, 0, 0, 0, 290, 295, 1, 0, 0, 0, 291, 289, 1, 0, 0, 0, 292, 294, 3, 26, 13, 0, 293, 292, 1, 0, 0, 0, 294, 297, 1, 0, 0, 0, 295, 293, 1, 0, 0, 0, 295, 296, 1, 0, 0, 0, 296, 299, 1, 0, 0, 0, 297, 295, 1, 0, 0, 0, 298, 300, 3, 28, 14, 0, 299, 298, 1, 0, 0, 0, 299, 300, 1, 0, 0, 0, 300, 23, 1, 0, 0, 0, 301, 302, 5, 12, 0, 0, 302, 303, 3, 146, 73, 0, 303, 304, 5, 7, 0, 0, 304, 305, 3, 130, 65, 0, 305, 306, 5, 2, 0, 0, 306, 25, 1, 0, 0, 0, 307, 308, 5, 13, 0, 0, 308, 309, 3, 156, 78, 0, 309, 310, 5, 7, 0, 0, 310, 311, 3, 130, 65, 0, 311, 312, 5, 2, 0, 0, 312, 27, 1, 0, 0, 0, 313, 314, 5, 15, 0, 0, 314, 315, 3, 186, 93, 0, 315, 319, 5, 5, 0, 0, 316, 318, 3, 30, 15, 0, 317, 316, 1, 0, 0, 0, 318, 321, 1, 0, 0, 0, 319, 317, 1, 0, 0, 0, 319, 320, 1, 0, 0, 0, 320, 323, 1, 0, 0, 0, 321, 319, 1, 0, 0, 0, 322, 324, 3, 32, 16, 0, 323, 322, 1, 0, 0, 0, 324, 325, 1, 0, 0, 0, 325, 323, 1, 0, 0, 0, 325, 326, 1, 0, 0, 0, 326, 29, 1, 0, 0, 0, 327, 328, 5, 12, 0, 0, 328, 329, 3, 146, 73, 0, 329, 330, 5, 7, 0, 0, 330, 331, 3, 134, 67, 0, 331, 332, 5, 2, 0, 0, 332, 31, 1, 0, 0, 0, 333, 344, 3, 34, 17, 0, 334, 344, 3, 36, 18, 0, 335, 344, 3, 38, 19, 0, 336, 344, 3, 40, 20, 0, 337, 344, 3, 42, 21, 0, 338, 344, 3, 44, 22, 0, 339, 344, 3, 46, 23, 0, 340, 344, 3, 48, 24, 0, 341, 344, 3, 50, 25, 0, 342, 344, 3, 52, 26, 0, 343, 333, 1, 0, 0, 0, 343, 334, 1, 0, 0, 0, 343, 335, 1, 0, 0, 0, 343, 336, 1, 0, 0, 0, 343, 337, 1, 0, 0, 0, 343, 338, 1, 0, 0, 0, 343, 339, 1, 0, 0, 0, 343, 340, 1, 0, 0, 0, 343, 341, 1, 0, 0, 0, 343, 342, 1, 0, 0, 0, 344, 33, 1, 0, 0, 0, 345, 346, 5, 16, 0, 0, 346, 347, 3, 186, 93, 0, 347, 348, 5, 17, 0, 0, 348, 349, 3, 156, 78, 0, 349, 350, 5, 18, 0, 0, 350, 351, 5, 19, 0, 0, 351, 352, 3, 148, 74, 0, 352, 353, 5, 2, 0, 0, 353, 35, 1, 0, 0, 0, 354, 355, 5, 20, 0, 0, 355, 356, 3, 186, 93, 0, 356, 357, 5, 17, 0, 0, 357, 358, 3, 156, 78, 0, 358, 359, 5, 18, 0, 0, 359, 360, 5, 19, 0, 0, 360, 361, 3, 148, 74, 0, 361, 362, 5, 2, 0, 0, 362, 37, 1, 0, 0, 0, 363, 364, 5, 21, 0, 0, 364, 365, 3, 186, 93, 0, 365, 366, 5, 17, 0, 0, 366, 367, 3, 156, 78, 0, 367, 368, 5, 18, 0, 0, 368, 369, 3, 156, 78, 0, 369, 370, 5, 19, 0, 0, 370, 371, 3, 148, 74, 0, 371, 372, 5, 2, 0, 0, 372, 39, 1, 0, 0, 0, 373, 374, 5, 22, 0, 0, 374, 375, 3, 156, 78, 0, 375, 376, 5, 19, 0, 0, 376, 377, 3, 186, 93, 0, 377, 378, 5, 17, 0, 0, 378, 379, 3, 156, 78, 0, 379, 380, 5, 18, 0, 0, 380, 381, 5, 2, 0, 0, 381, 41, 1, 0, 0, 0, 382, 383, 5, 23, 0, 0, 383, 384, 3, 186, 93, 0, 384, 385, 5, 17, 0, 0, 385, 386, 3, 156, 78, 0, 386, 387, 5, 18, 0, 0, 387, 388, 5, 2, 0, 0, 388, 43, 1, 0, 0, 0, 389, 393, 5, 24, 0, 0, 390, 392, 3, 156, 78, 0, 391, 390, 1, 0, 0, 0, 392, 395, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 393, 394, 1, 0, 0, 0, 394, 396, 1, 0, 0, 0, 395, 393, 1, 0, 0, 0, 396, 397, 5, 19, 0, 0, 397, 398, 3, 148, 74, 0, 398, 403, 5, 7, 0, 0, 399, 404, 3, 116, 58, 0, 400, 404, 3, 118, 59, 0, 401, 404, 3, 122, 61, 0, 402, 404, 3, 120, 60, 0, 403, 399, 1, 0, 0, 0, 403, 400, 1, 0, 0, 0, 403, 401, 1, 0, 0, 0, 403, 402, 1, 0, 0, 0, 404, 405, 1, 0, 0, 0, 405, 406, 5, 2, 0, 0, 406, 45, 1, 0, 0, 0, 407, 408, 5, 25, 0, 0, 408, 409, 3, 184, 92, 0, 409, 410, 5, 2, 0, 0, 410, 47, 1, 0, 0, 0, 411, 412, 3, 182, 91, 0, 412, 413, 3, 156, 78, 0, 413, 414, 3, 156, 78, 0, 414, 415, 5, 26, 0, 0, 415, 416, 3, 184, 92, 0, 416, 417, 5, 2, 0, 0, 417, 49, 1, 0, 0, 0, 418, 419, 5, 27, 0, 0, 419, 420, 3, 148, 74, 0, 420, 421, 5, 2, 0, 0, 421, 51, 1, 0, 0, 0, 422, 434, 3, 54, 27, 0, 423, 434, 3, 56, 28, 0, 424, 434, 3, 58, 29, 0, 425, 434, 3, 60, 30, 0, 426, 434, 3, 62, 31, 0, 427, 434, 3, 64, 32, 0, 428, 434, 3, 70, 35, 0, 429, 434, 3, 72, 36, 0, 430, 434, 3, 74, 37, 0, 431, 434, 3, 76, 38, 0, 432, 434, 3, 78, 39, 0, 433, 422, 1, 0, 0, 0, 433, 423, 1, 0, 0, 0, 433, 424, 1, 0, 0, 0, 433, 425, 1, 0, 0, 0, 433, 426, 1, 0, 0, 0, 433, 427, 1, 0, 0, 0, 433, 428, 1, 0, 0, 0, 433, 429, 1, 0, 0, 0, 433, 430, 1, 0, 0, 0, 433, 431, 1, 0, 0, 0, 433, 432, 1, 0, 0, 0, 434, 53, 1, 0, 0, 0, 435, 436, 3, 166, 83, 0, 436, 437, 3, 156, 78, 0, 437, 438, 5, 19, 0, 0, 438, 439, 3, 148, 74, 0, 439, 440, 5, 2, 0, 0, 440, 55, 1, 0, 0, 0, 441, 442, 3, 168, 84, 0, 442, 443, 3, 156, 78, 0, 443, 444, 3, 156, 78, 0, 444, 445, 5, 19, 0, 0, 445, 446, 3, 148, 74, 0, 446, 447, 5, 2, 0, 0, 447, 57, 1, 0, 0, 0, 448, 449, 5, 28, 0, 0, 449, 450, 3, 156, 78, 0, 450, 451, 3, 156, 78, 0, 451, 452, 3, 156, 78, 0, 452, 453, 5, 19, 0, 0, 453, 454, 3, 148, 74, 0, 454, 455, 5, 2, 0, 0, 455, 59, 1, 0, 0, 0, 456, 457, 3, 170, 85, 0, 457, 458, 3, 156, 78, 0, 458, 459, 3, 156, 78, 0, 459, 460, 5, 19, 0, 0, 460, 461, 3, 148, 74, 0, 461, 462, 5, 2, 0, 0, 462, 61, 1, 0, 0, 0, 463, 464, 3, 172, 86, 0, 464, 465, 3, 156, 78, 0, 465, 466, 3, 156, 78, 0, 466, 467, 5, 2, 0, 0, 467, 63, 1, 0, 0, 0, 468, 469, 3, 174, 87, 0, 469, 470, 3, 156, 78, 0, 470, 471, 3, 156, 78, 0, 471, 472, 5, 19, 0, 0, 472, 473, 3, 148, 74, 0, 473, 477, 5, 7, 0, 0, 474, 478, 3, 118, 59, 0, 475, 478, 3, 110, 55, 0, 476, 478, 3, 112, 56, 0, 477, 474, 1, 0, 0, 0, 477, 475, 1, 0, 0, 0, 477, 476, 1, 0, 0, 0, 478, 479, 1, 0, 0, 0, 479, 480, 5, 2, 0, 0, 480, 65, 1, 0, 0, 0, 481, 482, 3, 176, 88, 0, 482, 483, 3, 156, 78, 0, 483, 484, 5, 19, 0, 0, 484, 485, 3, 148, 74, 0, 485, 491, 5, 7, 0, 0, 486, 492, 3, 116, 58, 0, 487, 492, 3, 118, 59, 0, 488, 492, 3, 122, 61, 0, 489, 492, 3, 126, 63, 0, 490, 492, 3, 186, 93, 0, 491, 486, 1, 0, 0, 0, 491, 487, 1, 0, 0, 0, 491, 488, 1, 0, 0, 0, 491, 489, 1, 0, 0, 0, 491, 490, 1, 0, 0, 0, 492, 493, 1, 0, 0, 0, 493, 494, 5, 2, 0, 0, 494, 67, 1, 0, 0, 0, 495, 496, 3, 178, 89, 0, 496, 497, 3, 156, 78, 0, 497, 498, 3, 156, 78, 0, 498, 499, 5, 19, 0, 0, 499, 500, 3, 148, 74, 0, 500, 506, 5, 7, 0, 0, 501, 507, 3, 116, 58, 0, 502, 507, 3, 118, 59, 0, 503, 507, 3, 122, 61, 0, 504, 507, 3, 126, 63, 0, 505, 507, 3, 186, 93, 0, 506, 501, 1, 0, 0, 0, 506, 502, 1, 0, 0, 0, 506, 503, 1, 0, 0, 0, 506, 504, 1, 0, 0, 0, 506, 505, 1, 0, 0, 0, 507, 508, 1, 0, 0, 0, 508, 509, 5, 2, 0, 0, 509, 69, 1, 0, 0, 0, 510, 513, 3, 66, 33, 0, 511, 513, 3, 68, 34, 0, 512, 510, 1, 0, 0, 0, 512, 511, 1, 0, 0, 0, 513, 71, 1, 0, 0, 0, 514, 515, 7, 0, 0, 0, 515, 516, 3, 156, 78, 0, 516, 517, 3, 156, 78, 0, 517, 518, 3, 156, 78, 0, 518, 519, 5, 19, 0, 0, 519, 520, 3, 148, 74, 0, 520, 521, 5, 2, 0, 0, 521, 73, 1, 0, 0, 0, 522, 524, 3, 180, 90, 0, 523, 525, 3, 156, 78, 0, 524, 523, 1, 0, 0, 0, 525, 526, 1, 0, 0, 0, 526, 524, 1, 0, 0, 0, 526, 527, 1, 0, 0, 0, 527, 528, 1, 0, 0, 0, 528, 529, 5, 19, 0, 0, 529, 530, 3, 148, 74, 0, 530, 531, 5, 7, 0, 0, 531, 532, 3, 164, 82, 0, 532, 533, 5, 2, 0, 0, 533, 75, 1, 0, 0, 0, 534, 537, 5, 31, 0, 0, 535, 538, 3, 162, 81, 0, 536, 538, 3, 186, 93, 0, 537, 535, 1, 0, 0, 0, 537, 536, 1, 0, 0, 0, 538, 542, 1, 0, 0, 0, 539, 541, 3, 156, 78, 0, 540, 539, 1, 0, 0, 0, 541, 544, 1, 0, 0, 0, 542, 540, 1, 0, 0, 0, 542, 543, 1, 0, 0, 0, 543, 551, 1, 0, 0, 0, 544, 542, 1, 0, 0, 0, 545, 547, 5, 19, 0, 0, 546, 548, 3, 148, 74, 0, 547, 546, 1, 0, 0, 0, 548, 549, 1, 0, 0, 0, 549, 547, 1, 0, 0, 0, 549, 550, 1, 0, 0, 0, 550, 552, 1, 0, 0, 0, 551, 545, 1, 0, 0, 0, 551, 552, 1, 0, 0, 0, 552, 553, 1, 0, 0, 0, 553, 554, 5, 2, 0, 0, 554, 77, 1, 0, 0, 0, 555, 556, 5, 32, 0, 0, 556, 560, 3, 186, 93, 0, 557, 559, 3, 156, 78, 0, 558, 557, 1, 0, 0, 0, 559, 562, 1, 0, 0, 0, 560, 558, 1, 0, 0, 0, 560, 561, 1, 0, 0, 0, 561, 563, 1, 0, 0, 0, 562, 560, 1, 0, 0, 0, 563, 564, 5, 19, 0, 0, 564, 565, 3, 148, 74, 0, 565, 566, 5, 2, 0, 0, 566, 79, 1, 0, 0, 0, 567, 572, 3, 94, 47, 0, 568, 572, 3, 98, 49, 0, 569, 572, 3, 100, 50, 0, 570, 572, 3, 102, 51, 0, 571, 567, 1, 0, 0, 0, 571, 568, 1, 0, 0, 0, 571, 569, 1, 0, 0, 0, 571, 570, 1, 0, 0, 0, 572, 81, 1, 0, 0, 0, 573, 575, 5, 33, 0, 0, 574, 573, 1, 0, 0, 0, 574, 575, 1, 0, 0, 0, 575, 583, 1, 0, 0, 0, 576, 580, 5, 136, 0, 0, 577, 579, 5, 34, 0, 0, 578, 577, 1, 0, 0, 0, 579, 582, 1, 0, 0, 0, 580, 578, 1, 0, 0, 0, 580, 581, 1, 0, 0, 0, 581, 584, 1, 0, 0, 0, 582, 580, 1, 0, 0, 0, 583, 576, 1, 0, 0, 0, 584, 585, 1, 0, 0, 0, 585, 583, 1, 0, 0, 0, 585, 586, 1, 0, 0, 0, 586, 587, 1, 0, 0, 0, 587, 588, 3, 106, 53, 0, 588, 83, 1, 0, 0, 0, 589, 591, 5, 33, 0, 0, 590, 589, 1, 0, 0, 0, 590, 591, 1, 0, 0, 0, 591, 599, 1, 0, 0, 0, 592, 596, 5, 136, 0, 0, 593, 595, 5, 34, 0, 0, 594, 593, 1, 0, 0, 0, 595, 598, 1, 0, 0, 0, 596, 594, 1, 0, 0, 0, 596, 597, 1, 0, 0, 0, 597, 600, 1, 0, 0, 0, 598, 596, 1, 0, 0, 0, 599, 592, 1, 0, 0, 0, 600, 601, 1, 0, 0, 0, 601, 599, 1, 0, 0, 0, 601, 602, 1, 0, 0, 0, 602, 603, 1, 0, 0, 0, 603, 604, 3, 104, 52, 0, 604, 85, 1, 0, 0, 0, 605, 608, 3, 82, 41, 0, 606, 608, 3, 84, 42, 0, 607, 605, 1, 0, 0, 0, 607, 606, 1, 0, 0, 0, 608, 87, 1, 0, 0, 0, 609, 611, 5, 33, 0, 0, 610, 609, 1, 0, 0, 0, 610, 611, 1, 0, 0, 0, 611, 619, 1, 0, 0, 0, 612, 616, 5, 136, 0, 0, 613, 615, 5, 34, 0, 0, 614, 613, 1, 0, 0, 0, 615, 618, 1, 0, 0, 0, 616, 614, 1, 0, 0, 0, 616, 617, 1, 0, 0, 0, 617, 620, 1, 0, 0, 0, 618, 616, 1, 0, 0, 0, 619, 612, 1, 0, 0, 0, 620, 621, 1, 0, 0, 0, 621, 619, 1, 0, 0, 0, 621, 622, 1, 0, 0, 0, 622, 623, 1, 0, 0, 0, 623, 624, 3, 110, 55, 0, 624, 89, 1, 0, 0, 0, 625, 627, 5, 33, 0, 0, 626, 625, 1, 0, 0, 0, 626, 627, 1, 0, 0, 0, 627, 635, 1, 0, 0, 0, 628, 632, 5, 136, 0, 0, 629, 631, 5, 34, 0, 0, 630, 629, 1, 0, 0, 0, 631, 634, 1, 0, 0, 0, 632, 630, 1, 0, 0, 0, 632, 633, 1, 0, 0, 0, 633, 636, 1, 0, 0, 0, 634, 632, 1, 0, 0, 0, 635, 628, 1, 0, 0, 0, 636, 637, 1, 0, 0, 0, 637, 635, 1, 0, 0, 0, 637, 638, 1, 0, 0, 0, 638, 639, 1, 0, 0, 0, 639, 640, 3, 112, 56, 0, 640, 91, 1, 0, 0, 0, 641, 643, 5, 33, 0, 0, 642, 641, 1, 0, 0, 0, 642, 643, 1, 0, 0, 0, 643, 651, 1, 0, 0, 0, 644, 648, 5, 136, 0, 0, 645, 647, 5, 34, 0, 0, 646, 645, 1, 0, 0, 0, 647, 650, 1, 0, 0, 0, 648, 646, 1, 0, 0, 0, 648, 649, 1, 0, 0, 0, 649, 652, 1, 0, 0, 0, 650, 648, 1, 0, 0, 0, 651, 644, 1, 0, 0, 0, 652, 653, 1, 0, 0, 0, 653, 651, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 655, 1, 0, 0, 0, 655, 656, 3, 114, 57, 0, 656, 93, 1, 0, 0, 0, 657, 662, 3, 86, 43, 0, 658, 662, 3, 88, 44, 0, 659, 662, 3, 90, 45, 0, 660, 662, 3, 92, 46, 0, 661, 657, 1, 0, 0, 0, 661, 658, 1, 0, 0, 0, 661, 659, 1, 0, 0, 0, 661, 660, 1, 0, 0, 0, 662, 95, 1, 0, 0, 0, 663, 665, 5, 33, 0, 0, 664, 663, 1, 0, 0, 0, 664, 665, 1, 0, 0, 0, 665, 673, 1, 0, 0, 0, 666, 670, 5, 136, 0, 0, 667, 669, 5, 34, 0, 0, 668, 667, 1, 0, 0, 0, 669, 672, 1, 0, 0, 0, 670, 668, 1, 0, 0, 0, 670, 671, 1, 0, 0, 0, 671, 674, 1, 0, 0, 0, 672, 670, 1, 0, 0, 0, 673, 666, 1, 0, 0, 0, 674, 675, 1, 0, 0, 0, 675, 673, 1, 0, 0, 0, 675, 676, 1, 0, 0, 0, 676, 677, 1, 0, 0, 0, 677, 678, 5, 35, 0, 0, 678, 97, 1, 0, 0, 0, 679, 680, 5, 132, 0, 0, 680, 99, 1, 0, 0, 0, 681, 682, 5, 133, 0, 0, 682, 101, 1, 0, 0, 0, 683, 684, 7, 1, 0, 0, 684, 103, 1, 0, 0, 0, 685, 686, 7, 2, 0, 0, 686, 105, 1, 0, 0, 0, 687, 688, 7, 3, 0, 0, 688, 107, 1, 0, 0, 0, 689, 692, 3, 104, 52, 0, 690, 692, 3, 106, 53, 0, 691, 689, 1, 0, 0, 0, 691, 690, 1, 0, 0, 0, 692, 109, 1, 0, 0, 0, 693, 694, 5, 47, 0, 0, 694, 111, 1, 0, 0, 0, 695, 696, 5, 48, 0, 0, 696, 113, 1, 0, 0, 0, 697, 698, 5, 49, 0, 0, 698, 115, 1, 0, 0, 0, 699, 704, 3, 108, 54, 0, 700, 704, 3, 110, 55, 0, 701, 704, 3, 112, 56, 0, 702, 704, 3, 114, 57, 0, 703, 699, 1, 0, 0, 0, 703, 700, 1, 0, 0, 0, 703, 701, 1, 0, 0, 0, 703, 702, 1, 0, 0, 0, 704, 117, 1, 0, 0, 0, 705, 706, 5, 50, 0, 0, 706, 119, 1, 0, 0, 0, 707, 708, 5, 51, 0, 0, 708, 121, 1, 0, 0, 0, 709, 710, 5, 52, 0, 0, 710, 123, 1, 0, 0, 0, 711, 716, 3, 116, 58, 0, 712, 716, 3, 118, 59, 0, 713, 716, 3, 122, 61, 0, 714, 716, 3, 120, 60, 0, 715, 711, 1, 0, 0, 0, 715, 712, 1, 0, 0, 0, 715, 713, 1, 0, 0, 0, 715, 714, 1, 0, 0, 0, 716, 125, 1, 0, 0, 0, 717, 718, 5, 17, 0, 0, 718, 719, 3, 128, 64, 0, 719, 720, 5, 2, 0, 0, 720, 721, 3, 96, 48, 0, 721, 722, 5, 18, 0, 0, 722, 127, 1, 0, 0, 0, 723, 727, 3, 124, 62, 0, 724, 727, 3, 126, 63, 0, 725, 727, 3, 186, 93, 0, 726, 723, 1, 0, 0, 0, 726, 724, 1, 0, 0, 0, 726, 725, 1, 0, 0, 0, 727, 129, 1, 0, 0, 0, 728, 729, 3, 128, 64, 0, 729, 730, 5, 53, 0, 0, 730, 747, 1, 0, 0, 0, 731, 732, 3, 128, 64, 0, 732, 733, 5, 54, 0, 0, 733, 747, 1, 0, 0, 0, 734, 735, 3, 128, 64, 0, 735, 736, 5, 55, 0, 0, 736, 747, 1, 0, 0, 0, 737, 738, 3, 186, 93, 0, 738, 739, 5, 56, 0, 0, 739, 747, 1, 0, 0, 0, 740, 741, 3, 162, 81, 0, 741, 742, 5, 56, 0, 0, 742, 747, 1, 0, 0, 0, 743, 744, 3, 162, 81, 0, 744, 745, 5, 57, 0, 0, 745, 747, 1, 0, 0, 0, 746, 728, 1, 0, 0, 0, 746, 731, 1, 0, 0, 0, 746, 734, 1, 0, 0, 0, 746, 737, 1, 0, 0, 0, 746, 740, 1, 0, 0, 0, 746, 743, 1, 0, 0, 0, 747, 131, 1, 0, 0, 0, 748, 749, 3, 128, 64, 0, 749, 750, 5, 54, 0, 0, 750, 133, 1, 0, 0, 0, 751, 752, 3, 128, 64, 0, 752, 753, 5, 54, 0, 0, 753, 758, 1, 0, 0, 0, 754, 755, 3, 162, 81, 0, 755, 756, 5, 57, 0, 0, 756, 758, 1, 0, 0, 0, 757, 751, 1, 0, 0, 0, 757, 754, 1, 0, 0, 0, 758, 135, 1, 0, 0, 0, 759, 760, 3, 128, 64, 0, 760, 761, 7, 4, 0, 0, 761, 137, 1, 0, 0, 0, 762, 763, 3, 162, 81, 0, 763, 764, 5, 57, 0, 0, 764, 773, 1, 0, 0, 0, 765, 766, 3, 162, 81, 0, 766, 767, 5, 56, 0, 0, 767, 773, 1, 0, 0, 0, 768, 769, 3, 186, 93, 0, 769, 770, 5, 56, 0, 0, 770, 773, 1, 0, 0, 0, 771, 773, 3, 128, 64, 0, 772, 762, 1, 0, 0, 0, 772, 765, 1, 0, 0, 0, 772, 768, 1, 0, 0, 0, 772, 771, 1, 0, 0, 0, 773, 139, 1, 0, 0, 0, 774, 775, 3, 142, 71, 0, 775, 776, 5, 58, 0, 0, 776, 777, 3, 144, 72, 0, 777, 141, 1, 0, 0, 0, 778, 779, 3, 186, 93, 0, 779, 143, 1, 0, 0, 0, 780, 781, 3, 186, 93, 0, 781, 145, 1, 0, 0, 0, 782, 783, 5, 134, 0, 0, 783, 147, 1, 0, 0, 0, 784, 788, 3, 146, 73, 0, 785, 787, 3, 150, 75, 0, 786, 785, 1, 0, 0, 0, 787, 790, 1, 0, 0, 0, 788, 786, 1, 0, 0, 0, 788, 789, 1, 0, 0, 0, 789, 149, 1, 0, 0, 0, 790, 788, 1, 0, 0, 0, 791, 794, 3, 152, 76, 0, 792, 794, 3, 154, 77, 0, 793, 791, 1, 0, 0, 0, 793, 792, 1, 0, 0, 0, 794, 151, 1, 0, 0, 0, 795, 796, 5, 58, 0, 0, 796, 797, 3, 186, 93, 0, 797, 153, 1, 0, 0, 0, 798, 799, 5, 17, 0, 0, 799, 800, 3, 96, 48, 0, 800, 801, 5, 18, 0, 0, 801, 810, 1, 0, 0, 0, 802, 804, 5, 17, 0, 0, 803, 805, 5, 136, 0, 0, 804, 803, 1, 0, 0, 0, 805, 806, 1, 0, 0, 0, 806, 804, 1, 0, 0, 0, 806, 807, 1, 0, 0, 0, 807, 808, 1, 0, 0, 0, 808, 810, 5, 18, 0, 0, 809, 798, 1, 0, 0, 0, 809, 802, 1, 0, 0, 0, 810, 155, 1, 0, 0, 0, 811, 819, 3, 80, 40, 0, 812, 819, 5, 59, 0, 0, 813, 819, 3, 148, 74, 0, 814, 819, 3, 140, 70, 0, 815, 819, 5, 60, 0, 0, 816, 819, 5, 61, 0, 0, 817, 819, 5, 62, 0, 0, 818, 811, 1, 0, 0, 0, 818, 812, 1, 0, 0, 0, 818, 813, 1, 0, 0, 0, 818, 814, 1, 0, 0, 0, 818, 815, 1, 0, 0, 0, 818, 816, 1, 0, 0, 0, 818, 817, 1, 0, 0, 0, 819, 157, 1, 0, 0, 0, 820, 821, 3, 186, 93, 0, 821, 822, 5, 7, 0, 0, 822, 823, 3, 128, 64, 0, 823, 824, 5, 2, 0, 0, 824, 159, 1, 0, 0, 0, 825, 826, 3, 186, 93, 0, 826, 827, 5, 7, 0, 0, 827, 828, 3, 136, 68, 0, 828, 829, 5, 2, 0, 0, 829, 161, 1, 0, 0, 0, 830, 831, 3, 140, 70, 0, 831, 832, 5, 63, 0, 0, 832, 833, 3, 186, 93, 0, 833, 163, 1, 0, 0, 0, 834, 839, 3, 138, 69, 0, 835, 839, 3, 162, 81, 0, 836, 839, 5, 64, 0, 0, 837, 839, 5, 65, 0, 0, 838, 834, 1, 0, 0, 0, 838, 835, 1, 0, 0, 0, 838, 836, 1, 0, 0, 0, 838, 837, 1, 0, 0, 0, 839, 165, 1, 0, 0, 0, 840, 841, 7, 5, 0, 0, 841, 167, 1, 0, 0, 0, 842, 843, 7, 6, 0, 0, 843, 169, 1, 0, 0, 0, 844, 845, 7, 7, 0, 0, 845, 171, 1, 0, 0, 0, 846, 847, 7, 8, 0, 0, 847, 173, 1, 0, 0, 0, 848, 849, 7, 9, 0, 0, 849, 175, 1, 0, 0, 0, 850, 851, 7, 10, 0, 0, 851, 177, 1, 0, 0, 0, 852, 853, 7, 11, 0, 0, 853, 179, 1, 0, 0, 0, 854, 855, 7, 12, 0, 0, 855, 181, 1, 0, 0, 0, 856, 857, 7, 13, 0, 0, 857, 183, 1, 0, 0, 0, 858, 859, 3, 186, 93, 0, 859, 185, 1, 0, 0, 0, 860, 861, 5, 135, 0, 0, 861, 187, 1, 0, 0, 0, 62, 193, 204, 206, 234, 242, 251, 257, 262, 283, 289, 295, 299, 319, 325, 343, 393, 403, 433, 477, 491, 506, 512, 526, 537, 542, 549, 551, 560, 571, 574, 580, 585, 590, 596, 601, 607, 610, 616, 621, 626, 632, 637, 642, 648, 653, 661, 664, 670, 675, 691, 703, 715, 726, 746, 757, 772, 788, 793, 806, 809, 818, 838] \ No newline at end of file diff --git a/vanguard/aleo/parser/Aleo.tokens b/vanguard/aleo/parser/Aleo.tokens new file mode 100644 index 0000000..89e7efa --- /dev/null +++ b/vanguard/aleo/parser/Aleo.tokens @@ -0,0 +1,270 @@ +T__0=1 +T__1=2 +T__2=3 +T__3=4 +T__4=5 +T__5=6 +T__6=7 +T__7=8 +T__8=9 +T__9=10 +T__10=11 +T__11=12 +T__12=13 +T__13=14 +T__14=15 +T__15=16 +T__16=17 +T__17=18 +T__18=19 +T__19=20 +T__20=21 +T__21=22 +T__22=23 +T__23=24 +T__24=25 +T__25=26 +T__26=27 +T__27=28 +T__28=29 +T__29=30 +T__30=31 +T__31=32 +T__32=33 +T__33=34 +T__34=35 +T__35=36 +T__36=37 +T__37=38 +T__38=39 +T__39=40 +T__40=41 +T__41=42 +T__42=43 +T__43=44 +T__44=45 +T__45=46 +T__46=47 +T__47=48 +T__48=49 +T__49=50 +T__50=51 +T__51=52 +T__52=53 +T__53=54 +T__54=55 +T__55=56 +T__56=57 +T__57=58 +T__58=59 +T__59=60 +T__60=61 +T__61=62 +T__62=63 +T__63=64 +T__64=65 +T__65=66 +T__66=67 +T__67=68 +T__68=69 +T__69=70 +T__70=71 +T__71=72 +T__72=73 +T__73=74 +T__74=75 +T__75=76 +T__76=77 +T__77=78 +T__78=79 +T__79=80 +T__80=81 +T__81=82 +T__82=83 +T__83=84 +T__84=85 +T__85=86 +T__86=87 +T__87=88 +T__88=89 +T__89=90 +T__90=91 +T__91=92 +T__92=93 +T__93=94 +T__94=95 +T__95=96 +T__96=97 +T__97=98 +T__98=99 +T__99=100 +T__100=101 +T__101=102 +T__102=103 +T__103=104 +T__104=105 +T__105=106 +T__106=107 +T__107=108 +T__108=109 +T__109=110 +T__110=111 +T__111=112 +T__112=113 +T__113=114 +T__114=115 +T__115=116 +T__116=117 +T__117=118 +T__118=119 +T__119=120 +T__120=121 +T__121=122 +T__122=123 +T__123=124 +T__124=125 +T__125=126 +T__126=127 +T__127=128 +T__128=129 +T__129=130 +T__130=131 +ADDRESS_LITERAL=132 +SIGNATURE_LITERAL=133 +REGISTER=134 +IDENTIFIER=135 +DIGIT=136 +WS=137 +COMMENT=138 +LINE_COMMENT=139 +'program'=1 +';'=2 +'import'=3 +'mapping'=4 +':'=5 +'key'=6 +'as'=7 +'value'=8 +'struct'=9 +'record'=10 +'closure'=11 +'input'=12 +'output'=13 +'function'=14 +'finalize'=15 +'contains'=16 +'['=17 +']'=18 +'into'=19 +'get'=20 +'get.or_use'=21 +'set'=22 +'remove'=23 +'rand.chacha'=24 +'position'=25 +'to'=26 +'await'=27 +'ternary'=28 +'sign.verify'=29 +'sign_verify'=30 +'call'=31 +'async'=32 +'-'=33 +'_'=34 +'u32'=35 +'true'=36 +'false'=37 +'u8'=38 +'u16'=39 +'u64'=40 +'u128'=41 +'i8'=42 +'i16'=43 +'i32'=44 +'i64'=45 +'i128'=46 +'field'=47 +'group'=48 +'scalar'=49 +'address'=50 +'boolean'=51 +'signature'=52 +'.constant'=53 +'.public'=54 +'.private'=55 +'.record'=56 +'.future'=57 +'.'=58 +'group::GEN'=59 +'self.signer'=60 +'self.caller'=61 +'block.height'=62 +'/'=63 +'group.x'=64 +'group.y'=65 +'abs'=66 +'abs.w'=67 +'double'=68 +'inv'=69 +'neg'=70 +'not'=71 +'square'=72 +'sqrt'=73 +'add'=74 +'add.w'=75 +'sub'=76 +'sub.w'=77 +'mul'=78 +'mul.w'=79 +'div'=80 +'div.w'=81 +'rem'=82 +'rem.w'=83 +'pow'=84 +'pow.w'=85 +'shl'=86 +'shl.w'=87 +'shr'=88 +'shr.w'=89 +'mod'=90 +'and'=91 +'or'=92 +'xor'=93 +'nand'=94 +'nor'=95 +'gt'=96 +'gte'=97 +'lt'=98 +'lte'=99 +'is.eq'=100 +'is.neq'=101 +'assert.eq'=102 +'assert.neq'=103 +'commit.bhp256'=104 +'commit.bhp512'=105 +'commit.bhp768'=106 +'commit.bhp1024'=107 +'commit.ped64'=108 +'commit.ped128'=109 +'hash.bhp256'=110 +'hash.bhp512'=111 +'hash.bhp768'=112 +'hash.bhp1024'=113 +'hash.ped64'=114 +'hash.ped128'=115 +'hash.psd2'=116 +'hash.psd4'=117 +'hash.psd8'=118 +'hash.keccak256'=119 +'hash.keccak384'=120 +'hash.keccak512'=121 +'hash.sha3_256'=122 +'hash.sha3_384'=123 +'hash.sha3_512'=124 +'hash_many.psd2'=125 +'hash_many.psd4'=126 +'hash_many.psd8'=127 +'cast.lossy'=128 +'cast'=129 +'branch.eq'=130 +'branch.neq'=131 diff --git a/vanguard/aleo/parser/AleoLexer.interp b/vanguard/aleo/parser/AleoLexer.interp new file mode 100644 index 0000000..1894430 --- /dev/null +++ b/vanguard/aleo/parser/AleoLexer.interp @@ -0,0 +1,442 @@ +token literal names: +null +'program' +';' +'import' +'mapping' +':' +'key' +'as' +'value' +'struct' +'record' +'closure' +'input' +'output' +'function' +'finalize' +'contains' +'[' +']' +'into' +'get' +'get.or_use' +'set' +'remove' +'rand.chacha' +'position' +'to' +'await' +'ternary' +'sign.verify' +'sign_verify' +'call' +'async' +'-' +'_' +'u32' +'true' +'false' +'u8' +'u16' +'u64' +'u128' +'i8' +'i16' +'i32' +'i64' +'i128' +'field' +'group' +'scalar' +'address' +'boolean' +'signature' +'.constant' +'.public' +'.private' +'.record' +'.future' +'.' +'group::GEN' +'self.signer' +'self.caller' +'block.height' +'/' +'group.x' +'group.y' +'abs' +'abs.w' +'double' +'inv' +'neg' +'not' +'square' +'sqrt' +'add' +'add.w' +'sub' +'sub.w' +'mul' +'mul.w' +'div' +'div.w' +'rem' +'rem.w' +'pow' +'pow.w' +'shl' +'shl.w' +'shr' +'shr.w' +'mod' +'and' +'or' +'xor' +'nand' +'nor' +'gt' +'gte' +'lt' +'lte' +'is.eq' +'is.neq' +'assert.eq' +'assert.neq' +'commit.bhp256' +'commit.bhp512' +'commit.bhp768' +'commit.bhp1024' +'commit.ped64' +'commit.ped128' +'hash.bhp256' +'hash.bhp512' +'hash.bhp768' +'hash.bhp1024' +'hash.ped64' +'hash.ped128' +'hash.psd2' +'hash.psd4' +'hash.psd8' +'hash.keccak256' +'hash.keccak384' +'hash.keccak512' +'hash.sha3_256' +'hash.sha3_384' +'hash.sha3_512' +'hash_many.psd2' +'hash_many.psd4' +'hash_many.psd8' +'cast.lossy' +'cast' +'branch.eq' +'branch.neq' +null +null +null +null +null +null +null +null + +token symbolic names: +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +ADDRESS_LITERAL +SIGNATURE_LITERAL +REGISTER +IDENTIFIER +DIGIT +WS +COMMENT +LINE_COMMENT + +rule names: +T__0 +T__1 +T__2 +T__3 +T__4 +T__5 +T__6 +T__7 +T__8 +T__9 +T__10 +T__11 +T__12 +T__13 +T__14 +T__15 +T__16 +T__17 +T__18 +T__19 +T__20 +T__21 +T__22 +T__23 +T__24 +T__25 +T__26 +T__27 +T__28 +T__29 +T__30 +T__31 +T__32 +T__33 +T__34 +T__35 +T__36 +T__37 +T__38 +T__39 +T__40 +T__41 +T__42 +T__43 +T__44 +T__45 +T__46 +T__47 +T__48 +T__49 +T__50 +T__51 +T__52 +T__53 +T__54 +T__55 +T__56 +T__57 +T__58 +T__59 +T__60 +T__61 +T__62 +T__63 +T__64 +T__65 +T__66 +T__67 +T__68 +T__69 +T__70 +T__71 +T__72 +T__73 +T__74 +T__75 +T__76 +T__77 +T__78 +T__79 +T__80 +T__81 +T__82 +T__83 +T__84 +T__85 +T__86 +T__87 +T__88 +T__89 +T__90 +T__91 +T__92 +T__93 +T__94 +T__95 +T__96 +T__97 +T__98 +T__99 +T__100 +T__101 +T__102 +T__103 +T__104 +T__105 +T__106 +T__107 +T__108 +T__109 +T__110 +T__111 +T__112 +T__113 +T__114 +T__115 +T__116 +T__117 +T__118 +T__119 +T__120 +T__121 +T__122 +T__123 +T__124 +T__125 +T__126 +T__127 +T__128 +T__129 +T__130 +ADDRESS_LITERAL +SIGNATURE_LITERAL +ADDRESS_OR_SIGNATURE_CHAR +REGISTER +IDENTIFIER +LETTER +LOWERCASE_LETTER +ADDRESS_OR_SIGNATURE_LOWERCASE_LETTER +OTHER_LOWERCASE_LETTER +UPPERCASE_LETTER +DIGIT +ADDRESS_OR_SIGNATURE_DIGIT +OTHER_DIGIT +WS +COMMENT +LINE_COMMENT + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 139, 1371, 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, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 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, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 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, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 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, 32, 1, 32, 1, 33, 1, 33, 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, 36, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 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, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 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, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 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, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 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, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 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, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 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, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 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, 1, 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, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 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, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 5, 131, 1273, 8, 131, 10, 131, 12, 131, 1276, 9, 131, 4, 131, 1278, 8, 131, 11, 131, 12, 131, 1279, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 5, 132, 1290, 8, 132, 10, 132, 12, 132, 1293, 9, 132, 4, 132, 1295, 8, 132, 11, 132, 12, 132, 1296, 1, 133, 1, 133, 3, 133, 1301, 8, 133, 1, 134, 1, 134, 4, 134, 1305, 8, 134, 11, 134, 12, 134, 1306, 1, 135, 1, 135, 1, 135, 1, 135, 5, 135, 1313, 8, 135, 10, 135, 12, 135, 1316, 9, 135, 1, 136, 1, 136, 3, 136, 1320, 8, 136, 1, 137, 1, 137, 3, 137, 1324, 8, 137, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, 1, 141, 1, 141, 3, 141, 1334, 8, 141, 1, 142, 1, 142, 1, 143, 1, 143, 1, 144, 4, 144, 1341, 8, 144, 11, 144, 12, 144, 1342, 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 5, 145, 1351, 8, 145, 10, 145, 12, 145, 1354, 9, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 5, 146, 1365, 8, 146, 10, 146, 12, 146, 1368, 9, 146, 1, 146, 1, 146, 1, 1352, 0, 147, 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, 0, 269, 134, 271, 135, 273, 0, 275, 0, 277, 0, 279, 0, 281, 0, 283, 136, 285, 0, 287, 0, 289, 137, 291, 138, 293, 139, 1, 0, 6, 4, 0, 97, 97, 99, 104, 106, 110, 112, 122, 3, 0, 98, 98, 105, 105, 111, 111, 1, 0, 65, 90, 2, 0, 48, 48, 50, 57, 3, 0, 9, 10, 12, 13, 32, 32, 2, 0, 10, 10, 13, 13, 1377, 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, 269, 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 283, 1, 0, 0, 0, 0, 289, 1, 0, 0, 0, 0, 291, 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, 1, 295, 1, 0, 0, 0, 3, 303, 1, 0, 0, 0, 5, 305, 1, 0, 0, 0, 7, 312, 1, 0, 0, 0, 9, 320, 1, 0, 0, 0, 11, 322, 1, 0, 0, 0, 13, 326, 1, 0, 0, 0, 15, 329, 1, 0, 0, 0, 17, 335, 1, 0, 0, 0, 19, 342, 1, 0, 0, 0, 21, 349, 1, 0, 0, 0, 23, 357, 1, 0, 0, 0, 25, 363, 1, 0, 0, 0, 27, 370, 1, 0, 0, 0, 29, 379, 1, 0, 0, 0, 31, 388, 1, 0, 0, 0, 33, 397, 1, 0, 0, 0, 35, 399, 1, 0, 0, 0, 37, 401, 1, 0, 0, 0, 39, 406, 1, 0, 0, 0, 41, 410, 1, 0, 0, 0, 43, 421, 1, 0, 0, 0, 45, 425, 1, 0, 0, 0, 47, 432, 1, 0, 0, 0, 49, 444, 1, 0, 0, 0, 51, 453, 1, 0, 0, 0, 53, 456, 1, 0, 0, 0, 55, 462, 1, 0, 0, 0, 57, 470, 1, 0, 0, 0, 59, 482, 1, 0, 0, 0, 61, 494, 1, 0, 0, 0, 63, 499, 1, 0, 0, 0, 65, 505, 1, 0, 0, 0, 67, 507, 1, 0, 0, 0, 69, 509, 1, 0, 0, 0, 71, 513, 1, 0, 0, 0, 73, 518, 1, 0, 0, 0, 75, 524, 1, 0, 0, 0, 77, 527, 1, 0, 0, 0, 79, 531, 1, 0, 0, 0, 81, 535, 1, 0, 0, 0, 83, 540, 1, 0, 0, 0, 85, 543, 1, 0, 0, 0, 87, 547, 1, 0, 0, 0, 89, 551, 1, 0, 0, 0, 91, 555, 1, 0, 0, 0, 93, 560, 1, 0, 0, 0, 95, 566, 1, 0, 0, 0, 97, 572, 1, 0, 0, 0, 99, 579, 1, 0, 0, 0, 101, 587, 1, 0, 0, 0, 103, 595, 1, 0, 0, 0, 105, 605, 1, 0, 0, 0, 107, 615, 1, 0, 0, 0, 109, 623, 1, 0, 0, 0, 111, 632, 1, 0, 0, 0, 113, 640, 1, 0, 0, 0, 115, 648, 1, 0, 0, 0, 117, 650, 1, 0, 0, 0, 119, 661, 1, 0, 0, 0, 121, 673, 1, 0, 0, 0, 123, 685, 1, 0, 0, 0, 125, 698, 1, 0, 0, 0, 127, 700, 1, 0, 0, 0, 129, 708, 1, 0, 0, 0, 131, 716, 1, 0, 0, 0, 133, 720, 1, 0, 0, 0, 135, 726, 1, 0, 0, 0, 137, 733, 1, 0, 0, 0, 139, 737, 1, 0, 0, 0, 141, 741, 1, 0, 0, 0, 143, 745, 1, 0, 0, 0, 145, 752, 1, 0, 0, 0, 147, 757, 1, 0, 0, 0, 149, 761, 1, 0, 0, 0, 151, 767, 1, 0, 0, 0, 153, 771, 1, 0, 0, 0, 155, 777, 1, 0, 0, 0, 157, 781, 1, 0, 0, 0, 159, 787, 1, 0, 0, 0, 161, 791, 1, 0, 0, 0, 163, 797, 1, 0, 0, 0, 165, 801, 1, 0, 0, 0, 167, 807, 1, 0, 0, 0, 169, 811, 1, 0, 0, 0, 171, 817, 1, 0, 0, 0, 173, 821, 1, 0, 0, 0, 175, 827, 1, 0, 0, 0, 177, 831, 1, 0, 0, 0, 179, 837, 1, 0, 0, 0, 181, 841, 1, 0, 0, 0, 183, 845, 1, 0, 0, 0, 185, 848, 1, 0, 0, 0, 187, 852, 1, 0, 0, 0, 189, 857, 1, 0, 0, 0, 191, 861, 1, 0, 0, 0, 193, 864, 1, 0, 0, 0, 195, 868, 1, 0, 0, 0, 197, 871, 1, 0, 0, 0, 199, 875, 1, 0, 0, 0, 201, 881, 1, 0, 0, 0, 203, 888, 1, 0, 0, 0, 205, 898, 1, 0, 0, 0, 207, 909, 1, 0, 0, 0, 209, 923, 1, 0, 0, 0, 211, 937, 1, 0, 0, 0, 213, 951, 1, 0, 0, 0, 215, 966, 1, 0, 0, 0, 217, 979, 1, 0, 0, 0, 219, 993, 1, 0, 0, 0, 221, 1005, 1, 0, 0, 0, 223, 1017, 1, 0, 0, 0, 225, 1029, 1, 0, 0, 0, 227, 1042, 1, 0, 0, 0, 229, 1053, 1, 0, 0, 0, 231, 1065, 1, 0, 0, 0, 233, 1075, 1, 0, 0, 0, 235, 1085, 1, 0, 0, 0, 237, 1095, 1, 0, 0, 0, 239, 1110, 1, 0, 0, 0, 241, 1125, 1, 0, 0, 0, 243, 1140, 1, 0, 0, 0, 245, 1154, 1, 0, 0, 0, 247, 1168, 1, 0, 0, 0, 249, 1182, 1, 0, 0, 0, 251, 1197, 1, 0, 0, 0, 253, 1212, 1, 0, 0, 0, 255, 1227, 1, 0, 0, 0, 257, 1238, 1, 0, 0, 0, 259, 1243, 1, 0, 0, 0, 261, 1253, 1, 0, 0, 0, 263, 1264, 1, 0, 0, 0, 265, 1281, 1, 0, 0, 0, 267, 1300, 1, 0, 0, 0, 269, 1302, 1, 0, 0, 0, 271, 1308, 1, 0, 0, 0, 273, 1319, 1, 0, 0, 0, 275, 1323, 1, 0, 0, 0, 277, 1325, 1, 0, 0, 0, 279, 1327, 1, 0, 0, 0, 281, 1329, 1, 0, 0, 0, 283, 1333, 1, 0, 0, 0, 285, 1335, 1, 0, 0, 0, 287, 1337, 1, 0, 0, 0, 289, 1340, 1, 0, 0, 0, 291, 1346, 1, 0, 0, 0, 293, 1360, 1, 0, 0, 0, 295, 296, 5, 112, 0, 0, 296, 297, 5, 114, 0, 0, 297, 298, 5, 111, 0, 0, 298, 299, 5, 103, 0, 0, 299, 300, 5, 114, 0, 0, 300, 301, 5, 97, 0, 0, 301, 302, 5, 109, 0, 0, 302, 2, 1, 0, 0, 0, 303, 304, 5, 59, 0, 0, 304, 4, 1, 0, 0, 0, 305, 306, 5, 105, 0, 0, 306, 307, 5, 109, 0, 0, 307, 308, 5, 112, 0, 0, 308, 309, 5, 111, 0, 0, 309, 310, 5, 114, 0, 0, 310, 311, 5, 116, 0, 0, 311, 6, 1, 0, 0, 0, 312, 313, 5, 109, 0, 0, 313, 314, 5, 97, 0, 0, 314, 315, 5, 112, 0, 0, 315, 316, 5, 112, 0, 0, 316, 317, 5, 105, 0, 0, 317, 318, 5, 110, 0, 0, 318, 319, 5, 103, 0, 0, 319, 8, 1, 0, 0, 0, 320, 321, 5, 58, 0, 0, 321, 10, 1, 0, 0, 0, 322, 323, 5, 107, 0, 0, 323, 324, 5, 101, 0, 0, 324, 325, 5, 121, 0, 0, 325, 12, 1, 0, 0, 0, 326, 327, 5, 97, 0, 0, 327, 328, 5, 115, 0, 0, 328, 14, 1, 0, 0, 0, 329, 330, 5, 118, 0, 0, 330, 331, 5, 97, 0, 0, 331, 332, 5, 108, 0, 0, 332, 333, 5, 117, 0, 0, 333, 334, 5, 101, 0, 0, 334, 16, 1, 0, 0, 0, 335, 336, 5, 115, 0, 0, 336, 337, 5, 116, 0, 0, 337, 338, 5, 114, 0, 0, 338, 339, 5, 117, 0, 0, 339, 340, 5, 99, 0, 0, 340, 341, 5, 116, 0, 0, 341, 18, 1, 0, 0, 0, 342, 343, 5, 114, 0, 0, 343, 344, 5, 101, 0, 0, 344, 345, 5, 99, 0, 0, 345, 346, 5, 111, 0, 0, 346, 347, 5, 114, 0, 0, 347, 348, 5, 100, 0, 0, 348, 20, 1, 0, 0, 0, 349, 350, 5, 99, 0, 0, 350, 351, 5, 108, 0, 0, 351, 352, 5, 111, 0, 0, 352, 353, 5, 115, 0, 0, 353, 354, 5, 117, 0, 0, 354, 355, 5, 114, 0, 0, 355, 356, 5, 101, 0, 0, 356, 22, 1, 0, 0, 0, 357, 358, 5, 105, 0, 0, 358, 359, 5, 110, 0, 0, 359, 360, 5, 112, 0, 0, 360, 361, 5, 117, 0, 0, 361, 362, 5, 116, 0, 0, 362, 24, 1, 0, 0, 0, 363, 364, 5, 111, 0, 0, 364, 365, 5, 117, 0, 0, 365, 366, 5, 116, 0, 0, 366, 367, 5, 112, 0, 0, 367, 368, 5, 117, 0, 0, 368, 369, 5, 116, 0, 0, 369, 26, 1, 0, 0, 0, 370, 371, 5, 102, 0, 0, 371, 372, 5, 117, 0, 0, 372, 373, 5, 110, 0, 0, 373, 374, 5, 99, 0, 0, 374, 375, 5, 116, 0, 0, 375, 376, 5, 105, 0, 0, 376, 377, 5, 111, 0, 0, 377, 378, 5, 110, 0, 0, 378, 28, 1, 0, 0, 0, 379, 380, 5, 102, 0, 0, 380, 381, 5, 105, 0, 0, 381, 382, 5, 110, 0, 0, 382, 383, 5, 97, 0, 0, 383, 384, 5, 108, 0, 0, 384, 385, 5, 105, 0, 0, 385, 386, 5, 122, 0, 0, 386, 387, 5, 101, 0, 0, 387, 30, 1, 0, 0, 0, 388, 389, 5, 99, 0, 0, 389, 390, 5, 111, 0, 0, 390, 391, 5, 110, 0, 0, 391, 392, 5, 116, 0, 0, 392, 393, 5, 97, 0, 0, 393, 394, 5, 105, 0, 0, 394, 395, 5, 110, 0, 0, 395, 396, 5, 115, 0, 0, 396, 32, 1, 0, 0, 0, 397, 398, 5, 91, 0, 0, 398, 34, 1, 0, 0, 0, 399, 400, 5, 93, 0, 0, 400, 36, 1, 0, 0, 0, 401, 402, 5, 105, 0, 0, 402, 403, 5, 110, 0, 0, 403, 404, 5, 116, 0, 0, 404, 405, 5, 111, 0, 0, 405, 38, 1, 0, 0, 0, 406, 407, 5, 103, 0, 0, 407, 408, 5, 101, 0, 0, 408, 409, 5, 116, 0, 0, 409, 40, 1, 0, 0, 0, 410, 411, 5, 103, 0, 0, 411, 412, 5, 101, 0, 0, 412, 413, 5, 116, 0, 0, 413, 414, 5, 46, 0, 0, 414, 415, 5, 111, 0, 0, 415, 416, 5, 114, 0, 0, 416, 417, 5, 95, 0, 0, 417, 418, 5, 117, 0, 0, 418, 419, 5, 115, 0, 0, 419, 420, 5, 101, 0, 0, 420, 42, 1, 0, 0, 0, 421, 422, 5, 115, 0, 0, 422, 423, 5, 101, 0, 0, 423, 424, 5, 116, 0, 0, 424, 44, 1, 0, 0, 0, 425, 426, 5, 114, 0, 0, 426, 427, 5, 101, 0, 0, 427, 428, 5, 109, 0, 0, 428, 429, 5, 111, 0, 0, 429, 430, 5, 118, 0, 0, 430, 431, 5, 101, 0, 0, 431, 46, 1, 0, 0, 0, 432, 433, 5, 114, 0, 0, 433, 434, 5, 97, 0, 0, 434, 435, 5, 110, 0, 0, 435, 436, 5, 100, 0, 0, 436, 437, 5, 46, 0, 0, 437, 438, 5, 99, 0, 0, 438, 439, 5, 104, 0, 0, 439, 440, 5, 97, 0, 0, 440, 441, 5, 99, 0, 0, 441, 442, 5, 104, 0, 0, 442, 443, 5, 97, 0, 0, 443, 48, 1, 0, 0, 0, 444, 445, 5, 112, 0, 0, 445, 446, 5, 111, 0, 0, 446, 447, 5, 115, 0, 0, 447, 448, 5, 105, 0, 0, 448, 449, 5, 116, 0, 0, 449, 450, 5, 105, 0, 0, 450, 451, 5, 111, 0, 0, 451, 452, 5, 110, 0, 0, 452, 50, 1, 0, 0, 0, 453, 454, 5, 116, 0, 0, 454, 455, 5, 111, 0, 0, 455, 52, 1, 0, 0, 0, 456, 457, 5, 97, 0, 0, 457, 458, 5, 119, 0, 0, 458, 459, 5, 97, 0, 0, 459, 460, 5, 105, 0, 0, 460, 461, 5, 116, 0, 0, 461, 54, 1, 0, 0, 0, 462, 463, 5, 116, 0, 0, 463, 464, 5, 101, 0, 0, 464, 465, 5, 114, 0, 0, 465, 466, 5, 110, 0, 0, 466, 467, 5, 97, 0, 0, 467, 468, 5, 114, 0, 0, 468, 469, 5, 121, 0, 0, 469, 56, 1, 0, 0, 0, 470, 471, 5, 115, 0, 0, 471, 472, 5, 105, 0, 0, 472, 473, 5, 103, 0, 0, 473, 474, 5, 110, 0, 0, 474, 475, 5, 46, 0, 0, 475, 476, 5, 118, 0, 0, 476, 477, 5, 101, 0, 0, 477, 478, 5, 114, 0, 0, 478, 479, 5, 105, 0, 0, 479, 480, 5, 102, 0, 0, 480, 481, 5, 121, 0, 0, 481, 58, 1, 0, 0, 0, 482, 483, 5, 115, 0, 0, 483, 484, 5, 105, 0, 0, 484, 485, 5, 103, 0, 0, 485, 486, 5, 110, 0, 0, 486, 487, 5, 95, 0, 0, 487, 488, 5, 118, 0, 0, 488, 489, 5, 101, 0, 0, 489, 490, 5, 114, 0, 0, 490, 491, 5, 105, 0, 0, 491, 492, 5, 102, 0, 0, 492, 493, 5, 121, 0, 0, 493, 60, 1, 0, 0, 0, 494, 495, 5, 99, 0, 0, 495, 496, 5, 97, 0, 0, 496, 497, 5, 108, 0, 0, 497, 498, 5, 108, 0, 0, 498, 62, 1, 0, 0, 0, 499, 500, 5, 97, 0, 0, 500, 501, 5, 115, 0, 0, 501, 502, 5, 121, 0, 0, 502, 503, 5, 110, 0, 0, 503, 504, 5, 99, 0, 0, 504, 64, 1, 0, 0, 0, 505, 506, 5, 45, 0, 0, 506, 66, 1, 0, 0, 0, 507, 508, 5, 95, 0, 0, 508, 68, 1, 0, 0, 0, 509, 510, 5, 117, 0, 0, 510, 511, 5, 51, 0, 0, 511, 512, 5, 50, 0, 0, 512, 70, 1, 0, 0, 0, 513, 514, 5, 116, 0, 0, 514, 515, 5, 114, 0, 0, 515, 516, 5, 117, 0, 0, 516, 517, 5, 101, 0, 0, 517, 72, 1, 0, 0, 0, 518, 519, 5, 102, 0, 0, 519, 520, 5, 97, 0, 0, 520, 521, 5, 108, 0, 0, 521, 522, 5, 115, 0, 0, 522, 523, 5, 101, 0, 0, 523, 74, 1, 0, 0, 0, 524, 525, 5, 117, 0, 0, 525, 526, 5, 56, 0, 0, 526, 76, 1, 0, 0, 0, 527, 528, 5, 117, 0, 0, 528, 529, 5, 49, 0, 0, 529, 530, 5, 54, 0, 0, 530, 78, 1, 0, 0, 0, 531, 532, 5, 117, 0, 0, 532, 533, 5, 54, 0, 0, 533, 534, 5, 52, 0, 0, 534, 80, 1, 0, 0, 0, 535, 536, 5, 117, 0, 0, 536, 537, 5, 49, 0, 0, 537, 538, 5, 50, 0, 0, 538, 539, 5, 56, 0, 0, 539, 82, 1, 0, 0, 0, 540, 541, 5, 105, 0, 0, 541, 542, 5, 56, 0, 0, 542, 84, 1, 0, 0, 0, 543, 544, 5, 105, 0, 0, 544, 545, 5, 49, 0, 0, 545, 546, 5, 54, 0, 0, 546, 86, 1, 0, 0, 0, 547, 548, 5, 105, 0, 0, 548, 549, 5, 51, 0, 0, 549, 550, 5, 50, 0, 0, 550, 88, 1, 0, 0, 0, 551, 552, 5, 105, 0, 0, 552, 553, 5, 54, 0, 0, 553, 554, 5, 52, 0, 0, 554, 90, 1, 0, 0, 0, 555, 556, 5, 105, 0, 0, 556, 557, 5, 49, 0, 0, 557, 558, 5, 50, 0, 0, 558, 559, 5, 56, 0, 0, 559, 92, 1, 0, 0, 0, 560, 561, 5, 102, 0, 0, 561, 562, 5, 105, 0, 0, 562, 563, 5, 101, 0, 0, 563, 564, 5, 108, 0, 0, 564, 565, 5, 100, 0, 0, 565, 94, 1, 0, 0, 0, 566, 567, 5, 103, 0, 0, 567, 568, 5, 114, 0, 0, 568, 569, 5, 111, 0, 0, 569, 570, 5, 117, 0, 0, 570, 571, 5, 112, 0, 0, 571, 96, 1, 0, 0, 0, 572, 573, 5, 115, 0, 0, 573, 574, 5, 99, 0, 0, 574, 575, 5, 97, 0, 0, 575, 576, 5, 108, 0, 0, 576, 577, 5, 97, 0, 0, 577, 578, 5, 114, 0, 0, 578, 98, 1, 0, 0, 0, 579, 580, 5, 97, 0, 0, 580, 581, 5, 100, 0, 0, 581, 582, 5, 100, 0, 0, 582, 583, 5, 114, 0, 0, 583, 584, 5, 101, 0, 0, 584, 585, 5, 115, 0, 0, 585, 586, 5, 115, 0, 0, 586, 100, 1, 0, 0, 0, 587, 588, 5, 98, 0, 0, 588, 589, 5, 111, 0, 0, 589, 590, 5, 111, 0, 0, 590, 591, 5, 108, 0, 0, 591, 592, 5, 101, 0, 0, 592, 593, 5, 97, 0, 0, 593, 594, 5, 110, 0, 0, 594, 102, 1, 0, 0, 0, 595, 596, 5, 115, 0, 0, 596, 597, 5, 105, 0, 0, 597, 598, 5, 103, 0, 0, 598, 599, 5, 110, 0, 0, 599, 600, 5, 97, 0, 0, 600, 601, 5, 116, 0, 0, 601, 602, 5, 117, 0, 0, 602, 603, 5, 114, 0, 0, 603, 604, 5, 101, 0, 0, 604, 104, 1, 0, 0, 0, 605, 606, 5, 46, 0, 0, 606, 607, 5, 99, 0, 0, 607, 608, 5, 111, 0, 0, 608, 609, 5, 110, 0, 0, 609, 610, 5, 115, 0, 0, 610, 611, 5, 116, 0, 0, 611, 612, 5, 97, 0, 0, 612, 613, 5, 110, 0, 0, 613, 614, 5, 116, 0, 0, 614, 106, 1, 0, 0, 0, 615, 616, 5, 46, 0, 0, 616, 617, 5, 112, 0, 0, 617, 618, 5, 117, 0, 0, 618, 619, 5, 98, 0, 0, 619, 620, 5, 108, 0, 0, 620, 621, 5, 105, 0, 0, 621, 622, 5, 99, 0, 0, 622, 108, 1, 0, 0, 0, 623, 624, 5, 46, 0, 0, 624, 625, 5, 112, 0, 0, 625, 626, 5, 114, 0, 0, 626, 627, 5, 105, 0, 0, 627, 628, 5, 118, 0, 0, 628, 629, 5, 97, 0, 0, 629, 630, 5, 116, 0, 0, 630, 631, 5, 101, 0, 0, 631, 110, 1, 0, 0, 0, 632, 633, 5, 46, 0, 0, 633, 634, 5, 114, 0, 0, 634, 635, 5, 101, 0, 0, 635, 636, 5, 99, 0, 0, 636, 637, 5, 111, 0, 0, 637, 638, 5, 114, 0, 0, 638, 639, 5, 100, 0, 0, 639, 112, 1, 0, 0, 0, 640, 641, 5, 46, 0, 0, 641, 642, 5, 102, 0, 0, 642, 643, 5, 117, 0, 0, 643, 644, 5, 116, 0, 0, 644, 645, 5, 117, 0, 0, 645, 646, 5, 114, 0, 0, 646, 647, 5, 101, 0, 0, 647, 114, 1, 0, 0, 0, 648, 649, 5, 46, 0, 0, 649, 116, 1, 0, 0, 0, 650, 651, 5, 103, 0, 0, 651, 652, 5, 114, 0, 0, 652, 653, 5, 111, 0, 0, 653, 654, 5, 117, 0, 0, 654, 655, 5, 112, 0, 0, 655, 656, 5, 58, 0, 0, 656, 657, 5, 58, 0, 0, 657, 658, 5, 71, 0, 0, 658, 659, 5, 69, 0, 0, 659, 660, 5, 78, 0, 0, 660, 118, 1, 0, 0, 0, 661, 662, 5, 115, 0, 0, 662, 663, 5, 101, 0, 0, 663, 664, 5, 108, 0, 0, 664, 665, 5, 102, 0, 0, 665, 666, 5, 46, 0, 0, 666, 667, 5, 115, 0, 0, 667, 668, 5, 105, 0, 0, 668, 669, 5, 103, 0, 0, 669, 670, 5, 110, 0, 0, 670, 671, 5, 101, 0, 0, 671, 672, 5, 114, 0, 0, 672, 120, 1, 0, 0, 0, 673, 674, 5, 115, 0, 0, 674, 675, 5, 101, 0, 0, 675, 676, 5, 108, 0, 0, 676, 677, 5, 102, 0, 0, 677, 678, 5, 46, 0, 0, 678, 679, 5, 99, 0, 0, 679, 680, 5, 97, 0, 0, 680, 681, 5, 108, 0, 0, 681, 682, 5, 108, 0, 0, 682, 683, 5, 101, 0, 0, 683, 684, 5, 114, 0, 0, 684, 122, 1, 0, 0, 0, 685, 686, 5, 98, 0, 0, 686, 687, 5, 108, 0, 0, 687, 688, 5, 111, 0, 0, 688, 689, 5, 99, 0, 0, 689, 690, 5, 107, 0, 0, 690, 691, 5, 46, 0, 0, 691, 692, 5, 104, 0, 0, 692, 693, 5, 101, 0, 0, 693, 694, 5, 105, 0, 0, 694, 695, 5, 103, 0, 0, 695, 696, 5, 104, 0, 0, 696, 697, 5, 116, 0, 0, 697, 124, 1, 0, 0, 0, 698, 699, 5, 47, 0, 0, 699, 126, 1, 0, 0, 0, 700, 701, 5, 103, 0, 0, 701, 702, 5, 114, 0, 0, 702, 703, 5, 111, 0, 0, 703, 704, 5, 117, 0, 0, 704, 705, 5, 112, 0, 0, 705, 706, 5, 46, 0, 0, 706, 707, 5, 120, 0, 0, 707, 128, 1, 0, 0, 0, 708, 709, 5, 103, 0, 0, 709, 710, 5, 114, 0, 0, 710, 711, 5, 111, 0, 0, 711, 712, 5, 117, 0, 0, 712, 713, 5, 112, 0, 0, 713, 714, 5, 46, 0, 0, 714, 715, 5, 121, 0, 0, 715, 130, 1, 0, 0, 0, 716, 717, 5, 97, 0, 0, 717, 718, 5, 98, 0, 0, 718, 719, 5, 115, 0, 0, 719, 132, 1, 0, 0, 0, 720, 721, 5, 97, 0, 0, 721, 722, 5, 98, 0, 0, 722, 723, 5, 115, 0, 0, 723, 724, 5, 46, 0, 0, 724, 725, 5, 119, 0, 0, 725, 134, 1, 0, 0, 0, 726, 727, 5, 100, 0, 0, 727, 728, 5, 111, 0, 0, 728, 729, 5, 117, 0, 0, 729, 730, 5, 98, 0, 0, 730, 731, 5, 108, 0, 0, 731, 732, 5, 101, 0, 0, 732, 136, 1, 0, 0, 0, 733, 734, 5, 105, 0, 0, 734, 735, 5, 110, 0, 0, 735, 736, 5, 118, 0, 0, 736, 138, 1, 0, 0, 0, 737, 738, 5, 110, 0, 0, 738, 739, 5, 101, 0, 0, 739, 740, 5, 103, 0, 0, 740, 140, 1, 0, 0, 0, 741, 742, 5, 110, 0, 0, 742, 743, 5, 111, 0, 0, 743, 744, 5, 116, 0, 0, 744, 142, 1, 0, 0, 0, 745, 746, 5, 115, 0, 0, 746, 747, 5, 113, 0, 0, 747, 748, 5, 117, 0, 0, 748, 749, 5, 97, 0, 0, 749, 750, 5, 114, 0, 0, 750, 751, 5, 101, 0, 0, 751, 144, 1, 0, 0, 0, 752, 753, 5, 115, 0, 0, 753, 754, 5, 113, 0, 0, 754, 755, 5, 114, 0, 0, 755, 756, 5, 116, 0, 0, 756, 146, 1, 0, 0, 0, 757, 758, 5, 97, 0, 0, 758, 759, 5, 100, 0, 0, 759, 760, 5, 100, 0, 0, 760, 148, 1, 0, 0, 0, 761, 762, 5, 97, 0, 0, 762, 763, 5, 100, 0, 0, 763, 764, 5, 100, 0, 0, 764, 765, 5, 46, 0, 0, 765, 766, 5, 119, 0, 0, 766, 150, 1, 0, 0, 0, 767, 768, 5, 115, 0, 0, 768, 769, 5, 117, 0, 0, 769, 770, 5, 98, 0, 0, 770, 152, 1, 0, 0, 0, 771, 772, 5, 115, 0, 0, 772, 773, 5, 117, 0, 0, 773, 774, 5, 98, 0, 0, 774, 775, 5, 46, 0, 0, 775, 776, 5, 119, 0, 0, 776, 154, 1, 0, 0, 0, 777, 778, 5, 109, 0, 0, 778, 779, 5, 117, 0, 0, 779, 780, 5, 108, 0, 0, 780, 156, 1, 0, 0, 0, 781, 782, 5, 109, 0, 0, 782, 783, 5, 117, 0, 0, 783, 784, 5, 108, 0, 0, 784, 785, 5, 46, 0, 0, 785, 786, 5, 119, 0, 0, 786, 158, 1, 0, 0, 0, 787, 788, 5, 100, 0, 0, 788, 789, 5, 105, 0, 0, 789, 790, 5, 118, 0, 0, 790, 160, 1, 0, 0, 0, 791, 792, 5, 100, 0, 0, 792, 793, 5, 105, 0, 0, 793, 794, 5, 118, 0, 0, 794, 795, 5, 46, 0, 0, 795, 796, 5, 119, 0, 0, 796, 162, 1, 0, 0, 0, 797, 798, 5, 114, 0, 0, 798, 799, 5, 101, 0, 0, 799, 800, 5, 109, 0, 0, 800, 164, 1, 0, 0, 0, 801, 802, 5, 114, 0, 0, 802, 803, 5, 101, 0, 0, 803, 804, 5, 109, 0, 0, 804, 805, 5, 46, 0, 0, 805, 806, 5, 119, 0, 0, 806, 166, 1, 0, 0, 0, 807, 808, 5, 112, 0, 0, 808, 809, 5, 111, 0, 0, 809, 810, 5, 119, 0, 0, 810, 168, 1, 0, 0, 0, 811, 812, 5, 112, 0, 0, 812, 813, 5, 111, 0, 0, 813, 814, 5, 119, 0, 0, 814, 815, 5, 46, 0, 0, 815, 816, 5, 119, 0, 0, 816, 170, 1, 0, 0, 0, 817, 818, 5, 115, 0, 0, 818, 819, 5, 104, 0, 0, 819, 820, 5, 108, 0, 0, 820, 172, 1, 0, 0, 0, 821, 822, 5, 115, 0, 0, 822, 823, 5, 104, 0, 0, 823, 824, 5, 108, 0, 0, 824, 825, 5, 46, 0, 0, 825, 826, 5, 119, 0, 0, 826, 174, 1, 0, 0, 0, 827, 828, 5, 115, 0, 0, 828, 829, 5, 104, 0, 0, 829, 830, 5, 114, 0, 0, 830, 176, 1, 0, 0, 0, 831, 832, 5, 115, 0, 0, 832, 833, 5, 104, 0, 0, 833, 834, 5, 114, 0, 0, 834, 835, 5, 46, 0, 0, 835, 836, 5, 119, 0, 0, 836, 178, 1, 0, 0, 0, 837, 838, 5, 109, 0, 0, 838, 839, 5, 111, 0, 0, 839, 840, 5, 100, 0, 0, 840, 180, 1, 0, 0, 0, 841, 842, 5, 97, 0, 0, 842, 843, 5, 110, 0, 0, 843, 844, 5, 100, 0, 0, 844, 182, 1, 0, 0, 0, 845, 846, 5, 111, 0, 0, 846, 847, 5, 114, 0, 0, 847, 184, 1, 0, 0, 0, 848, 849, 5, 120, 0, 0, 849, 850, 5, 111, 0, 0, 850, 851, 5, 114, 0, 0, 851, 186, 1, 0, 0, 0, 852, 853, 5, 110, 0, 0, 853, 854, 5, 97, 0, 0, 854, 855, 5, 110, 0, 0, 855, 856, 5, 100, 0, 0, 856, 188, 1, 0, 0, 0, 857, 858, 5, 110, 0, 0, 858, 859, 5, 111, 0, 0, 859, 860, 5, 114, 0, 0, 860, 190, 1, 0, 0, 0, 861, 862, 5, 103, 0, 0, 862, 863, 5, 116, 0, 0, 863, 192, 1, 0, 0, 0, 864, 865, 5, 103, 0, 0, 865, 866, 5, 116, 0, 0, 866, 867, 5, 101, 0, 0, 867, 194, 1, 0, 0, 0, 868, 869, 5, 108, 0, 0, 869, 870, 5, 116, 0, 0, 870, 196, 1, 0, 0, 0, 871, 872, 5, 108, 0, 0, 872, 873, 5, 116, 0, 0, 873, 874, 5, 101, 0, 0, 874, 198, 1, 0, 0, 0, 875, 876, 5, 105, 0, 0, 876, 877, 5, 115, 0, 0, 877, 878, 5, 46, 0, 0, 878, 879, 5, 101, 0, 0, 879, 880, 5, 113, 0, 0, 880, 200, 1, 0, 0, 0, 881, 882, 5, 105, 0, 0, 882, 883, 5, 115, 0, 0, 883, 884, 5, 46, 0, 0, 884, 885, 5, 110, 0, 0, 885, 886, 5, 101, 0, 0, 886, 887, 5, 113, 0, 0, 887, 202, 1, 0, 0, 0, 888, 889, 5, 97, 0, 0, 889, 890, 5, 115, 0, 0, 890, 891, 5, 115, 0, 0, 891, 892, 5, 101, 0, 0, 892, 893, 5, 114, 0, 0, 893, 894, 5, 116, 0, 0, 894, 895, 5, 46, 0, 0, 895, 896, 5, 101, 0, 0, 896, 897, 5, 113, 0, 0, 897, 204, 1, 0, 0, 0, 898, 899, 5, 97, 0, 0, 899, 900, 5, 115, 0, 0, 900, 901, 5, 115, 0, 0, 901, 902, 5, 101, 0, 0, 902, 903, 5, 114, 0, 0, 903, 904, 5, 116, 0, 0, 904, 905, 5, 46, 0, 0, 905, 906, 5, 110, 0, 0, 906, 907, 5, 101, 0, 0, 907, 908, 5, 113, 0, 0, 908, 206, 1, 0, 0, 0, 909, 910, 5, 99, 0, 0, 910, 911, 5, 111, 0, 0, 911, 912, 5, 109, 0, 0, 912, 913, 5, 109, 0, 0, 913, 914, 5, 105, 0, 0, 914, 915, 5, 116, 0, 0, 915, 916, 5, 46, 0, 0, 916, 917, 5, 98, 0, 0, 917, 918, 5, 104, 0, 0, 918, 919, 5, 112, 0, 0, 919, 920, 5, 50, 0, 0, 920, 921, 5, 53, 0, 0, 921, 922, 5, 54, 0, 0, 922, 208, 1, 0, 0, 0, 923, 924, 5, 99, 0, 0, 924, 925, 5, 111, 0, 0, 925, 926, 5, 109, 0, 0, 926, 927, 5, 109, 0, 0, 927, 928, 5, 105, 0, 0, 928, 929, 5, 116, 0, 0, 929, 930, 5, 46, 0, 0, 930, 931, 5, 98, 0, 0, 931, 932, 5, 104, 0, 0, 932, 933, 5, 112, 0, 0, 933, 934, 5, 53, 0, 0, 934, 935, 5, 49, 0, 0, 935, 936, 5, 50, 0, 0, 936, 210, 1, 0, 0, 0, 937, 938, 5, 99, 0, 0, 938, 939, 5, 111, 0, 0, 939, 940, 5, 109, 0, 0, 940, 941, 5, 109, 0, 0, 941, 942, 5, 105, 0, 0, 942, 943, 5, 116, 0, 0, 943, 944, 5, 46, 0, 0, 944, 945, 5, 98, 0, 0, 945, 946, 5, 104, 0, 0, 946, 947, 5, 112, 0, 0, 947, 948, 5, 55, 0, 0, 948, 949, 5, 54, 0, 0, 949, 950, 5, 56, 0, 0, 950, 212, 1, 0, 0, 0, 951, 952, 5, 99, 0, 0, 952, 953, 5, 111, 0, 0, 953, 954, 5, 109, 0, 0, 954, 955, 5, 109, 0, 0, 955, 956, 5, 105, 0, 0, 956, 957, 5, 116, 0, 0, 957, 958, 5, 46, 0, 0, 958, 959, 5, 98, 0, 0, 959, 960, 5, 104, 0, 0, 960, 961, 5, 112, 0, 0, 961, 962, 5, 49, 0, 0, 962, 963, 5, 48, 0, 0, 963, 964, 5, 50, 0, 0, 964, 965, 5, 52, 0, 0, 965, 214, 1, 0, 0, 0, 966, 967, 5, 99, 0, 0, 967, 968, 5, 111, 0, 0, 968, 969, 5, 109, 0, 0, 969, 970, 5, 109, 0, 0, 970, 971, 5, 105, 0, 0, 971, 972, 5, 116, 0, 0, 972, 973, 5, 46, 0, 0, 973, 974, 5, 112, 0, 0, 974, 975, 5, 101, 0, 0, 975, 976, 5, 100, 0, 0, 976, 977, 5, 54, 0, 0, 977, 978, 5, 52, 0, 0, 978, 216, 1, 0, 0, 0, 979, 980, 5, 99, 0, 0, 980, 981, 5, 111, 0, 0, 981, 982, 5, 109, 0, 0, 982, 983, 5, 109, 0, 0, 983, 984, 5, 105, 0, 0, 984, 985, 5, 116, 0, 0, 985, 986, 5, 46, 0, 0, 986, 987, 5, 112, 0, 0, 987, 988, 5, 101, 0, 0, 988, 989, 5, 100, 0, 0, 989, 990, 5, 49, 0, 0, 990, 991, 5, 50, 0, 0, 991, 992, 5, 56, 0, 0, 992, 218, 1, 0, 0, 0, 993, 994, 5, 104, 0, 0, 994, 995, 5, 97, 0, 0, 995, 996, 5, 115, 0, 0, 996, 997, 5, 104, 0, 0, 997, 998, 5, 46, 0, 0, 998, 999, 5, 98, 0, 0, 999, 1000, 5, 104, 0, 0, 1000, 1001, 5, 112, 0, 0, 1001, 1002, 5, 50, 0, 0, 1002, 1003, 5, 53, 0, 0, 1003, 1004, 5, 54, 0, 0, 1004, 220, 1, 0, 0, 0, 1005, 1006, 5, 104, 0, 0, 1006, 1007, 5, 97, 0, 0, 1007, 1008, 5, 115, 0, 0, 1008, 1009, 5, 104, 0, 0, 1009, 1010, 5, 46, 0, 0, 1010, 1011, 5, 98, 0, 0, 1011, 1012, 5, 104, 0, 0, 1012, 1013, 5, 112, 0, 0, 1013, 1014, 5, 53, 0, 0, 1014, 1015, 5, 49, 0, 0, 1015, 1016, 5, 50, 0, 0, 1016, 222, 1, 0, 0, 0, 1017, 1018, 5, 104, 0, 0, 1018, 1019, 5, 97, 0, 0, 1019, 1020, 5, 115, 0, 0, 1020, 1021, 5, 104, 0, 0, 1021, 1022, 5, 46, 0, 0, 1022, 1023, 5, 98, 0, 0, 1023, 1024, 5, 104, 0, 0, 1024, 1025, 5, 112, 0, 0, 1025, 1026, 5, 55, 0, 0, 1026, 1027, 5, 54, 0, 0, 1027, 1028, 5, 56, 0, 0, 1028, 224, 1, 0, 0, 0, 1029, 1030, 5, 104, 0, 0, 1030, 1031, 5, 97, 0, 0, 1031, 1032, 5, 115, 0, 0, 1032, 1033, 5, 104, 0, 0, 1033, 1034, 5, 46, 0, 0, 1034, 1035, 5, 98, 0, 0, 1035, 1036, 5, 104, 0, 0, 1036, 1037, 5, 112, 0, 0, 1037, 1038, 5, 49, 0, 0, 1038, 1039, 5, 48, 0, 0, 1039, 1040, 5, 50, 0, 0, 1040, 1041, 5, 52, 0, 0, 1041, 226, 1, 0, 0, 0, 1042, 1043, 5, 104, 0, 0, 1043, 1044, 5, 97, 0, 0, 1044, 1045, 5, 115, 0, 0, 1045, 1046, 5, 104, 0, 0, 1046, 1047, 5, 46, 0, 0, 1047, 1048, 5, 112, 0, 0, 1048, 1049, 5, 101, 0, 0, 1049, 1050, 5, 100, 0, 0, 1050, 1051, 5, 54, 0, 0, 1051, 1052, 5, 52, 0, 0, 1052, 228, 1, 0, 0, 0, 1053, 1054, 5, 104, 0, 0, 1054, 1055, 5, 97, 0, 0, 1055, 1056, 5, 115, 0, 0, 1056, 1057, 5, 104, 0, 0, 1057, 1058, 5, 46, 0, 0, 1058, 1059, 5, 112, 0, 0, 1059, 1060, 5, 101, 0, 0, 1060, 1061, 5, 100, 0, 0, 1061, 1062, 5, 49, 0, 0, 1062, 1063, 5, 50, 0, 0, 1063, 1064, 5, 56, 0, 0, 1064, 230, 1, 0, 0, 0, 1065, 1066, 5, 104, 0, 0, 1066, 1067, 5, 97, 0, 0, 1067, 1068, 5, 115, 0, 0, 1068, 1069, 5, 104, 0, 0, 1069, 1070, 5, 46, 0, 0, 1070, 1071, 5, 112, 0, 0, 1071, 1072, 5, 115, 0, 0, 1072, 1073, 5, 100, 0, 0, 1073, 1074, 5, 50, 0, 0, 1074, 232, 1, 0, 0, 0, 1075, 1076, 5, 104, 0, 0, 1076, 1077, 5, 97, 0, 0, 1077, 1078, 5, 115, 0, 0, 1078, 1079, 5, 104, 0, 0, 1079, 1080, 5, 46, 0, 0, 1080, 1081, 5, 112, 0, 0, 1081, 1082, 5, 115, 0, 0, 1082, 1083, 5, 100, 0, 0, 1083, 1084, 5, 52, 0, 0, 1084, 234, 1, 0, 0, 0, 1085, 1086, 5, 104, 0, 0, 1086, 1087, 5, 97, 0, 0, 1087, 1088, 5, 115, 0, 0, 1088, 1089, 5, 104, 0, 0, 1089, 1090, 5, 46, 0, 0, 1090, 1091, 5, 112, 0, 0, 1091, 1092, 5, 115, 0, 0, 1092, 1093, 5, 100, 0, 0, 1093, 1094, 5, 56, 0, 0, 1094, 236, 1, 0, 0, 0, 1095, 1096, 5, 104, 0, 0, 1096, 1097, 5, 97, 0, 0, 1097, 1098, 5, 115, 0, 0, 1098, 1099, 5, 104, 0, 0, 1099, 1100, 5, 46, 0, 0, 1100, 1101, 5, 107, 0, 0, 1101, 1102, 5, 101, 0, 0, 1102, 1103, 5, 99, 0, 0, 1103, 1104, 5, 99, 0, 0, 1104, 1105, 5, 97, 0, 0, 1105, 1106, 5, 107, 0, 0, 1106, 1107, 5, 50, 0, 0, 1107, 1108, 5, 53, 0, 0, 1108, 1109, 5, 54, 0, 0, 1109, 238, 1, 0, 0, 0, 1110, 1111, 5, 104, 0, 0, 1111, 1112, 5, 97, 0, 0, 1112, 1113, 5, 115, 0, 0, 1113, 1114, 5, 104, 0, 0, 1114, 1115, 5, 46, 0, 0, 1115, 1116, 5, 107, 0, 0, 1116, 1117, 5, 101, 0, 0, 1117, 1118, 5, 99, 0, 0, 1118, 1119, 5, 99, 0, 0, 1119, 1120, 5, 97, 0, 0, 1120, 1121, 5, 107, 0, 0, 1121, 1122, 5, 51, 0, 0, 1122, 1123, 5, 56, 0, 0, 1123, 1124, 5, 52, 0, 0, 1124, 240, 1, 0, 0, 0, 1125, 1126, 5, 104, 0, 0, 1126, 1127, 5, 97, 0, 0, 1127, 1128, 5, 115, 0, 0, 1128, 1129, 5, 104, 0, 0, 1129, 1130, 5, 46, 0, 0, 1130, 1131, 5, 107, 0, 0, 1131, 1132, 5, 101, 0, 0, 1132, 1133, 5, 99, 0, 0, 1133, 1134, 5, 99, 0, 0, 1134, 1135, 5, 97, 0, 0, 1135, 1136, 5, 107, 0, 0, 1136, 1137, 5, 53, 0, 0, 1137, 1138, 5, 49, 0, 0, 1138, 1139, 5, 50, 0, 0, 1139, 242, 1, 0, 0, 0, 1140, 1141, 5, 104, 0, 0, 1141, 1142, 5, 97, 0, 0, 1142, 1143, 5, 115, 0, 0, 1143, 1144, 5, 104, 0, 0, 1144, 1145, 5, 46, 0, 0, 1145, 1146, 5, 115, 0, 0, 1146, 1147, 5, 104, 0, 0, 1147, 1148, 5, 97, 0, 0, 1148, 1149, 5, 51, 0, 0, 1149, 1150, 5, 95, 0, 0, 1150, 1151, 5, 50, 0, 0, 1151, 1152, 5, 53, 0, 0, 1152, 1153, 5, 54, 0, 0, 1153, 244, 1, 0, 0, 0, 1154, 1155, 5, 104, 0, 0, 1155, 1156, 5, 97, 0, 0, 1156, 1157, 5, 115, 0, 0, 1157, 1158, 5, 104, 0, 0, 1158, 1159, 5, 46, 0, 0, 1159, 1160, 5, 115, 0, 0, 1160, 1161, 5, 104, 0, 0, 1161, 1162, 5, 97, 0, 0, 1162, 1163, 5, 51, 0, 0, 1163, 1164, 5, 95, 0, 0, 1164, 1165, 5, 51, 0, 0, 1165, 1166, 5, 56, 0, 0, 1166, 1167, 5, 52, 0, 0, 1167, 246, 1, 0, 0, 0, 1168, 1169, 5, 104, 0, 0, 1169, 1170, 5, 97, 0, 0, 1170, 1171, 5, 115, 0, 0, 1171, 1172, 5, 104, 0, 0, 1172, 1173, 5, 46, 0, 0, 1173, 1174, 5, 115, 0, 0, 1174, 1175, 5, 104, 0, 0, 1175, 1176, 5, 97, 0, 0, 1176, 1177, 5, 51, 0, 0, 1177, 1178, 5, 95, 0, 0, 1178, 1179, 5, 53, 0, 0, 1179, 1180, 5, 49, 0, 0, 1180, 1181, 5, 50, 0, 0, 1181, 248, 1, 0, 0, 0, 1182, 1183, 5, 104, 0, 0, 1183, 1184, 5, 97, 0, 0, 1184, 1185, 5, 115, 0, 0, 1185, 1186, 5, 104, 0, 0, 1186, 1187, 5, 95, 0, 0, 1187, 1188, 5, 109, 0, 0, 1188, 1189, 5, 97, 0, 0, 1189, 1190, 5, 110, 0, 0, 1190, 1191, 5, 121, 0, 0, 1191, 1192, 5, 46, 0, 0, 1192, 1193, 5, 112, 0, 0, 1193, 1194, 5, 115, 0, 0, 1194, 1195, 5, 100, 0, 0, 1195, 1196, 5, 50, 0, 0, 1196, 250, 1, 0, 0, 0, 1197, 1198, 5, 104, 0, 0, 1198, 1199, 5, 97, 0, 0, 1199, 1200, 5, 115, 0, 0, 1200, 1201, 5, 104, 0, 0, 1201, 1202, 5, 95, 0, 0, 1202, 1203, 5, 109, 0, 0, 1203, 1204, 5, 97, 0, 0, 1204, 1205, 5, 110, 0, 0, 1205, 1206, 5, 121, 0, 0, 1206, 1207, 5, 46, 0, 0, 1207, 1208, 5, 112, 0, 0, 1208, 1209, 5, 115, 0, 0, 1209, 1210, 5, 100, 0, 0, 1210, 1211, 5, 52, 0, 0, 1211, 252, 1, 0, 0, 0, 1212, 1213, 5, 104, 0, 0, 1213, 1214, 5, 97, 0, 0, 1214, 1215, 5, 115, 0, 0, 1215, 1216, 5, 104, 0, 0, 1216, 1217, 5, 95, 0, 0, 1217, 1218, 5, 109, 0, 0, 1218, 1219, 5, 97, 0, 0, 1219, 1220, 5, 110, 0, 0, 1220, 1221, 5, 121, 0, 0, 1221, 1222, 5, 46, 0, 0, 1222, 1223, 5, 112, 0, 0, 1223, 1224, 5, 115, 0, 0, 1224, 1225, 5, 100, 0, 0, 1225, 1226, 5, 56, 0, 0, 1226, 254, 1, 0, 0, 0, 1227, 1228, 5, 99, 0, 0, 1228, 1229, 5, 97, 0, 0, 1229, 1230, 5, 115, 0, 0, 1230, 1231, 5, 116, 0, 0, 1231, 1232, 5, 46, 0, 0, 1232, 1233, 5, 108, 0, 0, 1233, 1234, 5, 111, 0, 0, 1234, 1235, 5, 115, 0, 0, 1235, 1236, 5, 115, 0, 0, 1236, 1237, 5, 121, 0, 0, 1237, 256, 1, 0, 0, 0, 1238, 1239, 5, 99, 0, 0, 1239, 1240, 5, 97, 0, 0, 1240, 1241, 5, 115, 0, 0, 1241, 1242, 5, 116, 0, 0, 1242, 258, 1, 0, 0, 0, 1243, 1244, 5, 98, 0, 0, 1244, 1245, 5, 114, 0, 0, 1245, 1246, 5, 97, 0, 0, 1246, 1247, 5, 110, 0, 0, 1247, 1248, 5, 99, 0, 0, 1248, 1249, 5, 104, 0, 0, 1249, 1250, 5, 46, 0, 0, 1250, 1251, 5, 101, 0, 0, 1251, 1252, 5, 113, 0, 0, 1252, 260, 1, 0, 0, 0, 1253, 1254, 5, 98, 0, 0, 1254, 1255, 5, 114, 0, 0, 1255, 1256, 5, 97, 0, 0, 1256, 1257, 5, 110, 0, 0, 1257, 1258, 5, 99, 0, 0, 1258, 1259, 5, 104, 0, 0, 1259, 1260, 5, 46, 0, 0, 1260, 1261, 5, 110, 0, 0, 1261, 1262, 5, 101, 0, 0, 1262, 1263, 5, 113, 0, 0, 1263, 262, 1, 0, 0, 0, 1264, 1265, 5, 97, 0, 0, 1265, 1266, 5, 108, 0, 0, 1266, 1267, 5, 101, 0, 0, 1267, 1268, 5, 111, 0, 0, 1268, 1269, 5, 49, 0, 0, 1269, 1277, 1, 0, 0, 0, 1270, 1274, 3, 267, 133, 0, 1271, 1273, 5, 95, 0, 0, 1272, 1271, 1, 0, 0, 0, 1273, 1276, 1, 0, 0, 0, 1274, 1272, 1, 0, 0, 0, 1274, 1275, 1, 0, 0, 0, 1275, 1278, 1, 0, 0, 0, 1276, 1274, 1, 0, 0, 0, 1277, 1270, 1, 0, 0, 0, 1278, 1279, 1, 0, 0, 0, 1279, 1277, 1, 0, 0, 0, 1279, 1280, 1, 0, 0, 0, 1280, 264, 1, 0, 0, 0, 1281, 1282, 5, 115, 0, 0, 1282, 1283, 5, 105, 0, 0, 1283, 1284, 5, 103, 0, 0, 1284, 1285, 5, 110, 0, 0, 1285, 1286, 5, 49, 0, 0, 1286, 1294, 1, 0, 0, 0, 1287, 1291, 3, 267, 133, 0, 1288, 1290, 5, 95, 0, 0, 1289, 1288, 1, 0, 0, 0, 1290, 1293, 1, 0, 0, 0, 1291, 1289, 1, 0, 0, 0, 1291, 1292, 1, 0, 0, 0, 1292, 1295, 1, 0, 0, 0, 1293, 1291, 1, 0, 0, 0, 1294, 1287, 1, 0, 0, 0, 1295, 1296, 1, 0, 0, 0, 1296, 1294, 1, 0, 0, 0, 1296, 1297, 1, 0, 0, 0, 1297, 266, 1, 0, 0, 0, 1298, 1301, 3, 277, 138, 0, 1299, 1301, 3, 285, 142, 0, 1300, 1298, 1, 0, 0, 0, 1300, 1299, 1, 0, 0, 0, 1301, 268, 1, 0, 0, 0, 1302, 1304, 5, 114, 0, 0, 1303, 1305, 3, 283, 141, 0, 1304, 1303, 1, 0, 0, 0, 1305, 1306, 1, 0, 0, 0, 1306, 1304, 1, 0, 0, 0, 1306, 1307, 1, 0, 0, 0, 1307, 270, 1, 0, 0, 0, 1308, 1314, 3, 273, 136, 0, 1309, 1313, 3, 273, 136, 0, 1310, 1313, 3, 283, 141, 0, 1311, 1313, 5, 95, 0, 0, 1312, 1309, 1, 0, 0, 0, 1312, 1310, 1, 0, 0, 0, 1312, 1311, 1, 0, 0, 0, 1313, 1316, 1, 0, 0, 0, 1314, 1312, 1, 0, 0, 0, 1314, 1315, 1, 0, 0, 0, 1315, 272, 1, 0, 0, 0, 1316, 1314, 1, 0, 0, 0, 1317, 1320, 3, 275, 137, 0, 1318, 1320, 3, 281, 140, 0, 1319, 1317, 1, 0, 0, 0, 1319, 1318, 1, 0, 0, 0, 1320, 274, 1, 0, 0, 0, 1321, 1324, 3, 277, 138, 0, 1322, 1324, 3, 279, 139, 0, 1323, 1321, 1, 0, 0, 0, 1323, 1322, 1, 0, 0, 0, 1324, 276, 1, 0, 0, 0, 1325, 1326, 7, 0, 0, 0, 1326, 278, 1, 0, 0, 0, 1327, 1328, 7, 1, 0, 0, 1328, 280, 1, 0, 0, 0, 1329, 1330, 7, 2, 0, 0, 1330, 282, 1, 0, 0, 0, 1331, 1334, 3, 285, 142, 0, 1332, 1334, 3, 287, 143, 0, 1333, 1331, 1, 0, 0, 0, 1333, 1332, 1, 0, 0, 0, 1334, 284, 1, 0, 0, 0, 1335, 1336, 7, 3, 0, 0, 1336, 286, 1, 0, 0, 0, 1337, 1338, 5, 49, 0, 0, 1338, 288, 1, 0, 0, 0, 1339, 1341, 7, 4, 0, 0, 1340, 1339, 1, 0, 0, 0, 1341, 1342, 1, 0, 0, 0, 1342, 1340, 1, 0, 0, 0, 1342, 1343, 1, 0, 0, 0, 1343, 1344, 1, 0, 0, 0, 1344, 1345, 6, 144, 0, 0, 1345, 290, 1, 0, 0, 0, 1346, 1347, 5, 47, 0, 0, 1347, 1348, 5, 42, 0, 0, 1348, 1352, 1, 0, 0, 0, 1349, 1351, 9, 0, 0, 0, 1350, 1349, 1, 0, 0, 0, 1351, 1354, 1, 0, 0, 0, 1352, 1353, 1, 0, 0, 0, 1352, 1350, 1, 0, 0, 0, 1353, 1355, 1, 0, 0, 0, 1354, 1352, 1, 0, 0, 0, 1355, 1356, 5, 42, 0, 0, 1356, 1357, 5, 47, 0, 0, 1357, 1358, 1, 0, 0, 0, 1358, 1359, 6, 145, 1, 0, 1359, 292, 1, 0, 0, 0, 1360, 1361, 5, 47, 0, 0, 1361, 1362, 5, 47, 0, 0, 1362, 1366, 1, 0, 0, 0, 1363, 1365, 8, 5, 0, 0, 1364, 1363, 1, 0, 0, 0, 1365, 1368, 1, 0, 0, 0, 1366, 1364, 1, 0, 0, 0, 1366, 1367, 1, 0, 0, 0, 1367, 1369, 1, 0, 0, 0, 1368, 1366, 1, 0, 0, 0, 1369, 1370, 6, 146, 1, 0, 1370, 294, 1, 0, 0, 0, 15, 0, 1274, 1279, 1291, 1296, 1300, 1306, 1312, 1314, 1319, 1323, 1333, 1342, 1352, 1366, 2, 6, 0, 0, 0, 1, 0] \ No newline at end of file diff --git a/vanguard/aleo/parser/AleoLexer.py b/vanguard/aleo/parser/AleoLexer.py new file mode 100644 index 0000000..312e9a8 --- /dev/null +++ b/vanguard/aleo/parser/AleoLexer.py @@ -0,0 +1,734 @@ +# Generated from ./Aleo.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,139,1371,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,1,0, + 1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,2,1,2,1,2,1,2,1,2,1,2,1,2, + 1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,4,1,4,1,5,1,5,1,5,1,5,1,6,1,6, + 1,6,1,7,1,7,1,7,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,9,1,9, + 1,9,1,9,1,9,1,9,1,9,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,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,13,1,14,1,14,1,14,1,14,1,14, + 1,14,1,14,1,14,1,14,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15, + 1,16,1,16,1,17,1,17,1,18,1,18,1,18,1,18,1,18,1,19,1,19,1,19,1,19, + 1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,21,1,21, + 1,21,1,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,23,1,23,1,23,1,23, + 1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,24,1,24,1,24,1,24,1,24, + 1,24,1,24,1,24,1,24,1,25,1,25,1,25,1,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,28,1,28,1,28,1,28,1,28, + 1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,29,1,29,1,29,1,29,1,29,1,29, + 1,29,1,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,32,1,32,1,33,1,33,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,36,1,37,1,37,1,37, + 1,38,1,38,1,38,1,38,1,39,1,39,1,39,1,39,1,40,1,40,1,40,1,40,1,40, + 1,41,1,41,1,41,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,45,1,45,1,45,1,45,1,45,1,46,1,46,1,46,1,46,1,46,1,46, + 1,47,1,47,1,47,1,47,1,47,1,47,1,48,1,48,1,48,1,48,1,48,1,48,1,48, + 1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,49,1,50,1,50,1,50,1,50,1,50, + 1,50,1,50,1,50,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51, + 1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,53,1,53,1,53, + 1,53,1,53,1,53,1,53,1,53,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54, + 1,54,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56, + 1,56,1,56,1,56,1,56,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,59, + 1,59,1,59,1,59,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60, + 1,60,1,60,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61, + 1,61,1,61,1,62,1,62,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,64, + 1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,65,1,65,1,65,1,65,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,67,1,68,1,68, + 1,68,1,68,1,69,1,69,1,69,1,69,1,70,1,70,1,70,1,70,1,71,1,71,1,71, + 1,71,1,71,1,71,1,71,1,72,1,72,1,72,1,72,1,72,1,73,1,73,1,73,1,73, + 1,74,1,74,1,74,1,74,1,74,1,74,1,75,1,75,1,75,1,75,1,76,1,76,1,76, + 1,76,1,76,1,76,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,80,1,80,1,80,1,80,1,80,1,80,1,81,1,81,1,81, + 1,81,1,82,1,82,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,84,1,85,1,85,1,85,1,85,1,86,1,86,1,86,1,86,1,86, + 1,86,1,87,1,87,1,87,1,87,1,88,1,88,1,88,1,88,1,88,1,88,1,89,1,89, + 1,89,1,89,1,90,1,90,1,90,1,90,1,91,1,91,1,91,1,92,1,92,1,92,1,92, + 1,93,1,93,1,93,1,93,1,93,1,94,1,94,1,94,1,94,1,95,1,95,1,95,1,96, + 1,96,1,96,1,96,1,97,1,97,1,97,1,98,1,98,1,98,1,98,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,102,1,102,1,102,1,102,1,102,1,102,1,102,1,103,1,103, + 1,103,1,103,1,103,1,103,1,103,1,103,1,103,1,103,1,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,1,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,1,105,1,106,1,106,1,106,1,106, + 1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106, + 1,107,1,107,1,107,1,107,1,107,1,107,1,107,1,107,1,107,1,107,1,107, + 1,107,1,107,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108, + 1,108,1,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,110,1,110,1,110,1,110,1,110, + 1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,111,1,111,1,111,1,111, + 1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,112,1,112,1,112, + 1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,113, + 1,113,1,113,1,113,1,113,1,113,1,113,1,113,1,113,1,113,1,113,1,114, + 1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114, + 1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,116, + 1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,117,1,117, + 1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,117,1,118,1,118,1,118, + 1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,118, + 1,118,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119,1,119, + 1,119,1,119,1,119,1,119,1,119,1,120,1,120,1,120,1,120,1,120,1,120, + 1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,121,1,121, + 1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,121, + 1,121,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,123,1,123,1,123,1,123,1,123,1,123,1,123, + 1,123,1,123,1,123,1,123,1,123,1,123,1,123,1,124,1,124,1,124,1,124, + 1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,124, + 1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,125, + 1,125,1,125,1,125,1,125,1,126,1,126,1,126,1,126,1,126,1,126,1,126, + 1,126,1,126,1,126,1,126,1,126,1,126,1,126,1,126,1,127,1,127,1,127, + 1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,128,1,128,1,128, + 1,128,1,128,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129, + 1,129,1,130,1,130,1,130,1,130,1,130,1,130,1,130,1,130,1,130,1,130, + 1,130,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,5,131,1273, + 8,131,10,131,12,131,1276,9,131,4,131,1278,8,131,11,131,12,131,1279, + 1,132,1,132,1,132,1,132,1,132,1,132,1,132,1,132,5,132,1290,8,132, + 10,132,12,132,1293,9,132,4,132,1295,8,132,11,132,12,132,1296,1,133, + 1,133,3,133,1301,8,133,1,134,1,134,4,134,1305,8,134,11,134,12,134, + 1306,1,135,1,135,1,135,1,135,5,135,1313,8,135,10,135,12,135,1316, + 9,135,1,136,1,136,3,136,1320,8,136,1,137,1,137,3,137,1324,8,137, + 1,138,1,138,1,139,1,139,1,140,1,140,1,141,1,141,3,141,1334,8,141, + 1,142,1,142,1,143,1,143,1,144,4,144,1341,8,144,11,144,12,144,1342, + 1,144,1,144,1,145,1,145,1,145,1,145,5,145,1351,8,145,10,145,12,145, + 1354,9,145,1,145,1,145,1,145,1,145,1,145,1,146,1,146,1,146,1,146, + 5,146,1365,8,146,10,146,12,146,1368,9,146,1,146,1,146,1,1352,0,147, + 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,0,269,134,271, + 135,273,0,275,0,277,0,279,0,281,0,283,136,285,0,287,0,289,137,291, + 138,293,139,1,0,6,4,0,97,97,99,104,106,110,112,122,3,0,98,98,105, + 105,111,111,1,0,65,90,2,0,48,48,50,57,3,0,9,10,12,13,32,32,2,0,10, + 10,13,13,1377,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,269,1,0,0,0,0,271,1,0,0,0,0,283,1,0,0,0,0,289,1, + 0,0,0,0,291,1,0,0,0,0,293,1,0,0,0,1,295,1,0,0,0,3,303,1,0,0,0,5, + 305,1,0,0,0,7,312,1,0,0,0,9,320,1,0,0,0,11,322,1,0,0,0,13,326,1, + 0,0,0,15,329,1,0,0,0,17,335,1,0,0,0,19,342,1,0,0,0,21,349,1,0,0, + 0,23,357,1,0,0,0,25,363,1,0,0,0,27,370,1,0,0,0,29,379,1,0,0,0,31, + 388,1,0,0,0,33,397,1,0,0,0,35,399,1,0,0,0,37,401,1,0,0,0,39,406, + 1,0,0,0,41,410,1,0,0,0,43,421,1,0,0,0,45,425,1,0,0,0,47,432,1,0, + 0,0,49,444,1,0,0,0,51,453,1,0,0,0,53,456,1,0,0,0,55,462,1,0,0,0, + 57,470,1,0,0,0,59,482,1,0,0,0,61,494,1,0,0,0,63,499,1,0,0,0,65,505, + 1,0,0,0,67,507,1,0,0,0,69,509,1,0,0,0,71,513,1,0,0,0,73,518,1,0, + 0,0,75,524,1,0,0,0,77,527,1,0,0,0,79,531,1,0,0,0,81,535,1,0,0,0, + 83,540,1,0,0,0,85,543,1,0,0,0,87,547,1,0,0,0,89,551,1,0,0,0,91,555, + 1,0,0,0,93,560,1,0,0,0,95,566,1,0,0,0,97,572,1,0,0,0,99,579,1,0, + 0,0,101,587,1,0,0,0,103,595,1,0,0,0,105,605,1,0,0,0,107,615,1,0, + 0,0,109,623,1,0,0,0,111,632,1,0,0,0,113,640,1,0,0,0,115,648,1,0, + 0,0,117,650,1,0,0,0,119,661,1,0,0,0,121,673,1,0,0,0,123,685,1,0, + 0,0,125,698,1,0,0,0,127,700,1,0,0,0,129,708,1,0,0,0,131,716,1,0, + 0,0,133,720,1,0,0,0,135,726,1,0,0,0,137,733,1,0,0,0,139,737,1,0, + 0,0,141,741,1,0,0,0,143,745,1,0,0,0,145,752,1,0,0,0,147,757,1,0, + 0,0,149,761,1,0,0,0,151,767,1,0,0,0,153,771,1,0,0,0,155,777,1,0, + 0,0,157,781,1,0,0,0,159,787,1,0,0,0,161,791,1,0,0,0,163,797,1,0, + 0,0,165,801,1,0,0,0,167,807,1,0,0,0,169,811,1,0,0,0,171,817,1,0, + 0,0,173,821,1,0,0,0,175,827,1,0,0,0,177,831,1,0,0,0,179,837,1,0, + 0,0,181,841,1,0,0,0,183,845,1,0,0,0,185,848,1,0,0,0,187,852,1,0, + 0,0,189,857,1,0,0,0,191,861,1,0,0,0,193,864,1,0,0,0,195,868,1,0, + 0,0,197,871,1,0,0,0,199,875,1,0,0,0,201,881,1,0,0,0,203,888,1,0, + 0,0,205,898,1,0,0,0,207,909,1,0,0,0,209,923,1,0,0,0,211,937,1,0, + 0,0,213,951,1,0,0,0,215,966,1,0,0,0,217,979,1,0,0,0,219,993,1,0, + 0,0,221,1005,1,0,0,0,223,1017,1,0,0,0,225,1029,1,0,0,0,227,1042, + 1,0,0,0,229,1053,1,0,0,0,231,1065,1,0,0,0,233,1075,1,0,0,0,235,1085, + 1,0,0,0,237,1095,1,0,0,0,239,1110,1,0,0,0,241,1125,1,0,0,0,243,1140, + 1,0,0,0,245,1154,1,0,0,0,247,1168,1,0,0,0,249,1182,1,0,0,0,251,1197, + 1,0,0,0,253,1212,1,0,0,0,255,1227,1,0,0,0,257,1238,1,0,0,0,259,1243, + 1,0,0,0,261,1253,1,0,0,0,263,1264,1,0,0,0,265,1281,1,0,0,0,267,1300, + 1,0,0,0,269,1302,1,0,0,0,271,1308,1,0,0,0,273,1319,1,0,0,0,275,1323, + 1,0,0,0,277,1325,1,0,0,0,279,1327,1,0,0,0,281,1329,1,0,0,0,283,1333, + 1,0,0,0,285,1335,1,0,0,0,287,1337,1,0,0,0,289,1340,1,0,0,0,291,1346, + 1,0,0,0,293,1360,1,0,0,0,295,296,5,112,0,0,296,297,5,114,0,0,297, + 298,5,111,0,0,298,299,5,103,0,0,299,300,5,114,0,0,300,301,5,97,0, + 0,301,302,5,109,0,0,302,2,1,0,0,0,303,304,5,59,0,0,304,4,1,0,0,0, + 305,306,5,105,0,0,306,307,5,109,0,0,307,308,5,112,0,0,308,309,5, + 111,0,0,309,310,5,114,0,0,310,311,5,116,0,0,311,6,1,0,0,0,312,313, + 5,109,0,0,313,314,5,97,0,0,314,315,5,112,0,0,315,316,5,112,0,0,316, + 317,5,105,0,0,317,318,5,110,0,0,318,319,5,103,0,0,319,8,1,0,0,0, + 320,321,5,58,0,0,321,10,1,0,0,0,322,323,5,107,0,0,323,324,5,101, + 0,0,324,325,5,121,0,0,325,12,1,0,0,0,326,327,5,97,0,0,327,328,5, + 115,0,0,328,14,1,0,0,0,329,330,5,118,0,0,330,331,5,97,0,0,331,332, + 5,108,0,0,332,333,5,117,0,0,333,334,5,101,0,0,334,16,1,0,0,0,335, + 336,5,115,0,0,336,337,5,116,0,0,337,338,5,114,0,0,338,339,5,117, + 0,0,339,340,5,99,0,0,340,341,5,116,0,0,341,18,1,0,0,0,342,343,5, + 114,0,0,343,344,5,101,0,0,344,345,5,99,0,0,345,346,5,111,0,0,346, + 347,5,114,0,0,347,348,5,100,0,0,348,20,1,0,0,0,349,350,5,99,0,0, + 350,351,5,108,0,0,351,352,5,111,0,0,352,353,5,115,0,0,353,354,5, + 117,0,0,354,355,5,114,0,0,355,356,5,101,0,0,356,22,1,0,0,0,357,358, + 5,105,0,0,358,359,5,110,0,0,359,360,5,112,0,0,360,361,5,117,0,0, + 361,362,5,116,0,0,362,24,1,0,0,0,363,364,5,111,0,0,364,365,5,117, + 0,0,365,366,5,116,0,0,366,367,5,112,0,0,367,368,5,117,0,0,368,369, + 5,116,0,0,369,26,1,0,0,0,370,371,5,102,0,0,371,372,5,117,0,0,372, + 373,5,110,0,0,373,374,5,99,0,0,374,375,5,116,0,0,375,376,5,105,0, + 0,376,377,5,111,0,0,377,378,5,110,0,0,378,28,1,0,0,0,379,380,5,102, + 0,0,380,381,5,105,0,0,381,382,5,110,0,0,382,383,5,97,0,0,383,384, + 5,108,0,0,384,385,5,105,0,0,385,386,5,122,0,0,386,387,5,101,0,0, + 387,30,1,0,0,0,388,389,5,99,0,0,389,390,5,111,0,0,390,391,5,110, + 0,0,391,392,5,116,0,0,392,393,5,97,0,0,393,394,5,105,0,0,394,395, + 5,110,0,0,395,396,5,115,0,0,396,32,1,0,0,0,397,398,5,91,0,0,398, + 34,1,0,0,0,399,400,5,93,0,0,400,36,1,0,0,0,401,402,5,105,0,0,402, + 403,5,110,0,0,403,404,5,116,0,0,404,405,5,111,0,0,405,38,1,0,0,0, + 406,407,5,103,0,0,407,408,5,101,0,0,408,409,5,116,0,0,409,40,1,0, + 0,0,410,411,5,103,0,0,411,412,5,101,0,0,412,413,5,116,0,0,413,414, + 5,46,0,0,414,415,5,111,0,0,415,416,5,114,0,0,416,417,5,95,0,0,417, + 418,5,117,0,0,418,419,5,115,0,0,419,420,5,101,0,0,420,42,1,0,0,0, + 421,422,5,115,0,0,422,423,5,101,0,0,423,424,5,116,0,0,424,44,1,0, + 0,0,425,426,5,114,0,0,426,427,5,101,0,0,427,428,5,109,0,0,428,429, + 5,111,0,0,429,430,5,118,0,0,430,431,5,101,0,0,431,46,1,0,0,0,432, + 433,5,114,0,0,433,434,5,97,0,0,434,435,5,110,0,0,435,436,5,100,0, + 0,436,437,5,46,0,0,437,438,5,99,0,0,438,439,5,104,0,0,439,440,5, + 97,0,0,440,441,5,99,0,0,441,442,5,104,0,0,442,443,5,97,0,0,443,48, + 1,0,0,0,444,445,5,112,0,0,445,446,5,111,0,0,446,447,5,115,0,0,447, + 448,5,105,0,0,448,449,5,116,0,0,449,450,5,105,0,0,450,451,5,111, + 0,0,451,452,5,110,0,0,452,50,1,0,0,0,453,454,5,116,0,0,454,455,5, + 111,0,0,455,52,1,0,0,0,456,457,5,97,0,0,457,458,5,119,0,0,458,459, + 5,97,0,0,459,460,5,105,0,0,460,461,5,116,0,0,461,54,1,0,0,0,462, + 463,5,116,0,0,463,464,5,101,0,0,464,465,5,114,0,0,465,466,5,110, + 0,0,466,467,5,97,0,0,467,468,5,114,0,0,468,469,5,121,0,0,469,56, + 1,0,0,0,470,471,5,115,0,0,471,472,5,105,0,0,472,473,5,103,0,0,473, + 474,5,110,0,0,474,475,5,46,0,0,475,476,5,118,0,0,476,477,5,101,0, + 0,477,478,5,114,0,0,478,479,5,105,0,0,479,480,5,102,0,0,480,481, + 5,121,0,0,481,58,1,0,0,0,482,483,5,115,0,0,483,484,5,105,0,0,484, + 485,5,103,0,0,485,486,5,110,0,0,486,487,5,95,0,0,487,488,5,118,0, + 0,488,489,5,101,0,0,489,490,5,114,0,0,490,491,5,105,0,0,491,492, + 5,102,0,0,492,493,5,121,0,0,493,60,1,0,0,0,494,495,5,99,0,0,495, + 496,5,97,0,0,496,497,5,108,0,0,497,498,5,108,0,0,498,62,1,0,0,0, + 499,500,5,97,0,0,500,501,5,115,0,0,501,502,5,121,0,0,502,503,5,110, + 0,0,503,504,5,99,0,0,504,64,1,0,0,0,505,506,5,45,0,0,506,66,1,0, + 0,0,507,508,5,95,0,0,508,68,1,0,0,0,509,510,5,117,0,0,510,511,5, + 51,0,0,511,512,5,50,0,0,512,70,1,0,0,0,513,514,5,116,0,0,514,515, + 5,114,0,0,515,516,5,117,0,0,516,517,5,101,0,0,517,72,1,0,0,0,518, + 519,5,102,0,0,519,520,5,97,0,0,520,521,5,108,0,0,521,522,5,115,0, + 0,522,523,5,101,0,0,523,74,1,0,0,0,524,525,5,117,0,0,525,526,5,56, + 0,0,526,76,1,0,0,0,527,528,5,117,0,0,528,529,5,49,0,0,529,530,5, + 54,0,0,530,78,1,0,0,0,531,532,5,117,0,0,532,533,5,54,0,0,533,534, + 5,52,0,0,534,80,1,0,0,0,535,536,5,117,0,0,536,537,5,49,0,0,537,538, + 5,50,0,0,538,539,5,56,0,0,539,82,1,0,0,0,540,541,5,105,0,0,541,542, + 5,56,0,0,542,84,1,0,0,0,543,544,5,105,0,0,544,545,5,49,0,0,545,546, + 5,54,0,0,546,86,1,0,0,0,547,548,5,105,0,0,548,549,5,51,0,0,549,550, + 5,50,0,0,550,88,1,0,0,0,551,552,5,105,0,0,552,553,5,54,0,0,553,554, + 5,52,0,0,554,90,1,0,0,0,555,556,5,105,0,0,556,557,5,49,0,0,557,558, + 5,50,0,0,558,559,5,56,0,0,559,92,1,0,0,0,560,561,5,102,0,0,561,562, + 5,105,0,0,562,563,5,101,0,0,563,564,5,108,0,0,564,565,5,100,0,0, + 565,94,1,0,0,0,566,567,5,103,0,0,567,568,5,114,0,0,568,569,5,111, + 0,0,569,570,5,117,0,0,570,571,5,112,0,0,571,96,1,0,0,0,572,573,5, + 115,0,0,573,574,5,99,0,0,574,575,5,97,0,0,575,576,5,108,0,0,576, + 577,5,97,0,0,577,578,5,114,0,0,578,98,1,0,0,0,579,580,5,97,0,0,580, + 581,5,100,0,0,581,582,5,100,0,0,582,583,5,114,0,0,583,584,5,101, + 0,0,584,585,5,115,0,0,585,586,5,115,0,0,586,100,1,0,0,0,587,588, + 5,98,0,0,588,589,5,111,0,0,589,590,5,111,0,0,590,591,5,108,0,0,591, + 592,5,101,0,0,592,593,5,97,0,0,593,594,5,110,0,0,594,102,1,0,0,0, + 595,596,5,115,0,0,596,597,5,105,0,0,597,598,5,103,0,0,598,599,5, + 110,0,0,599,600,5,97,0,0,600,601,5,116,0,0,601,602,5,117,0,0,602, + 603,5,114,0,0,603,604,5,101,0,0,604,104,1,0,0,0,605,606,5,46,0,0, + 606,607,5,99,0,0,607,608,5,111,0,0,608,609,5,110,0,0,609,610,5,115, + 0,0,610,611,5,116,0,0,611,612,5,97,0,0,612,613,5,110,0,0,613,614, + 5,116,0,0,614,106,1,0,0,0,615,616,5,46,0,0,616,617,5,112,0,0,617, + 618,5,117,0,0,618,619,5,98,0,0,619,620,5,108,0,0,620,621,5,105,0, + 0,621,622,5,99,0,0,622,108,1,0,0,0,623,624,5,46,0,0,624,625,5,112, + 0,0,625,626,5,114,0,0,626,627,5,105,0,0,627,628,5,118,0,0,628,629, + 5,97,0,0,629,630,5,116,0,0,630,631,5,101,0,0,631,110,1,0,0,0,632, + 633,5,46,0,0,633,634,5,114,0,0,634,635,5,101,0,0,635,636,5,99,0, + 0,636,637,5,111,0,0,637,638,5,114,0,0,638,639,5,100,0,0,639,112, + 1,0,0,0,640,641,5,46,0,0,641,642,5,102,0,0,642,643,5,117,0,0,643, + 644,5,116,0,0,644,645,5,117,0,0,645,646,5,114,0,0,646,647,5,101, + 0,0,647,114,1,0,0,0,648,649,5,46,0,0,649,116,1,0,0,0,650,651,5,103, + 0,0,651,652,5,114,0,0,652,653,5,111,0,0,653,654,5,117,0,0,654,655, + 5,112,0,0,655,656,5,58,0,0,656,657,5,58,0,0,657,658,5,71,0,0,658, + 659,5,69,0,0,659,660,5,78,0,0,660,118,1,0,0,0,661,662,5,115,0,0, + 662,663,5,101,0,0,663,664,5,108,0,0,664,665,5,102,0,0,665,666,5, + 46,0,0,666,667,5,115,0,0,667,668,5,105,0,0,668,669,5,103,0,0,669, + 670,5,110,0,0,670,671,5,101,0,0,671,672,5,114,0,0,672,120,1,0,0, + 0,673,674,5,115,0,0,674,675,5,101,0,0,675,676,5,108,0,0,676,677, + 5,102,0,0,677,678,5,46,0,0,678,679,5,99,0,0,679,680,5,97,0,0,680, + 681,5,108,0,0,681,682,5,108,0,0,682,683,5,101,0,0,683,684,5,114, + 0,0,684,122,1,0,0,0,685,686,5,98,0,0,686,687,5,108,0,0,687,688,5, + 111,0,0,688,689,5,99,0,0,689,690,5,107,0,0,690,691,5,46,0,0,691, + 692,5,104,0,0,692,693,5,101,0,0,693,694,5,105,0,0,694,695,5,103, + 0,0,695,696,5,104,0,0,696,697,5,116,0,0,697,124,1,0,0,0,698,699, + 5,47,0,0,699,126,1,0,0,0,700,701,5,103,0,0,701,702,5,114,0,0,702, + 703,5,111,0,0,703,704,5,117,0,0,704,705,5,112,0,0,705,706,5,46,0, + 0,706,707,5,120,0,0,707,128,1,0,0,0,708,709,5,103,0,0,709,710,5, + 114,0,0,710,711,5,111,0,0,711,712,5,117,0,0,712,713,5,112,0,0,713, + 714,5,46,0,0,714,715,5,121,0,0,715,130,1,0,0,0,716,717,5,97,0,0, + 717,718,5,98,0,0,718,719,5,115,0,0,719,132,1,0,0,0,720,721,5,97, + 0,0,721,722,5,98,0,0,722,723,5,115,0,0,723,724,5,46,0,0,724,725, + 5,119,0,0,725,134,1,0,0,0,726,727,5,100,0,0,727,728,5,111,0,0,728, + 729,5,117,0,0,729,730,5,98,0,0,730,731,5,108,0,0,731,732,5,101,0, + 0,732,136,1,0,0,0,733,734,5,105,0,0,734,735,5,110,0,0,735,736,5, + 118,0,0,736,138,1,0,0,0,737,738,5,110,0,0,738,739,5,101,0,0,739, + 740,5,103,0,0,740,140,1,0,0,0,741,742,5,110,0,0,742,743,5,111,0, + 0,743,744,5,116,0,0,744,142,1,0,0,0,745,746,5,115,0,0,746,747,5, + 113,0,0,747,748,5,117,0,0,748,749,5,97,0,0,749,750,5,114,0,0,750, + 751,5,101,0,0,751,144,1,0,0,0,752,753,5,115,0,0,753,754,5,113,0, + 0,754,755,5,114,0,0,755,756,5,116,0,0,756,146,1,0,0,0,757,758,5, + 97,0,0,758,759,5,100,0,0,759,760,5,100,0,0,760,148,1,0,0,0,761,762, + 5,97,0,0,762,763,5,100,0,0,763,764,5,100,0,0,764,765,5,46,0,0,765, + 766,5,119,0,0,766,150,1,0,0,0,767,768,5,115,0,0,768,769,5,117,0, + 0,769,770,5,98,0,0,770,152,1,0,0,0,771,772,5,115,0,0,772,773,5,117, + 0,0,773,774,5,98,0,0,774,775,5,46,0,0,775,776,5,119,0,0,776,154, + 1,0,0,0,777,778,5,109,0,0,778,779,5,117,0,0,779,780,5,108,0,0,780, + 156,1,0,0,0,781,782,5,109,0,0,782,783,5,117,0,0,783,784,5,108,0, + 0,784,785,5,46,0,0,785,786,5,119,0,0,786,158,1,0,0,0,787,788,5,100, + 0,0,788,789,5,105,0,0,789,790,5,118,0,0,790,160,1,0,0,0,791,792, + 5,100,0,0,792,793,5,105,0,0,793,794,5,118,0,0,794,795,5,46,0,0,795, + 796,5,119,0,0,796,162,1,0,0,0,797,798,5,114,0,0,798,799,5,101,0, + 0,799,800,5,109,0,0,800,164,1,0,0,0,801,802,5,114,0,0,802,803,5, + 101,0,0,803,804,5,109,0,0,804,805,5,46,0,0,805,806,5,119,0,0,806, + 166,1,0,0,0,807,808,5,112,0,0,808,809,5,111,0,0,809,810,5,119,0, + 0,810,168,1,0,0,0,811,812,5,112,0,0,812,813,5,111,0,0,813,814,5, + 119,0,0,814,815,5,46,0,0,815,816,5,119,0,0,816,170,1,0,0,0,817,818, + 5,115,0,0,818,819,5,104,0,0,819,820,5,108,0,0,820,172,1,0,0,0,821, + 822,5,115,0,0,822,823,5,104,0,0,823,824,5,108,0,0,824,825,5,46,0, + 0,825,826,5,119,0,0,826,174,1,0,0,0,827,828,5,115,0,0,828,829,5, + 104,0,0,829,830,5,114,0,0,830,176,1,0,0,0,831,832,5,115,0,0,832, + 833,5,104,0,0,833,834,5,114,0,0,834,835,5,46,0,0,835,836,5,119,0, + 0,836,178,1,0,0,0,837,838,5,109,0,0,838,839,5,111,0,0,839,840,5, + 100,0,0,840,180,1,0,0,0,841,842,5,97,0,0,842,843,5,110,0,0,843,844, + 5,100,0,0,844,182,1,0,0,0,845,846,5,111,0,0,846,847,5,114,0,0,847, + 184,1,0,0,0,848,849,5,120,0,0,849,850,5,111,0,0,850,851,5,114,0, + 0,851,186,1,0,0,0,852,853,5,110,0,0,853,854,5,97,0,0,854,855,5,110, + 0,0,855,856,5,100,0,0,856,188,1,0,0,0,857,858,5,110,0,0,858,859, + 5,111,0,0,859,860,5,114,0,0,860,190,1,0,0,0,861,862,5,103,0,0,862, + 863,5,116,0,0,863,192,1,0,0,0,864,865,5,103,0,0,865,866,5,116,0, + 0,866,867,5,101,0,0,867,194,1,0,0,0,868,869,5,108,0,0,869,870,5, + 116,0,0,870,196,1,0,0,0,871,872,5,108,0,0,872,873,5,116,0,0,873, + 874,5,101,0,0,874,198,1,0,0,0,875,876,5,105,0,0,876,877,5,115,0, + 0,877,878,5,46,0,0,878,879,5,101,0,0,879,880,5,113,0,0,880,200,1, + 0,0,0,881,882,5,105,0,0,882,883,5,115,0,0,883,884,5,46,0,0,884,885, + 5,110,0,0,885,886,5,101,0,0,886,887,5,113,0,0,887,202,1,0,0,0,888, + 889,5,97,0,0,889,890,5,115,0,0,890,891,5,115,0,0,891,892,5,101,0, + 0,892,893,5,114,0,0,893,894,5,116,0,0,894,895,5,46,0,0,895,896,5, + 101,0,0,896,897,5,113,0,0,897,204,1,0,0,0,898,899,5,97,0,0,899,900, + 5,115,0,0,900,901,5,115,0,0,901,902,5,101,0,0,902,903,5,114,0,0, + 903,904,5,116,0,0,904,905,5,46,0,0,905,906,5,110,0,0,906,907,5,101, + 0,0,907,908,5,113,0,0,908,206,1,0,0,0,909,910,5,99,0,0,910,911,5, + 111,0,0,911,912,5,109,0,0,912,913,5,109,0,0,913,914,5,105,0,0,914, + 915,5,116,0,0,915,916,5,46,0,0,916,917,5,98,0,0,917,918,5,104,0, + 0,918,919,5,112,0,0,919,920,5,50,0,0,920,921,5,53,0,0,921,922,5, + 54,0,0,922,208,1,0,0,0,923,924,5,99,0,0,924,925,5,111,0,0,925,926, + 5,109,0,0,926,927,5,109,0,0,927,928,5,105,0,0,928,929,5,116,0,0, + 929,930,5,46,0,0,930,931,5,98,0,0,931,932,5,104,0,0,932,933,5,112, + 0,0,933,934,5,53,0,0,934,935,5,49,0,0,935,936,5,50,0,0,936,210,1, + 0,0,0,937,938,5,99,0,0,938,939,5,111,0,0,939,940,5,109,0,0,940,941, + 5,109,0,0,941,942,5,105,0,0,942,943,5,116,0,0,943,944,5,46,0,0,944, + 945,5,98,0,0,945,946,5,104,0,0,946,947,5,112,0,0,947,948,5,55,0, + 0,948,949,5,54,0,0,949,950,5,56,0,0,950,212,1,0,0,0,951,952,5,99, + 0,0,952,953,5,111,0,0,953,954,5,109,0,0,954,955,5,109,0,0,955,956, + 5,105,0,0,956,957,5,116,0,0,957,958,5,46,0,0,958,959,5,98,0,0,959, + 960,5,104,0,0,960,961,5,112,0,0,961,962,5,49,0,0,962,963,5,48,0, + 0,963,964,5,50,0,0,964,965,5,52,0,0,965,214,1,0,0,0,966,967,5,99, + 0,0,967,968,5,111,0,0,968,969,5,109,0,0,969,970,5,109,0,0,970,971, + 5,105,0,0,971,972,5,116,0,0,972,973,5,46,0,0,973,974,5,112,0,0,974, + 975,5,101,0,0,975,976,5,100,0,0,976,977,5,54,0,0,977,978,5,52,0, + 0,978,216,1,0,0,0,979,980,5,99,0,0,980,981,5,111,0,0,981,982,5,109, + 0,0,982,983,5,109,0,0,983,984,5,105,0,0,984,985,5,116,0,0,985,986, + 5,46,0,0,986,987,5,112,0,0,987,988,5,101,0,0,988,989,5,100,0,0,989, + 990,5,49,0,0,990,991,5,50,0,0,991,992,5,56,0,0,992,218,1,0,0,0,993, + 994,5,104,0,0,994,995,5,97,0,0,995,996,5,115,0,0,996,997,5,104,0, + 0,997,998,5,46,0,0,998,999,5,98,0,0,999,1000,5,104,0,0,1000,1001, + 5,112,0,0,1001,1002,5,50,0,0,1002,1003,5,53,0,0,1003,1004,5,54,0, + 0,1004,220,1,0,0,0,1005,1006,5,104,0,0,1006,1007,5,97,0,0,1007,1008, + 5,115,0,0,1008,1009,5,104,0,0,1009,1010,5,46,0,0,1010,1011,5,98, + 0,0,1011,1012,5,104,0,0,1012,1013,5,112,0,0,1013,1014,5,53,0,0,1014, + 1015,5,49,0,0,1015,1016,5,50,0,0,1016,222,1,0,0,0,1017,1018,5,104, + 0,0,1018,1019,5,97,0,0,1019,1020,5,115,0,0,1020,1021,5,104,0,0,1021, + 1022,5,46,0,0,1022,1023,5,98,0,0,1023,1024,5,104,0,0,1024,1025,5, + 112,0,0,1025,1026,5,55,0,0,1026,1027,5,54,0,0,1027,1028,5,56,0,0, + 1028,224,1,0,0,0,1029,1030,5,104,0,0,1030,1031,5,97,0,0,1031,1032, + 5,115,0,0,1032,1033,5,104,0,0,1033,1034,5,46,0,0,1034,1035,5,98, + 0,0,1035,1036,5,104,0,0,1036,1037,5,112,0,0,1037,1038,5,49,0,0,1038, + 1039,5,48,0,0,1039,1040,5,50,0,0,1040,1041,5,52,0,0,1041,226,1,0, + 0,0,1042,1043,5,104,0,0,1043,1044,5,97,0,0,1044,1045,5,115,0,0,1045, + 1046,5,104,0,0,1046,1047,5,46,0,0,1047,1048,5,112,0,0,1048,1049, + 5,101,0,0,1049,1050,5,100,0,0,1050,1051,5,54,0,0,1051,1052,5,52, + 0,0,1052,228,1,0,0,0,1053,1054,5,104,0,0,1054,1055,5,97,0,0,1055, + 1056,5,115,0,0,1056,1057,5,104,0,0,1057,1058,5,46,0,0,1058,1059, + 5,112,0,0,1059,1060,5,101,0,0,1060,1061,5,100,0,0,1061,1062,5,49, + 0,0,1062,1063,5,50,0,0,1063,1064,5,56,0,0,1064,230,1,0,0,0,1065, + 1066,5,104,0,0,1066,1067,5,97,0,0,1067,1068,5,115,0,0,1068,1069, + 5,104,0,0,1069,1070,5,46,0,0,1070,1071,5,112,0,0,1071,1072,5,115, + 0,0,1072,1073,5,100,0,0,1073,1074,5,50,0,0,1074,232,1,0,0,0,1075, + 1076,5,104,0,0,1076,1077,5,97,0,0,1077,1078,5,115,0,0,1078,1079, + 5,104,0,0,1079,1080,5,46,0,0,1080,1081,5,112,0,0,1081,1082,5,115, + 0,0,1082,1083,5,100,0,0,1083,1084,5,52,0,0,1084,234,1,0,0,0,1085, + 1086,5,104,0,0,1086,1087,5,97,0,0,1087,1088,5,115,0,0,1088,1089, + 5,104,0,0,1089,1090,5,46,0,0,1090,1091,5,112,0,0,1091,1092,5,115, + 0,0,1092,1093,5,100,0,0,1093,1094,5,56,0,0,1094,236,1,0,0,0,1095, + 1096,5,104,0,0,1096,1097,5,97,0,0,1097,1098,5,115,0,0,1098,1099, + 5,104,0,0,1099,1100,5,46,0,0,1100,1101,5,107,0,0,1101,1102,5,101, + 0,0,1102,1103,5,99,0,0,1103,1104,5,99,0,0,1104,1105,5,97,0,0,1105, + 1106,5,107,0,0,1106,1107,5,50,0,0,1107,1108,5,53,0,0,1108,1109,5, + 54,0,0,1109,238,1,0,0,0,1110,1111,5,104,0,0,1111,1112,5,97,0,0,1112, + 1113,5,115,0,0,1113,1114,5,104,0,0,1114,1115,5,46,0,0,1115,1116, + 5,107,0,0,1116,1117,5,101,0,0,1117,1118,5,99,0,0,1118,1119,5,99, + 0,0,1119,1120,5,97,0,0,1120,1121,5,107,0,0,1121,1122,5,51,0,0,1122, + 1123,5,56,0,0,1123,1124,5,52,0,0,1124,240,1,0,0,0,1125,1126,5,104, + 0,0,1126,1127,5,97,0,0,1127,1128,5,115,0,0,1128,1129,5,104,0,0,1129, + 1130,5,46,0,0,1130,1131,5,107,0,0,1131,1132,5,101,0,0,1132,1133, + 5,99,0,0,1133,1134,5,99,0,0,1134,1135,5,97,0,0,1135,1136,5,107,0, + 0,1136,1137,5,53,0,0,1137,1138,5,49,0,0,1138,1139,5,50,0,0,1139, + 242,1,0,0,0,1140,1141,5,104,0,0,1141,1142,5,97,0,0,1142,1143,5,115, + 0,0,1143,1144,5,104,0,0,1144,1145,5,46,0,0,1145,1146,5,115,0,0,1146, + 1147,5,104,0,0,1147,1148,5,97,0,0,1148,1149,5,51,0,0,1149,1150,5, + 95,0,0,1150,1151,5,50,0,0,1151,1152,5,53,0,0,1152,1153,5,54,0,0, + 1153,244,1,0,0,0,1154,1155,5,104,0,0,1155,1156,5,97,0,0,1156,1157, + 5,115,0,0,1157,1158,5,104,0,0,1158,1159,5,46,0,0,1159,1160,5,115, + 0,0,1160,1161,5,104,0,0,1161,1162,5,97,0,0,1162,1163,5,51,0,0,1163, + 1164,5,95,0,0,1164,1165,5,51,0,0,1165,1166,5,56,0,0,1166,1167,5, + 52,0,0,1167,246,1,0,0,0,1168,1169,5,104,0,0,1169,1170,5,97,0,0,1170, + 1171,5,115,0,0,1171,1172,5,104,0,0,1172,1173,5,46,0,0,1173,1174, + 5,115,0,0,1174,1175,5,104,0,0,1175,1176,5,97,0,0,1176,1177,5,51, + 0,0,1177,1178,5,95,0,0,1178,1179,5,53,0,0,1179,1180,5,49,0,0,1180, + 1181,5,50,0,0,1181,248,1,0,0,0,1182,1183,5,104,0,0,1183,1184,5,97, + 0,0,1184,1185,5,115,0,0,1185,1186,5,104,0,0,1186,1187,5,95,0,0,1187, + 1188,5,109,0,0,1188,1189,5,97,0,0,1189,1190,5,110,0,0,1190,1191, + 5,121,0,0,1191,1192,5,46,0,0,1192,1193,5,112,0,0,1193,1194,5,115, + 0,0,1194,1195,5,100,0,0,1195,1196,5,50,0,0,1196,250,1,0,0,0,1197, + 1198,5,104,0,0,1198,1199,5,97,0,0,1199,1200,5,115,0,0,1200,1201, + 5,104,0,0,1201,1202,5,95,0,0,1202,1203,5,109,0,0,1203,1204,5,97, + 0,0,1204,1205,5,110,0,0,1205,1206,5,121,0,0,1206,1207,5,46,0,0,1207, + 1208,5,112,0,0,1208,1209,5,115,0,0,1209,1210,5,100,0,0,1210,1211, + 5,52,0,0,1211,252,1,0,0,0,1212,1213,5,104,0,0,1213,1214,5,97,0,0, + 1214,1215,5,115,0,0,1215,1216,5,104,0,0,1216,1217,5,95,0,0,1217, + 1218,5,109,0,0,1218,1219,5,97,0,0,1219,1220,5,110,0,0,1220,1221, + 5,121,0,0,1221,1222,5,46,0,0,1222,1223,5,112,0,0,1223,1224,5,115, + 0,0,1224,1225,5,100,0,0,1225,1226,5,56,0,0,1226,254,1,0,0,0,1227, + 1228,5,99,0,0,1228,1229,5,97,0,0,1229,1230,5,115,0,0,1230,1231,5, + 116,0,0,1231,1232,5,46,0,0,1232,1233,5,108,0,0,1233,1234,5,111,0, + 0,1234,1235,5,115,0,0,1235,1236,5,115,0,0,1236,1237,5,121,0,0,1237, + 256,1,0,0,0,1238,1239,5,99,0,0,1239,1240,5,97,0,0,1240,1241,5,115, + 0,0,1241,1242,5,116,0,0,1242,258,1,0,0,0,1243,1244,5,98,0,0,1244, + 1245,5,114,0,0,1245,1246,5,97,0,0,1246,1247,5,110,0,0,1247,1248, + 5,99,0,0,1248,1249,5,104,0,0,1249,1250,5,46,0,0,1250,1251,5,101, + 0,0,1251,1252,5,113,0,0,1252,260,1,0,0,0,1253,1254,5,98,0,0,1254, + 1255,5,114,0,0,1255,1256,5,97,0,0,1256,1257,5,110,0,0,1257,1258, + 5,99,0,0,1258,1259,5,104,0,0,1259,1260,5,46,0,0,1260,1261,5,110, + 0,0,1261,1262,5,101,0,0,1262,1263,5,113,0,0,1263,262,1,0,0,0,1264, + 1265,5,97,0,0,1265,1266,5,108,0,0,1266,1267,5,101,0,0,1267,1268, + 5,111,0,0,1268,1269,5,49,0,0,1269,1277,1,0,0,0,1270,1274,3,267,133, + 0,1271,1273,5,95,0,0,1272,1271,1,0,0,0,1273,1276,1,0,0,0,1274,1272, + 1,0,0,0,1274,1275,1,0,0,0,1275,1278,1,0,0,0,1276,1274,1,0,0,0,1277, + 1270,1,0,0,0,1278,1279,1,0,0,0,1279,1277,1,0,0,0,1279,1280,1,0,0, + 0,1280,264,1,0,0,0,1281,1282,5,115,0,0,1282,1283,5,105,0,0,1283, + 1284,5,103,0,0,1284,1285,5,110,0,0,1285,1286,5,49,0,0,1286,1294, + 1,0,0,0,1287,1291,3,267,133,0,1288,1290,5,95,0,0,1289,1288,1,0,0, + 0,1290,1293,1,0,0,0,1291,1289,1,0,0,0,1291,1292,1,0,0,0,1292,1295, + 1,0,0,0,1293,1291,1,0,0,0,1294,1287,1,0,0,0,1295,1296,1,0,0,0,1296, + 1294,1,0,0,0,1296,1297,1,0,0,0,1297,266,1,0,0,0,1298,1301,3,277, + 138,0,1299,1301,3,285,142,0,1300,1298,1,0,0,0,1300,1299,1,0,0,0, + 1301,268,1,0,0,0,1302,1304,5,114,0,0,1303,1305,3,283,141,0,1304, + 1303,1,0,0,0,1305,1306,1,0,0,0,1306,1304,1,0,0,0,1306,1307,1,0,0, + 0,1307,270,1,0,0,0,1308,1314,3,273,136,0,1309,1313,3,273,136,0,1310, + 1313,3,283,141,0,1311,1313,5,95,0,0,1312,1309,1,0,0,0,1312,1310, + 1,0,0,0,1312,1311,1,0,0,0,1313,1316,1,0,0,0,1314,1312,1,0,0,0,1314, + 1315,1,0,0,0,1315,272,1,0,0,0,1316,1314,1,0,0,0,1317,1320,3,275, + 137,0,1318,1320,3,281,140,0,1319,1317,1,0,0,0,1319,1318,1,0,0,0, + 1320,274,1,0,0,0,1321,1324,3,277,138,0,1322,1324,3,279,139,0,1323, + 1321,1,0,0,0,1323,1322,1,0,0,0,1324,276,1,0,0,0,1325,1326,7,0,0, + 0,1326,278,1,0,0,0,1327,1328,7,1,0,0,1328,280,1,0,0,0,1329,1330, + 7,2,0,0,1330,282,1,0,0,0,1331,1334,3,285,142,0,1332,1334,3,287,143, + 0,1333,1331,1,0,0,0,1333,1332,1,0,0,0,1334,284,1,0,0,0,1335,1336, + 7,3,0,0,1336,286,1,0,0,0,1337,1338,5,49,0,0,1338,288,1,0,0,0,1339, + 1341,7,4,0,0,1340,1339,1,0,0,0,1341,1342,1,0,0,0,1342,1340,1,0,0, + 0,1342,1343,1,0,0,0,1343,1344,1,0,0,0,1344,1345,6,144,0,0,1345,290, + 1,0,0,0,1346,1347,5,47,0,0,1347,1348,5,42,0,0,1348,1352,1,0,0,0, + 1349,1351,9,0,0,0,1350,1349,1,0,0,0,1351,1354,1,0,0,0,1352,1353, + 1,0,0,0,1352,1350,1,0,0,0,1353,1355,1,0,0,0,1354,1352,1,0,0,0,1355, + 1356,5,42,0,0,1356,1357,5,47,0,0,1357,1358,1,0,0,0,1358,1359,6,145, + 1,0,1359,292,1,0,0,0,1360,1361,5,47,0,0,1361,1362,5,47,0,0,1362, + 1366,1,0,0,0,1363,1365,8,5,0,0,1364,1363,1,0,0,0,1365,1368,1,0,0, + 0,1366,1364,1,0,0,0,1366,1367,1,0,0,0,1367,1369,1,0,0,0,1368,1366, + 1,0,0,0,1369,1370,6,146,1,0,1370,294,1,0,0,0,15,0,1274,1279,1291, + 1296,1300,1306,1312,1314,1319,1323,1333,1342,1352,1366,2,6,0,0,0, + 1,0 + ] + +class AleoLexer(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + T__0 = 1 + T__1 = 2 + T__2 = 3 + T__3 = 4 + T__4 = 5 + T__5 = 6 + T__6 = 7 + T__7 = 8 + T__8 = 9 + T__9 = 10 + T__10 = 11 + T__11 = 12 + T__12 = 13 + T__13 = 14 + T__14 = 15 + T__15 = 16 + T__16 = 17 + T__17 = 18 + T__18 = 19 + T__19 = 20 + T__20 = 21 + T__21 = 22 + T__22 = 23 + T__23 = 24 + T__24 = 25 + T__25 = 26 + T__26 = 27 + T__27 = 28 + T__28 = 29 + T__29 = 30 + T__30 = 31 + T__31 = 32 + T__32 = 33 + T__33 = 34 + T__34 = 35 + T__35 = 36 + T__36 = 37 + T__37 = 38 + T__38 = 39 + T__39 = 40 + T__40 = 41 + T__41 = 42 + T__42 = 43 + T__43 = 44 + T__44 = 45 + T__45 = 46 + T__46 = 47 + T__47 = 48 + T__48 = 49 + T__49 = 50 + T__50 = 51 + T__51 = 52 + T__52 = 53 + T__53 = 54 + T__54 = 55 + T__55 = 56 + T__56 = 57 + T__57 = 58 + T__58 = 59 + T__59 = 60 + T__60 = 61 + T__61 = 62 + T__62 = 63 + T__63 = 64 + T__64 = 65 + T__65 = 66 + T__66 = 67 + T__67 = 68 + T__68 = 69 + T__69 = 70 + T__70 = 71 + T__71 = 72 + T__72 = 73 + T__73 = 74 + T__74 = 75 + T__75 = 76 + T__76 = 77 + T__77 = 78 + T__78 = 79 + T__79 = 80 + T__80 = 81 + T__81 = 82 + T__82 = 83 + T__83 = 84 + T__84 = 85 + T__85 = 86 + T__86 = 87 + T__87 = 88 + T__88 = 89 + T__89 = 90 + T__90 = 91 + T__91 = 92 + T__92 = 93 + T__93 = 94 + T__94 = 95 + T__95 = 96 + T__96 = 97 + T__97 = 98 + T__98 = 99 + T__99 = 100 + T__100 = 101 + T__101 = 102 + T__102 = 103 + T__103 = 104 + T__104 = 105 + T__105 = 106 + T__106 = 107 + T__107 = 108 + T__108 = 109 + T__109 = 110 + T__110 = 111 + T__111 = 112 + T__112 = 113 + T__113 = 114 + T__114 = 115 + T__115 = 116 + T__116 = 117 + T__117 = 118 + T__118 = 119 + T__119 = 120 + T__120 = 121 + T__121 = 122 + T__122 = 123 + T__123 = 124 + T__124 = 125 + T__125 = 126 + T__126 = 127 + T__127 = 128 + T__128 = 129 + T__129 = 130 + T__130 = 131 + ADDRESS_LITERAL = 132 + SIGNATURE_LITERAL = 133 + REGISTER = 134 + IDENTIFIER = 135 + DIGIT = 136 + WS = 137 + COMMENT = 138 + LINE_COMMENT = 139 + + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + + modeNames = [ "DEFAULT_MODE" ] + + literalNames = [ "", + "'program'", "';'", "'import'", "'mapping'", "':'", "'key'", + "'as'", "'value'", "'struct'", "'record'", "'closure'", "'input'", + "'output'", "'function'", "'finalize'", "'contains'", "'['", + "']'", "'into'", "'get'", "'get.or_use'", "'set'", "'remove'", + "'rand.chacha'", "'position'", "'to'", "'await'", "'ternary'", + "'sign.verify'", "'sign_verify'", "'call'", "'async'", "'-'", + "'_'", "'u32'", "'true'", "'false'", "'u8'", "'u16'", "'u64'", + "'u128'", "'i8'", "'i16'", "'i32'", "'i64'", "'i128'", "'field'", + "'group'", "'scalar'", "'address'", "'boolean'", "'signature'", + "'.constant'", "'.public'", "'.private'", "'.record'", "'.future'", + "'.'", "'group::GEN'", "'self.signer'", "'self.caller'", "'block.height'", + "'/'", "'group.x'", "'group.y'", "'abs'", "'abs.w'", "'double'", + "'inv'", "'neg'", "'not'", "'square'", "'sqrt'", "'add'", "'add.w'", + "'sub'", "'sub.w'", "'mul'", "'mul.w'", "'div'", "'div.w'", + "'rem'", "'rem.w'", "'pow'", "'pow.w'", "'shl'", "'shl.w'", + "'shr'", "'shr.w'", "'mod'", "'and'", "'or'", "'xor'", "'nand'", + "'nor'", "'gt'", "'gte'", "'lt'", "'lte'", "'is.eq'", "'is.neq'", + "'assert.eq'", "'assert.neq'", "'commit.bhp256'", "'commit.bhp512'", + "'commit.bhp768'", "'commit.bhp1024'", "'commit.ped64'", "'commit.ped128'", + "'hash.bhp256'", "'hash.bhp512'", "'hash.bhp768'", "'hash.bhp1024'", + "'hash.ped64'", "'hash.ped128'", "'hash.psd2'", "'hash.psd4'", + "'hash.psd8'", "'hash.keccak256'", "'hash.keccak384'", "'hash.keccak512'", + "'hash.sha3_256'", "'hash.sha3_384'", "'hash.sha3_512'", "'hash_many.psd2'", + "'hash_many.psd4'", "'hash_many.psd8'", "'cast.lossy'", "'cast'", + "'branch.eq'", "'branch.neq'" ] + + symbolicNames = [ "", + "ADDRESS_LITERAL", "SIGNATURE_LITERAL", "REGISTER", "IDENTIFIER", + "DIGIT", "WS", "COMMENT", "LINE_COMMENT" ] + + ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", + "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13", + "T__14", "T__15", "T__16", "T__17", "T__18", "T__19", + "T__20", "T__21", "T__22", "T__23", "T__24", "T__25", + "T__26", "T__27", "T__28", "T__29", "T__30", "T__31", + "T__32", "T__33", "T__34", "T__35", "T__36", "T__37", + "T__38", "T__39", "T__40", "T__41", "T__42", "T__43", + "T__44", "T__45", "T__46", "T__47", "T__48", "T__49", + "T__50", "T__51", "T__52", "T__53", "T__54", "T__55", + "T__56", "T__57", "T__58", "T__59", "T__60", "T__61", + "T__62", "T__63", "T__64", "T__65", "T__66", "T__67", + "T__68", "T__69", "T__70", "T__71", "T__72", "T__73", + "T__74", "T__75", "T__76", "T__77", "T__78", "T__79", + "T__80", "T__81", "T__82", "T__83", "T__84", "T__85", + "T__86", "T__87", "T__88", "T__89", "T__90", "T__91", + "T__92", "T__93", "T__94", "T__95", "T__96", "T__97", + "T__98", "T__99", "T__100", "T__101", "T__102", "T__103", + "T__104", "T__105", "T__106", "T__107", "T__108", "T__109", + "T__110", "T__111", "T__112", "T__113", "T__114", "T__115", + "T__116", "T__117", "T__118", "T__119", "T__120", "T__121", + "T__122", "T__123", "T__124", "T__125", "T__126", "T__127", + "T__128", "T__129", "T__130", "ADDRESS_LITERAL", "SIGNATURE_LITERAL", + "ADDRESS_OR_SIGNATURE_CHAR", "REGISTER", "IDENTIFIER", + "LETTER", "LOWERCASE_LETTER", "ADDRESS_OR_SIGNATURE_LOWERCASE_LETTER", + "OTHER_LOWERCASE_LETTER", "UPPERCASE_LETTER", "DIGIT", + "ADDRESS_OR_SIGNATURE_DIGIT", "OTHER_DIGIT", "WS", "COMMENT", + "LINE_COMMENT" ] + + grammarFileName = "Aleo.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/vanguard/aleo/parser/AleoLexer.tokens b/vanguard/aleo/parser/AleoLexer.tokens new file mode 100644 index 0000000..89e7efa --- /dev/null +++ b/vanguard/aleo/parser/AleoLexer.tokens @@ -0,0 +1,270 @@ +T__0=1 +T__1=2 +T__2=3 +T__3=4 +T__4=5 +T__5=6 +T__6=7 +T__7=8 +T__8=9 +T__9=10 +T__10=11 +T__11=12 +T__12=13 +T__13=14 +T__14=15 +T__15=16 +T__16=17 +T__17=18 +T__18=19 +T__19=20 +T__20=21 +T__21=22 +T__22=23 +T__23=24 +T__24=25 +T__25=26 +T__26=27 +T__27=28 +T__28=29 +T__29=30 +T__30=31 +T__31=32 +T__32=33 +T__33=34 +T__34=35 +T__35=36 +T__36=37 +T__37=38 +T__38=39 +T__39=40 +T__40=41 +T__41=42 +T__42=43 +T__43=44 +T__44=45 +T__45=46 +T__46=47 +T__47=48 +T__48=49 +T__49=50 +T__50=51 +T__51=52 +T__52=53 +T__53=54 +T__54=55 +T__55=56 +T__56=57 +T__57=58 +T__58=59 +T__59=60 +T__60=61 +T__61=62 +T__62=63 +T__63=64 +T__64=65 +T__65=66 +T__66=67 +T__67=68 +T__68=69 +T__69=70 +T__70=71 +T__71=72 +T__72=73 +T__73=74 +T__74=75 +T__75=76 +T__76=77 +T__77=78 +T__78=79 +T__79=80 +T__80=81 +T__81=82 +T__82=83 +T__83=84 +T__84=85 +T__85=86 +T__86=87 +T__87=88 +T__88=89 +T__89=90 +T__90=91 +T__91=92 +T__92=93 +T__93=94 +T__94=95 +T__95=96 +T__96=97 +T__97=98 +T__98=99 +T__99=100 +T__100=101 +T__101=102 +T__102=103 +T__103=104 +T__104=105 +T__105=106 +T__106=107 +T__107=108 +T__108=109 +T__109=110 +T__110=111 +T__111=112 +T__112=113 +T__113=114 +T__114=115 +T__115=116 +T__116=117 +T__117=118 +T__118=119 +T__119=120 +T__120=121 +T__121=122 +T__122=123 +T__123=124 +T__124=125 +T__125=126 +T__126=127 +T__127=128 +T__128=129 +T__129=130 +T__130=131 +ADDRESS_LITERAL=132 +SIGNATURE_LITERAL=133 +REGISTER=134 +IDENTIFIER=135 +DIGIT=136 +WS=137 +COMMENT=138 +LINE_COMMENT=139 +'program'=1 +';'=2 +'import'=3 +'mapping'=4 +':'=5 +'key'=6 +'as'=7 +'value'=8 +'struct'=9 +'record'=10 +'closure'=11 +'input'=12 +'output'=13 +'function'=14 +'finalize'=15 +'contains'=16 +'['=17 +']'=18 +'into'=19 +'get'=20 +'get.or_use'=21 +'set'=22 +'remove'=23 +'rand.chacha'=24 +'position'=25 +'to'=26 +'await'=27 +'ternary'=28 +'sign.verify'=29 +'sign_verify'=30 +'call'=31 +'async'=32 +'-'=33 +'_'=34 +'u32'=35 +'true'=36 +'false'=37 +'u8'=38 +'u16'=39 +'u64'=40 +'u128'=41 +'i8'=42 +'i16'=43 +'i32'=44 +'i64'=45 +'i128'=46 +'field'=47 +'group'=48 +'scalar'=49 +'address'=50 +'boolean'=51 +'signature'=52 +'.constant'=53 +'.public'=54 +'.private'=55 +'.record'=56 +'.future'=57 +'.'=58 +'group::GEN'=59 +'self.signer'=60 +'self.caller'=61 +'block.height'=62 +'/'=63 +'group.x'=64 +'group.y'=65 +'abs'=66 +'abs.w'=67 +'double'=68 +'inv'=69 +'neg'=70 +'not'=71 +'square'=72 +'sqrt'=73 +'add'=74 +'add.w'=75 +'sub'=76 +'sub.w'=77 +'mul'=78 +'mul.w'=79 +'div'=80 +'div.w'=81 +'rem'=82 +'rem.w'=83 +'pow'=84 +'pow.w'=85 +'shl'=86 +'shl.w'=87 +'shr'=88 +'shr.w'=89 +'mod'=90 +'and'=91 +'or'=92 +'xor'=93 +'nand'=94 +'nor'=95 +'gt'=96 +'gte'=97 +'lt'=98 +'lte'=99 +'is.eq'=100 +'is.neq'=101 +'assert.eq'=102 +'assert.neq'=103 +'commit.bhp256'=104 +'commit.bhp512'=105 +'commit.bhp768'=106 +'commit.bhp1024'=107 +'commit.ped64'=108 +'commit.ped128'=109 +'hash.bhp256'=110 +'hash.bhp512'=111 +'hash.bhp768'=112 +'hash.bhp1024'=113 +'hash.ped64'=114 +'hash.ped128'=115 +'hash.psd2'=116 +'hash.psd4'=117 +'hash.psd8'=118 +'hash.keccak256'=119 +'hash.keccak384'=120 +'hash.keccak512'=121 +'hash.sha3_256'=122 +'hash.sha3_384'=123 +'hash.sha3_512'=124 +'hash_many.psd2'=125 +'hash_many.psd4'=126 +'hash_many.psd8'=127 +'cast.lossy'=128 +'cast'=129 +'branch.eq'=130 +'branch.neq'=131 diff --git a/vanguard/aleo/parser/AleoListener.py b/vanguard/aleo/parser/AleoListener.py new file mode 100644 index 0000000..9daf13c --- /dev/null +++ b/vanguard/aleo/parser/AleoListener.py @@ -0,0 +1,858 @@ +# Generated from ./Aleo.g4 by ANTLR 4.13.1 +from antlr4 import * +if "." in __name__: + from .AleoParser import AleoParser +else: + from AleoParser import AleoParser + +# This class defines a complete listener for a parse tree produced by AleoParser. +class AleoListener(ParseTreeListener): + + # Enter a parse tree produced by AleoParser#start. + def enterStart(self, ctx:AleoParser.StartContext): + pass + + # Exit a parse tree produced by AleoParser#start. + def exitStart(self, ctx:AleoParser.StartContext): + pass + + + # Enter a parse tree produced by AleoParser#program. + def enterProgram(self, ctx:AleoParser.ProgramContext): + pass + + # Exit a parse tree produced by AleoParser#program. + def exitProgram(self, ctx:AleoParser.ProgramContext): + pass + + + # Enter a parse tree produced by AleoParser#ximport. + def enterXimport(self, ctx:AleoParser.XimportContext): + pass + + # Exit a parse tree produced by AleoParser#ximport. + def exitXimport(self, ctx:AleoParser.XimportContext): + pass + + + # Enter a parse tree produced by AleoParser#mapping. + def enterMapping(self, ctx:AleoParser.MappingContext): + pass + + # Exit a parse tree produced by AleoParser#mapping. + def exitMapping(self, ctx:AleoParser.MappingContext): + pass + + + # Enter a parse tree produced by AleoParser#mapping_key. + def enterMapping_key(self, ctx:AleoParser.Mapping_keyContext): + pass + + # Exit a parse tree produced by AleoParser#mapping_key. + def exitMapping_key(self, ctx:AleoParser.Mapping_keyContext): + pass + + + # Enter a parse tree produced by AleoParser#mapping_value. + def enterMapping_value(self, ctx:AleoParser.Mapping_valueContext): + pass + + # Exit a parse tree produced by AleoParser#mapping_value. + def exitMapping_value(self, ctx:AleoParser.Mapping_valueContext): + pass + + + # Enter a parse tree produced by AleoParser#struct. + def enterStruct(self, ctx:AleoParser.StructContext): + pass + + # Exit a parse tree produced by AleoParser#struct. + def exitStruct(self, ctx:AleoParser.StructContext): + pass + + + # Enter a parse tree produced by AleoParser#record. + def enterRecord(self, ctx:AleoParser.RecordContext): + pass + + # Exit a parse tree produced by AleoParser#record. + def exitRecord(self, ctx:AleoParser.RecordContext): + pass + + + # Enter a parse tree produced by AleoParser#closure. + def enterClosure(self, ctx:AleoParser.ClosureContext): + pass + + # Exit a parse tree produced by AleoParser#closure. + def exitClosure(self, ctx:AleoParser.ClosureContext): + pass + + + # Enter a parse tree produced by AleoParser#closure_input. + def enterClosure_input(self, ctx:AleoParser.Closure_inputContext): + pass + + # Exit a parse tree produced by AleoParser#closure_input. + def exitClosure_input(self, ctx:AleoParser.Closure_inputContext): + pass + + + # Enter a parse tree produced by AleoParser#closure_output. + def enterClosure_output(self, ctx:AleoParser.Closure_outputContext): + pass + + # Exit a parse tree produced by AleoParser#closure_output. + def exitClosure_output(self, ctx:AleoParser.Closure_outputContext): + pass + + + # Enter a parse tree produced by AleoParser#function. + def enterFunction(self, ctx:AleoParser.FunctionContext): + pass + + # Exit a parse tree produced by AleoParser#function. + def exitFunction(self, ctx:AleoParser.FunctionContext): + pass + + + # Enter a parse tree produced by AleoParser#function_input. + def enterFunction_input(self, ctx:AleoParser.Function_inputContext): + pass + + # Exit a parse tree produced by AleoParser#function_input. + def exitFunction_input(self, ctx:AleoParser.Function_inputContext): + pass + + + # Enter a parse tree produced by AleoParser#function_output. + def enterFunction_output(self, ctx:AleoParser.Function_outputContext): + pass + + # Exit a parse tree produced by AleoParser#function_output. + def exitFunction_output(self, ctx:AleoParser.Function_outputContext): + pass + + + # Enter a parse tree produced by AleoParser#finalize. + def enterFinalize(self, ctx:AleoParser.FinalizeContext): + pass + + # Exit a parse tree produced by AleoParser#finalize. + def exitFinalize(self, ctx:AleoParser.FinalizeContext): + pass + + + # Enter a parse tree produced by AleoParser#finalize_input. + def enterFinalize_input(self, ctx:AleoParser.Finalize_inputContext): + pass + + # Exit a parse tree produced by AleoParser#finalize_input. + def exitFinalize_input(self, ctx:AleoParser.Finalize_inputContext): + pass + + + # Enter a parse tree produced by AleoParser#command. + def enterCommand(self, ctx:AleoParser.CommandContext): + pass + + # Exit a parse tree produced by AleoParser#command. + def exitCommand(self, ctx:AleoParser.CommandContext): + pass + + + # Enter a parse tree produced by AleoParser#contains. + def enterContains(self, ctx:AleoParser.ContainsContext): + pass + + # Exit a parse tree produced by AleoParser#contains. + def exitContains(self, ctx:AleoParser.ContainsContext): + pass + + + # Enter a parse tree produced by AleoParser#get. + def enterGet(self, ctx:AleoParser.GetContext): + pass + + # Exit a parse tree produced by AleoParser#get. + def exitGet(self, ctx:AleoParser.GetContext): + pass + + + # Enter a parse tree produced by AleoParser#get_or_use. + def enterGet_or_use(self, ctx:AleoParser.Get_or_useContext): + pass + + # Exit a parse tree produced by AleoParser#get_or_use. + def exitGet_or_use(self, ctx:AleoParser.Get_or_useContext): + pass + + + # Enter a parse tree produced by AleoParser#set. + def enterSet(self, ctx:AleoParser.SetContext): + pass + + # Exit a parse tree produced by AleoParser#set. + def exitSet(self, ctx:AleoParser.SetContext): + pass + + + # Enter a parse tree produced by AleoParser#remove. + def enterRemove(self, ctx:AleoParser.RemoveContext): + pass + + # Exit a parse tree produced by AleoParser#remove. + def exitRemove(self, ctx:AleoParser.RemoveContext): + pass + + + # Enter a parse tree produced by AleoParser#random. + def enterRandom(self, ctx:AleoParser.RandomContext): + pass + + # Exit a parse tree produced by AleoParser#random. + def exitRandom(self, ctx:AleoParser.RandomContext): + pass + + + # Enter a parse tree produced by AleoParser#position. + def enterPosition(self, ctx:AleoParser.PositionContext): + pass + + # Exit a parse tree produced by AleoParser#position. + def exitPosition(self, ctx:AleoParser.PositionContext): + pass + + + # Enter a parse tree produced by AleoParser#branch. + def enterBranch(self, ctx:AleoParser.BranchContext): + pass + + # Exit a parse tree produced by AleoParser#branch. + def exitBranch(self, ctx:AleoParser.BranchContext): + pass + + + # Enter a parse tree produced by AleoParser#xawait. + def enterXawait(self, ctx:AleoParser.XawaitContext): + pass + + # Exit a parse tree produced by AleoParser#xawait. + def exitXawait(self, ctx:AleoParser.XawaitContext): + pass + + + # Enter a parse tree produced by AleoParser#instruction. + def enterInstruction(self, ctx:AleoParser.InstructionContext): + pass + + # Exit a parse tree produced by AleoParser#instruction. + def exitInstruction(self, ctx:AleoParser.InstructionContext): + pass + + + # Enter a parse tree produced by AleoParser#unary. + def enterUnary(self, ctx:AleoParser.UnaryContext): + pass + + # Exit a parse tree produced by AleoParser#unary. + def exitUnary(self, ctx:AleoParser.UnaryContext): + pass + + + # Enter a parse tree produced by AleoParser#binary. + def enterBinary(self, ctx:AleoParser.BinaryContext): + pass + + # Exit a parse tree produced by AleoParser#binary. + def exitBinary(self, ctx:AleoParser.BinaryContext): + pass + + + # Enter a parse tree produced by AleoParser#ternary. + def enterTernary(self, ctx:AleoParser.TernaryContext): + pass + + # Exit a parse tree produced by AleoParser#ternary. + def exitTernary(self, ctx:AleoParser.TernaryContext): + pass + + + # Enter a parse tree produced by AleoParser#is. + def enterIs(self, ctx:AleoParser.IsContext): + pass + + # Exit a parse tree produced by AleoParser#is. + def exitIs(self, ctx:AleoParser.IsContext): + pass + + + # Enter a parse tree produced by AleoParser#assert. + def enterAssert(self, ctx:AleoParser.AssertContext): + pass + + # Exit a parse tree produced by AleoParser#assert. + def exitAssert(self, ctx:AleoParser.AssertContext): + pass + + + # Enter a parse tree produced by AleoParser#commit. + def enterCommit(self, ctx:AleoParser.CommitContext): + pass + + # Exit a parse tree produced by AleoParser#commit. + def exitCommit(self, ctx:AleoParser.CommitContext): + pass + + + # Enter a parse tree produced by AleoParser#hash1. + def enterHash1(self, ctx:AleoParser.Hash1Context): + pass + + # Exit a parse tree produced by AleoParser#hash1. + def exitHash1(self, ctx:AleoParser.Hash1Context): + pass + + + # Enter a parse tree produced by AleoParser#hash2. + def enterHash2(self, ctx:AleoParser.Hash2Context): + pass + + # Exit a parse tree produced by AleoParser#hash2. + def exitHash2(self, ctx:AleoParser.Hash2Context): + pass + + + # Enter a parse tree produced by AleoParser#hash. + def enterHash(self, ctx:AleoParser.HashContext): + pass + + # Exit a parse tree produced by AleoParser#hash. + def exitHash(self, ctx:AleoParser.HashContext): + pass + + + # Enter a parse tree produced by AleoParser#signverify. + def enterSignverify(self, ctx:AleoParser.SignverifyContext): + pass + + # Exit a parse tree produced by AleoParser#signverify. + def exitSignverify(self, ctx:AleoParser.SignverifyContext): + pass + + + # Enter a parse tree produced by AleoParser#cast. + def enterCast(self, ctx:AleoParser.CastContext): + pass + + # Exit a parse tree produced by AleoParser#cast. + def exitCast(self, ctx:AleoParser.CastContext): + pass + + + # Enter a parse tree produced by AleoParser#call. + def enterCall(self, ctx:AleoParser.CallContext): + pass + + # Exit a parse tree produced by AleoParser#call. + def exitCall(self, ctx:AleoParser.CallContext): + pass + + + # Enter a parse tree produced by AleoParser#xasync. + def enterXasync(self, ctx:AleoParser.XasyncContext): + pass + + # Exit a parse tree produced by AleoParser#xasync. + def exitXasync(self, ctx:AleoParser.XasyncContext): + pass + + + # Enter a parse tree produced by AleoParser#literal. + def enterLiteral(self, ctx:AleoParser.LiteralContext): + pass + + # Exit a parse tree produced by AleoParser#literal. + def exitLiteral(self, ctx:AleoParser.LiteralContext): + pass + + + # Enter a parse tree produced by AleoParser#signed_literal. + def enterSigned_literal(self, ctx:AleoParser.Signed_literalContext): + pass + + # Exit a parse tree produced by AleoParser#signed_literal. + def exitSigned_literal(self, ctx:AleoParser.Signed_literalContext): + pass + + + # Enter a parse tree produced by AleoParser#unsigned_literal. + def enterUnsigned_literal(self, ctx:AleoParser.Unsigned_literalContext): + pass + + # Exit a parse tree produced by AleoParser#unsigned_literal. + def exitUnsigned_literal(self, ctx:AleoParser.Unsigned_literalContext): + pass + + + # Enter a parse tree produced by AleoParser#integer_literal. + def enterInteger_literal(self, ctx:AleoParser.Integer_literalContext): + pass + + # Exit a parse tree produced by AleoParser#integer_literal. + def exitInteger_literal(self, ctx:AleoParser.Integer_literalContext): + pass + + + # Enter a parse tree produced by AleoParser#field_literal. + def enterField_literal(self, ctx:AleoParser.Field_literalContext): + pass + + # Exit a parse tree produced by AleoParser#field_literal. + def exitField_literal(self, ctx:AleoParser.Field_literalContext): + pass + + + # Enter a parse tree produced by AleoParser#group_literal. + def enterGroup_literal(self, ctx:AleoParser.Group_literalContext): + pass + + # Exit a parse tree produced by AleoParser#group_literal. + def exitGroup_literal(self, ctx:AleoParser.Group_literalContext): + pass + + + # Enter a parse tree produced by AleoParser#scalar_literal. + def enterScalar_literal(self, ctx:AleoParser.Scalar_literalContext): + pass + + # Exit a parse tree produced by AleoParser#scalar_literal. + def exitScalar_literal(self, ctx:AleoParser.Scalar_literalContext): + pass + + + # Enter a parse tree produced by AleoParser#arithmetic_literal. + def enterArithmetic_literal(self, ctx:AleoParser.Arithmetic_literalContext): + pass + + # Exit a parse tree produced by AleoParser#arithmetic_literal. + def exitArithmetic_literal(self, ctx:AleoParser.Arithmetic_literalContext): + pass + + + # Enter a parse tree produced by AleoParser#u32_literal. + def enterU32_literal(self, ctx:AleoParser.U32_literalContext): + pass + + # Exit a parse tree produced by AleoParser#u32_literal. + def exitU32_literal(self, ctx:AleoParser.U32_literalContext): + pass + + + # Enter a parse tree produced by AleoParser#address_literal. + def enterAddress_literal(self, ctx:AleoParser.Address_literalContext): + pass + + # Exit a parse tree produced by AleoParser#address_literal. + def exitAddress_literal(self, ctx:AleoParser.Address_literalContext): + pass + + + # Enter a parse tree produced by AleoParser#signature_literal. + def enterSignature_literal(self, ctx:AleoParser.Signature_literalContext): + pass + + # Exit a parse tree produced by AleoParser#signature_literal. + def exitSignature_literal(self, ctx:AleoParser.Signature_literalContext): + pass + + + # Enter a parse tree produced by AleoParser#boolean_literal. + def enterBoolean_literal(self, ctx:AleoParser.Boolean_literalContext): + pass + + # Exit a parse tree produced by AleoParser#boolean_literal. + def exitBoolean_literal(self, ctx:AleoParser.Boolean_literalContext): + pass + + + # Enter a parse tree produced by AleoParser#unsigned_type. + def enterUnsigned_type(self, ctx:AleoParser.Unsigned_typeContext): + pass + + # Exit a parse tree produced by AleoParser#unsigned_type. + def exitUnsigned_type(self, ctx:AleoParser.Unsigned_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#signed_type. + def enterSigned_type(self, ctx:AleoParser.Signed_typeContext): + pass + + # Exit a parse tree produced by AleoParser#signed_type. + def exitSigned_type(self, ctx:AleoParser.Signed_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#integer_type. + def enterInteger_type(self, ctx:AleoParser.Integer_typeContext): + pass + + # Exit a parse tree produced by AleoParser#integer_type. + def exitInteger_type(self, ctx:AleoParser.Integer_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#field_type. + def enterField_type(self, ctx:AleoParser.Field_typeContext): + pass + + # Exit a parse tree produced by AleoParser#field_type. + def exitField_type(self, ctx:AleoParser.Field_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#group_type. + def enterGroup_type(self, ctx:AleoParser.Group_typeContext): + pass + + # Exit a parse tree produced by AleoParser#group_type. + def exitGroup_type(self, ctx:AleoParser.Group_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#scalar_type. + def enterScalar_type(self, ctx:AleoParser.Scalar_typeContext): + pass + + # Exit a parse tree produced by AleoParser#scalar_type. + def exitScalar_type(self, ctx:AleoParser.Scalar_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#arithmetic_type. + def enterArithmetic_type(self, ctx:AleoParser.Arithmetic_typeContext): + pass + + # Exit a parse tree produced by AleoParser#arithmetic_type. + def exitArithmetic_type(self, ctx:AleoParser.Arithmetic_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#address_type. + def enterAddress_type(self, ctx:AleoParser.Address_typeContext): + pass + + # Exit a parse tree produced by AleoParser#address_type. + def exitAddress_type(self, ctx:AleoParser.Address_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#boolean_type. + def enterBoolean_type(self, ctx:AleoParser.Boolean_typeContext): + pass + + # Exit a parse tree produced by AleoParser#boolean_type. + def exitBoolean_type(self, ctx:AleoParser.Boolean_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#signature_type. + def enterSignature_type(self, ctx:AleoParser.Signature_typeContext): + pass + + # Exit a parse tree produced by AleoParser#signature_type. + def exitSignature_type(self, ctx:AleoParser.Signature_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#literal_type. + def enterLiteral_type(self, ctx:AleoParser.Literal_typeContext): + pass + + # Exit a parse tree produced by AleoParser#literal_type. + def exitLiteral_type(self, ctx:AleoParser.Literal_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#array_type. + def enterArray_type(self, ctx:AleoParser.Array_typeContext): + pass + + # Exit a parse tree produced by AleoParser#array_type. + def exitArray_type(self, ctx:AleoParser.Array_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#plaintext_type. + def enterPlaintext_type(self, ctx:AleoParser.Plaintext_typeContext): + pass + + # Exit a parse tree produced by AleoParser#plaintext_type. + def exitPlaintext_type(self, ctx:AleoParser.Plaintext_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#value_type. + def enterValue_type(self, ctx:AleoParser.Value_typeContext): + pass + + # Exit a parse tree produced by AleoParser#value_type. + def exitValue_type(self, ctx:AleoParser.Value_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#mapping_type. + def enterMapping_type(self, ctx:AleoParser.Mapping_typeContext): + pass + + # Exit a parse tree produced by AleoParser#mapping_type. + def exitMapping_type(self, ctx:AleoParser.Mapping_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#finalize_type. + def enterFinalize_type(self, ctx:AleoParser.Finalize_typeContext): + pass + + # Exit a parse tree produced by AleoParser#finalize_type. + def exitFinalize_type(self, ctx:AleoParser.Finalize_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#entry_type. + def enterEntry_type(self, ctx:AleoParser.Entry_typeContext): + pass + + # Exit a parse tree produced by AleoParser#entry_type. + def exitEntry_type(self, ctx:AleoParser.Entry_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#register_type. + def enterRegister_type(self, ctx:AleoParser.Register_typeContext): + pass + + # Exit a parse tree produced by AleoParser#register_type. + def exitRegister_type(self, ctx:AleoParser.Register_typeContext): + pass + + + # Enter a parse tree produced by AleoParser#program_id. + def enterProgram_id(self, ctx:AleoParser.Program_idContext): + pass + + # Exit a parse tree produced by AleoParser#program_id. + def exitProgram_id(self, ctx:AleoParser.Program_idContext): + pass + + + # Enter a parse tree produced by AleoParser#program_name. + def enterProgram_name(self, ctx:AleoParser.Program_nameContext): + pass + + # Exit a parse tree produced by AleoParser#program_name. + def exitProgram_name(self, ctx:AleoParser.Program_nameContext): + pass + + + # Enter a parse tree produced by AleoParser#program_domain. + def enterProgram_domain(self, ctx:AleoParser.Program_domainContext): + pass + + # Exit a parse tree produced by AleoParser#program_domain. + def exitProgram_domain(self, ctx:AleoParser.Program_domainContext): + pass + + + # Enter a parse tree produced by AleoParser#register. + def enterRegister(self, ctx:AleoParser.RegisterContext): + pass + + # Exit a parse tree produced by AleoParser#register. + def exitRegister(self, ctx:AleoParser.RegisterContext): + pass + + + # Enter a parse tree produced by AleoParser#register_access. + def enterRegister_access(self, ctx:AleoParser.Register_accessContext): + pass + + # Exit a parse tree produced by AleoParser#register_access. + def exitRegister_access(self, ctx:AleoParser.Register_accessContext): + pass + + + # Enter a parse tree produced by AleoParser#register_accessor. + def enterRegister_accessor(self, ctx:AleoParser.Register_accessorContext): + pass + + # Exit a parse tree produced by AleoParser#register_accessor. + def exitRegister_accessor(self, ctx:AleoParser.Register_accessorContext): + pass + + + # Enter a parse tree produced by AleoParser#access_by_field. + def enterAccess_by_field(self, ctx:AleoParser.Access_by_fieldContext): + pass + + # Exit a parse tree produced by AleoParser#access_by_field. + def exitAccess_by_field(self, ctx:AleoParser.Access_by_fieldContext): + pass + + + # Enter a parse tree produced by AleoParser#access_by_index. + def enterAccess_by_index(self, ctx:AleoParser.Access_by_indexContext): + pass + + # Exit a parse tree produced by AleoParser#access_by_index. + def exitAccess_by_index(self, ctx:AleoParser.Access_by_indexContext): + pass + + + # Enter a parse tree produced by AleoParser#operand. + def enterOperand(self, ctx:AleoParser.OperandContext): + pass + + # Exit a parse tree produced by AleoParser#operand. + def exitOperand(self, ctx:AleoParser.OperandContext): + pass + + + # Enter a parse tree produced by AleoParser#tuple. + def enterTuple(self, ctx:AleoParser.TupleContext): + pass + + # Exit a parse tree produced by AleoParser#tuple. + def exitTuple(self, ctx:AleoParser.TupleContext): + pass + + + # Enter a parse tree produced by AleoParser#entry. + def enterEntry(self, ctx:AleoParser.EntryContext): + pass + + # Exit a parse tree produced by AleoParser#entry. + def exitEntry(self, ctx:AleoParser.EntryContext): + pass + + + # Enter a parse tree produced by AleoParser#locator. + def enterLocator(self, ctx:AleoParser.LocatorContext): + pass + + # Exit a parse tree produced by AleoParser#locator. + def exitLocator(self, ctx:AleoParser.LocatorContext): + pass + + + # Enter a parse tree produced by AleoParser#cast_destination. + def enterCast_destination(self, ctx:AleoParser.Cast_destinationContext): + pass + + # Exit a parse tree produced by AleoParser#cast_destination. + def exitCast_destination(self, ctx:AleoParser.Cast_destinationContext): + pass + + + # Enter a parse tree produced by AleoParser#unary_op. + def enterUnary_op(self, ctx:AleoParser.Unary_opContext): + pass + + # Exit a parse tree produced by AleoParser#unary_op. + def exitUnary_op(self, ctx:AleoParser.Unary_opContext): + pass + + + # Enter a parse tree produced by AleoParser#binary_op. + def enterBinary_op(self, ctx:AleoParser.Binary_opContext): + pass + + # Exit a parse tree produced by AleoParser#binary_op. + def exitBinary_op(self, ctx:AleoParser.Binary_opContext): + pass + + + # Enter a parse tree produced by AleoParser#is_op. + def enterIs_op(self, ctx:AleoParser.Is_opContext): + pass + + # Exit a parse tree produced by AleoParser#is_op. + def exitIs_op(self, ctx:AleoParser.Is_opContext): + pass + + + # Enter a parse tree produced by AleoParser#assert_op. + def enterAssert_op(self, ctx:AleoParser.Assert_opContext): + pass + + # Exit a parse tree produced by AleoParser#assert_op. + def exitAssert_op(self, ctx:AleoParser.Assert_opContext): + pass + + + # Enter a parse tree produced by AleoParser#commit_op. + def enterCommit_op(self, ctx:AleoParser.Commit_opContext): + pass + + # Exit a parse tree produced by AleoParser#commit_op. + def exitCommit_op(self, ctx:AleoParser.Commit_opContext): + pass + + + # Enter a parse tree produced by AleoParser#hash1_op. + def enterHash1_op(self, ctx:AleoParser.Hash1_opContext): + pass + + # Exit a parse tree produced by AleoParser#hash1_op. + def exitHash1_op(self, ctx:AleoParser.Hash1_opContext): + pass + + + # Enter a parse tree produced by AleoParser#hash2_op. + def enterHash2_op(self, ctx:AleoParser.Hash2_opContext): + pass + + # Exit a parse tree produced by AleoParser#hash2_op. + def exitHash2_op(self, ctx:AleoParser.Hash2_opContext): + pass + + + # Enter a parse tree produced by AleoParser#cast_op. + def enterCast_op(self, ctx:AleoParser.Cast_opContext): + pass + + # Exit a parse tree produced by AleoParser#cast_op. + def exitCast_op(self, ctx:AleoParser.Cast_opContext): + pass + + + # Enter a parse tree produced by AleoParser#branch_op. + def enterBranch_op(self, ctx:AleoParser.Branch_opContext): + pass + + # Exit a parse tree produced by AleoParser#branch_op. + def exitBranch_op(self, ctx:AleoParser.Branch_opContext): + pass + + + # Enter a parse tree produced by AleoParser#label. + def enterLabel(self, ctx:AleoParser.LabelContext): + pass + + # Exit a parse tree produced by AleoParser#label. + def exitLabel(self, ctx:AleoParser.LabelContext): + pass + + + # Enter a parse tree produced by AleoParser#identifier. + def enterIdentifier(self, ctx:AleoParser.IdentifierContext): + pass + + # Exit a parse tree produced by AleoParser#identifier. + def exitIdentifier(self, ctx:AleoParser.IdentifierContext): + pass + + + +del AleoParser \ No newline at end of file diff --git a/vanguard/aleo/parser/AleoParser.py b/vanguard/aleo/parser/AleoParser.py new file mode 100644 index 0000000..a477c1a --- /dev/null +++ b/vanguard/aleo/parser/AleoParser.py @@ -0,0 +1,6613 @@ +# Generated from ./Aleo.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,139,863,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,1,0,1,0,1,1,5,1,192,8,1,10,1,12,1,195,9,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,205,8,1,11,1,12,1,206,1,2,1, + 2,1,2,1,2,1,3,1,3,1,3,1,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,5,1,5,1, + 5,1,5,1,5,1,6,1,6,1,6,1,6,4,6,233,8,6,11,6,12,6,234,1,7,1,7,1,7, + 1,7,5,7,241,8,7,10,7,12,7,244,9,7,1,8,1,8,1,8,1,8,5,8,250,8,8,10, + 8,12,8,253,9,8,1,8,4,8,256,8,8,11,8,12,8,257,1,8,5,8,261,8,8,10, + 8,12,8,264,9,8,1,9,1,9,1,9,1,9,1,9,1,9,1,10,1,10,1,10,1,10,1,10, + 1,10,1,11,1,11,1,11,1,11,5,11,282,8,11,10,11,12,11,285,9,11,1,11, + 5,11,288,8,11,10,11,12,11,291,9,11,1,11,5,11,294,8,11,10,11,12,11, + 297,9,11,1,11,3,11,300,8,11,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,14,1,14,1,14,1,14,5,14,318,8,14,10,14,12, + 14,321,9,14,1,14,4,14,324,8,14,11,14,12,14,325,1,15,1,15,1,15,1, + 15,1,15,1,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,3, + 16,344,8,16,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,18,1, + 18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,19,1,19,1,19,1,19,1,19,1, + 19,1,19,1,19,1,19,1,19,1,20,1,20,1,20,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,5,22,392,8,22,10, + 22,12,22,395,9,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,3,22,404,8, + 22,1,22,1,22,1,23,1,23,1,23,1,23,1,24,1,24,1,24,1,24,1,24,1,24,1, + 24,1,25,1,25,1,25,1,25,1,26,1,26,1,26,1,26,1,26,1,26,1,26,1,26,1, + 26,1,26,1,26,3,26,434,8,26,1,27,1,27,1,27,1,27,1,27,1,27,1,28,1, + 28,1,28,1,28,1,28,1,28,1,28,1,29,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,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,3,32,478,8,32,1,32,1, + 32,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,3,33,492,8, + 33,1,33,1,33,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1, + 34,3,34,507,8,34,1,34,1,34,1,35,1,35,3,35,513,8,35,1,36,1,36,1,36, + 1,36,1,36,1,36,1,36,1,36,1,37,1,37,4,37,525,8,37,11,37,12,37,526, + 1,37,1,37,1,37,1,37,1,37,1,37,1,38,1,38,1,38,3,38,538,8,38,1,38, + 5,38,541,8,38,10,38,12,38,544,9,38,1,38,1,38,4,38,548,8,38,11,38, + 12,38,549,3,38,552,8,38,1,38,1,38,1,39,1,39,1,39,5,39,559,8,39,10, + 39,12,39,562,9,39,1,39,1,39,1,39,1,39,1,40,1,40,1,40,1,40,3,40,572, + 8,40,1,41,3,41,575,8,41,1,41,1,41,5,41,579,8,41,10,41,12,41,582, + 9,41,4,41,584,8,41,11,41,12,41,585,1,41,1,41,1,42,3,42,591,8,42, + 1,42,1,42,5,42,595,8,42,10,42,12,42,598,9,42,4,42,600,8,42,11,42, + 12,42,601,1,42,1,42,1,43,1,43,3,43,608,8,43,1,44,3,44,611,8,44,1, + 44,1,44,5,44,615,8,44,10,44,12,44,618,9,44,4,44,620,8,44,11,44,12, + 44,621,1,44,1,44,1,45,3,45,627,8,45,1,45,1,45,5,45,631,8,45,10,45, + 12,45,634,9,45,4,45,636,8,45,11,45,12,45,637,1,45,1,45,1,46,3,46, + 643,8,46,1,46,1,46,5,46,647,8,46,10,46,12,46,650,9,46,4,46,652,8, + 46,11,46,12,46,653,1,46,1,46,1,47,1,47,1,47,1,47,3,47,662,8,47,1, + 48,3,48,665,8,48,1,48,1,48,5,48,669,8,48,10,48,12,48,672,9,48,4, + 48,674,8,48,11,48,12,48,675,1,48,1,48,1,49,1,49,1,50,1,50,1,51,1, + 51,1,52,1,52,1,53,1,53,1,54,1,54,3,54,692,8,54,1,55,1,55,1,56,1, + 56,1,57,1,57,1,58,1,58,1,58,1,58,3,58,704,8,58,1,59,1,59,1,60,1, + 60,1,61,1,61,1,62,1,62,1,62,1,62,3,62,716,8,62,1,63,1,63,1,63,1, + 63,1,63,1,63,1,64,1,64,1,64,3,64,727,8,64,1,65,1,65,1,65,1,65,1, + 65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1, + 65,3,65,747,8,65,1,66,1,66,1,66,1,67,1,67,1,67,1,67,1,67,1,67,3, + 67,758,8,67,1,68,1,68,1,68,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1, + 69,1,69,1,69,3,69,773,8,69,1,70,1,70,1,70,1,70,1,71,1,71,1,72,1, + 72,1,73,1,73,1,74,1,74,5,74,787,8,74,10,74,12,74,790,9,74,1,75,1, + 75,3,75,794,8,75,1,76,1,76,1,76,1,77,1,77,1,77,1,77,1,77,1,77,4, + 77,805,8,77,11,77,12,77,806,1,77,3,77,810,8,77,1,78,1,78,1,78,1, + 78,1,78,1,78,1,78,3,78,819,8,78,1,79,1,79,1,79,1,79,1,79,1,80,1, + 80,1,80,1,80,1,80,1,81,1,81,1,81,1,81,1,82,1,82,1,82,1,82,3,82,839, + 8,82,1,83,1,83,1,84,1,84,1,85,1,85,1,86,1,86,1,87,1,87,1,88,1,88, + 1,89,1,89,1,90,1,90,1,91,1,91,1,92,1,92,1,93,1,93,1,93,0,0,94,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,0,14, + 1,0,29,30,1,0,36,37,2,0,35,35,38,41,1,0,42,46,1,0,53,55,1,0,66,73, + 1,0,74,99,1,0,100,101,1,0,102,103,1,0,104,109,1,0,110,124,1,0,125, + 127,1,0,128,129,1,0,130,131,881,0,188,1,0,0,0,2,193,1,0,0,0,4,208, + 1,0,0,0,6,212,1,0,0,0,8,218,1,0,0,0,10,223,1,0,0,0,12,228,1,0,0, + 0,14,236,1,0,0,0,16,245,1,0,0,0,18,265,1,0,0,0,20,271,1,0,0,0,22, + 277,1,0,0,0,24,301,1,0,0,0,26,307,1,0,0,0,28,313,1,0,0,0,30,327, + 1,0,0,0,32,343,1,0,0,0,34,345,1,0,0,0,36,354,1,0,0,0,38,363,1,0, + 0,0,40,373,1,0,0,0,42,382,1,0,0,0,44,389,1,0,0,0,46,407,1,0,0,0, + 48,411,1,0,0,0,50,418,1,0,0,0,52,433,1,0,0,0,54,435,1,0,0,0,56,441, + 1,0,0,0,58,448,1,0,0,0,60,456,1,0,0,0,62,463,1,0,0,0,64,468,1,0, + 0,0,66,481,1,0,0,0,68,495,1,0,0,0,70,512,1,0,0,0,72,514,1,0,0,0, + 74,522,1,0,0,0,76,534,1,0,0,0,78,555,1,0,0,0,80,571,1,0,0,0,82,574, + 1,0,0,0,84,590,1,0,0,0,86,607,1,0,0,0,88,610,1,0,0,0,90,626,1,0, + 0,0,92,642,1,0,0,0,94,661,1,0,0,0,96,664,1,0,0,0,98,679,1,0,0,0, + 100,681,1,0,0,0,102,683,1,0,0,0,104,685,1,0,0,0,106,687,1,0,0,0, + 108,691,1,0,0,0,110,693,1,0,0,0,112,695,1,0,0,0,114,697,1,0,0,0, + 116,703,1,0,0,0,118,705,1,0,0,0,120,707,1,0,0,0,122,709,1,0,0,0, + 124,715,1,0,0,0,126,717,1,0,0,0,128,726,1,0,0,0,130,746,1,0,0,0, + 132,748,1,0,0,0,134,757,1,0,0,0,136,759,1,0,0,0,138,772,1,0,0,0, + 140,774,1,0,0,0,142,778,1,0,0,0,144,780,1,0,0,0,146,782,1,0,0,0, + 148,784,1,0,0,0,150,793,1,0,0,0,152,795,1,0,0,0,154,809,1,0,0,0, + 156,818,1,0,0,0,158,820,1,0,0,0,160,825,1,0,0,0,162,830,1,0,0,0, + 164,838,1,0,0,0,166,840,1,0,0,0,168,842,1,0,0,0,170,844,1,0,0,0, + 172,846,1,0,0,0,174,848,1,0,0,0,176,850,1,0,0,0,178,852,1,0,0,0, + 180,854,1,0,0,0,182,856,1,0,0,0,184,858,1,0,0,0,186,860,1,0,0,0, + 188,189,3,2,1,0,189,1,1,0,0,0,190,192,3,4,2,0,191,190,1,0,0,0,192, + 195,1,0,0,0,193,191,1,0,0,0,193,194,1,0,0,0,194,196,1,0,0,0,195, + 193,1,0,0,0,196,197,5,1,0,0,197,198,3,140,70,0,198,204,5,2,0,0,199, + 205,3,6,3,0,200,205,3,12,6,0,201,205,3,14,7,0,202,205,3,16,8,0,203, + 205,3,22,11,0,204,199,1,0,0,0,204,200,1,0,0,0,204,201,1,0,0,0,204, + 202,1,0,0,0,204,203,1,0,0,0,205,206,1,0,0,0,206,204,1,0,0,0,206, + 207,1,0,0,0,207,3,1,0,0,0,208,209,5,3,0,0,209,210,3,140,70,0,210, + 211,5,2,0,0,211,5,1,0,0,0,212,213,5,4,0,0,213,214,3,186,93,0,214, + 215,5,5,0,0,215,216,3,8,4,0,216,217,3,10,5,0,217,7,1,0,0,0,218,219, + 5,6,0,0,219,220,5,7,0,0,220,221,3,132,66,0,221,222,5,2,0,0,222,9, + 1,0,0,0,223,224,5,8,0,0,224,225,5,7,0,0,225,226,3,132,66,0,226,227, + 5,2,0,0,227,11,1,0,0,0,228,229,5,9,0,0,229,230,3,186,93,0,230,232, + 5,5,0,0,231,233,3,158,79,0,232,231,1,0,0,0,233,234,1,0,0,0,234,232, + 1,0,0,0,234,235,1,0,0,0,235,13,1,0,0,0,236,237,5,10,0,0,237,238, + 3,186,93,0,238,242,5,5,0,0,239,241,3,160,80,0,240,239,1,0,0,0,241, + 244,1,0,0,0,242,240,1,0,0,0,242,243,1,0,0,0,243,15,1,0,0,0,244,242, + 1,0,0,0,245,246,5,11,0,0,246,247,3,186,93,0,247,251,5,5,0,0,248, + 250,3,18,9,0,249,248,1,0,0,0,250,253,1,0,0,0,251,249,1,0,0,0,251, + 252,1,0,0,0,252,255,1,0,0,0,253,251,1,0,0,0,254,256,3,52,26,0,255, + 254,1,0,0,0,256,257,1,0,0,0,257,255,1,0,0,0,257,258,1,0,0,0,258, + 262,1,0,0,0,259,261,3,20,10,0,260,259,1,0,0,0,261,264,1,0,0,0,262, + 260,1,0,0,0,262,263,1,0,0,0,263,17,1,0,0,0,264,262,1,0,0,0,265,266, + 5,12,0,0,266,267,3,146,73,0,267,268,5,7,0,0,268,269,3,138,69,0,269, + 270,5,2,0,0,270,19,1,0,0,0,271,272,5,13,0,0,272,273,3,156,78,0,273, + 274,5,7,0,0,274,275,3,138,69,0,275,276,5,2,0,0,276,21,1,0,0,0,277, + 278,5,14,0,0,278,279,3,186,93,0,279,283,5,5,0,0,280,282,3,24,12, + 0,281,280,1,0,0,0,282,285,1,0,0,0,283,281,1,0,0,0,283,284,1,0,0, + 0,284,289,1,0,0,0,285,283,1,0,0,0,286,288,3,52,26,0,287,286,1,0, + 0,0,288,291,1,0,0,0,289,287,1,0,0,0,289,290,1,0,0,0,290,295,1,0, + 0,0,291,289,1,0,0,0,292,294,3,26,13,0,293,292,1,0,0,0,294,297,1, + 0,0,0,295,293,1,0,0,0,295,296,1,0,0,0,296,299,1,0,0,0,297,295,1, + 0,0,0,298,300,3,28,14,0,299,298,1,0,0,0,299,300,1,0,0,0,300,23,1, + 0,0,0,301,302,5,12,0,0,302,303,3,146,73,0,303,304,5,7,0,0,304,305, + 3,130,65,0,305,306,5,2,0,0,306,25,1,0,0,0,307,308,5,13,0,0,308,309, + 3,156,78,0,309,310,5,7,0,0,310,311,3,130,65,0,311,312,5,2,0,0,312, + 27,1,0,0,0,313,314,5,15,0,0,314,315,3,186,93,0,315,319,5,5,0,0,316, + 318,3,30,15,0,317,316,1,0,0,0,318,321,1,0,0,0,319,317,1,0,0,0,319, + 320,1,0,0,0,320,323,1,0,0,0,321,319,1,0,0,0,322,324,3,32,16,0,323, + 322,1,0,0,0,324,325,1,0,0,0,325,323,1,0,0,0,325,326,1,0,0,0,326, + 29,1,0,0,0,327,328,5,12,0,0,328,329,3,146,73,0,329,330,5,7,0,0,330, + 331,3,134,67,0,331,332,5,2,0,0,332,31,1,0,0,0,333,344,3,34,17,0, + 334,344,3,36,18,0,335,344,3,38,19,0,336,344,3,40,20,0,337,344,3, + 42,21,0,338,344,3,44,22,0,339,344,3,46,23,0,340,344,3,48,24,0,341, + 344,3,50,25,0,342,344,3,52,26,0,343,333,1,0,0,0,343,334,1,0,0,0, + 343,335,1,0,0,0,343,336,1,0,0,0,343,337,1,0,0,0,343,338,1,0,0,0, + 343,339,1,0,0,0,343,340,1,0,0,0,343,341,1,0,0,0,343,342,1,0,0,0, + 344,33,1,0,0,0,345,346,5,16,0,0,346,347,3,186,93,0,347,348,5,17, + 0,0,348,349,3,156,78,0,349,350,5,18,0,0,350,351,5,19,0,0,351,352, + 3,148,74,0,352,353,5,2,0,0,353,35,1,0,0,0,354,355,5,20,0,0,355,356, + 3,186,93,0,356,357,5,17,0,0,357,358,3,156,78,0,358,359,5,18,0,0, + 359,360,5,19,0,0,360,361,3,148,74,0,361,362,5,2,0,0,362,37,1,0,0, + 0,363,364,5,21,0,0,364,365,3,186,93,0,365,366,5,17,0,0,366,367,3, + 156,78,0,367,368,5,18,0,0,368,369,3,156,78,0,369,370,5,19,0,0,370, + 371,3,148,74,0,371,372,5,2,0,0,372,39,1,0,0,0,373,374,5,22,0,0,374, + 375,3,156,78,0,375,376,5,19,0,0,376,377,3,186,93,0,377,378,5,17, + 0,0,378,379,3,156,78,0,379,380,5,18,0,0,380,381,5,2,0,0,381,41,1, + 0,0,0,382,383,5,23,0,0,383,384,3,186,93,0,384,385,5,17,0,0,385,386, + 3,156,78,0,386,387,5,18,0,0,387,388,5,2,0,0,388,43,1,0,0,0,389,393, + 5,24,0,0,390,392,3,156,78,0,391,390,1,0,0,0,392,395,1,0,0,0,393, + 391,1,0,0,0,393,394,1,0,0,0,394,396,1,0,0,0,395,393,1,0,0,0,396, + 397,5,19,0,0,397,398,3,148,74,0,398,403,5,7,0,0,399,404,3,116,58, + 0,400,404,3,118,59,0,401,404,3,122,61,0,402,404,3,120,60,0,403,399, + 1,0,0,0,403,400,1,0,0,0,403,401,1,0,0,0,403,402,1,0,0,0,404,405, + 1,0,0,0,405,406,5,2,0,0,406,45,1,0,0,0,407,408,5,25,0,0,408,409, + 3,184,92,0,409,410,5,2,0,0,410,47,1,0,0,0,411,412,3,182,91,0,412, + 413,3,156,78,0,413,414,3,156,78,0,414,415,5,26,0,0,415,416,3,184, + 92,0,416,417,5,2,0,0,417,49,1,0,0,0,418,419,5,27,0,0,419,420,3,148, + 74,0,420,421,5,2,0,0,421,51,1,0,0,0,422,434,3,54,27,0,423,434,3, + 56,28,0,424,434,3,58,29,0,425,434,3,60,30,0,426,434,3,62,31,0,427, + 434,3,64,32,0,428,434,3,70,35,0,429,434,3,72,36,0,430,434,3,74,37, + 0,431,434,3,76,38,0,432,434,3,78,39,0,433,422,1,0,0,0,433,423,1, + 0,0,0,433,424,1,0,0,0,433,425,1,0,0,0,433,426,1,0,0,0,433,427,1, + 0,0,0,433,428,1,0,0,0,433,429,1,0,0,0,433,430,1,0,0,0,433,431,1, + 0,0,0,433,432,1,0,0,0,434,53,1,0,0,0,435,436,3,166,83,0,436,437, + 3,156,78,0,437,438,5,19,0,0,438,439,3,148,74,0,439,440,5,2,0,0,440, + 55,1,0,0,0,441,442,3,168,84,0,442,443,3,156,78,0,443,444,3,156,78, + 0,444,445,5,19,0,0,445,446,3,148,74,0,446,447,5,2,0,0,447,57,1,0, + 0,0,448,449,5,28,0,0,449,450,3,156,78,0,450,451,3,156,78,0,451,452, + 3,156,78,0,452,453,5,19,0,0,453,454,3,148,74,0,454,455,5,2,0,0,455, + 59,1,0,0,0,456,457,3,170,85,0,457,458,3,156,78,0,458,459,3,156,78, + 0,459,460,5,19,0,0,460,461,3,148,74,0,461,462,5,2,0,0,462,61,1,0, + 0,0,463,464,3,172,86,0,464,465,3,156,78,0,465,466,3,156,78,0,466, + 467,5,2,0,0,467,63,1,0,0,0,468,469,3,174,87,0,469,470,3,156,78,0, + 470,471,3,156,78,0,471,472,5,19,0,0,472,473,3,148,74,0,473,477,5, + 7,0,0,474,478,3,118,59,0,475,478,3,110,55,0,476,478,3,112,56,0,477, + 474,1,0,0,0,477,475,1,0,0,0,477,476,1,0,0,0,478,479,1,0,0,0,479, + 480,5,2,0,0,480,65,1,0,0,0,481,482,3,176,88,0,482,483,3,156,78,0, + 483,484,5,19,0,0,484,485,3,148,74,0,485,491,5,7,0,0,486,492,3,116, + 58,0,487,492,3,118,59,0,488,492,3,122,61,0,489,492,3,126,63,0,490, + 492,3,186,93,0,491,486,1,0,0,0,491,487,1,0,0,0,491,488,1,0,0,0,491, + 489,1,0,0,0,491,490,1,0,0,0,492,493,1,0,0,0,493,494,5,2,0,0,494, + 67,1,0,0,0,495,496,3,178,89,0,496,497,3,156,78,0,497,498,3,156,78, + 0,498,499,5,19,0,0,499,500,3,148,74,0,500,506,5,7,0,0,501,507,3, + 116,58,0,502,507,3,118,59,0,503,507,3,122,61,0,504,507,3,126,63, + 0,505,507,3,186,93,0,506,501,1,0,0,0,506,502,1,0,0,0,506,503,1,0, + 0,0,506,504,1,0,0,0,506,505,1,0,0,0,507,508,1,0,0,0,508,509,5,2, + 0,0,509,69,1,0,0,0,510,513,3,66,33,0,511,513,3,68,34,0,512,510,1, + 0,0,0,512,511,1,0,0,0,513,71,1,0,0,0,514,515,7,0,0,0,515,516,3,156, + 78,0,516,517,3,156,78,0,517,518,3,156,78,0,518,519,5,19,0,0,519, + 520,3,148,74,0,520,521,5,2,0,0,521,73,1,0,0,0,522,524,3,180,90,0, + 523,525,3,156,78,0,524,523,1,0,0,0,525,526,1,0,0,0,526,524,1,0,0, + 0,526,527,1,0,0,0,527,528,1,0,0,0,528,529,5,19,0,0,529,530,3,148, + 74,0,530,531,5,7,0,0,531,532,3,164,82,0,532,533,5,2,0,0,533,75,1, + 0,0,0,534,537,5,31,0,0,535,538,3,162,81,0,536,538,3,186,93,0,537, + 535,1,0,0,0,537,536,1,0,0,0,538,542,1,0,0,0,539,541,3,156,78,0,540, + 539,1,0,0,0,541,544,1,0,0,0,542,540,1,0,0,0,542,543,1,0,0,0,543, + 551,1,0,0,0,544,542,1,0,0,0,545,547,5,19,0,0,546,548,3,148,74,0, + 547,546,1,0,0,0,548,549,1,0,0,0,549,547,1,0,0,0,549,550,1,0,0,0, + 550,552,1,0,0,0,551,545,1,0,0,0,551,552,1,0,0,0,552,553,1,0,0,0, + 553,554,5,2,0,0,554,77,1,0,0,0,555,556,5,32,0,0,556,560,3,186,93, + 0,557,559,3,156,78,0,558,557,1,0,0,0,559,562,1,0,0,0,560,558,1,0, + 0,0,560,561,1,0,0,0,561,563,1,0,0,0,562,560,1,0,0,0,563,564,5,19, + 0,0,564,565,3,148,74,0,565,566,5,2,0,0,566,79,1,0,0,0,567,572,3, + 94,47,0,568,572,3,98,49,0,569,572,3,100,50,0,570,572,3,102,51,0, + 571,567,1,0,0,0,571,568,1,0,0,0,571,569,1,0,0,0,571,570,1,0,0,0, + 572,81,1,0,0,0,573,575,5,33,0,0,574,573,1,0,0,0,574,575,1,0,0,0, + 575,583,1,0,0,0,576,580,5,136,0,0,577,579,5,34,0,0,578,577,1,0,0, + 0,579,582,1,0,0,0,580,578,1,0,0,0,580,581,1,0,0,0,581,584,1,0,0, + 0,582,580,1,0,0,0,583,576,1,0,0,0,584,585,1,0,0,0,585,583,1,0,0, + 0,585,586,1,0,0,0,586,587,1,0,0,0,587,588,3,106,53,0,588,83,1,0, + 0,0,589,591,5,33,0,0,590,589,1,0,0,0,590,591,1,0,0,0,591,599,1,0, + 0,0,592,596,5,136,0,0,593,595,5,34,0,0,594,593,1,0,0,0,595,598,1, + 0,0,0,596,594,1,0,0,0,596,597,1,0,0,0,597,600,1,0,0,0,598,596,1, + 0,0,0,599,592,1,0,0,0,600,601,1,0,0,0,601,599,1,0,0,0,601,602,1, + 0,0,0,602,603,1,0,0,0,603,604,3,104,52,0,604,85,1,0,0,0,605,608, + 3,82,41,0,606,608,3,84,42,0,607,605,1,0,0,0,607,606,1,0,0,0,608, + 87,1,0,0,0,609,611,5,33,0,0,610,609,1,0,0,0,610,611,1,0,0,0,611, + 619,1,0,0,0,612,616,5,136,0,0,613,615,5,34,0,0,614,613,1,0,0,0,615, + 618,1,0,0,0,616,614,1,0,0,0,616,617,1,0,0,0,617,620,1,0,0,0,618, + 616,1,0,0,0,619,612,1,0,0,0,620,621,1,0,0,0,621,619,1,0,0,0,621, + 622,1,0,0,0,622,623,1,0,0,0,623,624,3,110,55,0,624,89,1,0,0,0,625, + 627,5,33,0,0,626,625,1,0,0,0,626,627,1,0,0,0,627,635,1,0,0,0,628, + 632,5,136,0,0,629,631,5,34,0,0,630,629,1,0,0,0,631,634,1,0,0,0,632, + 630,1,0,0,0,632,633,1,0,0,0,633,636,1,0,0,0,634,632,1,0,0,0,635, + 628,1,0,0,0,636,637,1,0,0,0,637,635,1,0,0,0,637,638,1,0,0,0,638, + 639,1,0,0,0,639,640,3,112,56,0,640,91,1,0,0,0,641,643,5,33,0,0,642, + 641,1,0,0,0,642,643,1,0,0,0,643,651,1,0,0,0,644,648,5,136,0,0,645, + 647,5,34,0,0,646,645,1,0,0,0,647,650,1,0,0,0,648,646,1,0,0,0,648, + 649,1,0,0,0,649,652,1,0,0,0,650,648,1,0,0,0,651,644,1,0,0,0,652, + 653,1,0,0,0,653,651,1,0,0,0,653,654,1,0,0,0,654,655,1,0,0,0,655, + 656,3,114,57,0,656,93,1,0,0,0,657,662,3,86,43,0,658,662,3,88,44, + 0,659,662,3,90,45,0,660,662,3,92,46,0,661,657,1,0,0,0,661,658,1, + 0,0,0,661,659,1,0,0,0,661,660,1,0,0,0,662,95,1,0,0,0,663,665,5,33, + 0,0,664,663,1,0,0,0,664,665,1,0,0,0,665,673,1,0,0,0,666,670,5,136, + 0,0,667,669,5,34,0,0,668,667,1,0,0,0,669,672,1,0,0,0,670,668,1,0, + 0,0,670,671,1,0,0,0,671,674,1,0,0,0,672,670,1,0,0,0,673,666,1,0, + 0,0,674,675,1,0,0,0,675,673,1,0,0,0,675,676,1,0,0,0,676,677,1,0, + 0,0,677,678,5,35,0,0,678,97,1,0,0,0,679,680,5,132,0,0,680,99,1,0, + 0,0,681,682,5,133,0,0,682,101,1,0,0,0,683,684,7,1,0,0,684,103,1, + 0,0,0,685,686,7,2,0,0,686,105,1,0,0,0,687,688,7,3,0,0,688,107,1, + 0,0,0,689,692,3,104,52,0,690,692,3,106,53,0,691,689,1,0,0,0,691, + 690,1,0,0,0,692,109,1,0,0,0,693,694,5,47,0,0,694,111,1,0,0,0,695, + 696,5,48,0,0,696,113,1,0,0,0,697,698,5,49,0,0,698,115,1,0,0,0,699, + 704,3,108,54,0,700,704,3,110,55,0,701,704,3,112,56,0,702,704,3,114, + 57,0,703,699,1,0,0,0,703,700,1,0,0,0,703,701,1,0,0,0,703,702,1,0, + 0,0,704,117,1,0,0,0,705,706,5,50,0,0,706,119,1,0,0,0,707,708,5,51, + 0,0,708,121,1,0,0,0,709,710,5,52,0,0,710,123,1,0,0,0,711,716,3,116, + 58,0,712,716,3,118,59,0,713,716,3,122,61,0,714,716,3,120,60,0,715, + 711,1,0,0,0,715,712,1,0,0,0,715,713,1,0,0,0,715,714,1,0,0,0,716, + 125,1,0,0,0,717,718,5,17,0,0,718,719,3,128,64,0,719,720,5,2,0,0, + 720,721,3,96,48,0,721,722,5,18,0,0,722,127,1,0,0,0,723,727,3,124, + 62,0,724,727,3,126,63,0,725,727,3,186,93,0,726,723,1,0,0,0,726,724, + 1,0,0,0,726,725,1,0,0,0,727,129,1,0,0,0,728,729,3,128,64,0,729,730, + 5,53,0,0,730,747,1,0,0,0,731,732,3,128,64,0,732,733,5,54,0,0,733, + 747,1,0,0,0,734,735,3,128,64,0,735,736,5,55,0,0,736,747,1,0,0,0, + 737,738,3,186,93,0,738,739,5,56,0,0,739,747,1,0,0,0,740,741,3,162, + 81,0,741,742,5,56,0,0,742,747,1,0,0,0,743,744,3,162,81,0,744,745, + 5,57,0,0,745,747,1,0,0,0,746,728,1,0,0,0,746,731,1,0,0,0,746,734, + 1,0,0,0,746,737,1,0,0,0,746,740,1,0,0,0,746,743,1,0,0,0,747,131, + 1,0,0,0,748,749,3,128,64,0,749,750,5,54,0,0,750,133,1,0,0,0,751, + 752,3,128,64,0,752,753,5,54,0,0,753,758,1,0,0,0,754,755,3,162,81, + 0,755,756,5,57,0,0,756,758,1,0,0,0,757,751,1,0,0,0,757,754,1,0,0, + 0,758,135,1,0,0,0,759,760,3,128,64,0,760,761,7,4,0,0,761,137,1,0, + 0,0,762,763,3,162,81,0,763,764,5,57,0,0,764,773,1,0,0,0,765,766, + 3,162,81,0,766,767,5,56,0,0,767,773,1,0,0,0,768,769,3,186,93,0,769, + 770,5,56,0,0,770,773,1,0,0,0,771,773,3,128,64,0,772,762,1,0,0,0, + 772,765,1,0,0,0,772,768,1,0,0,0,772,771,1,0,0,0,773,139,1,0,0,0, + 774,775,3,142,71,0,775,776,5,58,0,0,776,777,3,144,72,0,777,141,1, + 0,0,0,778,779,3,186,93,0,779,143,1,0,0,0,780,781,3,186,93,0,781, + 145,1,0,0,0,782,783,5,134,0,0,783,147,1,0,0,0,784,788,3,146,73,0, + 785,787,3,150,75,0,786,785,1,0,0,0,787,790,1,0,0,0,788,786,1,0,0, + 0,788,789,1,0,0,0,789,149,1,0,0,0,790,788,1,0,0,0,791,794,3,152, + 76,0,792,794,3,154,77,0,793,791,1,0,0,0,793,792,1,0,0,0,794,151, + 1,0,0,0,795,796,5,58,0,0,796,797,3,186,93,0,797,153,1,0,0,0,798, + 799,5,17,0,0,799,800,3,96,48,0,800,801,5,18,0,0,801,810,1,0,0,0, + 802,804,5,17,0,0,803,805,5,136,0,0,804,803,1,0,0,0,805,806,1,0,0, + 0,806,804,1,0,0,0,806,807,1,0,0,0,807,808,1,0,0,0,808,810,5,18,0, + 0,809,798,1,0,0,0,809,802,1,0,0,0,810,155,1,0,0,0,811,819,3,80,40, + 0,812,819,5,59,0,0,813,819,3,148,74,0,814,819,3,140,70,0,815,819, + 5,60,0,0,816,819,5,61,0,0,817,819,5,62,0,0,818,811,1,0,0,0,818,812, + 1,0,0,0,818,813,1,0,0,0,818,814,1,0,0,0,818,815,1,0,0,0,818,816, + 1,0,0,0,818,817,1,0,0,0,819,157,1,0,0,0,820,821,3,186,93,0,821,822, + 5,7,0,0,822,823,3,128,64,0,823,824,5,2,0,0,824,159,1,0,0,0,825,826, + 3,186,93,0,826,827,5,7,0,0,827,828,3,136,68,0,828,829,5,2,0,0,829, + 161,1,0,0,0,830,831,3,140,70,0,831,832,5,63,0,0,832,833,3,186,93, + 0,833,163,1,0,0,0,834,839,3,138,69,0,835,839,3,162,81,0,836,839, + 5,64,0,0,837,839,5,65,0,0,838,834,1,0,0,0,838,835,1,0,0,0,838,836, + 1,0,0,0,838,837,1,0,0,0,839,165,1,0,0,0,840,841,7,5,0,0,841,167, + 1,0,0,0,842,843,7,6,0,0,843,169,1,0,0,0,844,845,7,7,0,0,845,171, + 1,0,0,0,846,847,7,8,0,0,847,173,1,0,0,0,848,849,7,9,0,0,849,175, + 1,0,0,0,850,851,7,10,0,0,851,177,1,0,0,0,852,853,7,11,0,0,853,179, + 1,0,0,0,854,855,7,12,0,0,855,181,1,0,0,0,856,857,7,13,0,0,857,183, + 1,0,0,0,858,859,3,186,93,0,859,185,1,0,0,0,860,861,5,135,0,0,861, + 187,1,0,0,0,62,193,204,206,234,242,251,257,262,283,289,295,299,319, + 325,343,393,403,433,477,491,506,512,526,537,542,549,551,560,571, + 574,580,585,590,596,601,607,610,616,621,626,632,637,642,648,653, + 661,664,670,675,691,703,715,726,746,757,772,788,793,806,809,818, + 838 + ] + +class AleoParser ( Parser ): + + grammarFileName = "Aleo.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + sharedContextCache = PredictionContextCache() + + literalNames = [ "", "'program'", "';'", "'import'", "'mapping'", + "':'", "'key'", "'as'", "'value'", "'struct'", "'record'", + "'closure'", "'input'", "'output'", "'function'", "'finalize'", + "'contains'", "'['", "']'", "'into'", "'get'", "'get.or_use'", + "'set'", "'remove'", "'rand.chacha'", "'position'", + "'to'", "'await'", "'ternary'", "'sign.verify'", "'sign_verify'", + "'call'", "'async'", "'-'", "'_'", "'u32'", "'true'", + "'false'", "'u8'", "'u16'", "'u64'", "'u128'", "'i8'", + "'i16'", "'i32'", "'i64'", "'i128'", "'field'", "'group'", + "'scalar'", "'address'", "'boolean'", "'signature'", + "'.constant'", "'.public'", "'.private'", "'.record'", + "'.future'", "'.'", "'group::GEN'", "'self.signer'", + "'self.caller'", "'block.height'", "'/'", "'group.x'", + "'group.y'", "'abs'", "'abs.w'", "'double'", "'inv'", + "'neg'", "'not'", "'square'", "'sqrt'", "'add'", "'add.w'", + "'sub'", "'sub.w'", "'mul'", "'mul.w'", "'div'", "'div.w'", + "'rem'", "'rem.w'", "'pow'", "'pow.w'", "'shl'", "'shl.w'", + "'shr'", "'shr.w'", "'mod'", "'and'", "'or'", "'xor'", + "'nand'", "'nor'", "'gt'", "'gte'", "'lt'", "'lte'", + "'is.eq'", "'is.neq'", "'assert.eq'", "'assert.neq'", + "'commit.bhp256'", "'commit.bhp512'", "'commit.bhp768'", + "'commit.bhp1024'", "'commit.ped64'", "'commit.ped128'", + "'hash.bhp256'", "'hash.bhp512'", "'hash.bhp768'", + "'hash.bhp1024'", "'hash.ped64'", "'hash.ped128'", + "'hash.psd2'", "'hash.psd4'", "'hash.psd8'", "'hash.keccak256'", + "'hash.keccak384'", "'hash.keccak512'", "'hash.sha3_256'", + "'hash.sha3_384'", "'hash.sha3_512'", "'hash_many.psd2'", + "'hash_many.psd4'", "'hash_many.psd8'", "'cast.lossy'", + "'cast'", "'branch.eq'", "'branch.neq'" ] + + symbolicNames = [ "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "ADDRESS_LITERAL", "SIGNATURE_LITERAL", "REGISTER", + "IDENTIFIER", "DIGIT", "WS", "COMMENT", "LINE_COMMENT" ] + + RULE_start = 0 + RULE_program = 1 + RULE_ximport = 2 + RULE_mapping = 3 + RULE_mapping_key = 4 + RULE_mapping_value = 5 + RULE_struct = 6 + RULE_record = 7 + RULE_closure = 8 + RULE_closure_input = 9 + RULE_closure_output = 10 + RULE_function = 11 + RULE_function_input = 12 + RULE_function_output = 13 + RULE_finalize = 14 + RULE_finalize_input = 15 + RULE_command = 16 + RULE_contains = 17 + RULE_get = 18 + RULE_get_or_use = 19 + RULE_set = 20 + RULE_remove = 21 + RULE_random = 22 + RULE_position = 23 + RULE_branch = 24 + RULE_xawait = 25 + RULE_instruction = 26 + RULE_unary = 27 + RULE_binary = 28 + RULE_ternary = 29 + RULE_is = 30 + RULE_assert = 31 + RULE_commit = 32 + RULE_hash1 = 33 + RULE_hash2 = 34 + RULE_hash = 35 + RULE_signverify = 36 + RULE_cast = 37 + RULE_call = 38 + RULE_xasync = 39 + RULE_literal = 40 + RULE_signed_literal = 41 + RULE_unsigned_literal = 42 + RULE_integer_literal = 43 + RULE_field_literal = 44 + RULE_group_literal = 45 + RULE_scalar_literal = 46 + RULE_arithmetic_literal = 47 + RULE_u32_literal = 48 + RULE_address_literal = 49 + RULE_signature_literal = 50 + RULE_boolean_literal = 51 + RULE_unsigned_type = 52 + RULE_signed_type = 53 + RULE_integer_type = 54 + RULE_field_type = 55 + RULE_group_type = 56 + RULE_scalar_type = 57 + RULE_arithmetic_type = 58 + RULE_address_type = 59 + RULE_boolean_type = 60 + RULE_signature_type = 61 + RULE_literal_type = 62 + RULE_array_type = 63 + RULE_plaintext_type = 64 + RULE_value_type = 65 + RULE_mapping_type = 66 + RULE_finalize_type = 67 + RULE_entry_type = 68 + RULE_register_type = 69 + RULE_program_id = 70 + RULE_program_name = 71 + RULE_program_domain = 72 + RULE_register = 73 + RULE_register_access = 74 + RULE_register_accessor = 75 + RULE_access_by_field = 76 + RULE_access_by_index = 77 + RULE_operand = 78 + RULE_tuple = 79 + RULE_entry = 80 + RULE_locator = 81 + RULE_cast_destination = 82 + RULE_unary_op = 83 + RULE_binary_op = 84 + RULE_is_op = 85 + RULE_assert_op = 86 + RULE_commit_op = 87 + RULE_hash1_op = 88 + RULE_hash2_op = 89 + RULE_cast_op = 90 + RULE_branch_op = 91 + RULE_label = 92 + RULE_identifier = 93 + + ruleNames = [ "start", "program", "ximport", "mapping", "mapping_key", + "mapping_value", "struct", "record", "closure", "closure_input", + "closure_output", "function", "function_input", "function_output", + "finalize", "finalize_input", "command", "contains", + "get", "get_or_use", "set", "remove", "random", "position", + "branch", "xawait", "instruction", "unary", "binary", + "ternary", "is", "assert", "commit", "hash1", "hash2", + "hash", "signverify", "cast", "call", "xasync", "literal", + "signed_literal", "unsigned_literal", "integer_literal", + "field_literal", "group_literal", "scalar_literal", "arithmetic_literal", + "u32_literal", "address_literal", "signature_literal", + "boolean_literal", "unsigned_type", "signed_type", "integer_type", + "field_type", "group_type", "scalar_type", "arithmetic_type", + "address_type", "boolean_type", "signature_type", "literal_type", + "array_type", "plaintext_type", "value_type", "mapping_type", + "finalize_type", "entry_type", "register_type", "program_id", + "program_name", "program_domain", "register", "register_access", + "register_accessor", "access_by_field", "access_by_index", + "operand", "tuple", "entry", "locator", "cast_destination", + "unary_op", "binary_op", "is_op", "assert_op", "commit_op", + "hash1_op", "hash2_op", "cast_op", "branch_op", "label", + "identifier" ] + + EOF = Token.EOF + T__0=1 + T__1=2 + T__2=3 + T__3=4 + T__4=5 + T__5=6 + T__6=7 + T__7=8 + T__8=9 + T__9=10 + T__10=11 + T__11=12 + T__12=13 + T__13=14 + T__14=15 + T__15=16 + T__16=17 + T__17=18 + T__18=19 + T__19=20 + T__20=21 + T__21=22 + T__22=23 + T__23=24 + T__24=25 + T__25=26 + T__26=27 + T__27=28 + T__28=29 + T__29=30 + T__30=31 + T__31=32 + T__32=33 + T__33=34 + T__34=35 + T__35=36 + T__36=37 + T__37=38 + T__38=39 + T__39=40 + T__40=41 + T__41=42 + T__42=43 + T__43=44 + T__44=45 + T__45=46 + T__46=47 + T__47=48 + T__48=49 + T__49=50 + T__50=51 + T__51=52 + T__52=53 + T__53=54 + T__54=55 + T__55=56 + T__56=57 + T__57=58 + T__58=59 + T__59=60 + T__60=61 + T__61=62 + T__62=63 + T__63=64 + T__64=65 + T__65=66 + T__66=67 + T__67=68 + T__68=69 + T__69=70 + T__70=71 + T__71=72 + T__72=73 + T__73=74 + T__74=75 + T__75=76 + T__76=77 + T__77=78 + T__78=79 + T__79=80 + T__80=81 + T__81=82 + T__82=83 + T__83=84 + T__84=85 + T__85=86 + T__86=87 + T__87=88 + T__88=89 + T__89=90 + T__90=91 + T__91=92 + T__92=93 + T__93=94 + T__94=95 + T__95=96 + T__96=97 + T__97=98 + T__98=99 + T__99=100 + T__100=101 + T__101=102 + T__102=103 + T__103=104 + T__104=105 + T__105=106 + T__106=107 + T__107=108 + T__108=109 + T__109=110 + T__110=111 + T__111=112 + T__112=113 + T__113=114 + T__114=115 + T__115=116 + T__116=117 + T__117=118 + T__118=119 + T__119=120 + T__120=121 + T__121=122 + T__122=123 + T__123=124 + T__124=125 + T__125=126 + T__126=127 + T__127=128 + T__128=129 + T__129=130 + T__130=131 + ADDRESS_LITERAL=132 + SIGNATURE_LITERAL=133 + REGISTER=134 + IDENTIFIER=135 + DIGIT=136 + WS=137 + COMMENT=138 + LINE_COMMENT=139 + + 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 StartContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def program(self): + return self.getTypedRuleContext(AleoParser.ProgramContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_start + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStart" ): + listener.enterStart(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStart" ): + listener.exitStart(self) + + + + + def start(self): + + localctx = AleoParser.StartContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_start) + try: + self.enterOuterAlt(localctx, 1) + self.state = 188 + self.program() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ProgramContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def program_id(self): + return self.getTypedRuleContext(AleoParser.Program_idContext,0) + + + def ximport(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.XimportContext) + else: + return self.getTypedRuleContext(AleoParser.XimportContext,i) + + + def mapping(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.MappingContext) + else: + return self.getTypedRuleContext(AleoParser.MappingContext,i) + + + def struct(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.StructContext) + else: + return self.getTypedRuleContext(AleoParser.StructContext,i) + + + def record(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.RecordContext) + else: + return self.getTypedRuleContext(AleoParser.RecordContext,i) + + + def closure(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.ClosureContext) + else: + return self.getTypedRuleContext(AleoParser.ClosureContext,i) + + + def function(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.FunctionContext) + else: + return self.getTypedRuleContext(AleoParser.FunctionContext,i) + + + def getRuleIndex(self): + return AleoParser.RULE_program + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProgram" ): + listener.enterProgram(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProgram" ): + listener.exitProgram(self) + + + + + def program(self): + + localctx = AleoParser.ProgramContext(self, self._ctx, self.state) + self.enterRule(localctx, 2, self.RULE_program) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 193 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==3: + self.state = 190 + self.ximport() + self.state = 195 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 196 + self.match(AleoParser.T__0) + self.state = 197 + self.program_id() + self.state = 198 + self.match(AleoParser.T__1) + self.state = 204 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 204 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [4]: + self.state = 199 + self.mapping() + pass + elif token in [9]: + self.state = 200 + self.struct() + pass + elif token in [10]: + self.state = 201 + self.record() + pass + elif token in [11]: + self.state = 202 + self.closure() + pass + elif token in [14]: + self.state = 203 + self.function() + pass + else: + raise NoViableAltException(self) + + self.state = 206 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 19984) != 0)): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class XimportContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def program_id(self): + return self.getTypedRuleContext(AleoParser.Program_idContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_ximport + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterXimport" ): + listener.enterXimport(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitXimport" ): + listener.exitXimport(self) + + + + + def ximport(self): + + localctx = AleoParser.XimportContext(self, self._ctx, self.state) + self.enterRule(localctx, 4, self.RULE_ximport) + try: + self.enterOuterAlt(localctx, 1) + self.state = 208 + self.match(AleoParser.T__2) + self.state = 209 + self.program_id() + self.state = 210 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MappingContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def mapping_key(self): + return self.getTypedRuleContext(AleoParser.Mapping_keyContext,0) + + + def mapping_value(self): + return self.getTypedRuleContext(AleoParser.Mapping_valueContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_mapping + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMapping" ): + listener.enterMapping(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMapping" ): + listener.exitMapping(self) + + + + + def mapping(self): + + localctx = AleoParser.MappingContext(self, self._ctx, self.state) + self.enterRule(localctx, 6, self.RULE_mapping) + try: + self.enterOuterAlt(localctx, 1) + self.state = 212 + self.match(AleoParser.T__3) + self.state = 213 + self.identifier() + self.state = 214 + self.match(AleoParser.T__4) + self.state = 215 + self.mapping_key() + self.state = 216 + self.mapping_value() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Mapping_keyContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def mapping_type(self): + return self.getTypedRuleContext(AleoParser.Mapping_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_mapping_key + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMapping_key" ): + listener.enterMapping_key(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMapping_key" ): + listener.exitMapping_key(self) + + + + + def mapping_key(self): + + localctx = AleoParser.Mapping_keyContext(self, self._ctx, self.state) + self.enterRule(localctx, 8, self.RULE_mapping_key) + try: + self.enterOuterAlt(localctx, 1) + self.state = 218 + self.match(AleoParser.T__5) + self.state = 219 + self.match(AleoParser.T__6) + self.state = 220 + self.mapping_type() + self.state = 221 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Mapping_valueContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def mapping_type(self): + return self.getTypedRuleContext(AleoParser.Mapping_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_mapping_value + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMapping_value" ): + listener.enterMapping_value(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMapping_value" ): + listener.exitMapping_value(self) + + + + + def mapping_value(self): + + localctx = AleoParser.Mapping_valueContext(self, self._ctx, self.state) + self.enterRule(localctx, 10, self.RULE_mapping_value) + try: + self.enterOuterAlt(localctx, 1) + self.state = 223 + self.match(AleoParser.T__7) + self.state = 224 + self.match(AleoParser.T__6) + self.state = 225 + self.mapping_type() + self.state = 226 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class StructContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def tuple_(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.TupleContext) + else: + return self.getTypedRuleContext(AleoParser.TupleContext,i) + + + def getRuleIndex(self): + return AleoParser.RULE_struct + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStruct" ): + listener.enterStruct(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStruct" ): + listener.exitStruct(self) + + + + + def struct(self): + + localctx = AleoParser.StructContext(self, self._ctx, self.state) + self.enterRule(localctx, 12, self.RULE_struct) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 228 + self.match(AleoParser.T__8) + self.state = 229 + self.identifier() + self.state = 230 + self.match(AleoParser.T__4) + self.state = 232 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 231 + self.tuple_() + self.state = 234 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==135): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RecordContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def entry(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.EntryContext) + else: + return self.getTypedRuleContext(AleoParser.EntryContext,i) + + + def getRuleIndex(self): + return AleoParser.RULE_record + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRecord" ): + listener.enterRecord(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRecord" ): + listener.exitRecord(self) + + + + + def record(self): + + localctx = AleoParser.RecordContext(self, self._ctx, self.state) + self.enterRule(localctx, 14, self.RULE_record) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 236 + self.match(AleoParser.T__9) + self.state = 237 + self.identifier() + self.state = 238 + self.match(AleoParser.T__4) + self.state = 242 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==135: + self.state = 239 + self.entry() + self.state = 244 + 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 ClosureContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def closure_input(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.Closure_inputContext) + else: + return self.getTypedRuleContext(AleoParser.Closure_inputContext,i) + + + def instruction(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.InstructionContext) + else: + return self.getTypedRuleContext(AleoParser.InstructionContext,i) + + + def closure_output(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.Closure_outputContext) + else: + return self.getTypedRuleContext(AleoParser.Closure_outputContext,i) + + + def getRuleIndex(self): + return AleoParser.RULE_closure + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterClosure" ): + listener.enterClosure(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitClosure" ): + listener.exitClosure(self) + + + + + def closure(self): + + localctx = AleoParser.ClosureContext(self, self._ctx, self.state) + self.enterRule(localctx, 16, self.RULE_closure) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 245 + self.match(AleoParser.T__10) + self.state = 246 + self.identifier() + self.state = 247 + self.match(AleoParser.T__4) + self.state = 251 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==12: + self.state = 248 + self.closure_input() + self.state = 253 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 255 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 254 + self.instruction() + self.state = 257 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 8321499136) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & -1) != 0)): + break + + self.state = 262 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==13: + self.state = 259 + self.closure_output() + self.state = 264 + 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 Closure_inputContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def register(self): + return self.getTypedRuleContext(AleoParser.RegisterContext,0) + + + def register_type(self): + return self.getTypedRuleContext(AleoParser.Register_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_closure_input + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterClosure_input" ): + listener.enterClosure_input(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitClosure_input" ): + listener.exitClosure_input(self) + + + + + def closure_input(self): + + localctx = AleoParser.Closure_inputContext(self, self._ctx, self.state) + self.enterRule(localctx, 18, self.RULE_closure_input) + try: + self.enterOuterAlt(localctx, 1) + self.state = 265 + self.match(AleoParser.T__11) + self.state = 266 + self.register() + self.state = 267 + self.match(AleoParser.T__6) + self.state = 268 + self.register_type() + self.state = 269 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Closure_outputContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def operand(self): + return self.getTypedRuleContext(AleoParser.OperandContext,0) + + + def register_type(self): + return self.getTypedRuleContext(AleoParser.Register_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_closure_output + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterClosure_output" ): + listener.enterClosure_output(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitClosure_output" ): + listener.exitClosure_output(self) + + + + + def closure_output(self): + + localctx = AleoParser.Closure_outputContext(self, self._ctx, self.state) + self.enterRule(localctx, 20, self.RULE_closure_output) + try: + self.enterOuterAlt(localctx, 1) + self.state = 271 + self.match(AleoParser.T__12) + self.state = 272 + self.operand() + self.state = 273 + self.match(AleoParser.T__6) + self.state = 274 + self.register_type() + self.state = 275 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class FunctionContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def function_input(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.Function_inputContext) + else: + return self.getTypedRuleContext(AleoParser.Function_inputContext,i) + + + def instruction(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.InstructionContext) + else: + return self.getTypedRuleContext(AleoParser.InstructionContext,i) + + + def function_output(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.Function_outputContext) + else: + return self.getTypedRuleContext(AleoParser.Function_outputContext,i) + + + def finalize(self): + return self.getTypedRuleContext(AleoParser.FinalizeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_function + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction" ): + listener.enterFunction(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction" ): + listener.exitFunction(self) + + + + + def function(self): + + localctx = AleoParser.FunctionContext(self, self._ctx, self.state) + self.enterRule(localctx, 22, self.RULE_function) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 277 + self.match(AleoParser.T__13) + self.state = 278 + self.identifier() + self.state = 279 + self.match(AleoParser.T__4) + self.state = 283 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==12: + self.state = 280 + self.function_input() + self.state = 285 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 289 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 8321499136) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & -1) != 0): + self.state = 286 + self.instruction() + self.state = 291 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 295 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==13: + self.state = 292 + self.function_output() + self.state = 297 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 299 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==15: + self.state = 298 + self.finalize() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Function_inputContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def register(self): + return self.getTypedRuleContext(AleoParser.RegisterContext,0) + + + def value_type(self): + return self.getTypedRuleContext(AleoParser.Value_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_function_input + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction_input" ): + listener.enterFunction_input(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction_input" ): + listener.exitFunction_input(self) + + + + + def function_input(self): + + localctx = AleoParser.Function_inputContext(self, self._ctx, self.state) + self.enterRule(localctx, 24, self.RULE_function_input) + try: + self.enterOuterAlt(localctx, 1) + self.state = 301 + self.match(AleoParser.T__11) + self.state = 302 + self.register() + self.state = 303 + self.match(AleoParser.T__6) + self.state = 304 + self.value_type() + self.state = 305 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Function_outputContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def operand(self): + return self.getTypedRuleContext(AleoParser.OperandContext,0) + + + def value_type(self): + return self.getTypedRuleContext(AleoParser.Value_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_function_output + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunction_output" ): + listener.enterFunction_output(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunction_output" ): + listener.exitFunction_output(self) + + + + + def function_output(self): + + localctx = AleoParser.Function_outputContext(self, self._ctx, self.state) + self.enterRule(localctx, 26, self.RULE_function_output) + try: + self.enterOuterAlt(localctx, 1) + self.state = 307 + self.match(AleoParser.T__12) + self.state = 308 + self.operand() + self.state = 309 + self.match(AleoParser.T__6) + self.state = 310 + self.value_type() + self.state = 311 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class FinalizeContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def finalize_input(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.Finalize_inputContext) + else: + return self.getTypedRuleContext(AleoParser.Finalize_inputContext,i) + + + def command(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.CommandContext) + else: + return self.getTypedRuleContext(AleoParser.CommandContext,i) + + + def getRuleIndex(self): + return AleoParser.RULE_finalize + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFinalize" ): + listener.enterFinalize(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFinalize" ): + listener.exitFinalize(self) + + + + + def finalize(self): + + localctx = AleoParser.FinalizeContext(self, self._ctx, self.state) + self.enterRule(localctx, 28, self.RULE_finalize) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 313 + self.match(AleoParser.T__14) + self.state = 314 + self.identifier() + self.state = 315 + self.match(AleoParser.T__4) + self.state = 319 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==12: + self.state = 316 + self.finalize_input() + self.state = 321 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 323 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 322 + self.command() + self.state = 325 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (((((_la - 16)) & ~0x3f) == 0 and ((1 << (_la - 16)) & -1125899906712591) != 0) or ((((_la - 80)) & ~0x3f) == 0 and ((1 << (_la - 80)) & 4503599627370495) != 0)): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Finalize_inputContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def register(self): + return self.getTypedRuleContext(AleoParser.RegisterContext,0) + + + def finalize_type(self): + return self.getTypedRuleContext(AleoParser.Finalize_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_finalize_input + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFinalize_input" ): + listener.enterFinalize_input(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFinalize_input" ): + listener.exitFinalize_input(self) + + + + + def finalize_input(self): + + localctx = AleoParser.Finalize_inputContext(self, self._ctx, self.state) + self.enterRule(localctx, 30, self.RULE_finalize_input) + try: + self.enterOuterAlt(localctx, 1) + self.state = 327 + self.match(AleoParser.T__11) + self.state = 328 + self.register() + self.state = 329 + self.match(AleoParser.T__6) + self.state = 330 + self.finalize_type() + self.state = 331 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CommandContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def contains(self): + return self.getTypedRuleContext(AleoParser.ContainsContext,0) + + + def get(self): + return self.getTypedRuleContext(AleoParser.GetContext,0) + + + def get_or_use(self): + return self.getTypedRuleContext(AleoParser.Get_or_useContext,0) + + + def set_(self): + return self.getTypedRuleContext(AleoParser.SetContext,0) + + + def remove(self): + return self.getTypedRuleContext(AleoParser.RemoveContext,0) + + + def random(self): + return self.getTypedRuleContext(AleoParser.RandomContext,0) + + + def position(self): + return self.getTypedRuleContext(AleoParser.PositionContext,0) + + + def branch(self): + return self.getTypedRuleContext(AleoParser.BranchContext,0) + + + def xawait(self): + return self.getTypedRuleContext(AleoParser.XawaitContext,0) + + + def instruction(self): + return self.getTypedRuleContext(AleoParser.InstructionContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_command + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCommand" ): + listener.enterCommand(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCommand" ): + listener.exitCommand(self) + + + + + def command(self): + + localctx = AleoParser.CommandContext(self, self._ctx, self.state) + self.enterRule(localctx, 32, self.RULE_command) + try: + self.state = 343 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [16]: + self.enterOuterAlt(localctx, 1) + self.state = 333 + self.contains() + pass + elif token in [20]: + self.enterOuterAlt(localctx, 2) + self.state = 334 + self.get() + pass + elif token in [21]: + self.enterOuterAlt(localctx, 3) + self.state = 335 + self.get_or_use() + pass + elif token in [22]: + self.enterOuterAlt(localctx, 4) + self.state = 336 + self.set_() + pass + elif token in [23]: + self.enterOuterAlt(localctx, 5) + self.state = 337 + self.remove() + pass + elif token in [24]: + self.enterOuterAlt(localctx, 6) + self.state = 338 + self.random() + pass + elif token in [25]: + self.enterOuterAlt(localctx, 7) + self.state = 339 + self.position() + pass + elif token in [130, 131]: + self.enterOuterAlt(localctx, 8) + self.state = 340 + self.branch() + pass + elif token in [27]: + self.enterOuterAlt(localctx, 9) + self.state = 341 + self.xawait() + pass + elif token in [28, 29, 30, 31, 32, 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]: + self.enterOuterAlt(localctx, 10) + self.state = 342 + self.instruction() + 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 ContainsContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def operand(self): + return self.getTypedRuleContext(AleoParser.OperandContext,0) + + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_contains + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterContains" ): + listener.enterContains(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitContains" ): + listener.exitContains(self) + + + + + def contains(self): + + localctx = AleoParser.ContainsContext(self, self._ctx, self.state) + self.enterRule(localctx, 34, self.RULE_contains) + try: + self.enterOuterAlt(localctx, 1) + self.state = 345 + self.match(AleoParser.T__15) + self.state = 346 + self.identifier() + self.state = 347 + self.match(AleoParser.T__16) + self.state = 348 + self.operand() + self.state = 349 + self.match(AleoParser.T__17) + self.state = 350 + self.match(AleoParser.T__18) + self.state = 351 + self.register_access() + self.state = 352 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class GetContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def operand(self): + return self.getTypedRuleContext(AleoParser.OperandContext,0) + + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_get + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGet" ): + listener.enterGet(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGet" ): + listener.exitGet(self) + + + + + def get(self): + + localctx = AleoParser.GetContext(self, self._ctx, self.state) + self.enterRule(localctx, 36, self.RULE_get) + try: + self.enterOuterAlt(localctx, 1) + self.state = 354 + self.match(AleoParser.T__19) + self.state = 355 + self.identifier() + self.state = 356 + self.match(AleoParser.T__16) + self.state = 357 + self.operand() + self.state = 358 + self.match(AleoParser.T__17) + self.state = 359 + self.match(AleoParser.T__18) + self.state = 360 + self.register_access() + self.state = 361 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Get_or_useContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def operand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.OperandContext) + else: + return self.getTypedRuleContext(AleoParser.OperandContext,i) + + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_get_or_use + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGet_or_use" ): + listener.enterGet_or_use(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGet_or_use" ): + listener.exitGet_or_use(self) + + + + + def get_or_use(self): + + localctx = AleoParser.Get_or_useContext(self, self._ctx, self.state) + self.enterRule(localctx, 38, self.RULE_get_or_use) + try: + self.enterOuterAlt(localctx, 1) + self.state = 363 + self.match(AleoParser.T__20) + self.state = 364 + self.identifier() + self.state = 365 + self.match(AleoParser.T__16) + self.state = 366 + self.operand() + self.state = 367 + self.match(AleoParser.T__17) + self.state = 368 + self.operand() + self.state = 369 + self.match(AleoParser.T__18) + self.state = 370 + self.register_access() + self.state = 371 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SetContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def operand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.OperandContext) + else: + return self.getTypedRuleContext(AleoParser.OperandContext,i) + + + def identifier(self): + return self.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_set + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSet" ): + listener.enterSet(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSet" ): + listener.exitSet(self) + + + + + def set_(self): + + localctx = AleoParser.SetContext(self, self._ctx, self.state) + self.enterRule(localctx, 40, self.RULE_set) + try: + self.enterOuterAlt(localctx, 1) + self.state = 373 + self.match(AleoParser.T__21) + self.state = 374 + self.operand() + self.state = 375 + self.match(AleoParser.T__18) + self.state = 376 + self.identifier() + self.state = 377 + self.match(AleoParser.T__16) + self.state = 378 + self.operand() + self.state = 379 + self.match(AleoParser.T__17) + self.state = 380 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RemoveContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def operand(self): + return self.getTypedRuleContext(AleoParser.OperandContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_remove + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRemove" ): + listener.enterRemove(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRemove" ): + listener.exitRemove(self) + + + + + def remove(self): + + localctx = AleoParser.RemoveContext(self, self._ctx, self.state) + self.enterRule(localctx, 42, self.RULE_remove) + try: + self.enterOuterAlt(localctx, 1) + self.state = 382 + self.match(AleoParser.T__22) + self.state = 383 + self.identifier() + self.state = 384 + self.match(AleoParser.T__16) + self.state = 385 + self.operand() + self.state = 386 + self.match(AleoParser.T__17) + self.state = 387 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RandomContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def arithmetic_type(self): + return self.getTypedRuleContext(AleoParser.Arithmetic_typeContext,0) + + + def address_type(self): + return self.getTypedRuleContext(AleoParser.Address_typeContext,0) + + + def signature_type(self): + return self.getTypedRuleContext(AleoParser.Signature_typeContext,0) + + + def boolean_type(self): + return self.getTypedRuleContext(AleoParser.Boolean_typeContext,0) + + + def operand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.OperandContext) + else: + return self.getTypedRuleContext(AleoParser.OperandContext,i) + + + def getRuleIndex(self): + return AleoParser.RULE_random + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRandom" ): + listener.enterRandom(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRandom" ): + listener.exitRandom(self) + + + + + def random(self): + + localctx = AleoParser.RandomContext(self, self._ctx, self.state) + self.enterRule(localctx, 44, self.RULE_random) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 389 + self.match(AleoParser.T__23) + self.state = 393 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 8646911499299717120) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & 31) != 0): + self.state = 390 + self.operand() + self.state = 395 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 396 + self.match(AleoParser.T__18) + self.state = 397 + self.register_access() + self.state = 398 + self.match(AleoParser.T__6) + self.state = 403 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [35, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]: + self.state = 399 + self.arithmetic_type() + pass + elif token in [50]: + self.state = 400 + self.address_type() + pass + elif token in [52]: + self.state = 401 + self.signature_type() + pass + elif token in [51]: + self.state = 402 + self.boolean_type() + pass + else: + raise NoViableAltException(self) + + self.state = 405 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PositionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def label(self): + return self.getTypedRuleContext(AleoParser.LabelContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_position + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPosition" ): + listener.enterPosition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPosition" ): + listener.exitPosition(self) + + + + + def position(self): + + localctx = AleoParser.PositionContext(self, self._ctx, self.state) + self.enterRule(localctx, 46, self.RULE_position) + try: + self.enterOuterAlt(localctx, 1) + self.state = 407 + self.match(AleoParser.T__24) + self.state = 408 + self.label() + self.state = 409 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class BranchContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def branch_op(self): + return self.getTypedRuleContext(AleoParser.Branch_opContext,0) + + + def operand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.OperandContext) + else: + return self.getTypedRuleContext(AleoParser.OperandContext,i) + + + def label(self): + return self.getTypedRuleContext(AleoParser.LabelContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_branch + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBranch" ): + listener.enterBranch(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBranch" ): + listener.exitBranch(self) + + + + + def branch(self): + + localctx = AleoParser.BranchContext(self, self._ctx, self.state) + self.enterRule(localctx, 48, self.RULE_branch) + try: + self.enterOuterAlt(localctx, 1) + self.state = 411 + self.branch_op() + self.state = 412 + self.operand() + self.state = 413 + self.operand() + self.state = 414 + self.match(AleoParser.T__25) + self.state = 415 + self.label() + self.state = 416 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class XawaitContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_xawait + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterXawait" ): + listener.enterXawait(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitXawait" ): + listener.exitXawait(self) + + + + + def xawait(self): + + localctx = AleoParser.XawaitContext(self, self._ctx, self.state) + self.enterRule(localctx, 50, self.RULE_xawait) + try: + self.enterOuterAlt(localctx, 1) + self.state = 418 + self.match(AleoParser.T__26) + self.state = 419 + self.register_access() + self.state = 420 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InstructionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def unary(self): + return self.getTypedRuleContext(AleoParser.UnaryContext,0) + + + def binary(self): + return self.getTypedRuleContext(AleoParser.BinaryContext,0) + + + def ternary(self): + return self.getTypedRuleContext(AleoParser.TernaryContext,0) + + + def is_(self): + return self.getTypedRuleContext(AleoParser.IsContext,0) + + + def assert_(self): + return self.getTypedRuleContext(AleoParser.AssertContext,0) + + + def commit(self): + return self.getTypedRuleContext(AleoParser.CommitContext,0) + + + def hash_(self): + return self.getTypedRuleContext(AleoParser.HashContext,0) + + + def signverify(self): + return self.getTypedRuleContext(AleoParser.SignverifyContext,0) + + + def cast(self): + return self.getTypedRuleContext(AleoParser.CastContext,0) + + + def call(self): + return self.getTypedRuleContext(AleoParser.CallContext,0) + + + def xasync(self): + return self.getTypedRuleContext(AleoParser.XasyncContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_instruction + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInstruction" ): + listener.enterInstruction(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInstruction" ): + listener.exitInstruction(self) + + + + + def instruction(self): + + localctx = AleoParser.InstructionContext(self, self._ctx, self.state) + self.enterRule(localctx, 52, self.RULE_instruction) + try: + self.state = 433 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [66, 67, 68, 69, 70, 71, 72, 73]: + self.enterOuterAlt(localctx, 1) + self.state = 422 + self.unary() + pass + elif token in [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]: + self.enterOuterAlt(localctx, 2) + self.state = 423 + self.binary() + pass + elif token in [28]: + self.enterOuterAlt(localctx, 3) + self.state = 424 + self.ternary() + pass + elif token in [100, 101]: + self.enterOuterAlt(localctx, 4) + self.state = 425 + self.is_() + pass + elif token in [102, 103]: + self.enterOuterAlt(localctx, 5) + self.state = 426 + self.assert_() + pass + elif token in [104, 105, 106, 107, 108, 109]: + self.enterOuterAlt(localctx, 6) + self.state = 427 + self.commit() + pass + elif token in [110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127]: + self.enterOuterAlt(localctx, 7) + self.state = 428 + self.hash_() + pass + elif token in [29, 30]: + self.enterOuterAlt(localctx, 8) + self.state = 429 + self.signverify() + pass + elif token in [128, 129]: + self.enterOuterAlt(localctx, 9) + self.state = 430 + self.cast() + pass + elif token in [31]: + self.enterOuterAlt(localctx, 10) + self.state = 431 + self.call() + pass + elif token in [32]: + self.enterOuterAlt(localctx, 11) + self.state = 432 + self.xasync() + 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 UnaryContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def unary_op(self): + return self.getTypedRuleContext(AleoParser.Unary_opContext,0) + + + def operand(self): + return self.getTypedRuleContext(AleoParser.OperandContext,0) + + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_unary + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnary" ): + listener.enterUnary(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnary" ): + listener.exitUnary(self) + + + + + def unary(self): + + localctx = AleoParser.UnaryContext(self, self._ctx, self.state) + self.enterRule(localctx, 54, self.RULE_unary) + try: + self.enterOuterAlt(localctx, 1) + self.state = 435 + self.unary_op() + self.state = 436 + self.operand() + self.state = 437 + self.match(AleoParser.T__18) + self.state = 438 + self.register_access() + self.state = 439 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class BinaryContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def binary_op(self): + return self.getTypedRuleContext(AleoParser.Binary_opContext,0) + + + def operand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.OperandContext) + else: + return self.getTypedRuleContext(AleoParser.OperandContext,i) + + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_binary + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBinary" ): + listener.enterBinary(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBinary" ): + listener.exitBinary(self) + + + + + def binary(self): + + localctx = AleoParser.BinaryContext(self, self._ctx, self.state) + self.enterRule(localctx, 56, self.RULE_binary) + try: + self.enterOuterAlt(localctx, 1) + self.state = 441 + self.binary_op() + self.state = 442 + self.operand() + self.state = 443 + self.operand() + self.state = 444 + self.match(AleoParser.T__18) + self.state = 445 + self.register_access() + self.state = 446 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TernaryContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def operand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.OperandContext) + else: + return self.getTypedRuleContext(AleoParser.OperandContext,i) + + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_ternary + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTernary" ): + listener.enterTernary(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTernary" ): + listener.exitTernary(self) + + + + + def ternary(self): + + localctx = AleoParser.TernaryContext(self, self._ctx, self.state) + self.enterRule(localctx, 58, self.RULE_ternary) + try: + self.enterOuterAlt(localctx, 1) + self.state = 448 + self.match(AleoParser.T__27) + self.state = 449 + self.operand() + self.state = 450 + self.operand() + self.state = 451 + self.operand() + self.state = 452 + self.match(AleoParser.T__18) + self.state = 453 + self.register_access() + self.state = 454 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IsContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def is_op(self): + return self.getTypedRuleContext(AleoParser.Is_opContext,0) + + + def operand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.OperandContext) + else: + return self.getTypedRuleContext(AleoParser.OperandContext,i) + + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_is + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIs" ): + listener.enterIs(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIs" ): + listener.exitIs(self) + + + + + def is_(self): + + localctx = AleoParser.IsContext(self, self._ctx, self.state) + self.enterRule(localctx, 60, self.RULE_is) + try: + self.enterOuterAlt(localctx, 1) + self.state = 456 + self.is_op() + self.state = 457 + self.operand() + self.state = 458 + self.operand() + self.state = 459 + self.match(AleoParser.T__18) + self.state = 460 + self.register_access() + self.state = 461 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AssertContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def assert_op(self): + return self.getTypedRuleContext(AleoParser.Assert_opContext,0) + + + def operand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.OperandContext) + else: + return self.getTypedRuleContext(AleoParser.OperandContext,i) + + + def getRuleIndex(self): + return AleoParser.RULE_assert + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAssert" ): + listener.enterAssert(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAssert" ): + listener.exitAssert(self) + + + + + def assert_(self): + + localctx = AleoParser.AssertContext(self, self._ctx, self.state) + self.enterRule(localctx, 62, self.RULE_assert) + try: + self.enterOuterAlt(localctx, 1) + self.state = 463 + self.assert_op() + self.state = 464 + self.operand() + self.state = 465 + self.operand() + self.state = 466 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CommitContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def commit_op(self): + return self.getTypedRuleContext(AleoParser.Commit_opContext,0) + + + def operand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.OperandContext) + else: + return self.getTypedRuleContext(AleoParser.OperandContext,i) + + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def address_type(self): + return self.getTypedRuleContext(AleoParser.Address_typeContext,0) + + + def field_type(self): + return self.getTypedRuleContext(AleoParser.Field_typeContext,0) + + + def group_type(self): + return self.getTypedRuleContext(AleoParser.Group_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_commit + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCommit" ): + listener.enterCommit(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCommit" ): + listener.exitCommit(self) + + + + + def commit(self): + + localctx = AleoParser.CommitContext(self, self._ctx, self.state) + self.enterRule(localctx, 64, self.RULE_commit) + try: + self.enterOuterAlt(localctx, 1) + self.state = 468 + self.commit_op() + self.state = 469 + self.operand() + self.state = 470 + self.operand() + self.state = 471 + self.match(AleoParser.T__18) + self.state = 472 + self.register_access() + self.state = 473 + self.match(AleoParser.T__6) + self.state = 477 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [50]: + self.state = 474 + self.address_type() + pass + elif token in [47]: + self.state = 475 + self.field_type() + pass + elif token in [48]: + self.state = 476 + self.group_type() + pass + else: + raise NoViableAltException(self) + + self.state = 479 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Hash1Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def hash1_op(self): + return self.getTypedRuleContext(AleoParser.Hash1_opContext,0) + + + def operand(self): + return self.getTypedRuleContext(AleoParser.OperandContext,0) + + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def arithmetic_type(self): + return self.getTypedRuleContext(AleoParser.Arithmetic_typeContext,0) + + + def address_type(self): + return self.getTypedRuleContext(AleoParser.Address_typeContext,0) + + + def signature_type(self): + return self.getTypedRuleContext(AleoParser.Signature_typeContext,0) + + + def array_type(self): + return self.getTypedRuleContext(AleoParser.Array_typeContext,0) + + + def identifier(self): + return self.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_hash1 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHash1" ): + listener.enterHash1(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHash1" ): + listener.exitHash1(self) + + + + + def hash1(self): + + localctx = AleoParser.Hash1Context(self, self._ctx, self.state) + self.enterRule(localctx, 66, self.RULE_hash1) + try: + self.enterOuterAlt(localctx, 1) + self.state = 481 + self.hash1_op() + self.state = 482 + self.operand() + self.state = 483 + self.match(AleoParser.T__18) + self.state = 484 + self.register_access() + self.state = 485 + self.match(AleoParser.T__6) + self.state = 491 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [35, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]: + self.state = 486 + self.arithmetic_type() + pass + elif token in [50]: + self.state = 487 + self.address_type() + pass + elif token in [52]: + self.state = 488 + self.signature_type() + pass + elif token in [17]: + self.state = 489 + self.array_type() + pass + elif token in [135]: + self.state = 490 + self.identifier() + pass + else: + raise NoViableAltException(self) + + self.state = 493 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Hash2Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def hash2_op(self): + return self.getTypedRuleContext(AleoParser.Hash2_opContext,0) + + + def operand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.OperandContext) + else: + return self.getTypedRuleContext(AleoParser.OperandContext,i) + + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def arithmetic_type(self): + return self.getTypedRuleContext(AleoParser.Arithmetic_typeContext,0) + + + def address_type(self): + return self.getTypedRuleContext(AleoParser.Address_typeContext,0) + + + def signature_type(self): + return self.getTypedRuleContext(AleoParser.Signature_typeContext,0) + + + def array_type(self): + return self.getTypedRuleContext(AleoParser.Array_typeContext,0) + + + def identifier(self): + return self.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_hash2 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHash2" ): + listener.enterHash2(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHash2" ): + listener.exitHash2(self) + + + + + def hash2(self): + + localctx = AleoParser.Hash2Context(self, self._ctx, self.state) + self.enterRule(localctx, 68, self.RULE_hash2) + try: + self.enterOuterAlt(localctx, 1) + self.state = 495 + self.hash2_op() + self.state = 496 + self.operand() + self.state = 497 + self.operand() + self.state = 498 + self.match(AleoParser.T__18) + self.state = 499 + self.register_access() + self.state = 500 + self.match(AleoParser.T__6) + self.state = 506 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [35, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]: + self.state = 501 + self.arithmetic_type() + pass + elif token in [50]: + self.state = 502 + self.address_type() + pass + elif token in [52]: + self.state = 503 + self.signature_type() + pass + elif token in [17]: + self.state = 504 + self.array_type() + pass + elif token in [135]: + self.state = 505 + self.identifier() + pass + else: + raise NoViableAltException(self) + + self.state = 508 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class HashContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def hash1(self): + return self.getTypedRuleContext(AleoParser.Hash1Context,0) + + + def hash2(self): + return self.getTypedRuleContext(AleoParser.Hash2Context,0) + + + def getRuleIndex(self): + return AleoParser.RULE_hash + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHash" ): + listener.enterHash(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHash" ): + listener.exitHash(self) + + + + + def hash_(self): + + localctx = AleoParser.HashContext(self, self._ctx, self.state) + self.enterRule(localctx, 70, self.RULE_hash) + try: + self.state = 512 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124]: + self.enterOuterAlt(localctx, 1) + self.state = 510 + self.hash1() + pass + elif token in [125, 126, 127]: + self.enterOuterAlt(localctx, 2) + self.state = 511 + self.hash2() + 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 SignverifyContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def operand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.OperandContext) + else: + return self.getTypedRuleContext(AleoParser.OperandContext,i) + + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_signverify + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSignverify" ): + listener.enterSignverify(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSignverify" ): + listener.exitSignverify(self) + + + + + def signverify(self): + + localctx = AleoParser.SignverifyContext(self, self._ctx, self.state) + self.enterRule(localctx, 72, self.RULE_signverify) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 514 + _la = self._input.LA(1) + if not(_la==29 or _la==30): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 515 + self.operand() + self.state = 516 + self.operand() + self.state = 517 + self.operand() + self.state = 518 + self.match(AleoParser.T__18) + self.state = 519 + self.register_access() + self.state = 520 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CastContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cast_op(self): + return self.getTypedRuleContext(AleoParser.Cast_opContext,0) + + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def cast_destination(self): + return self.getTypedRuleContext(AleoParser.Cast_destinationContext,0) + + + def operand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.OperandContext) + else: + return self.getTypedRuleContext(AleoParser.OperandContext,i) + + + def getRuleIndex(self): + return AleoParser.RULE_cast + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCast" ): + listener.enterCast(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCast" ): + listener.exitCast(self) + + + + + def cast(self): + + localctx = AleoParser.CastContext(self, self._ctx, self.state) + self.enterRule(localctx, 74, self.RULE_cast) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 522 + self.cast_op() + self.state = 524 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 523 + self.operand() + self.state = 526 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 8646911499299717120) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & 31) != 0)): + break + + self.state = 528 + self.match(AleoParser.T__18) + self.state = 529 + self.register_access() + self.state = 530 + self.match(AleoParser.T__6) + self.state = 531 + self.cast_destination() + self.state = 532 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CallContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def locator(self): + return self.getTypedRuleContext(AleoParser.LocatorContext,0) + + + def identifier(self): + return self.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def operand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.OperandContext) + else: + return self.getTypedRuleContext(AleoParser.OperandContext,i) + + + def register_access(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.Register_accessContext) + else: + return self.getTypedRuleContext(AleoParser.Register_accessContext,i) + + + def getRuleIndex(self): + return AleoParser.RULE_call + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCall" ): + listener.enterCall(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCall" ): + listener.exitCall(self) + + + + + def call(self): + + localctx = AleoParser.CallContext(self, self._ctx, self.state) + self.enterRule(localctx, 76, self.RULE_call) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 534 + self.match(AleoParser.T__30) + self.state = 537 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,23,self._ctx) + if la_ == 1: + self.state = 535 + self.locator() + pass + + elif la_ == 2: + self.state = 536 + self.identifier() + pass + + + self.state = 542 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 8646911499299717120) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & 31) != 0): + self.state = 539 + self.operand() + self.state = 544 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 551 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==19: + self.state = 545 + self.match(AleoParser.T__18) + self.state = 547 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 546 + self.register_access() + self.state = 549 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==134): + break + + + + self.state = 553 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class XasyncContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def operand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.OperandContext) + else: + return self.getTypedRuleContext(AleoParser.OperandContext,i) + + + def getRuleIndex(self): + return AleoParser.RULE_xasync + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterXasync" ): + listener.enterXasync(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitXasync" ): + listener.exitXasync(self) + + + + + def xasync(self): + + localctx = AleoParser.XasyncContext(self, self._ctx, self.state) + self.enterRule(localctx, 78, self.RULE_xasync) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 555 + self.match(AleoParser.T__31) + self.state = 556 + self.identifier() + self.state = 560 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 8646911499299717120) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & 31) != 0): + self.state = 557 + self.operand() + self.state = 562 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 563 + self.match(AleoParser.T__18) + self.state = 564 + self.register_access() + self.state = 565 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LiteralContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def arithmetic_literal(self): + return self.getTypedRuleContext(AleoParser.Arithmetic_literalContext,0) + + + def address_literal(self): + return self.getTypedRuleContext(AleoParser.Address_literalContext,0) + + + def signature_literal(self): + return self.getTypedRuleContext(AleoParser.Signature_literalContext,0) + + + def boolean_literal(self): + return self.getTypedRuleContext(AleoParser.Boolean_literalContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_literal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLiteral" ): + listener.enterLiteral(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLiteral" ): + listener.exitLiteral(self) + + + + + def literal(self): + + localctx = AleoParser.LiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 80, self.RULE_literal) + try: + self.state = 571 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [33, 136]: + self.enterOuterAlt(localctx, 1) + self.state = 567 + self.arithmetic_literal() + pass + elif token in [132]: + self.enterOuterAlt(localctx, 2) + self.state = 568 + self.address_literal() + pass + elif token in [133]: + self.enterOuterAlt(localctx, 3) + self.state = 569 + self.signature_literal() + pass + elif token in [36, 37]: + self.enterOuterAlt(localctx, 4) + self.state = 570 + self.boolean_literal() + 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 Signed_literalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def signed_type(self): + return self.getTypedRuleContext(AleoParser.Signed_typeContext,0) + + + def DIGIT(self, i:int=None): + if i is None: + return self.getTokens(AleoParser.DIGIT) + else: + return self.getToken(AleoParser.DIGIT, i) + + def getRuleIndex(self): + return AleoParser.RULE_signed_literal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSigned_literal" ): + listener.enterSigned_literal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSigned_literal" ): + listener.exitSigned_literal(self) + + + + + def signed_literal(self): + + localctx = AleoParser.Signed_literalContext(self, self._ctx, self.state) + self.enterRule(localctx, 82, self.RULE_signed_literal) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 574 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==33: + self.state = 573 + self.match(AleoParser.T__32) + + + self.state = 583 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 576 + self.match(AleoParser.DIGIT) + self.state = 580 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==34: + self.state = 577 + self.match(AleoParser.T__33) + self.state = 582 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 585 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==136): + break + + self.state = 587 + self.signed_type() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Unsigned_literalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def unsigned_type(self): + return self.getTypedRuleContext(AleoParser.Unsigned_typeContext,0) + + + def DIGIT(self, i:int=None): + if i is None: + return self.getTokens(AleoParser.DIGIT) + else: + return self.getToken(AleoParser.DIGIT, i) + + def getRuleIndex(self): + return AleoParser.RULE_unsigned_literal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnsigned_literal" ): + listener.enterUnsigned_literal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnsigned_literal" ): + listener.exitUnsigned_literal(self) + + + + + def unsigned_literal(self): + + localctx = AleoParser.Unsigned_literalContext(self, self._ctx, self.state) + self.enterRule(localctx, 84, self.RULE_unsigned_literal) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 590 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==33: + self.state = 589 + self.match(AleoParser.T__32) + + + self.state = 599 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 592 + self.match(AleoParser.DIGIT) + self.state = 596 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==34: + self.state = 593 + self.match(AleoParser.T__33) + self.state = 598 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 601 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==136): + break + + self.state = 603 + self.unsigned_type() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Integer_literalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def signed_literal(self): + return self.getTypedRuleContext(AleoParser.Signed_literalContext,0) + + + def unsigned_literal(self): + return self.getTypedRuleContext(AleoParser.Unsigned_literalContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_integer_literal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInteger_literal" ): + listener.enterInteger_literal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInteger_literal" ): + listener.exitInteger_literal(self) + + + + + def integer_literal(self): + + localctx = AleoParser.Integer_literalContext(self, self._ctx, self.state) + self.enterRule(localctx, 86, self.RULE_integer_literal) + try: + self.state = 607 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,35,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 605 + self.signed_literal() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 606 + self.unsigned_literal() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Field_literalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def field_type(self): + return self.getTypedRuleContext(AleoParser.Field_typeContext,0) + + + def DIGIT(self, i:int=None): + if i is None: + return self.getTokens(AleoParser.DIGIT) + else: + return self.getToken(AleoParser.DIGIT, i) + + def getRuleIndex(self): + return AleoParser.RULE_field_literal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterField_literal" ): + listener.enterField_literal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitField_literal" ): + listener.exitField_literal(self) + + + + + def field_literal(self): + + localctx = AleoParser.Field_literalContext(self, self._ctx, self.state) + self.enterRule(localctx, 88, self.RULE_field_literal) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 610 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==33: + self.state = 609 + self.match(AleoParser.T__32) + + + self.state = 619 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 612 + self.match(AleoParser.DIGIT) + self.state = 616 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==34: + self.state = 613 + self.match(AleoParser.T__33) + self.state = 618 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 621 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==136): + break + + self.state = 623 + self.field_type() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Group_literalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def group_type(self): + return self.getTypedRuleContext(AleoParser.Group_typeContext,0) + + + def DIGIT(self, i:int=None): + if i is None: + return self.getTokens(AleoParser.DIGIT) + else: + return self.getToken(AleoParser.DIGIT, i) + + def getRuleIndex(self): + return AleoParser.RULE_group_literal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGroup_literal" ): + listener.enterGroup_literal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGroup_literal" ): + listener.exitGroup_literal(self) + + + + + def group_literal(self): + + localctx = AleoParser.Group_literalContext(self, self._ctx, self.state) + self.enterRule(localctx, 90, self.RULE_group_literal) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 626 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==33: + self.state = 625 + self.match(AleoParser.T__32) + + + self.state = 635 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 628 + self.match(AleoParser.DIGIT) + self.state = 632 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==34: + self.state = 629 + self.match(AleoParser.T__33) + self.state = 634 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 637 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==136): + break + + self.state = 639 + self.group_type() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Scalar_literalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def scalar_type(self): + return self.getTypedRuleContext(AleoParser.Scalar_typeContext,0) + + + def DIGIT(self, i:int=None): + if i is None: + return self.getTokens(AleoParser.DIGIT) + else: + return self.getToken(AleoParser.DIGIT, i) + + def getRuleIndex(self): + return AleoParser.RULE_scalar_literal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScalar_literal" ): + listener.enterScalar_literal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScalar_literal" ): + listener.exitScalar_literal(self) + + + + + def scalar_literal(self): + + localctx = AleoParser.Scalar_literalContext(self, self._ctx, self.state) + self.enterRule(localctx, 92, self.RULE_scalar_literal) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 642 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==33: + self.state = 641 + self.match(AleoParser.T__32) + + + self.state = 651 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 644 + self.match(AleoParser.DIGIT) + self.state = 648 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==34: + self.state = 645 + self.match(AleoParser.T__33) + self.state = 650 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 653 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==136): + break + + self.state = 655 + self.scalar_type() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Arithmetic_literalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def integer_literal(self): + return self.getTypedRuleContext(AleoParser.Integer_literalContext,0) + + + def field_literal(self): + return self.getTypedRuleContext(AleoParser.Field_literalContext,0) + + + def group_literal(self): + return self.getTypedRuleContext(AleoParser.Group_literalContext,0) + + + def scalar_literal(self): + return self.getTypedRuleContext(AleoParser.Scalar_literalContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_arithmetic_literal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArithmetic_literal" ): + listener.enterArithmetic_literal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArithmetic_literal" ): + listener.exitArithmetic_literal(self) + + + + + def arithmetic_literal(self): + + localctx = AleoParser.Arithmetic_literalContext(self, self._ctx, self.state) + self.enterRule(localctx, 94, self.RULE_arithmetic_literal) + try: + self.state = 661 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,45,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 657 + self.integer_literal() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 658 + self.field_literal() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 659 + self.group_literal() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 660 + self.scalar_literal() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class U32_literalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DIGIT(self, i:int=None): + if i is None: + return self.getTokens(AleoParser.DIGIT) + else: + return self.getToken(AleoParser.DIGIT, i) + + def getRuleIndex(self): + return AleoParser.RULE_u32_literal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterU32_literal" ): + listener.enterU32_literal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitU32_literal" ): + listener.exitU32_literal(self) + + + + + def u32_literal(self): + + localctx = AleoParser.U32_literalContext(self, self._ctx, self.state) + self.enterRule(localctx, 96, self.RULE_u32_literal) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 664 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==33: + self.state = 663 + self.match(AleoParser.T__32) + + + self.state = 673 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 666 + self.match(AleoParser.DIGIT) + self.state = 670 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==34: + self.state = 667 + self.match(AleoParser.T__33) + self.state = 672 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 675 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==136): + break + + self.state = 677 + self.match(AleoParser.T__34) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Address_literalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ADDRESS_LITERAL(self): + return self.getToken(AleoParser.ADDRESS_LITERAL, 0) + + def getRuleIndex(self): + return AleoParser.RULE_address_literal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAddress_literal" ): + listener.enterAddress_literal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAddress_literal" ): + listener.exitAddress_literal(self) + + + + + def address_literal(self): + + localctx = AleoParser.Address_literalContext(self, self._ctx, self.state) + self.enterRule(localctx, 98, self.RULE_address_literal) + try: + self.enterOuterAlt(localctx, 1) + self.state = 679 + self.match(AleoParser.ADDRESS_LITERAL) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Signature_literalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SIGNATURE_LITERAL(self): + return self.getToken(AleoParser.SIGNATURE_LITERAL, 0) + + def getRuleIndex(self): + return AleoParser.RULE_signature_literal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSignature_literal" ): + listener.enterSignature_literal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSignature_literal" ): + listener.exitSignature_literal(self) + + + + + def signature_literal(self): + + localctx = AleoParser.Signature_literalContext(self, self._ctx, self.state) + self.enterRule(localctx, 100, self.RULE_signature_literal) + try: + self.enterOuterAlt(localctx, 1) + self.state = 681 + self.match(AleoParser.SIGNATURE_LITERAL) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Boolean_literalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_boolean_literal + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBoolean_literal" ): + listener.enterBoolean_literal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBoolean_literal" ): + listener.exitBoolean_literal(self) + + + + + def boolean_literal(self): + + localctx = AleoParser.Boolean_literalContext(self, self._ctx, self.state) + self.enterRule(localctx, 102, self.RULE_boolean_literal) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 683 + _la = self._input.LA(1) + if not(_la==36 or _la==37): + 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 Unsigned_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_unsigned_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnsigned_type" ): + listener.enterUnsigned_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnsigned_type" ): + listener.exitUnsigned_type(self) + + + + + def unsigned_type(self): + + localctx = AleoParser.Unsigned_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 104, self.RULE_unsigned_type) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 685 + _la = self._input.LA(1) + if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 4157528342528) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Signed_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_signed_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSigned_type" ): + listener.enterSigned_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSigned_type" ): + listener.exitSigned_type(self) + + + + + def signed_type(self): + + localctx = AleoParser.Signed_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 106, self.RULE_signed_type) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 687 + _la = self._input.LA(1) + if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 136339441844224) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Integer_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def unsigned_type(self): + return self.getTypedRuleContext(AleoParser.Unsigned_typeContext,0) + + + def signed_type(self): + return self.getTypedRuleContext(AleoParser.Signed_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_integer_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInteger_type" ): + listener.enterInteger_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInteger_type" ): + listener.exitInteger_type(self) + + + + + def integer_type(self): + + localctx = AleoParser.Integer_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 108, self.RULE_integer_type) + try: + self.state = 691 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [35, 38, 39, 40, 41]: + self.enterOuterAlt(localctx, 1) + self.state = 689 + self.unsigned_type() + pass + elif token in [42, 43, 44, 45, 46]: + self.enterOuterAlt(localctx, 2) + self.state = 690 + self.signed_type() + 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 Field_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_field_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterField_type" ): + listener.enterField_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitField_type" ): + listener.exitField_type(self) + + + + + def field_type(self): + + localctx = AleoParser.Field_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 110, self.RULE_field_type) + try: + self.enterOuterAlt(localctx, 1) + self.state = 693 + self.match(AleoParser.T__46) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Group_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_group_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGroup_type" ): + listener.enterGroup_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGroup_type" ): + listener.exitGroup_type(self) + + + + + def group_type(self): + + localctx = AleoParser.Group_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 112, self.RULE_group_type) + try: + self.enterOuterAlt(localctx, 1) + self.state = 695 + self.match(AleoParser.T__47) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Scalar_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_scalar_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScalar_type" ): + listener.enterScalar_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScalar_type" ): + listener.exitScalar_type(self) + + + + + def scalar_type(self): + + localctx = AleoParser.Scalar_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 114, self.RULE_scalar_type) + try: + self.enterOuterAlt(localctx, 1) + self.state = 697 + self.match(AleoParser.T__48) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Arithmetic_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def integer_type(self): + return self.getTypedRuleContext(AleoParser.Integer_typeContext,0) + + + def field_type(self): + return self.getTypedRuleContext(AleoParser.Field_typeContext,0) + + + def group_type(self): + return self.getTypedRuleContext(AleoParser.Group_typeContext,0) + + + def scalar_type(self): + return self.getTypedRuleContext(AleoParser.Scalar_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_arithmetic_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArithmetic_type" ): + listener.enterArithmetic_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArithmetic_type" ): + listener.exitArithmetic_type(self) + + + + + def arithmetic_type(self): + + localctx = AleoParser.Arithmetic_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 116, self.RULE_arithmetic_type) + try: + self.state = 703 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [35, 38, 39, 40, 41, 42, 43, 44, 45, 46]: + self.enterOuterAlt(localctx, 1) + self.state = 699 + self.integer_type() + pass + elif token in [47]: + self.enterOuterAlt(localctx, 2) + self.state = 700 + self.field_type() + pass + elif token in [48]: + self.enterOuterAlt(localctx, 3) + self.state = 701 + self.group_type() + pass + elif token in [49]: + self.enterOuterAlt(localctx, 4) + self.state = 702 + self.scalar_type() + 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 Address_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_address_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAddress_type" ): + listener.enterAddress_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAddress_type" ): + listener.exitAddress_type(self) + + + + + def address_type(self): + + localctx = AleoParser.Address_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 118, self.RULE_address_type) + try: + self.enterOuterAlt(localctx, 1) + self.state = 705 + self.match(AleoParser.T__49) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Boolean_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_boolean_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBoolean_type" ): + listener.enterBoolean_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBoolean_type" ): + listener.exitBoolean_type(self) + + + + + def boolean_type(self): + + localctx = AleoParser.Boolean_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 120, self.RULE_boolean_type) + try: + self.enterOuterAlt(localctx, 1) + self.state = 707 + self.match(AleoParser.T__50) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Signature_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_signature_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSignature_type" ): + listener.enterSignature_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSignature_type" ): + listener.exitSignature_type(self) + + + + + def signature_type(self): + + localctx = AleoParser.Signature_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 122, self.RULE_signature_type) + try: + self.enterOuterAlt(localctx, 1) + self.state = 709 + self.match(AleoParser.T__51) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Literal_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def arithmetic_type(self): + return self.getTypedRuleContext(AleoParser.Arithmetic_typeContext,0) + + + def address_type(self): + return self.getTypedRuleContext(AleoParser.Address_typeContext,0) + + + def signature_type(self): + return self.getTypedRuleContext(AleoParser.Signature_typeContext,0) + + + def boolean_type(self): + return self.getTypedRuleContext(AleoParser.Boolean_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_literal_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLiteral_type" ): + listener.enterLiteral_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLiteral_type" ): + listener.exitLiteral_type(self) + + + + + def literal_type(self): + + localctx = AleoParser.Literal_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 124, self.RULE_literal_type) + try: + self.state = 715 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [35, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49]: + self.enterOuterAlt(localctx, 1) + self.state = 711 + self.arithmetic_type() + pass + elif token in [50]: + self.enterOuterAlt(localctx, 2) + self.state = 712 + self.address_type() + pass + elif token in [52]: + self.enterOuterAlt(localctx, 3) + self.state = 713 + self.signature_type() + pass + elif token in [51]: + self.enterOuterAlt(localctx, 4) + self.state = 714 + self.boolean_type() + 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 Array_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def plaintext_type(self): + return self.getTypedRuleContext(AleoParser.Plaintext_typeContext,0) + + + def u32_literal(self): + return self.getTypedRuleContext(AleoParser.U32_literalContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_array_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArray_type" ): + listener.enterArray_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArray_type" ): + listener.exitArray_type(self) + + + + + def array_type(self): + + localctx = AleoParser.Array_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 126, self.RULE_array_type) + try: + self.enterOuterAlt(localctx, 1) + self.state = 717 + self.match(AleoParser.T__16) + self.state = 718 + self.plaintext_type() + self.state = 719 + self.match(AleoParser.T__1) + self.state = 720 + self.u32_literal() + self.state = 721 + self.match(AleoParser.T__17) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Plaintext_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def literal_type(self): + return self.getTypedRuleContext(AleoParser.Literal_typeContext,0) + + + def array_type(self): + return self.getTypedRuleContext(AleoParser.Array_typeContext,0) + + + def identifier(self): + return self.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_plaintext_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPlaintext_type" ): + listener.enterPlaintext_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPlaintext_type" ): + listener.exitPlaintext_type(self) + + + + + def plaintext_type(self): + + localctx = AleoParser.Plaintext_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 128, self.RULE_plaintext_type) + try: + self.state = 726 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [35, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52]: + self.enterOuterAlt(localctx, 1) + self.state = 723 + self.literal_type() + pass + elif token in [17]: + self.enterOuterAlt(localctx, 2) + self.state = 724 + self.array_type() + pass + elif token in [135]: + self.enterOuterAlt(localctx, 3) + self.state = 725 + self.identifier() + 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 Value_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def plaintext_type(self): + return self.getTypedRuleContext(AleoParser.Plaintext_typeContext,0) + + + def identifier(self): + return self.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def locator(self): + return self.getTypedRuleContext(AleoParser.LocatorContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_value_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValue_type" ): + listener.enterValue_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValue_type" ): + listener.exitValue_type(self) + + + + + def value_type(self): + + localctx = AleoParser.Value_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 130, self.RULE_value_type) + try: + self.state = 746 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,53,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 728 + self.plaintext_type() + self.state = 729 + self.match(AleoParser.T__52) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 731 + self.plaintext_type() + self.state = 732 + self.match(AleoParser.T__53) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 734 + self.plaintext_type() + self.state = 735 + self.match(AleoParser.T__54) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 737 + self.identifier() + self.state = 738 + self.match(AleoParser.T__55) + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 740 + self.locator() + self.state = 741 + self.match(AleoParser.T__55) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 743 + self.locator() + self.state = 744 + self.match(AleoParser.T__56) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Mapping_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def plaintext_type(self): + return self.getTypedRuleContext(AleoParser.Plaintext_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_mapping_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMapping_type" ): + listener.enterMapping_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMapping_type" ): + listener.exitMapping_type(self) + + + + + def mapping_type(self): + + localctx = AleoParser.Mapping_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 132, self.RULE_mapping_type) + try: + self.enterOuterAlt(localctx, 1) + self.state = 748 + self.plaintext_type() + self.state = 749 + self.match(AleoParser.T__53) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Finalize_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def plaintext_type(self): + return self.getTypedRuleContext(AleoParser.Plaintext_typeContext,0) + + + def locator(self): + return self.getTypedRuleContext(AleoParser.LocatorContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_finalize_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFinalize_type" ): + listener.enterFinalize_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFinalize_type" ): + listener.exitFinalize_type(self) + + + + + def finalize_type(self): + + localctx = AleoParser.Finalize_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 134, self.RULE_finalize_type) + try: + self.state = 757 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,54,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 751 + self.plaintext_type() + self.state = 752 + self.match(AleoParser.T__53) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 754 + self.locator() + self.state = 755 + self.match(AleoParser.T__56) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Entry_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def plaintext_type(self): + return self.getTypedRuleContext(AleoParser.Plaintext_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_entry_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEntry_type" ): + listener.enterEntry_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEntry_type" ): + listener.exitEntry_type(self) + + + + + def entry_type(self): + + localctx = AleoParser.Entry_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 136, self.RULE_entry_type) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 759 + self.plaintext_type() + self.state = 760 + _la = self._input.LA(1) + if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 63050394783186944) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Register_typeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def locator(self): + return self.getTypedRuleContext(AleoParser.LocatorContext,0) + + + def identifier(self): + return self.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def plaintext_type(self): + return self.getTypedRuleContext(AleoParser.Plaintext_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_register_type + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRegister_type" ): + listener.enterRegister_type(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRegister_type" ): + listener.exitRegister_type(self) + + + + + def register_type(self): + + localctx = AleoParser.Register_typeContext(self, self._ctx, self.state) + self.enterRule(localctx, 138, self.RULE_register_type) + try: + self.state = 772 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,55,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 762 + self.locator() + self.state = 763 + self.match(AleoParser.T__56) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 765 + self.locator() + self.state = 766 + self.match(AleoParser.T__55) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 768 + self.identifier() + self.state = 769 + self.match(AleoParser.T__55) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 771 + self.plaintext_type() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Program_idContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def program_name(self): + return self.getTypedRuleContext(AleoParser.Program_nameContext,0) + + + def program_domain(self): + return self.getTypedRuleContext(AleoParser.Program_domainContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_program_id + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProgram_id" ): + listener.enterProgram_id(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProgram_id" ): + listener.exitProgram_id(self) + + + + + def program_id(self): + + localctx = AleoParser.Program_idContext(self, self._ctx, self.state) + self.enterRule(localctx, 140, self.RULE_program_id) + try: + self.enterOuterAlt(localctx, 1) + self.state = 774 + self.program_name() + self.state = 775 + self.match(AleoParser.T__57) + self.state = 776 + self.program_domain() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Program_nameContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_program_name + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProgram_name" ): + listener.enterProgram_name(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProgram_name" ): + listener.exitProgram_name(self) + + + + + def program_name(self): + + localctx = AleoParser.Program_nameContext(self, self._ctx, self.state) + self.enterRule(localctx, 142, self.RULE_program_name) + try: + self.enterOuterAlt(localctx, 1) + self.state = 778 + self.identifier() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Program_domainContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_program_domain + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProgram_domain" ): + listener.enterProgram_domain(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProgram_domain" ): + listener.exitProgram_domain(self) + + + + + def program_domain(self): + + localctx = AleoParser.Program_domainContext(self, self._ctx, self.state) + self.enterRule(localctx, 144, self.RULE_program_domain) + try: + self.enterOuterAlt(localctx, 1) + self.state = 780 + self.identifier() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RegisterContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REGISTER(self): + return self.getToken(AleoParser.REGISTER, 0) + + def getRuleIndex(self): + return AleoParser.RULE_register + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRegister" ): + listener.enterRegister(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRegister" ): + listener.exitRegister(self) + + + + + def register(self): + + localctx = AleoParser.RegisterContext(self, self._ctx, self.state) + self.enterRule(localctx, 146, self.RULE_register) + try: + self.enterOuterAlt(localctx, 1) + self.state = 782 + self.match(AleoParser.REGISTER) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Register_accessContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def register(self): + return self.getTypedRuleContext(AleoParser.RegisterContext,0) + + + def register_accessor(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(AleoParser.Register_accessorContext) + else: + return self.getTypedRuleContext(AleoParser.Register_accessorContext,i) + + + def getRuleIndex(self): + return AleoParser.RULE_register_access + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRegister_access" ): + listener.enterRegister_access(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRegister_access" ): + listener.exitRegister_access(self) + + + + + def register_access(self): + + localctx = AleoParser.Register_accessContext(self, self._ctx, self.state) + self.enterRule(localctx, 148, self.RULE_register_access) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 784 + self.register() + self.state = 788 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==17 or _la==58: + self.state = 785 + self.register_accessor() + self.state = 790 + 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 Register_accessorContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def access_by_field(self): + return self.getTypedRuleContext(AleoParser.Access_by_fieldContext,0) + + + def access_by_index(self): + return self.getTypedRuleContext(AleoParser.Access_by_indexContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_register_accessor + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRegister_accessor" ): + listener.enterRegister_accessor(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRegister_accessor" ): + listener.exitRegister_accessor(self) + + + + + def register_accessor(self): + + localctx = AleoParser.Register_accessorContext(self, self._ctx, self.state) + self.enterRule(localctx, 150, self.RULE_register_accessor) + try: + self.state = 793 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [58]: + self.enterOuterAlt(localctx, 1) + self.state = 791 + self.access_by_field() + pass + elif token in [17]: + self.enterOuterAlt(localctx, 2) + self.state = 792 + self.access_by_index() + 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 Access_by_fieldContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_access_by_field + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAccess_by_field" ): + listener.enterAccess_by_field(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAccess_by_field" ): + listener.exitAccess_by_field(self) + + + + + def access_by_field(self): + + localctx = AleoParser.Access_by_fieldContext(self, self._ctx, self.state) + self.enterRule(localctx, 152, self.RULE_access_by_field) + try: + self.enterOuterAlt(localctx, 1) + self.state = 795 + self.match(AleoParser.T__57) + self.state = 796 + self.identifier() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Access_by_indexContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def u32_literal(self): + return self.getTypedRuleContext(AleoParser.U32_literalContext,0) + + + def DIGIT(self, i:int=None): + if i is None: + return self.getTokens(AleoParser.DIGIT) + else: + return self.getToken(AleoParser.DIGIT, i) + + def getRuleIndex(self): + return AleoParser.RULE_access_by_index + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAccess_by_index" ): + listener.enterAccess_by_index(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAccess_by_index" ): + listener.exitAccess_by_index(self) + + + + + def access_by_index(self): + + localctx = AleoParser.Access_by_indexContext(self, self._ctx, self.state) + self.enterRule(localctx, 154, self.RULE_access_by_index) + self._la = 0 # Token type + try: + self.state = 809 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,59,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 798 + self.match(AleoParser.T__16) + self.state = 799 + self.u32_literal() + self.state = 800 + self.match(AleoParser.T__17) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 802 + self.match(AleoParser.T__16) + self.state = 804 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 803 + self.match(AleoParser.DIGIT) + self.state = 806 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==136): + break + + self.state = 808 + self.match(AleoParser.T__17) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class OperandContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def literal(self): + return self.getTypedRuleContext(AleoParser.LiteralContext,0) + + + def register_access(self): + return self.getTypedRuleContext(AleoParser.Register_accessContext,0) + + + def program_id(self): + return self.getTypedRuleContext(AleoParser.Program_idContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_operand + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOperand" ): + listener.enterOperand(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOperand" ): + listener.exitOperand(self) + + + + + def operand(self): + + localctx = AleoParser.OperandContext(self, self._ctx, self.state) + self.enterRule(localctx, 156, self.RULE_operand) + try: + self.state = 818 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [33, 36, 37, 132, 133, 136]: + self.enterOuterAlt(localctx, 1) + self.state = 811 + self.literal() + pass + elif token in [59]: + self.enterOuterAlt(localctx, 2) + self.state = 812 + self.match(AleoParser.T__58) + pass + elif token in [134]: + self.enterOuterAlt(localctx, 3) + self.state = 813 + self.register_access() + pass + elif token in [135]: + self.enterOuterAlt(localctx, 4) + self.state = 814 + self.program_id() + pass + elif token in [60]: + self.enterOuterAlt(localctx, 5) + self.state = 815 + self.match(AleoParser.T__59) + pass + elif token in [61]: + self.enterOuterAlt(localctx, 6) + self.state = 816 + self.match(AleoParser.T__60) + pass + elif token in [62]: + self.enterOuterAlt(localctx, 7) + self.state = 817 + self.match(AleoParser.T__61) + 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 TupleContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def plaintext_type(self): + return self.getTypedRuleContext(AleoParser.Plaintext_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_tuple + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTuple" ): + listener.enterTuple(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTuple" ): + listener.exitTuple(self) + + + + + def tuple_(self): + + localctx = AleoParser.TupleContext(self, self._ctx, self.state) + self.enterRule(localctx, 158, self.RULE_tuple) + try: + self.enterOuterAlt(localctx, 1) + self.state = 820 + self.identifier() + self.state = 821 + self.match(AleoParser.T__6) + self.state = 822 + self.plaintext_type() + self.state = 823 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class EntryContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def entry_type(self): + return self.getTypedRuleContext(AleoParser.Entry_typeContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_entry + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEntry" ): + listener.enterEntry(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEntry" ): + listener.exitEntry(self) + + + + + def entry(self): + + localctx = AleoParser.EntryContext(self, self._ctx, self.state) + self.enterRule(localctx, 160, self.RULE_entry) + try: + self.enterOuterAlt(localctx, 1) + self.state = 825 + self.identifier() + self.state = 826 + self.match(AleoParser.T__6) + self.state = 827 + self.entry_type() + self.state = 828 + self.match(AleoParser.T__1) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LocatorContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def program_id(self): + return self.getTypedRuleContext(AleoParser.Program_idContext,0) + + + def identifier(self): + return self.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_locator + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLocator" ): + listener.enterLocator(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLocator" ): + listener.exitLocator(self) + + + + + def locator(self): + + localctx = AleoParser.LocatorContext(self, self._ctx, self.state) + self.enterRule(localctx, 162, self.RULE_locator) + try: + self.enterOuterAlt(localctx, 1) + self.state = 830 + self.program_id() + self.state = 831 + self.match(AleoParser.T__62) + self.state = 832 + self.identifier() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Cast_destinationContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def register_type(self): + return self.getTypedRuleContext(AleoParser.Register_typeContext,0) + + + def locator(self): + return self.getTypedRuleContext(AleoParser.LocatorContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_cast_destination + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCast_destination" ): + listener.enterCast_destination(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCast_destination" ): + listener.exitCast_destination(self) + + + + + def cast_destination(self): + + localctx = AleoParser.Cast_destinationContext(self, self._ctx, self.state) + self.enterRule(localctx, 164, self.RULE_cast_destination) + try: + self.state = 838 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,61,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 834 + self.register_type() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 835 + self.locator() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 836 + self.match(AleoParser.T__63) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 837 + self.match(AleoParser.T__64) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Unary_opContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_unary_op + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnary_op" ): + listener.enterUnary_op(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnary_op" ): + listener.exitUnary_op(self) + + + + + def unary_op(self): + + localctx = AleoParser.Unary_opContext(self, self._ctx, self.state) + self.enterRule(localctx, 166, self.RULE_unary_op) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 840 + _la = self._input.LA(1) + if not(((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 255) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Binary_opContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_binary_op + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBinary_op" ): + listener.enterBinary_op(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBinary_op" ): + listener.exitBinary_op(self) + + + + + def binary_op(self): + + localctx = AleoParser.Binary_opContext(self, self._ctx, self.state) + self.enterRule(localctx, 168, self.RULE_binary_op) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 842 + _la = self._input.LA(1) + if not(((((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & 67108863) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Is_opContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_is_op + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIs_op" ): + listener.enterIs_op(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIs_op" ): + listener.exitIs_op(self) + + + + + def is_op(self): + + localctx = AleoParser.Is_opContext(self, self._ctx, self.state) + self.enterRule(localctx, 170, self.RULE_is_op) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 844 + _la = self._input.LA(1) + if not(_la==100 or _la==101): + 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 Assert_opContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_assert_op + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAssert_op" ): + listener.enterAssert_op(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAssert_op" ): + listener.exitAssert_op(self) + + + + + def assert_op(self): + + localctx = AleoParser.Assert_opContext(self, self._ctx, self.state) + self.enterRule(localctx, 172, self.RULE_assert_op) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 846 + _la = self._input.LA(1) + if not(_la==102 or _la==103): + 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 Commit_opContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_commit_op + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCommit_op" ): + listener.enterCommit_op(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCommit_op" ): + listener.exitCommit_op(self) + + + + + def commit_op(self): + + localctx = AleoParser.Commit_opContext(self, self._ctx, self.state) + self.enterRule(localctx, 174, self.RULE_commit_op) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 848 + _la = self._input.LA(1) + if not(((((_la - 104)) & ~0x3f) == 0 and ((1 << (_la - 104)) & 63) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Hash1_opContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_hash1_op + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHash1_op" ): + listener.enterHash1_op(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHash1_op" ): + listener.exitHash1_op(self) + + + + + def hash1_op(self): + + localctx = AleoParser.Hash1_opContext(self, self._ctx, self.state) + self.enterRule(localctx, 176, self.RULE_hash1_op) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 850 + _la = self._input.LA(1) + if not(((((_la - 110)) & ~0x3f) == 0 and ((1 << (_la - 110)) & 32767) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Hash2_opContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_hash2_op + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHash2_op" ): + listener.enterHash2_op(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHash2_op" ): + listener.exitHash2_op(self) + + + + + def hash2_op(self): + + localctx = AleoParser.Hash2_opContext(self, self._ctx, self.state) + self.enterRule(localctx, 178, self.RULE_hash2_op) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 852 + _la = self._input.LA(1) + if not(((((_la - 125)) & ~0x3f) == 0 and ((1 << (_la - 125)) & 7) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Cast_opContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_cast_op + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCast_op" ): + listener.enterCast_op(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCast_op" ): + listener.exitCast_op(self) + + + + + def cast_op(self): + + localctx = AleoParser.Cast_opContext(self, self._ctx, self.state) + self.enterRule(localctx, 180, self.RULE_cast_op) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 854 + _la = self._input.LA(1) + if not(_la==128 or _la==129): + 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 Branch_opContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return AleoParser.RULE_branch_op + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBranch_op" ): + listener.enterBranch_op(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBranch_op" ): + listener.exitBranch_op(self) + + + + + def branch_op(self): + + localctx = AleoParser.Branch_opContext(self, self._ctx, self.state) + self.enterRule(localctx, 182, self.RULE_branch_op) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 856 + _la = self._input.LA(1) + if not(_la==130 or _la==131): + 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 LabelContext(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.getTypedRuleContext(AleoParser.IdentifierContext,0) + + + def getRuleIndex(self): + return AleoParser.RULE_label + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLabel" ): + listener.enterLabel(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLabel" ): + listener.exitLabel(self) + + + + + def label(self): + + localctx = AleoParser.LabelContext(self, self._ctx, self.state) + self.enterRule(localctx, 184, self.RULE_label) + try: + self.enterOuterAlt(localctx, 1) + self.state = 858 + self.identifier() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IdentifierContext(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(AleoParser.IDENTIFIER, 0) + + def getRuleIndex(self): + return AleoParser.RULE_identifier + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIdentifier" ): + listener.enterIdentifier(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIdentifier" ): + listener.exitIdentifier(self) + + + + + def identifier(self): + + localctx = AleoParser.IdentifierContext(self, self._ctx, self.state) + self.enterRule(localctx, 186, self.RULE_identifier) + try: + self.enterOuterAlt(localctx, 1) + self.state = 860 + self.match(AleoParser.IDENTIFIER) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + + + diff --git a/vanguard/aleo/testing.py b/vanguard/aleo/testing.py index a3647ee..997a755 100644 --- a/vanguard/aleo/testing.py +++ b/vanguard/aleo/testing.py @@ -1,38 +1,47 @@ import requests import time import json +import pandas as pd from bs4 import BeautifulSoup -from .common import aleo2json -from .grammar import AleoProgram -from .detectors.infoleak import detector_infoleak -from .detectors.rtcnst import detector_rtcnst -from .detectors.unused import detector_unused -from .detectors.divz import detector_divz -from .detectors.divrd import detector_divrd +from .grammar import AleoEnvironment -def run_test_suite(path, detector): - obj = aleo2json(path) - ap = AleoProgram(json=obj) +def run_test_suite(build_path, detector, verbose=False): + env = AleoEnvironment(build_path) # locate the vanguard_helper function and retrieve the label info - vanguard_helper = ap.sjson["functions"]["vanguard_helper"] - raw_labels = vanguard_helper["instructions"][0]["value"]["operands"] - - # parse labels - expected_labels = [p["value"]["value"]["boolean"] for p in raw_labels] - expected_infos = [] # FIXME: add support for this + expected_labels = env.main.functions["vanguard_helper"].instructions[0].operands + expected_labels = [ p.value for p in expected_labels ] + expected_infos = [] # FIXME: add support when available # run detector on all benchmarks, and compare actual_labels = [] actual_infos = [] + ncorrect = 0 for i in range(len(expected_labels)): # call detector directly - label, info = detector(ap, f"ex{i}") + label, info = detector(env, env.main.id, f"ex{i}") actual_labels.append(label) actual_infos.append(info) + result = "✗" + if label == expected_labels[i]: + result = "✓" + ncorrect += 1 + if verbose: + print(f"# [{result}][test] pid: {env.main.id}, fid: ex{i}, expected: {expected_labels[i]}, actual: {label}") + + if verbose: + print(f"# [test] accuracy: {ncorrect}/{len(actual_labels)} ({ncorrect/len(actual_labels):.4f})") + if verbose: + pd_expected = pd.Series(expected_labels, name="expected") + pd_actual = pd.Series(actual_labels, name="actual") + mtx =pd.crosstab(pd_expected, pd_actual) + mtx_norm = mtx.div(mtx.sum(axis=1), axis="index") + print(f"# [test] confusion matrix:\n {mtx}") + print(f"# [test] normalized confusion matrix:\n {mtx_norm}") + return (expected_labels, expected_infos, actual_labels, actual_infos) def crawl_from_haruka_explorer(istart, iend, folder):