diff --git a/README.md b/README.md index 7600637..b514cd7 100644 --- a/README.md +++ b/README.md @@ -86,3 +86,11 @@ https://github.com/mlbelobraydi/TXRRC_data_harvest/wiki/TXRRC-Data-Source-Refere If this code isn't what you are looking for, here is a list of other TXRRC projects on github. https://github.com/mlbelobraydi/TXRRC_data_harvest/wiki/Similar-projects + +## Generation of Python struct from Cobol Copybook Parser + +The RRC datasets have PDF files that define the COBOL Copybook statements. +It would be nice to be able to pass these copybook fragments into a python tool +that would then generate the struct format for parsing the raw binary stream. + +The work under [Cobol Parser](src/cobol_parser.md) addresses this desire. diff --git a/requirements.txt b/requirements.txt index 484bae8..ce23c85 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,250 @@ -numpy>=1.19.2 -pandas>=1.1.2 -python-dateutil>=2.8.1 -pytz>=2020.1 -six>=1.15.0 +agate==1.7.1 +airbyte==0.7.4 +airbyte-cdk==0.58.9 +airbyte-protocol-models==0.5.1 +altair==5.2.0 +analytics-python==1.4.post1 +antlr4-python3-runtime==4.13.1 +antlr4-tools==0.2.1 +archspec @ file:///croot/archspec_1709217642129/work +asgiref @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_edg6nzjrx0/croots/recipe/asgiref_1661287549316/work +asn1crypto==1.5.1 +asttokens @ file:///opt/conda/conda-bld/asttokens_1646925590279/work +astunparse==1.6.3 +attrs==23.2.0 +Babel==2.14.0 +backoff==1.10.0 +backports.functools-lru-cache @ file:///tmp/build/80754af9/backports.functools_lru_cache_1618170165463/work +backports.tempfile @ file:///home/linux1/recipes/ci/backports.tempfile_1610991236607/work +backports.weakref==1.0.post1 +beautifulsoup4 @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_bczxn9gqkq/croot/beautifulsoup4-split_1681493044307/work +blinker==1.7.0 +boltons @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_afe23cncsc/croot/boltons_1677628707735/work +Bottleneck @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_cfe9itj_y_/croot/bottleneck_1707864223016/work +bracex==2.4 +Brotli @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_01vdzesc6m/croots/recipe/brotli-split_1659616063272/work +-e git+https://github.com/markfyoung0711/buckstop-refinery.git@f759c4b714fb98110d6bdd9e6973a5c90f636034#egg=bsl_refinery +build==1.1.1 +cached-property==1.5.2 +cachetools==5.3.3 +cattrs==23.2.3 +certifi @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_dfez5lkpj0/croot/certifi_1707229180975/work/certifi +cffi @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_44mvycfmuf/croot/cffi_1700254431144/work +chardet @ file:///Users/builder/ci_310/chardet_1642531418028/work +charset-normalizer @ file:///tmp/build/80754af9/charset-normalizer_1630003229654/work +click @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_f27dk3zwrb/croot/click_1698129816363/work +coboljsonifier==1.0.5 +colorama==0.4.6 +conda @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_05eqn2x4t4/croot/conda_1708369127465/work +conda-libmamba-solver @ file:///croot/conda-libmamba-solver_1706733287605/work/src +conda-package-handling @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_99vcqjo8cf/croot/conda-package-handling_1690999935230/work +conda-verify==3.4.2 +conda_index @ file:///croot/conda-index_1706633791028/work +conda_package_streaming @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_d5wg6eonuu/croot/conda-package-streaming_1690987980119/work +contourpy==1.2.1 +cryptography==41.0.7 +cycler==0.12.1 +dbt-core==1.7.9 +dbt-extractor==0.5.1 +dbt-postgres==1.7.9 +dbt-semantic-interfaces==0.4.4 +decorator @ file:///opt/conda/conda-bld/decorator_1643638310831/work +Deprecated==1.2.14 +distro @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_e85zz_84gd/croot/distro_1701455023959/work +Django @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_066uop7vqa/croots/recipe/django_1661292540858/work +dlt==0.4.6 +docstring_parser==0.16 +dpath==2.0.8 +duckdb==0.9.2 +duckdb-engine==0.9.2 +et-xmlfile==1.1.0 +exceptiongroup @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_f147j11jio/croot/exceptiongroup_1706031400682/work +executing @ file:///opt/conda/conda-bld/executing_1646925071911/work +filelock @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_cd61an5em3/croot/filelock_1700591192468/work +Flask==3.0.3 +fonttools==4.51.0 +fsspec==2024.2.0 +future @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_27i98bxita/croot/future_1677599886956/work +genson==1.2.2 +gitdb==4.0.11 +GitPython==3.1.42 +giturlparse==0.12.0 +google-api-core==2.17.1 +google-auth==2.28.2 +google-cloud-aiplatform==1.50.0 +google-cloud-appengine-logging==1.4.3 +google-cloud-audit-log==0.2.5 +google-cloud-bigquery==3.19.0 +google-cloud-core==2.4.1 +google-cloud-error-reporting==1.11.0 +google-cloud-language==2.13.3 +google-cloud-logging==3.10.0 +google-cloud-resource-manager==1.12.3 +google-cloud-storage==2.16.0 +google-crc32c==1.5.0 +google-resumable-media==2.7.0 +googleapis-common-protos==1.63.0 +greenlet==3.0.3 +grpc-google-iam-v1==0.13.0 +grpcio==1.62.1 +grpcio-status==1.62.1 +h11==0.14.0 +hexbytes==1.1.0 +huggingface-hub==0.23.0 +humanize==4.9.0 +idna @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_00jf0h4zbt/croot/idna_1666125573348/work +importlib-metadata==6.11.0 +importlib_resources==6.3.0 +inflection==0.5.1 +iniconfig @ file:///home/linux1/recipes/ci/iniconfig_1610983019677/work +install-jdk==1.1.0 +interfax==1.0.0 +ipython @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_32zk9b7snp/croot/ipython_1704833017294/work +isodate==0.6.1 +itsdangerous==2.2.0 +jedi @ file:///opt/concourse/worker/volumes/live/18b71546-5bde-4add-72d1-7d16b76f0f7a/volume/jedi_1644315243726/work +Jinja2 @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_524l12w9yv/croot/jinja2_1706733629737/work +jsonpatch @ file:///tmp/build/80754af9/jsonpatch_1615747632069/work +jsonpath-ng==1.6.1 +jsonpointer==2.1 +jsonref==0.3.0 +jsonschema==4.0.0 +jsonschema-specifications @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_a8fa_vbpr0/croot/jsonschema-specifications_1699032391984/work +kiwisolver==1.4.5 +leather==0.4.0 +libarchive-c @ file:///tmp/build/80754af9/python-libarchive-c_1617780486945/work +libmambapy @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_f92phu8xz5/croot/mamba-split_1704219410331/work/libmambapy +Logbook==1.5.3 +lxml==5.2.1 +makefun==1.15.2 +markdown-it-py==3.0.0 +MarkupSafe @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_3a_cffw83x/croot/markupsafe_1704205995714/work +mashumaro==3.12 +matplotlib==3.8.4 +matplotlib-inline @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_9ddl71oqte/croots/recipe/matplotlib-inline_1662014471815/work +mdurl==0.1.2 +menuinst @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_0bl_d_k5ae/croot/menuinst_1706732940486/work +minimal-snowplow-tracker==0.0.2 +mkl-fft @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_af8wl3mjfu/croot/mkl_fft_1695058185839/work +mkl-random @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_0fq2s894lk/croot/mkl_random_1695059822529/work +mkl-service==2.4.0 +monotonic==1.6 +more-itertools @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_f1d0z8hojr/croot/more-itertools_1700662151147/work +msgpack==1.0.8 +networkx==3.2.1 +numexpr @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_c2pokmr868/croot/numexpr_1696515300257/work +numpy @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_b7iptlxgej/croot/numpy_and_numpy_base_1708638622773/work/dist/numpy-1.26.4-cp310-cp310-macosx_10_9_x86_64.whl#sha256=3a091282d65449198047c750ee795786a0222d5b42b704d32838b504a7523d8c +openpyxl==3.0.10 +orjson==3.9.10 +outcome==1.3.0.post0 +overrides==7.7.0 +packaging @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_2algm5p9lp/croot/packaging_1693575178038/work +pandas @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_80pc5xjc2v/croot/pandas_1702317994691/work/dist/pandas-2.1.4-cp310-cp310-macosx_10_9_x86_64.whl#sha256=fcaa4513f87ad6f52af993463267ab6d051da228ed95494fe05db9c48a3ec2b9 +parsedatetime==2.6 +parso @ file:///opt/conda/conda-bld/parso_1641458642106/work +pathspec==0.11.2 +pathvalidate==3.2.0 +pendulum==2.1.2 +pexpect @ file:///tmp/build/80754af9/pexpect_1605563209008/work +pillow==10.2.0 +pkginfo @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_d976p03z5u/croot/pkginfo_1679431175529/work +platformdirs @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_640usff2p5/croot/platformdirs_1692205656061/work +pluggy @ file:///opt/concourse/worker/volumes/live/8277900c-164a-49c8-6f2a-f55c3c0154be/volume/pluggy_1648042581708/work +ply==3.11 +prompt-toolkit @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_4d8kk9w3ed/croot/prompt-toolkit_1704404354789/work +proto-plus==1.23.0 +protobuf==4.25.3 +psutil @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_c9b604bf-685f-47f6-8304-238e4e70557e1o7mmsot/croots/recipe/psutil_1656431274701/work +psycopg2-binary==2.9.9 +ptyprocess @ file:///tmp/build/80754af9/ptyprocess_1609355006118/work/dist/ptyprocess-0.7.0-py2.py3-none-any.whl +pure-eval @ file:///opt/conda/conda-bld/pure_eval_1646925070566/work +pyarrow==14.0.2 +pyasn1==0.5.1 +pyasn1-modules==0.3.0 +pycosat @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_09anpuxx5u/croot/pycosat_1696536514697/work +pycparser @ file:///tmp/build/80754af9/pycparser_1636541352034/work +pydantic==1.10.14 +pydeck==0.8.1b0 +Pygments @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_cflayrfqsi/croot/pygments_1684279981084/work +PyJWT==2.8.0 +pyOpenSSL==23.3.0 +pyparsing==3.1.2 +pypdf==4.2.0 +pyproject_hooks==1.0.0 +pyrate-limiter==3.1.1 +pyrsistent==0.20.0 +PySocks @ file:///Users/builder/ci_310/pysocks_1642536366386/work +pytest @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_7089yk6bfu/croot/pytest_1690474697638/work +python-dateutil @ file:///tmp/build/80754af9/python-dateutil_1626374649649/work +python-dotenv==1.0.1 +python-magic==0.4.27 +python-slugify==8.0.4 +python-ulid==2.2.0 +pytimeparse==1.1.8 +pytz @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_e0y2h1cdsw/croot/pytz_1695131602326/work +pytzdata==2020.1 +PyYAML @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_37cfd0k_yi/croot/pyyaml_1698096054183/work +re_data==0.11.0 +referencing @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_15mb8b6xor/croot/referencing_1699012045485/work +regex==2024.4.28 +requests @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_4fp_3tflo8/croot/requests_1707355574897/work +requests-cache==1.2.0 +requests-file==2.0.0 +requests-toolbelt==1.0.0 +requirements-parser==0.5.0 +rich==13.7.0 +rpds-py @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_e9l2yxcal2/croot/rpds-py_1698945951668/work +rsa==4.9 +ruamel.yaml @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_7de1zqcaou/croot/ruamel.yaml_1666304553877/work +ruamel.yaml.clib @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_c7s0zxy4t2/croot/ruamel.yaml.clib_1666302244557/work +safetensors==0.4.3 +selenium==4.21.0 +semver==3.0.2 +shapely==2.0.4 +simple-salesforce==1.12.6 +simplejson==3.19.2 +six @ file:///tmp/build/80754af9/six_1644875935023/work +smmap==5.0.1 +sniffio==1.3.1 +snowflake-connector-python==3.6.0 +snowflake-sqlalchemy==1.5.1 +sortedcontainers==2.4.0 +soupsieve @ file:///private/var/folders/c_/qfmhj66j0tn016nkx_th4hxm0000gp/T/abs_9cjy8iflks/croot/soupsieve_1696347576367/work +SQLAlchemy==1.4.51 +sqlalchemy-bigquery==1.9.0 +sqlparse @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_cb77ukgrpu/croot/sqlparse_1690901947630/work +stack-data @ file:///opt/conda/conda-bld/stack_data_1646927590127/work +streamlit==1.32.2 +tabulate==0.8.9 +tenacity==8.2.3 +text-unidecode==1.3 +tokenizers==0.19.1 +toml==0.10.2 +tomli @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_90762ba4-f339-47e8-bd29-416854a59b233d27hku_/croots/recipe/tomli_1657175507767/work +tomlkit==0.12.4 +toolz==0.12.1 +tornado==6.4 +tqdm @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_03acd6t6ca/croot/tqdm_1679561866522/work +traitlets @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_0dtilxc0bw/croot/traitlets_1671143889152/work +transformers==4.40.2 +trio==0.25.1 +trio-websocket==0.11.1 +truststore @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_d4qy09ztdt/croot/truststore_1695244322396/work +types-PyYAML==6.0.12.12 +types-setuptools==69.1.0.20240310 +typing_extensions==4.10.0 +tzdata @ file:///croot/python-tzdata_1690578112552/work +ulid==1.1 +url-normalize==1.4.3 +urllib3==1.26.18 +watchdog==4.0.0 +wcmatch==8.4 +wcwidth @ file:///Users/ktietz/demo/mc3/conda-bld/wcwidth_1629357192024/work +websockets==12.0 +Werkzeug==3.0.3 +wrapt==1.16.0 +wsproto==1.2.0 +yachalk==0.1.5 +zeep==4.2.1 +zipp==3.18.0 +zstandard @ file:///private/var/folders/sy/f16zz6x50xz3113nwtb9bvq00000gp/T/abs_40ayfv1xn6/croot/zstandard_1677014126754/work diff --git a/src/Cobol85.g4 b/src/Cobol85.g4 new file mode 100644 index 0000000..d037bf1 --- /dev/null +++ b/src/Cobol85.g4 @@ -0,0 +1,5655 @@ +/* +* Copyright (C) 2017, Ulrich Wolffgang +* All rights reserved. +* +* This software may be modified and distributed under the terms +* of the MIT license. See the LICENSE file for details. +*/ + +/* +* COBOL 85 Grammar for ANTLR4 +* +* This is a COBOL 85 grammar, which is part of the COBOL parser at +* https://github.com/uwol/cobol85parser. +* +* The grammar passes the NIST test suite and has successfully been applied to +* numerous COBOL files from banking and insurance. To be used in conjunction +* with the provided preprocessor, which executes COPY and REPLACE statements. +*/ + +// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false +// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging + +grammar Cobol85; + +startRule + : compilationUnit EOF + ; + +compilationUnit + : programUnit+ + ; + +programUnit + : identificationDivision environmentDivision? dataDivision? procedureDivision? programUnit* endProgramStatement? + ; + +endProgramStatement + : END PROGRAM programName DOT_FS + ; + +// --- identification division -------------------------------------------------------------------- + +identificationDivision + : (IDENTIFICATION | ID) DIVISION DOT_FS programIdParagraph identificationDivisionBody* + ; + +identificationDivisionBody + : authorParagraph + | installationParagraph + | dateWrittenParagraph + | dateCompiledParagraph + | securityParagraph + | remarksParagraph + ; + +// - program id paragraph ---------------------------------- + +programIdParagraph + : PROGRAM_ID DOT_FS programName ( + IS? (COMMON | INITIAL | LIBRARY | DEFINITION | RECURSIVE) PROGRAM? + )? DOT_FS? commentEntry? + ; + +// - author paragraph ---------------------------------- + +authorParagraph + : AUTHOR DOT_FS commentEntry? + ; + +// - installation paragraph ---------------------------------- + +installationParagraph + : INSTALLATION DOT_FS commentEntry? + ; + +// - date written paragraph ---------------------------------- + +dateWrittenParagraph + : DATE_WRITTEN DOT_FS commentEntry? + ; + +// - date compiled paragraph ---------------------------------- + +dateCompiledParagraph + : DATE_COMPILED DOT_FS commentEntry? + ; + +// - security paragraph ---------------------------------- + +securityParagraph + : SECURITY DOT_FS commentEntry? + ; + +// - remarks paragraph ---------------------------------- + +remarksParagraph + : REMARKS DOT_FS commentEntry? + ; + +// --- environment division -------------------------------------------------------------------- + +environmentDivision + : ENVIRONMENT DIVISION DOT_FS environmentDivisionBody* + ; + +environmentDivisionBody + : configurationSection + | specialNamesParagraph + | inputOutputSection + ; + +// -- configuration section ---------------------------------- + +configurationSection + : CONFIGURATION SECTION DOT_FS configurationSectionParagraph* + ; + +// - configuration section paragraph ---------------------------------- + +configurationSectionParagraph + : sourceComputerParagraph + | objectComputerParagraph + | specialNamesParagraph + // strictly, specialNamesParagraph does not belong into configurationSectionParagraph, but ibm-cobol allows this + ; + +// - source computer paragraph ---------------------------------- + +sourceComputerParagraph + : SOURCE_COMPUTER DOT_FS computerName (WITH? DEBUGGING MODE)? DOT_FS + ; + +// - object computer paragraph ---------------------------------- + +objectComputerParagraph + : OBJECT_COMPUTER DOT_FS computerName objectComputerClause* DOT_FS + ; + +objectComputerClause + : memorySizeClause + | diskSizeClause + | collatingSequenceClause + | segmentLimitClause + | characterSetClause + ; + +memorySizeClause + : MEMORY SIZE? (integerLiteral | cobolWord) (WORDS | CHARACTERS | MODULES)? + ; + +diskSizeClause + : DISK SIZE? IS? (integerLiteral | cobolWord) (WORDS | MODULES)? + ; + +collatingSequenceClause + : PROGRAM? COLLATING? SEQUENCE (IS? alphabetName+) collatingSequenceClauseAlphanumeric? collatingSequenceClauseNational? + ; + +collatingSequenceClauseAlphanumeric + : FOR? ALPHANUMERIC IS? alphabetName + ; + +collatingSequenceClauseNational + : FOR? NATIONAL IS? alphabetName + ; + +segmentLimitClause + : SEGMENT_LIMIT IS? integerLiteral + ; + +characterSetClause + : CHARACTER SET DOT_FS + ; + +// - special names paragraph ---------------------------------- + +specialNamesParagraph + : SPECIAL_NAMES DOT_FS (specialNameClause+ DOT_FS)? + ; + +specialNameClause + : channelClause + | odtClause + | alphabetClause + | classClause + | currencySignClause + | decimalPointClause + | symbolicCharactersClause + | environmentSwitchNameClause + | defaultDisplaySignClause + | defaultComputationalSignClause + | reserveNetworkClause + ; + +alphabetClause + : alphabetClauseFormat1 + | alphabetClauseFormat2 + ; + +alphabetClauseFormat1 + : ALPHABET alphabetName (FOR ALPHANUMERIC)? IS? ( + EBCDIC + | ASCII + | STANDARD_1 + | STANDARD_2 + | NATIVE + | cobolWord + | alphabetLiterals+ + ) + ; + +alphabetLiterals + : literal (alphabetThrough | alphabetAlso+)? + ; + +alphabetThrough + : (THROUGH | THRU) literal + ; + +alphabetAlso + : ALSO literal+ + ; + +alphabetClauseFormat2 + : ALPHABET alphabetName FOR? NATIONAL IS? (NATIVE | CCSVERSION literal) + ; + +channelClause + : CHANNEL integerLiteral IS? mnemonicName + ; + +classClause + : CLASS className (FOR? (ALPHANUMERIC | NATIONAL))? IS? classClauseThrough+ + ; + +classClauseThrough + : classClauseFrom ((THROUGH | THRU) classClauseTo)? + ; + +classClauseFrom + : identifier + | literal + ; + +classClauseTo + : identifier + | literal + ; + +currencySignClause + : CURRENCY SIGN? IS? literal (WITH? PICTURE SYMBOL literal)? + ; + +decimalPointClause + : DECIMAL_POINT IS? COMMA + ; + +defaultComputationalSignClause + : DEFAULT (COMPUTATIONAL | COMP)? (SIGN IS?)? (LEADING | TRAILING)? (SEPARATE CHARACTER?) + ; + +defaultDisplaySignClause + : DEFAULT_DISPLAY (SIGN IS?)? (LEADING | TRAILING) (SEPARATE CHARACTER?)? + ; + +environmentSwitchNameClause + : environmentName IS? mnemonicName environmentSwitchNameSpecialNamesStatusPhrase? + | environmentSwitchNameSpecialNamesStatusPhrase + ; + +environmentSwitchNameSpecialNamesStatusPhrase + : ON STATUS? IS? condition (OFF STATUS? IS? condition)? + | OFF STATUS? IS? condition (ON STATUS? IS? condition)? + ; + +odtClause + : ODT IS? mnemonicName + ; + +reserveNetworkClause + : RESERVE WORDS? LIST? IS? NETWORK CAPABLE? + ; + +symbolicCharactersClause + : SYMBOLIC CHARACTERS? (FOR? (ALPHANUMERIC | NATIONAL))? symbolicCharacters+ (IN alphabetName)? + ; + +symbolicCharacters + : symbolicCharacter+ (IS | ARE)? integerLiteral+ + ; + +// -- input output section ---------------------------------- + +inputOutputSection + : INPUT_OUTPUT SECTION DOT_FS inputOutputSectionParagraph* + ; + +// - input output section paragraph ---------------------------------- + +inputOutputSectionParagraph + : fileControlParagraph + | ioControlParagraph + ; + +// - file control paragraph ---------------------------------- + +fileControlParagraph + : FILE_CONTROL (DOT_FS? fileControlEntry)* DOT_FS + ; + +fileControlEntry + : selectClause fileControlClause* + ; + +selectClause + : SELECT OPTIONAL? fileName + ; + +fileControlClause + : assignClause + | reserveClause + | organizationClause + | paddingCharacterClause + | recordDelimiterClause + | accessModeClause + | recordKeyClause + | alternateRecordKeyClause + | fileStatusClause + | passwordClause + | relativeKeyClause + ; + +assignClause + : ASSIGN TO? ( + DISK + | DISPLAY + | KEYBOARD + | PORT + | PRINTER + | READER + | REMOTE + | TAPE + | VIRTUAL + | assignmentName + | literal + ) + ; + +reserveClause + : RESERVE (NO | integerLiteral) ALTERNATE? (AREA | AREAS)? + ; + +organizationClause + : (ORGANIZATION IS?)? (LINE | RECORD BINARY | RECORD | BINARY)? ( + SEQUENTIAL + | RELATIVE + | INDEXED + ) + ; + +paddingCharacterClause + : PADDING CHARACTER? IS? (qualifiedDataName | literal) + ; + +recordDelimiterClause + : RECORD DELIMITER IS? (STANDARD_1 | IMPLICIT | assignmentName) + ; + +accessModeClause + : ACCESS MODE? IS? (SEQUENTIAL | RANDOM | DYNAMIC | EXCLUSIVE) + ; + +recordKeyClause + : RECORD KEY? IS? qualifiedDataName passwordClause? (WITH? DUPLICATES)? + ; + +alternateRecordKeyClause + : ALTERNATE RECORD KEY? IS? qualifiedDataName passwordClause? (WITH? DUPLICATES)? + ; + +passwordClause + : PASSWORD IS? dataName + ; + +fileStatusClause + : FILE? STATUS IS? qualifiedDataName qualifiedDataName? + ; + +relativeKeyClause + : RELATIVE KEY? IS? qualifiedDataName + ; + +// - io control paragraph ---------------------------------- + +ioControlParagraph + : I_O_CONTROL DOT_FS (fileName DOT_FS)? (ioControlClause* DOT_FS)? + ; + +ioControlClause + : rerunClause + | sameClause + | multipleFileClause + | commitmentControlClause + ; + +rerunClause + : RERUN (ON (assignmentName | fileName))? EVERY ( + rerunEveryRecords + | rerunEveryOf + | rerunEveryClock + ) + ; + +rerunEveryRecords + : integerLiteral RECORDS + ; + +rerunEveryOf + : END? OF? (REEL | UNIT) OF fileName + ; + +rerunEveryClock + : integerLiteral CLOCK_UNITS? + ; + +sameClause + : SAME (RECORD | SORT | SORT_MERGE)? AREA? FOR? fileName+ + ; + +multipleFileClause + : MULTIPLE FILE TAPE? CONTAINS? multipleFilePosition+ + ; + +multipleFilePosition + : fileName (POSITION integerLiteral)? + ; + +commitmentControlClause + : COMMITMENT CONTROL FOR? fileName + ; + +// --- data division -------------------------------------------------------------------- + +dataDivision + : DATA DIVISION DOT_FS dataDivisionSection* + ; + +dataDivisionSection + : fileSection + | dataBaseSection + | workingStorageSection + | linkageSection + | communicationSection + | localStorageSection + | screenSection + | reportSection + | programLibrarySection + ; + +// -- file section ---------------------------------- + +fileSection + : FILE SECTION DOT_FS fileDescriptionEntry* + ; + +fileDescriptionEntry + : (FD | SD) fileName (DOT_FS? fileDescriptionEntryClause)* DOT_FS dataDescriptionEntry* + ; + +fileDescriptionEntryClause + : externalClause + | globalClause + | blockContainsClause + | recordContainsClause + | labelRecordsClause + | valueOfClause + | dataRecordsClause + | linageClause + | codeSetClause + | reportClause + | recordingModeClause + ; + +externalClause + : IS? EXTERNAL + ; + +globalClause + : IS? GLOBAL + ; + +blockContainsClause + : BLOCK CONTAINS? integerLiteral blockContainsTo? (RECORDS | CHARACTERS)? + ; + +blockContainsTo + : TO integerLiteral + ; + +recordContainsClause + : RECORD ( + recordContainsClauseFormat1 + | recordContainsClauseFormat2 + | recordContainsClauseFormat3 + ) + ; + +recordContainsClauseFormat1 + : CONTAINS? integerLiteral CHARACTERS? + ; + +recordContainsClauseFormat2 + : IS? VARYING IN? SIZE? (FROM? integerLiteral recordContainsTo? CHARACTERS?)? ( + DEPENDING ON? qualifiedDataName + )? + ; + +recordContainsClauseFormat3 + : CONTAINS? integerLiteral recordContainsTo CHARACTERS? + ; + +recordContainsTo + : TO integerLiteral + ; + +labelRecordsClause + : LABEL (RECORD IS? | RECORDS ARE?) (OMITTED | STANDARD | dataName+) + ; + +valueOfClause + : VALUE OF valuePair+ + ; + +valuePair + : systemName IS? (qualifiedDataName | literal) + ; + +dataRecordsClause + : DATA (RECORD IS? | RECORDS ARE?) dataName+ + ; + +linageClause + : LINAGE IS? (dataName | integerLiteral) LINES? linageAt* + ; + +linageAt + : linageFootingAt + | linageLinesAtTop + | linageLinesAtBottom + ; + +linageFootingAt + : WITH? FOOTING AT? (dataName | integerLiteral) + ; + +linageLinesAtTop + : LINES? AT? TOP (dataName | integerLiteral) + ; + +linageLinesAtBottom + : LINES? AT? BOTTOM (dataName | integerLiteral) + ; + +recordingModeClause + : RECORDING MODE? IS? modeStatement + ; + +modeStatement + : cobolWord + ; + +codeSetClause + : CODE_SET IS? alphabetName + ; + +reportClause + : (REPORT IS? | REPORTS ARE?) reportName+ + ; + +// -- data base section ---------------------------------- + +dataBaseSection + : DATA_BASE SECTION DOT_FS dataBaseSectionEntry* + ; + +dataBaseSectionEntry + : integerLiteral literal INVOKE literal + ; + +// -- working storage section ---------------------------------- + +workingStorageSection + : WORKING_STORAGE SECTION DOT_FS dataDescriptionEntry* + ; + +// -- linkage section ---------------------------------- + +linkageSection + : LINKAGE SECTION DOT_FS dataDescriptionEntry* + ; + +// -- communication section ---------------------------------- + +communicationSection + : COMMUNICATION SECTION DOT_FS (communicationDescriptionEntry | dataDescriptionEntry)* + ; + +communicationDescriptionEntry + : communicationDescriptionEntryFormat1 + | communicationDescriptionEntryFormat2 + | communicationDescriptionEntryFormat3 + ; + +communicationDescriptionEntryFormat1 + : CD cdName FOR? INITIAL? INPUT ( + ( + symbolicQueueClause + | symbolicSubQueueClause + | messageDateClause + | messageTimeClause + | symbolicSourceClause + | textLengthClause + | endKeyClause + | statusKeyClause + | messageCountClause + ) + | dataDescName + )* DOT_FS + ; + +communicationDescriptionEntryFormat2 + : CD cdName FOR? OUTPUT ( + destinationCountClause + | textLengthClause + | statusKeyClause + | destinationTableClause + | errorKeyClause + | symbolicDestinationClause + )* DOT_FS + ; + +communicationDescriptionEntryFormat3 + : CD cdName FOR? INITIAL I_O ( + ( + messageDateClause + | messageTimeClause + | symbolicTerminalClause + | textLengthClause + | endKeyClause + | statusKeyClause + ) + | dataDescName + )* DOT_FS + ; + +destinationCountClause + : DESTINATION COUNT IS? dataDescName + ; + +destinationTableClause + : DESTINATION TABLE OCCURS integerLiteral TIMES (INDEXED BY indexName+)? + ; + +endKeyClause + : END KEY IS? dataDescName + ; + +errorKeyClause + : ERROR KEY IS? dataDescName + ; + +messageCountClause + : MESSAGE? COUNT IS? dataDescName + ; + +messageDateClause + : MESSAGE DATE IS? dataDescName + ; + +messageTimeClause + : MESSAGE TIME IS? dataDescName + ; + +statusKeyClause + : STATUS KEY IS? dataDescName + ; + +symbolicDestinationClause + : SYMBOLIC? DESTINATION IS? dataDescName + ; + +symbolicQueueClause + : SYMBOLIC? QUEUE IS? dataDescName + ; + +symbolicSourceClause + : SYMBOLIC? SOURCE IS? dataDescName + ; + +symbolicTerminalClause + : SYMBOLIC? TERMINAL IS? dataDescName + ; + +symbolicSubQueueClause + : SYMBOLIC? (SUB_QUEUE_1 | SUB_QUEUE_2 | SUB_QUEUE_3) IS? dataDescName + ; + +textLengthClause + : TEXT LENGTH IS? dataDescName + ; + +// -- local storage section ---------------------------------- + +localStorageSection + : LOCAL_STORAGE SECTION DOT_FS (LD localName DOT_FS)? dataDescriptionEntry* + ; + +// -- screen section ---------------------------------- + +screenSection + : SCREEN SECTION DOT_FS screenDescriptionEntry* + ; + +screenDescriptionEntry + : INTEGERLITERAL (FILLER | screenName)? ( + screenDescriptionBlankClause + | screenDescriptionBellClause + | screenDescriptionBlinkClause + | screenDescriptionEraseClause + | screenDescriptionLightClause + | screenDescriptionGridClause + | screenDescriptionReverseVideoClause + | screenDescriptionUnderlineClause + | screenDescriptionSizeClause + | screenDescriptionLineClause + | screenDescriptionColumnClause + | screenDescriptionForegroundColorClause + | screenDescriptionBackgroundColorClause + | screenDescriptionControlClause + | screenDescriptionValueClause + | screenDescriptionPictureClause + | (screenDescriptionFromClause | screenDescriptionUsingClause) + | screenDescriptionUsageClause + | screenDescriptionBlankWhenZeroClause + | screenDescriptionJustifiedClause + | screenDescriptionSignClause + | screenDescriptionAutoClause + | screenDescriptionSecureClause + | screenDescriptionRequiredClause + | screenDescriptionPromptClause + | screenDescriptionFullClause + | screenDescriptionZeroFillClause + )* DOT_FS + ; + +screenDescriptionBlankClause + : BLANK (SCREEN | LINE) + ; + +screenDescriptionBellClause + : BELL + | BEEP + ; + +screenDescriptionBlinkClause + : BLINK + ; + +screenDescriptionEraseClause + : ERASE (EOL | EOS) + ; + +screenDescriptionLightClause + : HIGHLIGHT + | LOWLIGHT + ; + +screenDescriptionGridClause + : GRID + | LEFTLINE + | OVERLINE + ; + +screenDescriptionReverseVideoClause + : REVERSE_VIDEO + ; + +screenDescriptionUnderlineClause + : UNDERLINE + ; + +screenDescriptionSizeClause + : SIZE IS? (identifier | integerLiteral) + ; + +screenDescriptionLineClause + : LINE (NUMBER? IS? (PLUS | PLUSCHAR | MINUSCHAR))? (identifier | integerLiteral) + ; + +screenDescriptionColumnClause + : (COLUMN | COL) (NUMBER? IS? (PLUS | PLUSCHAR | MINUSCHAR))? (identifier | integerLiteral) + ; + +screenDescriptionForegroundColorClause + : (FOREGROUND_COLOR | FOREGROUND_COLOUR) IS? (identifier | integerLiteral) + ; + +screenDescriptionBackgroundColorClause + : (BACKGROUND_COLOR | BACKGROUND_COLOUR) IS? (identifier | integerLiteral) + ; + +screenDescriptionControlClause + : CONTROL IS? identifier + ; + +screenDescriptionValueClause + : (VALUE IS?) literal + ; + +screenDescriptionPictureClause + : (PICTURE | PIC) IS? pictureString + ; + +screenDescriptionFromClause + : FROM (identifier | literal) screenDescriptionToClause? + ; + +screenDescriptionToClause + : TO identifier + ; + +screenDescriptionUsingClause + : USING identifier + ; + +screenDescriptionUsageClause + : (USAGE IS?) (DISPLAY | DISPLAY_1) + ; + +screenDescriptionBlankWhenZeroClause + : BLANK WHEN? ZERO + ; + +screenDescriptionJustifiedClause + : (JUSTIFIED | JUST) RIGHT? + ; + +screenDescriptionSignClause + : (SIGN IS?)? (LEADING | TRAILING) (SEPARATE CHARACTER?)? + ; + +screenDescriptionAutoClause + : AUTO + | AUTO_SKIP + ; + +screenDescriptionSecureClause + : SECURE + | NO_ECHO + ; + +screenDescriptionRequiredClause + : REQUIRED + | EMPTY_CHECK + ; + +screenDescriptionPromptClause + : PROMPT CHARACTER? IS? (identifier | literal) screenDescriptionPromptOccursClause? + ; + +screenDescriptionPromptOccursClause + : OCCURS integerLiteral TIMES? + ; + +screenDescriptionFullClause + : FULL + | LENGTH_CHECK + ; + +screenDescriptionZeroFillClause + : ZERO_FILL + ; + +// -- report section ---------------------------------- + +reportSection + : REPORT SECTION DOT_FS reportDescription* + ; + +reportDescription + : reportDescriptionEntry reportGroupDescriptionEntry+ + ; + +reportDescriptionEntry + : RD reportName reportDescriptionGlobalClause? ( + reportDescriptionPageLimitClause reportDescriptionHeadingClause? reportDescriptionFirstDetailClause? reportDescriptionLastDetailClause? + reportDescriptionFootingClause? + )? DOT_FS + ; + +reportDescriptionGlobalClause + : IS? GLOBAL + ; + +reportDescriptionPageLimitClause + : PAGE (LIMIT IS? | LIMITS ARE?)? integerLiteral (LINE | LINES)? + ; + +reportDescriptionHeadingClause + : HEADING integerLiteral + ; + +reportDescriptionFirstDetailClause + : FIRST DETAIL integerLiteral + ; + +reportDescriptionLastDetailClause + : LAST DETAIL integerLiteral + ; + +reportDescriptionFootingClause + : FOOTING integerLiteral + ; + +reportGroupDescriptionEntry + : reportGroupDescriptionEntryFormat1 + | reportGroupDescriptionEntryFormat2 + | reportGroupDescriptionEntryFormat3 + ; + +reportGroupDescriptionEntryFormat1 + : integerLiteral dataName reportGroupLineNumberClause? reportGroupNextGroupClause? reportGroupTypeClause reportGroupUsageClause? DOT_FS + ; + +reportGroupDescriptionEntryFormat2 + : integerLiteral dataName? reportGroupLineNumberClause? reportGroupUsageClause DOT_FS + ; + +reportGroupDescriptionEntryFormat3 + : integerLiteral dataName? ( + reportGroupPictureClause + | reportGroupUsageClause + | reportGroupSignClause + | reportGroupJustifiedClause + | reportGroupBlankWhenZeroClause + | reportGroupLineNumberClause + | reportGroupColumnNumberClause + | ( + reportGroupSourceClause + | reportGroupValueClause + | reportGroupSumClause + | reportGroupResetClause + ) + | reportGroupIndicateClause + )* DOT_FS + ; + +reportGroupBlankWhenZeroClause + : BLANK WHEN? ZERO + ; + +reportGroupColumnNumberClause + : COLUMN NUMBER? IS? integerLiteral + ; + +reportGroupIndicateClause + : GROUP INDICATE? + ; + +reportGroupJustifiedClause + : (JUSTIFIED | JUST) RIGHT? + ; + +reportGroupLineNumberClause + : LINE? NUMBER? IS? (reportGroupLineNumberNextPage | reportGroupLineNumberPlus) + ; + +reportGroupLineNumberNextPage + : integerLiteral (ON? NEXT PAGE)? + ; + +reportGroupLineNumberPlus + : PLUS integerLiteral + ; + +reportGroupNextGroupClause + : NEXT GROUP IS? (integerLiteral | reportGroupNextGroupNextPage | reportGroupNextGroupPlus) + ; + +reportGroupNextGroupPlus + : PLUS integerLiteral + ; + +reportGroupNextGroupNextPage + : NEXT PAGE + ; + +reportGroupPictureClause + : (PICTURE | PIC) IS? pictureString + ; + +reportGroupResetClause + : RESET ON? (FINAL | dataName) + ; + +reportGroupSignClause + : SIGN IS? (LEADING | TRAILING) SEPARATE CHARACTER? + ; + +reportGroupSourceClause + : SOURCE IS? identifier + ; + +reportGroupSumClause + : SUM identifier (COMMACHAR? identifier)* (UPON dataName (COMMACHAR? dataName)*)? + ; + +reportGroupTypeClause + : TYPE IS? ( + reportGroupTypeReportHeading + | reportGroupTypePageHeading + | reportGroupTypeControlHeading + | reportGroupTypeDetail + | reportGroupTypeControlFooting + | reportGroupTypePageFooting + | reportGroupTypeReportFooting + ) + ; + +reportGroupTypeReportHeading + : REPORT HEADING + | RH + ; + +reportGroupTypePageHeading + : PAGE HEADING + | PH + ; + +reportGroupTypeControlHeading + : (CONTROL HEADING | CH) (FINAL | dataName) + ; + +reportGroupTypeDetail + : DETAIL + | DE + ; + +reportGroupTypeControlFooting + : (CONTROL FOOTING | CF) (FINAL | dataName) + ; + +reportGroupUsageClause + : (USAGE IS?)? (DISPLAY | DISPLAY_1) + ; + +reportGroupTypePageFooting + : PAGE FOOTING + | PF + ; + +reportGroupTypeReportFooting + : REPORT FOOTING + | RF + ; + +reportGroupValueClause + : VALUE IS? literal + ; + +// -- program library section ---------------------------------- + +programLibrarySection + : PROGRAM_LIBRARY SECTION DOT_FS libraryDescriptionEntry* + ; + +libraryDescriptionEntry + : libraryDescriptionEntryFormat1 + | libraryDescriptionEntryFormat2 + ; + +libraryDescriptionEntryFormat1 + : LD libraryName EXPORT libraryAttributeClauseFormat1? libraryEntryProcedureClauseFormat1? + ; + +libraryDescriptionEntryFormat2 + : LB libraryName IMPORT libraryIsGlobalClause? libraryIsCommonClause? ( + libraryAttributeClauseFormat2 + | libraryEntryProcedureClauseFormat2 + )* + ; + +libraryAttributeClauseFormat1 + : ATTRIBUTE (SHARING IS? (DONTCARE | PRIVATE | SHAREDBYRUNUNIT | SHAREDBYALL))? + ; + +libraryAttributeClauseFormat2 + : ATTRIBUTE libraryAttributeFunction? (LIBACCESS IS? (BYFUNCTION | BYTITLE))? libraryAttributeParameter? libraryAttributeTitle? + ; + +libraryAttributeFunction + : FUNCTIONNAME IS literal + ; + +libraryAttributeParameter + : LIBPARAMETER IS? literal + ; + +libraryAttributeTitle + : TITLE IS? literal + ; + +libraryEntryProcedureClauseFormat1 + : ENTRY_PROCEDURE programName libraryEntryProcedureForClause? + ; + +libraryEntryProcedureClauseFormat2 + : ENTRY_PROCEDURE programName libraryEntryProcedureForClause? libraryEntryProcedureWithClause? libraryEntryProcedureUsingClause? + libraryEntryProcedureGivingClause? + ; + +libraryEntryProcedureForClause + : FOR literal + ; + +libraryEntryProcedureGivingClause + : GIVING dataName + ; + +libraryEntryProcedureUsingClause + : USING libraryEntryProcedureUsingName+ + ; + +libraryEntryProcedureUsingName + : dataName + | fileName + ; + +libraryEntryProcedureWithClause + : WITH libraryEntryProcedureWithName+ + ; + +libraryEntryProcedureWithName + : localName + | fileName + ; + +libraryIsCommonClause + : IS? COMMON + ; + +libraryIsGlobalClause + : IS? GLOBAL + ; + +// data description entry ---------------------------------- + +dataDescriptionEntry + : dataDescriptionEntryFormat1 + | dataDescriptionEntryFormat2 + | dataDescriptionEntryFormat3 + | dataDescriptionEntryExecSql + ; + +dataDescriptionEntryFormat1 + : (INTEGERLITERAL | LEVEL_NUMBER_77) (FILLER | dataName)? ( + dataRedefinesClause + | dataIntegerStringClause + | dataExternalClause + | dataGlobalClause + | dataTypeDefClause + | dataThreadLocalClause + | dataPictureClause + | dataCommonOwnLocalClause + | dataTypeClause + | dataUsingClause + | dataUsageClause + | dataValueClause + | dataReceivedByClause + | dataOccursClause + | dataSignClause + | dataSynchronizedClause + | dataJustifiedClause + | dataBlankWhenZeroClause + | dataWithLowerBoundsClause + | dataAlignedClause + | dataRecordAreaClause + )* DOT_FS + ; + +dataDescriptionEntryFormat2 + : LEVEL_NUMBER_66 dataName dataRenamesClause DOT_FS + ; + +dataDescriptionEntryFormat3 + : LEVEL_NUMBER_88 conditionName dataValueClause DOT_FS + ; + +dataDescriptionEntryExecSql + : EXECSQLLINE+ DOT_FS? + ; + +dataAlignedClause + : ALIGNED + ; + +dataBlankWhenZeroClause + : BLANK WHEN? (ZERO | ZEROS | ZEROES) + ; + +dataCommonOwnLocalClause + : COMMON + | OWN + | LOCAL + ; + +dataExternalClause + : IS? EXTERNAL (BY literal)? + ; + +dataGlobalClause + : IS? GLOBAL + ; + +dataIntegerStringClause + : INTEGER + | STRING + ; + +dataJustifiedClause + : (JUSTIFIED | JUST) RIGHT? + ; + +dataOccursClause + : OCCURS integerLiteral dataOccursTo? TIMES? (DEPENDING ON? qualifiedDataName)? dataOccursSort* ( + INDEXED BY? LOCAL? indexName+ + )? + ; + +dataOccursTo + : TO integerLiteral + ; + +dataOccursSort + : (ASCENDING | DESCENDING) KEY? IS? qualifiedDataName+ + ; + +dataPictureClause + : (PICTURE | PIC) IS? pictureString + ; + +pictureString + : (pictureChars+ pictureCardinality?)+ + ; + +pictureChars + : DOLLARCHAR + | IDENTIFIER + | NUMERICLITERAL + | SLASHCHAR + | COMMACHAR + | DOT + | COLONCHAR + | ASTERISKCHAR + | DOUBLEASTERISKCHAR + | LPARENCHAR + | RPARENCHAR + | PLUSCHAR + | MINUSCHAR + | LESSTHANCHAR + | MORETHANCHAR + | integerLiteral + ; + +pictureCardinality + : LPARENCHAR integerLiteral RPARENCHAR + ; + +dataReceivedByClause + : RECEIVED? BY? (CONTENT | REFERENCE | REF) + ; + +dataRecordAreaClause + : RECORD AREA + ; + +dataRedefinesClause + : REDEFINES dataName + ; + +dataRenamesClause + : RENAMES qualifiedDataName ((THROUGH | THRU) qualifiedDataName)? + ; + +dataSignClause + : (SIGN IS?)? (LEADING | TRAILING) (SEPARATE CHARACTER?)? + ; + +dataSynchronizedClause + : (SYNCHRONIZED | SYNC) (LEFT | RIGHT)? + ; + +dataThreadLocalClause + : IS? THREAD_LOCAL + ; + +dataTypeClause + : TYPE IS? (SHORT_DATE | LONG_DATE | NUMERIC_DATE | NUMERIC_TIME | LONG_TIME) + ; + +dataTypeDefClause + : IS? TYPEDEF + ; + +dataUsageClause + : (USAGE IS?)? ( + BINARY (TRUNCATED | EXTENDED)? + | BIT + | COMP + | COMP_1 + | COMP_2 + | COMP_3 + | COMP_4 + | COMP_5 + | COMPUTATIONAL + | COMPUTATIONAL_1 + | COMPUTATIONAL_2 + | COMPUTATIONAL_3 + | COMPUTATIONAL_4 + | COMPUTATIONAL_5 + | CONTROL_POINT + | DATE + | DISPLAY + | DISPLAY_1 + | DOUBLE + | EVENT + | FUNCTION_POINTER + | INDEX + | KANJI + | LOCK + | NATIONAL + | PACKED_DECIMAL + | POINTER + | PROCEDURE_POINTER + | REAL + | TASK + ) + ; + +dataUsingClause + : USING (LANGUAGE | CONVENTION) OF? (cobolWord | dataName) + ; + +dataValueClause + : (VALUE IS? | VALUES ARE?)? dataValueInterval (COMMACHAR? dataValueInterval)* + ; + +dataValueInterval + : dataValueIntervalFrom dataValueIntervalTo? + ; + +dataValueIntervalFrom + : literal + | cobolWord + ; + +dataValueIntervalTo + : (THROUGH | THRU) literal + ; + +dataWithLowerBoundsClause + : WITH? LOWER BOUNDS + ; + +// --- procedure division -------------------------------------------------------------------- + +procedureDivision + : PROCEDURE DIVISION procedureDivisionUsingClause? procedureDivisionGivingClause? DOT_FS procedureDeclaratives? procedureDivisionBody + ; + +procedureDivisionUsingClause + : (USING | CHAINING) procedureDivisionUsingParameter+ + ; + +procedureDivisionGivingClause + : (GIVING | RETURNING) dataName + ; + +procedureDivisionUsingParameter + : procedureDivisionByReferencePhrase + | procedureDivisionByValuePhrase + ; + +procedureDivisionByReferencePhrase + : (BY? REFERENCE)? procedureDivisionByReference+ + ; + +procedureDivisionByReference + : (OPTIONAL? (identifier | fileName)) + | ANY + ; + +procedureDivisionByValuePhrase + : BY? VALUE procedureDivisionByValue+ + ; + +procedureDivisionByValue + : identifier + | literal + | ANY + ; + +procedureDeclaratives + : DECLARATIVES DOT_FS procedureDeclarative+ END DECLARATIVES DOT_FS + ; + +procedureDeclarative + : procedureSectionHeader DOT_FS useStatement DOT_FS paragraphs + ; + +procedureSectionHeader + : sectionName SECTION integerLiteral? + ; + +procedureDivisionBody + : paragraphs procedureSection* + ; + +// -- procedure section ---------------------------------- + +procedureSection + : procedureSectionHeader DOT_FS paragraphs + ; + +paragraphs + : sentence* paragraph* + ; + +paragraph + : paragraphName DOT_FS (alteredGoTo | sentence*) + ; + +sentence + : statement* DOT_FS + ; + +statement + : acceptStatement + | addStatement + | alterStatement + | callStatement + | cancelStatement + | closeStatement + | computeStatement + | continueStatement + | deleteStatement + | disableStatement + | displayStatement + | divideStatement + | enableStatement + | entryStatement + | evaluateStatement + | exhibitStatement + | execCicsStatement + | execSqlStatement + | execSqlImsStatement + | exitStatement + | generateStatement + | gobackStatement + | goToStatement + | ifStatement + | initializeStatement + | initiateStatement + | inspectStatement + | mergeStatement + | moveStatement + | multiplyStatement + | openStatement + | performStatement + | purgeStatement + | readStatement + | receiveStatement + | releaseStatement + | returnStatement + | rewriteStatement + | searchStatement + | sendStatement + | setStatement + | sortStatement + | startStatement + | stopStatement + | stringStatement + | subtractStatement + | terminateStatement + | unstringStatement + | writeStatement + ; + +// accept statement + +acceptStatement + : ACCEPT identifier ( + acceptFromDateStatement + | acceptFromEscapeKeyStatement + | acceptFromMnemonicStatement + | acceptMessageCountStatement + )? onExceptionClause? notOnExceptionClause? END_ACCEPT? + ; + +acceptFromDateStatement + : FROM ( + DATE YYYYMMDD? + | DAY YYYYDDD? + | DAY_OF_WEEK + | TIME + | TIMER + | TODAYS_DATE MMDDYYYY? + | TODAYS_NAME + | YEAR + | YYYYMMDD + | YYYYDDD + ) + ; + +acceptFromMnemonicStatement + : FROM mnemonicName + ; + +acceptFromEscapeKeyStatement + : FROM ESCAPE KEY + ; + +acceptMessageCountStatement + : MESSAGE? COUNT + ; + +// add statement + +addStatement + : ADD (addToStatement | addToGivingStatement | addCorrespondingStatement) onSizeErrorPhrase? notOnSizeErrorPhrase? END_ADD? + ; + +addToStatement + : addFrom+ TO addTo+ + ; + +addToGivingStatement + : addFrom+ (TO addToGiving+)? GIVING addGiving+ + ; + +addCorrespondingStatement + : (CORRESPONDING | CORR) identifier TO addTo + ; + +addFrom + : identifier + | literal + ; + +addTo + : identifier ROUNDED? + ; + +addToGiving + : identifier + | literal + ; + +addGiving + : identifier ROUNDED? + ; + +// altered go to statement + +alteredGoTo + : GO TO? DOT_FS + ; + +// alter statement + +alterStatement + : ALTER alterProceedTo+ + ; + +alterProceedTo + : procedureName TO (PROCEED TO)? procedureName + ; + +// call statement + +callStatement + : CALL (identifier | literal) callUsingPhrase? callGivingPhrase? onOverflowPhrase? onExceptionClause? notOnExceptionClause? END_CALL? + ; + +callUsingPhrase + : USING callUsingParameter+ + ; + +callUsingParameter + : callByReferencePhrase + | callByValuePhrase + | callByContentPhrase + ; + +callByReferencePhrase + : (BY? REFERENCE)? callByReference+ + ; + +callByReference + : ((ADDRESS OF | INTEGER | STRING)? identifier | literal | fileName) + | OMITTED + ; + +callByValuePhrase + : BY? VALUE callByValue+ + ; + +callByValue + : (ADDRESS OF | LENGTH OF?)? (identifier | literal) + ; + +callByContentPhrase + : BY? CONTENT callByContent+ + ; + +callByContent + : (ADDRESS OF | LENGTH OF?)? identifier + | literal + | OMITTED + ; + +callGivingPhrase + : (GIVING | RETURNING) identifier + ; + +// cancel statement + +cancelStatement + : CANCEL cancelCall+ + ; + +cancelCall + : libraryName (BYTITLE | BYFUNCTION) + | identifier + | literal + ; + +// close statement + +closeStatement + : CLOSE closeFile+ + ; + +closeFile + : fileName (closeReelUnitStatement | closeRelativeStatement | closePortFileIOStatement)? + ; + +closeReelUnitStatement + : (REEL | UNIT) (FOR? REMOVAL)? (WITH? (NO REWIND | LOCK))? + ; + +closeRelativeStatement + : WITH? (NO REWIND | LOCK) + ; + +closePortFileIOStatement + : (WITH? NO WAIT | WITH WAIT) (USING closePortFileIOUsing+)? + ; + +closePortFileIOUsing + : closePortFileIOUsingCloseDisposition + | closePortFileIOUsingAssociatedData + | closePortFileIOUsingAssociatedDataLength + ; + +closePortFileIOUsingCloseDisposition + : CLOSE_DISPOSITION OF? (ABORT | ORDERLY) + ; + +closePortFileIOUsingAssociatedData + : ASSOCIATED_DATA (identifier | integerLiteral) + ; + +closePortFileIOUsingAssociatedDataLength + : ASSOCIATED_DATA_LENGTH OF? (identifier | integerLiteral) + ; + +// compute statement + +computeStatement + : COMPUTE computeStore+ (EQUALCHAR | EQUAL) arithmeticExpression onSizeErrorPhrase? notOnSizeErrorPhrase? END_COMPUTE? + ; + +computeStore + : identifier ROUNDED? + ; + +// continue statement + +continueStatement + : CONTINUE + ; + +// delete statement + +deleteStatement + : DELETE fileName RECORD? invalidKeyPhrase? notInvalidKeyPhrase? END_DELETE? + ; + +// disable statement + +disableStatement + : DISABLE (INPUT TERMINAL? | I_O TERMINAL | OUTPUT) cdName WITH? KEY (identifier | literal) + ; + +// display statement + +displayStatement + : DISPLAY displayOperand+ displayAt? displayUpon? displayWith? + ; + +displayOperand + : identifier + | literal + ; + +displayAt + : AT (identifier | literal) + ; + +displayUpon + : UPON (mnemonicName | environmentName) + ; + +displayWith + : WITH? NO ADVANCING + ; + +// divide statement + +divideStatement + : DIVIDE (identifier | literal) ( + divideIntoStatement + | divideIntoGivingStatement + | divideByGivingStatement + ) divideRemainder? onSizeErrorPhrase? notOnSizeErrorPhrase? END_DIVIDE? + ; + +divideIntoStatement + : INTO divideInto+ + ; + +divideIntoGivingStatement + : INTO (identifier | literal) divideGivingPhrase? + ; + +divideByGivingStatement + : BY (identifier | literal) divideGivingPhrase? + ; + +divideGivingPhrase + : GIVING divideGiving+ + ; + +divideInto + : identifier ROUNDED? + ; + +divideGiving + : identifier ROUNDED? + ; + +divideRemainder + : REMAINDER identifier + ; + +// enable statement + +enableStatement + : ENABLE (INPUT TERMINAL? | I_O TERMINAL | OUTPUT) cdName WITH? KEY (literal | identifier) + ; + +// entry statement + +entryStatement + : ENTRY literal (USING identifier+)? + ; + +// evaluate statement + +evaluateStatement + : EVALUATE evaluateSelect evaluateAlsoSelect* evaluateWhenPhrase+ evaluateWhenOther? END_EVALUATE? + ; + +evaluateSelect + : identifier + | literal + | arithmeticExpression + | condition + ; + +evaluateAlsoSelect + : ALSO evaluateSelect + ; + +evaluateWhenPhrase + : evaluateWhen+ statement* + ; + +evaluateWhen + : WHEN evaluateCondition evaluateAlsoCondition* + ; + +evaluateCondition + : ANY + | NOT? evaluateValue evaluateThrough? + | condition + | booleanLiteral + ; + +evaluateThrough + : (THROUGH | THRU) evaluateValue + ; + +evaluateAlsoCondition + : ALSO evaluateCondition + ; + +evaluateWhenOther + : WHEN OTHER statement* + ; + +evaluateValue + : identifier + | literal + | arithmeticExpression + ; + +// exec cics statement + +execCicsStatement + : EXECCICSLINE+ + ; + +// exec sql statement + +execSqlStatement + : EXECSQLLINE+ + ; + +// exec sql ims statement + +execSqlImsStatement + : EXECSQLIMSLINE+ + ; + +// exhibit statement + +exhibitStatement + : EXHIBIT NAMED? CHANGED? exhibitOperand+ + ; + +exhibitOperand + : identifier + | literal + ; + +// exit statement + +exitStatement + : EXIT PROGRAM? + ; + +// generate statement + +generateStatement + : GENERATE reportName + ; + +// goback statement + +gobackStatement + : GOBACK + ; + +// goto statement + +goToStatement + : GO TO? (goToStatementSimple | goToDependingOnStatement) + ; + +goToStatementSimple + : procedureName + ; + +goToDependingOnStatement + : MORE_LABELS + | procedureName+ (DEPENDING ON? identifier)? + ; + +// if statement + +ifStatement + : IF condition ifThen ifElse? END_IF? + ; + +ifThen + : THEN? (NEXT SENTENCE | statement*) + ; + +ifElse + : ELSE (NEXT SENTENCE | statement*) + ; + +// initialize statement + +initializeStatement + : INITIALIZE identifier+ initializeReplacingPhrase? + ; + +initializeReplacingPhrase + : REPLACING initializeReplacingBy+ + ; + +initializeReplacingBy + : ( + ALPHABETIC + | ALPHANUMERIC + | ALPHANUMERIC_EDITED + | NATIONAL + | NATIONAL_EDITED + | NUMERIC + | NUMERIC_EDITED + | DBCS + | EGCS + ) DATA? BY (identifier | literal) + ; + +// initiate statement + +initiateStatement + : INITIATE reportName+ + ; + +// inspect statement + +inspectStatement + : INSPECT identifier ( + inspectTallyingPhrase + | inspectReplacingPhrase + | inspectTallyingReplacingPhrase + | inspectConvertingPhrase + ) + ; + +inspectTallyingPhrase + : TALLYING inspectFor+ + ; + +inspectReplacingPhrase + : REPLACING (inspectReplacingCharacters | inspectReplacingAllLeadings)+ + ; + +inspectTallyingReplacingPhrase + : TALLYING inspectFor+ inspectReplacingPhrase+ + ; + +inspectConvertingPhrase + : CONVERTING (identifier | literal) inspectTo inspectBeforeAfter* + ; + +inspectFor + : identifier FOR (inspectCharacters | inspectAllLeadings)+ + ; + +inspectCharacters + : CHARACTERS inspectBeforeAfter* + ; + +inspectReplacingCharacters + : CHARACTERS inspectBy inspectBeforeAfter* + ; + +inspectAllLeadings + : (ALL | LEADING) inspectAllLeading+ + ; + +inspectReplacingAllLeadings + : (ALL | LEADING | FIRST) inspectReplacingAllLeading+ + ; + +inspectAllLeading + : (identifier | literal) inspectBeforeAfter* + ; + +inspectReplacingAllLeading + : (identifier | literal) inspectBy inspectBeforeAfter* + ; + +inspectBy + : BY (identifier | literal) + ; + +inspectTo + : TO (identifier | literal) + ; + +inspectBeforeAfter + : (BEFORE | AFTER) INITIAL? (identifier | literal) + ; + +// merge statement + +mergeStatement + : MERGE fileName mergeOnKeyClause+ mergeCollatingSequencePhrase? mergeUsing* mergeOutputProcedurePhrase? mergeGivingPhrase* + ; + +mergeOnKeyClause + : ON? (ASCENDING | DESCENDING) KEY? qualifiedDataName+ + ; + +mergeCollatingSequencePhrase + : COLLATING? SEQUENCE IS? alphabetName+ mergeCollatingAlphanumeric? mergeCollatingNational? + ; + +mergeCollatingAlphanumeric + : FOR? ALPHANUMERIC IS alphabetName + ; + +mergeCollatingNational + : FOR? NATIONAL IS? alphabetName + ; + +mergeUsing + : USING fileName+ + ; + +mergeOutputProcedurePhrase + : OUTPUT PROCEDURE IS? procedureName mergeOutputThrough? + ; + +mergeOutputThrough + : (THROUGH | THRU) procedureName + ; + +mergeGivingPhrase + : GIVING mergeGiving+ + ; + +mergeGiving + : fileName (LOCK | SAVE | NO REWIND | CRUNCH | RELEASE | WITH REMOVE CRUNCH)? + ; + +// move statement + +moveStatement + : MOVE ALL? (moveToStatement | moveCorrespondingToStatement) + ; + +moveToStatement + : moveToSendingArea TO identifier+ + ; + +moveToSendingArea + : identifier + | literal + ; + +moveCorrespondingToStatement + : (CORRESPONDING | CORR) moveCorrespondingToSendingArea TO identifier+ + ; + +moveCorrespondingToSendingArea + : identifier + ; + +// multiply statement + +multiplyStatement + : MULTIPLY (identifier | literal) BY (multiplyRegular | multiplyGiving) onSizeErrorPhrase? notOnSizeErrorPhrase? END_MULTIPLY? + ; + +multiplyRegular + : multiplyRegularOperand+ + ; + +multiplyRegularOperand + : identifier ROUNDED? + ; + +multiplyGiving + : multiplyGivingOperand GIVING multiplyGivingResult+ + ; + +multiplyGivingOperand + : identifier + | literal + ; + +multiplyGivingResult + : identifier ROUNDED? + ; + +// open statement + +openStatement + : OPEN (openInputStatement | openOutputStatement | openIOStatement | openExtendStatement)+ + ; + +openInputStatement + : INPUT openInput+ + ; + +openInput + : fileName (REVERSED | WITH? NO REWIND)? + ; + +openOutputStatement + : OUTPUT openOutput+ + ; + +openOutput + : fileName (WITH? NO REWIND)? + ; + +openIOStatement + : I_O fileName+ + ; + +openExtendStatement + : EXTEND fileName+ + ; + +// perform statement + +performStatement + : PERFORM (performInlineStatement | performProcedureStatement) + ; + +performInlineStatement + : performType? statement* END_PERFORM + ; + +performProcedureStatement + : procedureName ((THROUGH | THRU) procedureName)? performType? + ; + +performType + : performTimes + | performUntil + | performVarying + ; + +performTimes + : (identifier | integerLiteral) TIMES + ; + +performUntil + : performTestClause? UNTIL condition + ; + +performVarying + : performTestClause performVaryingClause + | performVaryingClause performTestClause? + ; + +performVaryingClause + : VARYING performVaryingPhrase performAfter* + ; + +performVaryingPhrase + : (identifier | literal) performFrom performBy performUntil + ; + +performAfter + : AFTER performVaryingPhrase + ; + +performFrom + : FROM (identifier | literal | arithmeticExpression) + ; + +performBy + : BY (identifier | literal | arithmeticExpression) + ; + +performTestClause + : WITH? TEST (BEFORE | AFTER) + ; + +// purge statement + +purgeStatement + : PURGE cdName+ + ; + +// read statement + +readStatement + : READ fileName NEXT? RECORD? readInto? readWith? readKey? invalidKeyPhrase? notInvalidKeyPhrase? atEndPhrase? notAtEndPhrase? END_READ? + ; + +readInto + : INTO identifier + ; + +readWith + : WITH? ((KEPT | NO) LOCK | WAIT) + ; + +readKey + : KEY IS? qualifiedDataName + ; + +// receive statement + +receiveStatement + : RECEIVE (receiveFromStatement | receiveIntoStatement) onExceptionClause? notOnExceptionClause? END_RECEIVE? + ; + +receiveFromStatement + : dataName FROM receiveFrom ( + receiveBefore + | receiveWith + | receiveThread + | receiveSize + | receiveStatus + )* + ; + +receiveFrom + : THREAD dataName + | LAST THREAD + | ANY THREAD + ; + +receiveIntoStatement + : cdName (MESSAGE | SEGMENT) INTO? identifier receiveNoData? receiveWithData? + ; + +receiveNoData + : NO DATA statement* + ; + +receiveWithData + : WITH DATA statement* + ; + +receiveBefore + : BEFORE TIME? (numericLiteral | identifier) + ; + +receiveWith + : WITH? NO WAIT + ; + +receiveThread + : THREAD IN? dataName + ; + +receiveSize + : SIZE IN? (numericLiteral | identifier) + ; + +receiveStatus + : STATUS IN? (identifier) + ; + +// release statement + +releaseStatement + : RELEASE recordName (FROM qualifiedDataName)? + ; + +// return statement + +returnStatement + : RETURN fileName RECORD? returnInto? atEndPhrase notAtEndPhrase? END_RETURN? + ; + +returnInto + : INTO qualifiedDataName + ; + +// rewrite statement + +rewriteStatement + : REWRITE recordName rewriteFrom? invalidKeyPhrase? notInvalidKeyPhrase? END_REWRITE? + ; + +rewriteFrom + : FROM identifier + ; + +// search statement + +searchStatement + : SEARCH ALL? qualifiedDataName searchVarying? atEndPhrase? searchWhen+ END_SEARCH? + ; + +searchVarying + : VARYING qualifiedDataName + ; + +searchWhen + : WHEN condition (NEXT SENTENCE | statement*) + ; + +// send statement + +sendStatement + : SEND (sendStatementSync | sendStatementAsync) onExceptionClause? notOnExceptionClause? + ; + +sendStatementSync + : (identifier | literal) sendFromPhrase? sendWithPhrase? sendReplacingPhrase? sendAdvancingPhrase? + ; + +sendStatementAsync + : TO (TOP | BOTTOM) identifier + ; + +sendFromPhrase + : FROM identifier + ; + +sendWithPhrase + : WITH (EGI | EMI | ESI | identifier) + ; + +sendReplacingPhrase + : REPLACING LINE? + ; + +sendAdvancingPhrase + : (BEFORE | AFTER) ADVANCING? (sendAdvancingPage | sendAdvancingLines | sendAdvancingMnemonic) + ; + +sendAdvancingPage + : PAGE + ; + +sendAdvancingLines + : (identifier | literal) (LINE | LINES)? + ; + +sendAdvancingMnemonic + : mnemonicName + ; + +// set statement + +setStatement + : SET (setToStatement+ | setUpDownByStatement) + ; + +setToStatement + : setTo+ TO setToValue+ + ; + +setUpDownByStatement + : setTo+ (UP BY | DOWN BY) setByValue + ; + +setTo + : identifier + ; + +setToValue + : ON + | OFF + | ENTRY (identifier | literal) + | identifier + | literal + ; + +setByValue + : identifier + | literal + ; + +// sort statement + +sortStatement + : SORT fileName sortOnKeyClause+ sortDuplicatesPhrase? sortCollatingSequencePhrase? sortInputProcedurePhrase? sortUsing* sortOutputProcedurePhrase + ? sortGivingPhrase* + ; + +sortOnKeyClause + : ON? (ASCENDING | DESCENDING) KEY? qualifiedDataName+ + ; + +sortDuplicatesPhrase + : WITH? DUPLICATES IN? ORDER? + ; + +sortCollatingSequencePhrase + : COLLATING? SEQUENCE IS? alphabetName+ sortCollatingAlphanumeric? sortCollatingNational? + ; + +sortCollatingAlphanumeric + : FOR? ALPHANUMERIC IS alphabetName + ; + +sortCollatingNational + : FOR? NATIONAL IS? alphabetName + ; + +sortInputProcedurePhrase + : INPUT PROCEDURE IS? procedureName sortInputThrough? + ; + +sortInputThrough + : (THROUGH | THRU) procedureName + ; + +sortUsing + : USING fileName+ + ; + +sortOutputProcedurePhrase + : OUTPUT PROCEDURE IS? procedureName sortOutputThrough? + ; + +sortOutputThrough + : (THROUGH | THRU) procedureName + ; + +sortGivingPhrase + : GIVING sortGiving+ + ; + +sortGiving + : fileName (LOCK | SAVE | NO REWIND | CRUNCH | RELEASE | WITH REMOVE CRUNCH)? + ; + +// start statement + +startStatement + : START fileName startKey? invalidKeyPhrase? notInvalidKeyPhrase? END_START? + ; + +startKey + : KEY IS? ( + EQUAL TO? + | EQUALCHAR + | GREATER THAN? + | MORETHANCHAR + | NOT LESS THAN? + | NOT LESSTHANCHAR + | GREATER THAN? OR EQUAL TO? + | MORETHANOREQUAL + ) qualifiedDataName + ; + +// stop statement + +stopStatement + : STOP (RUN | literal) + ; + +// string statement + +stringStatement + : STRING stringSendingPhrase+ stringIntoPhrase stringWithPointerPhrase? onOverflowPhrase? notOnOverflowPhrase? END_STRING? + ; + +stringSendingPhrase + : stringSending+ (stringDelimitedByPhrase | stringForPhrase) + ; + +stringSending + : identifier + | literal + ; + +stringDelimitedByPhrase + : DELIMITED BY? (SIZE | identifier | literal) + ; + +stringForPhrase + : FOR (identifier | literal) + ; + +stringIntoPhrase + : INTO identifier + ; + +stringWithPointerPhrase + : WITH? POINTER qualifiedDataName + ; + +// subtract statement + +subtractStatement + : SUBTRACT ( + subtractFromStatement + | subtractFromGivingStatement + | subtractCorrespondingStatement + ) onSizeErrorPhrase? notOnSizeErrorPhrase? END_SUBTRACT? + ; + +subtractFromStatement + : subtractSubtrahend+ FROM subtractMinuend+ + ; + +subtractFromGivingStatement + : subtractSubtrahend+ FROM subtractMinuendGiving GIVING subtractGiving+ + ; + +subtractCorrespondingStatement + : (CORRESPONDING | CORR) qualifiedDataName FROM subtractMinuendCorresponding + ; + +subtractSubtrahend + : identifier + | literal + ; + +subtractMinuend + : identifier ROUNDED? + ; + +subtractMinuendGiving + : identifier + | literal + ; + +subtractGiving + : identifier ROUNDED? + ; + +subtractMinuendCorresponding + : qualifiedDataName ROUNDED? + ; + +// terminate statement + +terminateStatement + : TERMINATE reportName + ; + +// unstring statement + +unstringStatement + : UNSTRING unstringSendingPhrase unstringIntoPhrase unstringWithPointerPhrase? unstringTallyingPhrase? onOverflowPhrase? notOnOverflowPhrase? + END_UNSTRING? + ; + +unstringSendingPhrase + : identifier (unstringDelimitedByPhrase unstringOrAllPhrase*)? + ; + +unstringDelimitedByPhrase + : DELIMITED BY? ALL? (identifier | literal) + ; + +unstringOrAllPhrase + : OR ALL? (identifier | literal) + ; + +unstringIntoPhrase + : INTO unstringInto+ + ; + +unstringInto + : identifier unstringDelimiterIn? unstringCountIn? + ; + +unstringDelimiterIn + : DELIMITER IN? identifier + ; + +unstringCountIn + : COUNT IN? identifier + ; + +unstringWithPointerPhrase + : WITH? POINTER qualifiedDataName + ; + +unstringTallyingPhrase + : TALLYING IN? qualifiedDataName + ; + +// use statement + +useStatement + : USE (useAfterClause | useDebugClause) + ; + +useAfterClause + : GLOBAL? AFTER STANDARD? (EXCEPTION | ERROR) PROCEDURE ON? useAfterOn + ; + +useAfterOn + : INPUT + | OUTPUT + | I_O + | EXTEND + | fileName+ + ; + +useDebugClause + : FOR? DEBUGGING ON? useDebugOn+ + ; + +useDebugOn + : ALL PROCEDURES + | ALL REFERENCES? OF? identifier + | procedureName + | fileName + ; + +// write statement + +writeStatement + : WRITE recordName writeFromPhrase? writeAdvancingPhrase? writeAtEndOfPagePhrase? writeNotAtEndOfPagePhrase? invalidKeyPhrase? notInvalidKeyPhrase + ? END_WRITE? + ; + +writeFromPhrase + : FROM (identifier | literal) + ; + +writeAdvancingPhrase + : (BEFORE | AFTER) ADVANCING? ( + writeAdvancingPage + | writeAdvancingLines + | writeAdvancingMnemonic + ) + ; + +writeAdvancingPage + : PAGE + ; + +writeAdvancingLines + : (identifier | literal) (LINE | LINES)? + ; + +writeAdvancingMnemonic + : mnemonicName + ; + +writeAtEndOfPagePhrase + : AT? (END_OF_PAGE | EOP) statement* + ; + +writeNotAtEndOfPagePhrase + : NOT AT? (END_OF_PAGE | EOP) statement* + ; + +// statement phrases ---------------------------------- + +atEndPhrase + : AT? END statement* + ; + +notAtEndPhrase + : NOT AT? END statement* + ; + +invalidKeyPhrase + : INVALID KEY? statement* + ; + +notInvalidKeyPhrase + : NOT INVALID KEY? statement* + ; + +onOverflowPhrase + : ON? OVERFLOW statement* + ; + +notOnOverflowPhrase + : NOT ON? OVERFLOW statement* + ; + +onSizeErrorPhrase + : ON? SIZE ERROR statement* + ; + +notOnSizeErrorPhrase + : NOT ON? SIZE ERROR statement* + ; + +// statement clauses ---------------------------------- + +onExceptionClause + : ON? EXCEPTION statement* + ; + +notOnExceptionClause + : NOT ON? EXCEPTION statement* + ; + +// arithmetic expression ---------------------------------- + +arithmeticExpression + : multDivs plusMinus* + ; + +plusMinus + : (PLUSCHAR | MINUSCHAR) multDivs + ; + +multDivs + : powers multDiv* + ; + +multDiv + : (ASTERISKCHAR | SLASHCHAR) powers + ; + +powers + : (PLUSCHAR | MINUSCHAR)? basis power* + ; + +power + : DOUBLEASTERISKCHAR basis + ; + +basis + : LPARENCHAR arithmeticExpression RPARENCHAR + | identifier + | literal + ; + +// condition ---------------------------------- + +condition + : combinableCondition andOrCondition* + ; + +andOrCondition + : (AND | OR) (combinableCondition | abbreviation+) + ; + +combinableCondition + : NOT? simpleCondition + ; + +simpleCondition + : LPARENCHAR condition RPARENCHAR + | relationCondition + | classCondition + | conditionNameReference + ; + +classCondition + : identifier IS? NOT? ( + NUMERIC + | ALPHABETIC + | ALPHABETIC_LOWER + | ALPHABETIC_UPPER + | DBCS + | KANJI + | className + ) + ; + +conditionNameReference + : conditionName (inData* inFile? conditionNameSubscriptReference* | inMnemonic*) + ; + +conditionNameSubscriptReference + : LPARENCHAR subscript_ (COMMACHAR? subscript_)* RPARENCHAR + ; + +// relation ---------------------------------- + +relationCondition + : relationSignCondition + | relationArithmeticComparison + | relationCombinedComparison + ; + +relationSignCondition + : arithmeticExpression IS? NOT? (POSITIVE | NEGATIVE | ZERO) + ; + +relationArithmeticComparison + : arithmeticExpression relationalOperator arithmeticExpression + ; + +relationCombinedComparison + : arithmeticExpression relationalOperator LPARENCHAR relationCombinedCondition RPARENCHAR + ; + +relationCombinedCondition + : arithmeticExpression ((AND | OR) arithmeticExpression)+ + ; + +relationalOperator + : (IS | ARE)? ( + NOT? (GREATER THAN? | MORETHANCHAR | LESS THAN? | LESSTHANCHAR | EQUAL TO? | EQUALCHAR) + | NOTEQUALCHAR + | GREATER THAN? OR EQUAL TO? + | MORETHANOREQUAL + | LESS THAN? OR EQUAL TO? + | LESSTHANOREQUAL + ) + ; + +abbreviation + : NOT? relationalOperator? ( + arithmeticExpression + | LPARENCHAR arithmeticExpression abbreviation RPARENCHAR + ) + ; + +// identifier ---------------------------------- + +identifier + : qualifiedDataName + | tableCall + | functionCall + | specialRegister + ; + +tableCall + : qualifiedDataName (LPARENCHAR subscript_ (COMMACHAR? subscript_)* RPARENCHAR)* referenceModifier? + ; + +functionCall + : FUNCTION functionName (LPARENCHAR argument (COMMACHAR? argument)* RPARENCHAR)* referenceModifier? + ; + +referenceModifier + : LPARENCHAR characterPosition COLONCHAR length? RPARENCHAR + ; + +characterPosition + : arithmeticExpression + ; + +length + : arithmeticExpression + ; + +subscript_ + : ALL + | integerLiteral + | qualifiedDataName integerLiteral? + | indexName integerLiteral? + | arithmeticExpression + ; + +argument + : literal + | identifier + | qualifiedDataName integerLiteral? + | indexName integerLiteral? + | arithmeticExpression + ; + +// qualified data name ---------------------------------- + +qualifiedDataName + : qualifiedDataNameFormat1 + | qualifiedDataNameFormat2 + | qualifiedDataNameFormat3 + | qualifiedDataNameFormat4 + ; + +qualifiedDataNameFormat1 + : (dataName | conditionName) (qualifiedInData+ inFile? | inFile)? + ; + +qualifiedDataNameFormat2 + : paragraphName inSection + ; + +qualifiedDataNameFormat3 + : textName inLibrary + ; + +qualifiedDataNameFormat4 + : LINAGE_COUNTER inFile + ; + +qualifiedInData + : inData + | inTable + ; + +// in ---------------------------------- + +inData + : (IN | OF) dataName + ; + +inFile + : (IN | OF) fileName + ; + +inMnemonic + : (IN | OF) mnemonicName + ; + +inSection + : (IN | OF) sectionName + ; + +inLibrary + : (IN | OF) libraryName + ; + +inTable + : (IN | OF) tableCall + ; + +// names ---------------------------------- + +alphabetName + : cobolWord + ; + +assignmentName + : systemName + ; + +basisName + : programName + ; + +cdName + : cobolWord + ; + +className + : cobolWord + ; + +computerName + : systemName + ; + +conditionName + : cobolWord + ; + +dataName + : cobolWord + ; + +dataDescName + : FILLER + | CURSOR + | dataName + ; + +environmentName + : systemName + ; + +fileName + : cobolWord + ; + +functionName + : INTEGER + | LENGTH + | RANDOM + | SUM + | WHEN_COMPILED + | cobolWord + ; + +indexName + : cobolWord + ; + +languageName + : systemName + ; + +libraryName + : cobolWord + ; + +localName + : cobolWord + ; + +mnemonicName + : cobolWord + ; + +paragraphName + : cobolWord + | integerLiteral + ; + +procedureName + : paragraphName inSection? + | sectionName + ; + +programName + : NONNUMERICLITERAL + | cobolWord + ; + +recordName + : qualifiedDataName + ; + +reportName + : qualifiedDataName + ; + +routineName + : cobolWord + ; + +screenName + : cobolWord + ; + +sectionName + : cobolWord + | integerLiteral + ; + +systemName + : cobolWord + ; + +symbolicCharacter + : cobolWord + ; + +textName + : cobolWord + ; + +// literal ---------------------------------- + +cobolWord + : IDENTIFIER + | COBOL + | PROGRAM + | ABORT + | AS + | ASCII + | ASSOCIATED_DATA + | ASSOCIATED_DATA_LENGTH + | ATTRIBUTE + | AUTO + | AUTO_SKIP + | BACKGROUND_COLOR + | BACKGROUND_COLOUR + | BEEP + | BELL + | BINARY + | BIT + | BLINK + | BOUNDS + | CAPABLE + | CCSVERSION + | CHANGED + | CHANNEL + | CLOSE_DISPOSITION + | COMMITMENT + | CONTROL_POINT + | CONVENTION + | CRUNCH + | CURSOR + | DEFAULT + | DEFAULT_DISPLAY + | DEFINITION + | DFHRESP + | DFHVALUE + | DISK + | DONTCARE + | DOUBLE + | EBCDIC + | EMPTY_CHECK + | ENTER + | ENTRY_PROCEDURE + | EOL + | EOS + | ERASE + | ESCAPE + | EVENT + | EXCLUSIVE + | EXPORT + | EXTENDED + | FOREGROUND_COLOR + | FOREGROUND_COLOUR + | FULL + | FUNCTIONNAME + | FUNCTION_POINTER + | GRID + | HIGHLIGHT + | IMPLICIT + | IMPORT + | INTEGER + | KEPT + | KEYBOARD + | LANGUAGE + | LB + | LD + | LEFTLINE + | LENGTH_CHECK + | LIBACCESS + | LIBPARAMETER + | LIBRARY + | LIST + | LOCAL + | LONG_DATE + | LONG_TIME + | LOWER + | LOWLIGHT + | MMDDYYYY + | NAMED + | NATIONAL + | NATIONAL_EDITED + | NETWORK + | NO_ECHO + | NUMERIC_DATE + | NUMERIC_TIME + | ODT + | ORDERLY + | OVERLINE + | OWN + | PASSWORD + | PORT + | PRINTER + | PRIVATE + | PROCESS + | PROMPT + | READER + | REAL + | RECEIVED + | RECURSIVE + | REF + | REMOTE + | REMOVE + | REQUIRED + | REVERSE_VIDEO + | SAVE + | SECURE + | SHARED + | SHAREDBYALL + | SHAREDBYRUNUNIT + | SHARING + | SHORT_DATE + | SYMBOL + | TASK + | THREAD + | THREAD_LOCAL + | TIMER + | TODAYS_DATE + | TODAYS_NAME + | TRUNCATED + | TYPEDEF + | UNDERLINE + | VIRTUAL + | WAIT + | YEAR + | YYYYMMDD + | YYYYDDD + | ZERO_FILL + ; + +literal + : NONNUMERICLITERAL + | figurativeConstant + | numericLiteral + | booleanLiteral + | cicsDfhRespLiteral + | cicsDfhValueLiteral + ; + +booleanLiteral + : TRUE + | FALSE + ; + +numericLiteral + : NUMERICLITERAL + | ZERO + | integerLiteral + ; + +integerLiteral + : INTEGERLITERAL + | LEVEL_NUMBER_66 + | LEVEL_NUMBER_77 + | LEVEL_NUMBER_88 + ; + +cicsDfhRespLiteral + : DFHRESP LPARENCHAR (cobolWord | literal) RPARENCHAR + ; + +cicsDfhValueLiteral + : DFHVALUE LPARENCHAR (cobolWord | literal) RPARENCHAR + ; + +// keywords ---------------------------------- + +figurativeConstant + : ALL literal + | HIGH_VALUE + | HIGH_VALUES + | LOW_VALUE + | LOW_VALUES + | NULL_ + | NULLS + | QUOTE + | QUOTES + | SPACE + | SPACES + | ZERO + | ZEROS + | ZEROES + ; + +specialRegister + : ADDRESS OF identifier + | DATE + | DAY + | DAY_OF_WEEK + | DEBUG_CONTENTS + | DEBUG_ITEM + | DEBUG_LINE + | DEBUG_NAME + | DEBUG_SUB_1 + | DEBUG_SUB_2 + | DEBUG_SUB_3 + | LENGTH OF? identifier + | LINAGE_COUNTER + | LINE_COUNTER + | PAGE_COUNTER + | RETURN_CODE + | SHIFT_IN + | SHIFT_OUT + | SORT_CONTROL + | SORT_CORE_SIZE + | SORT_FILE_SIZE + | SORT_MESSAGE + | SORT_MODE_SIZE + | SORT_RETURN + | TALLY + | TIME + | WHEN_COMPILED + ; + +// comment entry + +commentEntry + : COMMENTENTRYLINE+ + ; + +// lexer rules -------------------------------------------------------------------------------- + +// keywords +ABORT + : A B O R T + ; + +ACCEPT + : A C C E P T + ; + +ACCESS + : A C C E S S + ; + +ADD + : A D D + ; + +ADDRESS + : A D D R E S S + ; + +ADVANCING + : A D V A N C I N G + ; + +AFTER + : A F T E R + ; + +ALIGNED + : A L I G N E D + ; + +ALL + : A L L + ; + +ALPHABET + : A L P H A B E T + ; + +ALPHABETIC + : A L P H A B E T I C + ; + +ALPHABETIC_LOWER + : A L P H A B E T I C MINUSCHAR L O W E R + ; + +ALPHABETIC_UPPER + : A L P H A B E T I C MINUSCHAR U P P E R + ; + +ALPHANUMERIC + : A L P H A N U M E R I C + ; + +ALPHANUMERIC_EDITED + : A L P H A N U M E R I C MINUSCHAR E D I T E D + ; + +ALSO + : A L S O + ; + +ALTER + : A L T E R + ; + +ALTERNATE + : A L T E R N A T E + ; + +AND + : A N D + ; + +ANY + : A N Y + ; + +ARE + : A R E + ; + +AREA + : A R E A + ; + +AREAS + : A R E A S + ; + +AS + : A S + ; + +ASCENDING + : A S C E N D I N G + ; + +ASCII + : A S C I I + ; + +ASSIGN + : A S S I G N + ; + +ASSOCIATED_DATA + : A S S O C I A T E D MINUSCHAR D A T A + ; + +ASSOCIATED_DATA_LENGTH + : A S S O C I A T E D MINUSCHAR D A T A MINUSCHAR L E N G T H + ; + +AT + : A T + ; + +ATTRIBUTE + : A T T R I B U T E + ; + +AUTHOR + : A U T H O R + ; + +AUTO + : A U T O + ; + +AUTO_SKIP + : A U T O MINUSCHAR S K I P + ; + +BACKGROUND_COLOR + : B A C K G R O U N D MINUSCHAR C O L O R + ; + +BACKGROUND_COLOUR + : B A C K G R O U N D MINUSCHAR C O L O U R + ; + +BASIS + : B A S I S + ; + +BEEP + : B E E P + ; + +BEFORE + : B E F O R E + ; + +BEGINNING + : B E G I N N I N G + ; + +BELL + : B E L L + ; + +BINARY + : B I N A R Y + ; + +BIT + : B I T + ; + +BLANK + : B L A N K + ; + +BLINK + : B L I N K + ; + +BLOCK + : B L O C K + ; + +BOUNDS + : B O U N D S + ; + +BOTTOM + : B O T T O M + ; + +BY + : B Y + ; + +BYFUNCTION + : B Y F U N C T I O N + ; + +BYTITLE + : B Y T I T L E + ; + +CALL + : C A L L + ; + +CANCEL + : C A N C E L + ; + +CAPABLE + : C A P A B L E + ; + +CCSVERSION + : C C S V E R S I O N + ; + +CD + : C D + ; + +CF + : C F + ; + +CH + : C H + ; + +CHAINING + : C H A I N I N G + ; + +CHANGED + : C H A N G E D + ; + +CHANNEL + : C H A N N E L + ; + +CHARACTER + : C H A R A C T E R + ; + +CHARACTERS + : C H A R A C T E R S + ; + +CLASS + : C L A S S + ; + +CLASS_ID + : C L A S S MINUSCHAR I D + ; + +CLOCK_UNITS + : C L O C K MINUSCHAR U N I T S + ; + +CLOSE + : C L O S E + ; + +CLOSE_DISPOSITION + : C L O S E MINUSCHAR D I S P O S I T I O N + ; + +COBOL + : C O B O L + ; + +CODE + : C O D E + ; + +CODE_SET + : C O D E MINUSCHAR S E T + ; + +COLLATING + : C O L L A T I N G + ; + +COL + : C O L + ; + +COLUMN + : C O L U M N + ; + +COM_REG + : C O M MINUSCHAR R E G + ; + +COMMA + : C O M M A + ; + +COMMITMENT + : C O M M I T M E N T + ; + +COMMON + : C O M M O N + ; + +COMMUNICATION + : C O M M U N I C A T I O N + ; + +COMP + : C O M P + ; + +COMP_1 + : C O M P MINUSCHAR '1' + ; + +COMP_2 + : C O M P MINUSCHAR '2' + ; + +COMP_3 + : C O M P MINUSCHAR '3' + ; + +COMP_4 + : C O M P MINUSCHAR '4' + ; + +COMP_5 + : C O M P MINUSCHAR '5' + ; + +COMPUTATIONAL + : C O M P U T A T I O N A L + ; + +COMPUTATIONAL_1 + : C O M P U T A T I O N A L MINUSCHAR '1' + ; + +COMPUTATIONAL_2 + : C O M P U T A T I O N A L MINUSCHAR '2' + ; + +COMPUTATIONAL_3 + : C O M P U T A T I O N A L MINUSCHAR '3' + ; + +COMPUTATIONAL_4 + : C O M P U T A T I O N A L MINUSCHAR '4' + ; + +COMPUTATIONAL_5 + : C O M P U T A T I O N A L MINUSCHAR '5' + ; + +COMPUTE + : C O M P U T E + ; + +CONFIGURATION + : C O N F I G U R A T I O N + ; + +CONTAINS + : C O N T A I N S + ; + +CONTENT + : C O N T E N T + ; + +CONTINUE + : C O N T I N U E + ; + +CONTROL + : C O N T R O L + ; + +CONTROL_POINT + : C O N T R O L MINUSCHAR P O I N T + ; + +CONTROLS + : C O N T R O L S + ; + +CONVENTION + : C O N V E N T I O N + ; + +CONVERTING + : C O N V E R T I N G + ; + +COPY + : C O P Y + ; + +CORR + : C O R R + ; + +CORRESPONDING + : C O R R E S P O N D I N G + ; + +COUNT + : C O U N T + ; + +CRUNCH + : C R U N C H + ; + +CURRENCY + : C U R R E N C Y + ; + +CURSOR + : C U R S O R + ; + +DATA + : D A T A + ; + +DATA_BASE + : D A T A MINUSCHAR B A S E + ; + +DATE + : D A T E + ; + +DATE_COMPILED + : D A T E MINUSCHAR C O M P I L E D + ; + +DATE_WRITTEN + : D A T E MINUSCHAR W R I T T E N + ; + +DAY + : D A Y + ; + +DAY_OF_WEEK + : D A Y MINUSCHAR O F MINUSCHAR W E E K + ; + +DBCS + : D B C S + ; + +DE + : D E + ; + +DEBUG_CONTENTS + : D E B U G MINUSCHAR C O N T E N T S + ; + +DEBUG_ITEM + : D E B U G MINUSCHAR I T E M + ; + +DEBUG_LINE + : D E B U G MINUSCHAR L I N E + ; + +DEBUG_NAME + : D E B U G MINUSCHAR N A M E + ; + +DEBUG_SUB_1 + : D E B U G MINUSCHAR S U B MINUSCHAR '1' + ; + +DEBUG_SUB_2 + : D E B U G MINUSCHAR S U B MINUSCHAR '2' + ; + +DEBUG_SUB_3 + : D E B U G MINUSCHAR S U B MINUSCHAR '3' + ; + +DEBUGGING + : D E B U G G I N G + ; + +DECIMAL_POINT + : D E C I M A L MINUSCHAR P O I N T + ; + +DECLARATIVES + : D E C L A R A T I V E S + ; + +DEFAULT + : D E F A U L T + ; + +DEFAULT_DISPLAY + : D E F A U L T MINUSCHAR D I S P L A Y + ; + +DEFINITION + : D E F I N I T I O N + ; + +DELETE + : D E L E T E + ; + +DELIMITED + : D E L I M I T E D + ; + +DELIMITER + : D E L I M I T E R + ; + +DEPENDING + : D E P E N D I N G + ; + +DESCENDING + : D E S C E N D I N G + ; + +DESTINATION + : D E S T I N A T I O N + ; + +DETAIL + : D E T A I L + ; + +DFHRESP + : D F H R E S P + ; + +DFHVALUE + : D F H V A L U E + ; + +DISABLE + : D I S A B L E + ; + +DISK + : D I S K + ; + +DISPLAY + : D I S P L A Y + ; + +DISPLAY_1 + : D I S P L A Y MINUSCHAR '1' + ; + +DIVIDE + : D I V I D E + ; + +DIVISION + : D I V I S I O N + ; + +DONTCARE + : D O N T C A R E + ; + +DOUBLE + : D O U B L E + ; + +DOWN + : D O W N + ; + +DUPLICATES + : D U P L I C A T E S + ; + +DYNAMIC + : D Y N A M I C + ; + +EBCDIC + : E B C D I C + ; + +EGCS + : E G C S + ; // E X T E N S I O N + +EGI + : E G I + ; + +ELSE + : E L S E + ; + +EMI + : E M I + ; + +EMPTY_CHECK + : E M P T Y MINUSCHAR C H E C K + ; + +ENABLE + : E N A B L E + ; + +END + : E N D + ; + +END_ACCEPT + : E N D MINUSCHAR A C C E P T + ; + +END_ADD + : E N D MINUSCHAR A D D + ; + +END_CALL + : E N D MINUSCHAR C A L L + ; + +END_COMPUTE + : E N D MINUSCHAR C O M P U T E + ; + +END_DELETE + : E N D MINUSCHAR D E L E T E + ; + +END_DIVIDE + : E N D MINUSCHAR D I V I D E + ; + +END_EVALUATE + : E N D MINUSCHAR E V A L U A T E + ; + +END_IF + : E N D MINUSCHAR I F + ; + +END_MULTIPLY + : E N D MINUSCHAR M U L T I P L Y + ; + +END_OF_PAGE + : E N D MINUSCHAR O F MINUSCHAR P A G E + ; + +END_PERFORM + : E N D MINUSCHAR P E R F O R M + ; + +END_READ + : E N D MINUSCHAR R E A D + ; + +END_RECEIVE + : E N D MINUSCHAR R E C E I V E + ; + +END_RETURN + : E N D MINUSCHAR R E T U R N + ; + +END_REWRITE + : E N D MINUSCHAR R E W R I T E + ; + +END_SEARCH + : E N D MINUSCHAR S E A R C H + ; + +END_START + : E N D MINUSCHAR S T A R T + ; + +END_STRING + : E N D MINUSCHAR S T R I N G + ; + +END_SUBTRACT + : E N D MINUSCHAR S U B T R A C T + ; + +END_UNSTRING + : E N D MINUSCHAR U N S T R I N G + ; + +END_WRITE + : E N D MINUSCHAR W R I T E + ; + +ENDING + : E N D I N F + ; + +ENTER + : E N T E R + ; + +ENTRY + : E N T R Y + ; + +ENTRY_PROCEDURE + : E N T R Y MINUSCHAR P R O C E D U R E + ; + +ENVIRONMENT + : E N V I R O N M E N T + ; + +EOP + : E O P + ; + +EQUAL + : E Q U A L + ; + +ERASE + : E R A S E + ; + +ERROR + : E R R O R + ; + +EOL + : E O L + ; + +EOS + : E O S + ; + +ESCAPE + : E S C A P E + ; + +ESI + : E S I + ; + +EVALUATE + : E V A L U A T E + ; + +EVENT + : E V E N T + ; + +EVERY + : E V E R Y + ; + +EXCEPTION + : E X C E P T I O N + ; + +EXCLUSIVE + : E X C L U S I V E + ; + +EXHIBIT + : E X H I B I T + ; + +EXIT + : E X I T + ; + +EXPORT + : E X P O R T + ; + +EXTEND + : E X T E N D + ; + +EXTENDED + : E X T E N D E D + ; + +EXTERNAL + : E X T E R N A L + ; + +FALSE + : F A L S E + ; + +FD + : F D + ; + +FILE + : F I L E + ; + +FILE_CONTROL + : F I L E MINUSCHAR C O N T R O L + ; + +FILLER + : F I L L E R + ; + +FINAL + : F I N A L + ; + +FIRST + : F I R S T + ; + +FOOTING + : F O O T I N G + ; + +FOR + : F O R + ; + +FOREGROUND_COLOR + : F O R E G R O U N D MINUSCHAR C O L O R + ; + +FOREGROUND_COLOUR + : F O R E G R O U N D MINUSCHAR C O L O U R + ; + +FROM + : F R O M + ; + +FULL + : F U L L + ; + +FUNCTION + : F U N C T I O N + ; + +FUNCTIONNAME + : F U N C T I O N N A M E + ; + +FUNCTION_POINTER + : F U N C T I O N MINUSCHAR P O I N T E R + ; + +GENERATE + : G E N E R A T E + ; + +GOBACK + : G O B A C K + ; + +GIVING + : G I V I N G + ; + +GLOBAL + : G L O B A L + ; + +GO + : G O + ; + +GREATER + : G R E A T E R + ; + +GRID + : G R I D + ; + +GROUP + : G R O U P + ; + +HEADING + : H E A D I N G + ; + +HIGHLIGHT + : H I G H L I G H T + ; + +HIGH_VALUE + : H I G H MINUSCHAR V A L U E + ; + +HIGH_VALUES + : H I G H MINUSCHAR V A L U E S + ; + +I_O + : I MINUSCHAR O + ; + +I_O_CONTROL + : I MINUSCHAR O MINUSCHAR C O N T R O L + ; + +ID + : I D + ; + +IDENTIFICATION + : I D E N T I F I C A T I O N + ; + +IF + : I F + ; + +IMPLICIT + : I M P L I C I T + ; + +IMPORT + : I M P O R T + ; + +IN + : I N + ; + +INDEX + : I N D E X + ; + +INDEXED + : I N D E X E D + ; + +INDICATE + : I N D I C A T E + ; + +INITIAL + : I N I T I A L + ; + +INITIALIZE + : I N I T I A L I Z E + ; + +INITIATE + : I N I T I A T E + ; + +INPUT + : I N P U T + ; + +INPUT_OUTPUT + : I N P U T MINUSCHAR O U T P U T + ; + +INSPECT + : I N S P E C T + ; + +INSTALLATION + : I N S T A L L A T I O N + ; + +INTEGER + : I N T E G E R + ; + +INTO + : I N T O + ; + +INVALID + : I N V A L I D + ; + +INVOKE + : I N V O K E + ; + +IS + : I S + ; + +JUST + : J U S T + ; + +JUSTIFIED + : J U S T I F I E D + ; + +KANJI + : K A N J I + ; + +KEPT + : K E P T + ; + +KEY + : K E Y + ; + +KEYBOARD + : K E Y B O A R D + ; + +LABEL + : L A B E L + ; + +LANGUAGE + : L A N G U A G E + ; + +LAST + : L A S T + ; + +LB + : L B + ; + +LD + : L D + ; + +LEADING + : L E A D I N G + ; + +LEFT + : L E F T + ; + +LEFTLINE + : L E F T L I N E + ; + +LENGTH + : L E N G T H + ; + +LENGTH_CHECK + : L E N G T H MINUSCHAR C H E C K + ; + +LESS + : L E S S + ; + +LIBACCESS + : L I B A C C E S S + ; + +LIBPARAMETER + : L I B P A R A M E T E R + ; + +LIBRARY + : L I B R A R Y + ; + +LIMIT + : L I M I T + ; + +LIMITS + : L I M I T S + ; + +LINAGE + : L I N A G E + ; + +LINAGE_COUNTER + : L I N A G E MINUSCHAR C O U N T E R + ; + +LINE + : L I N E + ; + +LINES + : L I N E S + ; + +LINE_COUNTER + : L I N E MINUSCHAR C O U N T E R + ; + +LINKAGE + : L I N K A G E + ; + +LIST + : L I S T + ; + +LOCAL + : L O C A L + ; + +LOCAL_STORAGE + : L O C A L MINUSCHAR S T O R A G E + ; + +LOCK + : L O C K + ; + +LONG_DATE + : L O N G MINUSCHAR D A T E + ; + +LONG_TIME + : L O N G MINUSCHAR T I M E + ; + +LOWER + : L O W E R + ; + +LOWLIGHT + : L O W L I G H T + ; + +LOW_VALUE + : L O W MINUSCHAR V A L U E + ; + +LOW_VALUES + : L O W MINUSCHAR V A L U E S + ; + +MEMORY + : M E M O R Y + ; + +MERGE + : M E R G E + ; + +MESSAGE + : M E S S A G E + ; + +MMDDYYYY + : M M D D Y Y Y Y + ; + +MODE + : M O D E + ; + +MODULES + : M O D U L E S + ; + +MORE_LABELS + : M O R E MINUSCHAR L A B E L S + ; + +MOVE + : M O V E + ; + +MULTIPLE + : M U L T I P L E + ; + +MULTIPLY + : M U L T I P L Y + ; + +NAMED + : N A M E D + ; + +NATIONAL + : N A T I O N A L + ; + +NATIONAL_EDITED + : N A T I O N A L MINUSCHAR E D I T E D + ; + +NATIVE + : N A T I V E + ; + +NEGATIVE + : N E G A T I V E + ; + +NETWORK + : N E T W O R K + ; + +NEXT + : N E X T + ; + +NO + : N O + ; + +NO_ECHO + : N O MINUSCHAR E C H O + ; + +NOT + : N O T + ; + +NULL_ + : N U L L + ; + +NULLS + : N U L L S + ; + +NUMBER + : N U M B E R + ; + +NUMERIC + : N U M E R I C + ; + +NUMERIC_DATE + : N U M E R I C MINUSCHAR D A T E + ; + +NUMERIC_EDITED + : N U M E R I C MINUSCHAR E D I T E D + ; + +NUMERIC_TIME + : N U M E R I C MINUSCHAR T I M E + ; + +OBJECT_COMPUTER + : O B J E C T MINUSCHAR C O M P U T E R + ; + +OCCURS + : O C C U R S + ; + +ODT + : O D T + ; + +OF + : O F + ; + +OFF + : O F F + ; + +OMITTED + : O M I T T E D + ; + +ON + : O N + ; + +OPEN + : O P E N + ; + +OPTIONAL + : O P T I O N A L + ; + +OR + : O R + ; + +ORDER + : O R D E R + ; + +ORDERLY + : O R D E R L Y + ; + +ORGANIZATION + : O R G A N I Z A T I O N + ; + +OTHER + : O T H E R + ; + +OUTPUT + : O U T P U T + ; + +OVERFLOW + : O V E R F L O W + ; + +OVERLINE + : O V E R L I N E + ; + +OWN + : O W N + ; + +PACKED_DECIMAL + : P A C K E D MINUSCHAR D E C I M A L + ; + +PADDING + : P A D D I N G + ; + +PAGE + : P A G E + ; + +PAGE_COUNTER + : P A G E MINUSCHAR C O U N T E R + ; + +PASSWORD + : P A S S W O R D + ; + +PERFORM + : P E R F O R M + ; + +PF + : P F + ; + +PH + : P H + ; + +PIC + : P I C + ; + +PICTURE + : P I C T U R E + ; + +PLUS + : P L U S + ; + +POINTER + : P O I N T E R + ; + +POSITION + : P O S I T I O N + ; + +POSITIVE + : P O S I T I V E + ; + +PORT + : P O R T + ; + +PRINTER + : P R I N T E R + ; + +PRINTING + : P R I N T I N G + ; + +PRIVATE + : P R I V A T E + ; + +PROCEDURE + : P R O C E D U R E + ; + +PROCEDURE_POINTER + : P R O C E D U R E MINUSCHAR P O I N T E R + ; + +PROCEDURES + : P R O C E D U R E S + ; + +PROCEED + : P R O C E E D + ; + +PROCESS + : P R O C E S S + ; + +PROGRAM + : P R O G R A M + ; + +PROGRAM_ID + : P R O G R A M MINUSCHAR I D + ; + +PROGRAM_LIBRARY + : P R O G R A M MINUSCHAR L I B R A R Y + ; + +PROMPT + : P R O M P T + ; + +PURGE + : P U R G E + ; + +QUEUE + : Q U E U E + ; + +QUOTE + : Q U O T E + ; + +QUOTES + : Q U O T E S + ; + +RANDOM + : R A N D O M + ; + +READER + : R E A D E R + ; + +REMOTE + : R E M O T E + ; + +RD + : R D + ; + +REAL + : R E A L + ; + +READ + : R E A D + ; + +RECEIVE + : R E C E I V E + ; + +RECEIVED + : R E C E I V E D + ; + +RECORD + : R E C O R D + ; + +RECORDING + : R E C O R D I N G + ; + +RECORDS + : R E C O R D S + ; + +RECURSIVE + : R E C U R S I V E + ; + +REDEFINES + : R E D E F I N E S + ; + +REEL + : R E E L + ; + +REF + : R E F + ; + +REFERENCE + : R E F E R E N C E + ; + +REFERENCES + : R E F E R E N C E S + ; + +RELATIVE + : R E L A T I V E + ; + +RELEASE + : R E L E A S E + ; + +REMAINDER + : R E M A I N D E R + ; + +REMARKS + : R E M A R K S + ; + +REMOVAL + : R E M O V A L + ; + +REMOVE + : R E M O V E + ; + +RENAMES + : R E N A M E S + ; + +REPLACE + : R E P L A C E + ; + +REPLACING + : R E P L A C I N G + ; + +REPORT + : R E P O R T + ; + +REPORTING + : R E P O R T I N G + ; + +REPORTS + : R E P O R T S + ; + +REQUIRED + : R E Q U I R E D + ; + +RERUN + : R E R U N + ; + +RESERVE + : R E S E R V E + ; + +REVERSE_VIDEO + : R E S E R V E MINUSCHAR V I D E O + ; + +RESET + : R E S E T + ; + +RETURN + : R E T U R N + ; + +RETURN_CODE + : R E T U R N MINUSCHAR C O D E + ; + +RETURNING + : R E T U R N I N G + ; + +REVERSED + : R E V E R S E D + ; + +REWIND + : R E W I N D + ; + +REWRITE + : R E W R I T E + ; + +RF + : R F + ; + +RH + : R H + ; + +RIGHT + : R I G H T + ; + +ROUNDED + : R O U N D E D + ; + +RUN + : R U N + ; + +SAME + : S A M E + ; + +SAVE + : S A V E + ; + +SCREEN + : S C R E E N + ; + +SD + : S D + ; + +SEARCH + : S E A R C H + ; + +SECTION + : S E C T I O N + ; + +SECURE + : S E C U R E + ; + +SECURITY + : S E C U R I T Y + ; + +SEGMENT + : S E G M E N T + ; + +SEGMENT_LIMIT + : S E G M E N T MINUSCHAR L I M I T + ; + +SELECT + : S E L E C T + ; + +SEND + : S E N D + ; + +SENTENCE + : S E N T E N C E + ; + +SEPARATE + : S E P A R A T E + ; + +SEQUENCE + : S E Q U E N C E + ; + +SEQUENTIAL + : S E Q U E N T I A L + ; + +SET + : S E T + ; + +SHARED + : S H A R E D + ; + +SHAREDBYALL + : S H A R E D B Y A L L + ; + +SHAREDBYRUNUNIT + : S H A R E D B Y R U N U N I T + ; + +SHARING + : S H A R I N G + ; + +SHIFT_IN + : S H I F T MINUSCHAR I N + ; + +SHIFT_OUT + : S H I F T MINUSCHAR O U T + ; + +SHORT_DATE + : S H O R T MINUSCHAR D A T E + ; + +SIGN + : S I G N + ; + +SIZE + : S I Z E + ; + +SORT + : S O R T + ; + +SORT_CONTROL + : S O R T MINUSCHAR C O N T R O L + ; + +SORT_CORE_SIZE + : S O R T MINUSCHAR C O R E MINUSCHAR S I Z E + ; + +SORT_FILE_SIZE + : S O R T MINUSCHAR F I L E MINUSCHAR S I Z E + ; + +SORT_MERGE + : S O R T MINUSCHAR M E R G E + ; + +SORT_MESSAGE + : S O R T MINUSCHAR M E S S A G E + ; + +SORT_MODE_SIZE + : S O R T MINUSCHAR M O D E MINUSCHAR S I Z E + ; + +SORT_RETURN + : S O R T MINUSCHAR R E T U R N + ; + +SOURCE + : S O U R C E + ; + +SOURCE_COMPUTER + : S O U R C E MINUSCHAR C O M P U T E R + ; + +SPACE + : S P A C E + ; + +SPACES + : S P A C E S + ; + +SPECIAL_NAMES + : S P E C I A L MINUSCHAR N A M E S + ; + +STANDARD + : S T A N D A R D + ; + +STANDARD_1 + : S T A N D A R D MINUSCHAR '1' + ; + +STANDARD_2 + : S T A N D A R D MINUSCHAR '2' + ; + +START + : S T A R T + ; + +STATUS + : S T A T U S + ; + +STOP + : S T O P + ; + +STRING + : S T R I N G + ; + +SUB_QUEUE_1 + : S U B MINUSCHAR Q U E U E MINUSCHAR '1' + ; + +SUB_QUEUE_2 + : S U B MINUSCHAR Q U E U E MINUSCHAR '2' + ; + +SUB_QUEUE_3 + : S U B MINUSCHAR Q U E U E MINUSCHAR '3' + ; + +SUBTRACT + : S U B T R A C T + ; + +SUM + : S U M + ; + +SUPPRESS + : S U P P R E S S + ; + +SYMBOL + : S Y M B O L + ; + +SYMBOLIC + : S Y M B O L I C + ; + +SYNC + : S Y N C + ; + +SYNCHRONIZED + : S Y N C H R O N I Z E D + ; + +TABLE + : T A B L E + ; + +TALLY + : T A L L Y + ; + +TALLYING + : T A L L Y I N G + ; + +TASK + : T A S K + ; + +TAPE + : T A P E + ; + +TERMINAL + : T E R M I N A L + ; + +TERMINATE + : T E R M I N A T E + ; + +TEST + : T E S T + ; + +TEXT + : T E X T + ; + +THAN + : T H A N + ; + +THEN + : T H E N + ; + +THREAD + : T H R E A D + ; + +THREAD_LOCAL + : T H R E A D MINUSCHAR L O C A L + ; + +THROUGH + : T H R O U G H + ; + +THRU + : T H R U + ; + +TIME + : T I M E + ; + +TIMER + : T I M E R + ; + +TIMES + : T I M E S + ; + +TITLE + : T I T L E + ; + +TO + : T O + ; + +TODAYS_DATE + : T O D A Y S MINUSCHAR D A T E + ; + +TODAYS_NAME + : T O D A Y S MINUSCHAR N A M E + ; + +TOP + : T O P + ; + +TRAILING + : T R A I L I N G + ; + +TRUE + : T R U E + ; + +TRUNCATED + : T R U N C A T E D + ; + +TYPE + : T Y P E + ; + +TYPEDEF + : T Y P E D E F + ; + +UNDERLINE + : U N D E R L I N E + ; + +UNIT + : U N I T + ; + +UNSTRING + : U N S T R I N G + ; + +UNTIL + : U N T I L + ; + +UP + : U P + ; + +UPON + : U P O N + ; + +USAGE + : U S A G E + ; + +USE + : U S E + ; + +USING + : U S I N G + ; + +VALUE + : V A L U E + ; + +VALUES + : V A L U E S + ; + +VARYING + : V A R Y I N G + ; + +VIRTUAL + : V I R T U A L + ; + +WAIT + : W A I T + ; + +WHEN + : W H E N + ; + +WHEN_COMPILED + : W H E N MINUSCHAR C O M P I L E D + ; + +WITH + : W I T H + ; + +WORDS + : W O R D S + ; + +WORKING_STORAGE + : W O R K I N G MINUSCHAR S T O R A G E + ; + +WRITE + : W R I T E + ; + +YEAR + : Y E A R + ; + +YYYYMMDD + : Y Y Y Y M M D D + ; + +YYYYDDD + : Y Y Y Y D D D + ; + +ZERO + : Z E R O + ; + +ZERO_FILL + : Z E R O MINUSCHAR F I L L + ; + +ZEROS + : Z E R O S + ; + +ZEROES + : Z E R O E S + ; + +// symbols +AMPCHAR + : '&' + ; + +ASTERISKCHAR + : '*' + ; + +DOUBLEASTERISKCHAR + : '**' + ; + +COLONCHAR + : ':' + ; + +COMMACHAR + : ',' + ; + +COMMENTENTRYTAG + : '*>CE' + ; + +COMMENTTAG + : '*>' + ; + +DOLLARCHAR + : '$' + ; + +DOUBLEQUOTE + : '"' + ; + +// period full stop +DOT_FS + : '.' ('\r' | '\n' | '\f' | '\t' | ' ')+ + | '.' EOF + ; + +DOT + : '.' + ; + +EQUALCHAR + : '=' + ; + +EXECCICSTAG + : '*>EXECCICS' + ; + +EXECSQLTAG + : '*>EXECSQL' + ; + +EXECSQLIMSTAG + : '*>EXECSQLIMS' + ; + +LESSTHANCHAR + : '<' + ; + +LESSTHANOREQUAL + : '<=' + ; + +LPARENCHAR + : '(' + ; + +MINUSCHAR + : '-' + ; + +MORETHANCHAR + : '>' + ; + +MORETHANOREQUAL + : '>=' + ; + +NOTEQUALCHAR + : '<>' + ; + +PLUSCHAR + : '+' + ; + +SINGLEQUOTE + : '\'' + ; + +RPARENCHAR + : ')' + ; + +SLASHCHAR + : '/' + ; + +// literals +NONNUMERICLITERAL + : STRINGLITERAL + | DBCSLITERAL + | HEXNUMBER + | NULLTERMINATED + ; + +fragment HEXNUMBER + : X '"' [0-9A-F]+ '"' + | X '\'' [0-9A-F]+ '\'' + ; + +fragment NULLTERMINATED + : Z '"' (~["\n\r] | '""' | '\'')* '"' + | Z '\'' (~['\n\r] | '\'\'' | '"')* '\'' + ; + +fragment STRINGLITERAL + : '"' (~["\n\r] | '""' | '\'')* '"' + | '\'' (~['\n\r] | '\'\'' | '"')* '\'' + ; + +fragment DBCSLITERAL + : [GN] '"' (~["\n\r] | '""' | '\'')* '"' + | [GN] '\'' (~['\n\r] | '\'\'' | '"')* '\'' + ; + +LEVEL_NUMBER_66 + : '66' + ; + +LEVEL_NUMBER_77 + : '77' + ; + +LEVEL_NUMBER_88 + : '88' + ; + +INTEGERLITERAL + : (PLUSCHAR | MINUSCHAR)? [0-9]+ + ; + +NUMERICLITERAL + : (PLUSCHAR | MINUSCHAR)? [0-9]* (DOT | COMMACHAR) [0-9]+ ( + ('e' | 'E') (PLUSCHAR | MINUSCHAR)? [0-9]+ + )? + ; + +IDENTIFIER + : [a-zA-Z0-9]+ ([-_]+ [a-zA-Z0-9]+)* + ; + +// whitespace, line breaks, comments, ... +NEWLINE + : '\r'? '\n' -> channel(HIDDEN) + ; + +EXECCICSLINE + : EXECCICSTAG WS ~('\n' | '\r' | '}')* ('\n' | '\r' | '}') + ; + +EXECSQLIMSLINE + : EXECSQLIMSTAG WS ~('\n' | '\r' | '}')* ('\n' | '\r' | '}') + ; + +EXECSQLLINE + : EXECSQLTAG WS ~('\n' | '\r' | '}')* ('\n' | '\r' | '}') + ; + +COMMENTENTRYLINE + : COMMENTENTRYTAG WS ~('\n' | '\r')* + ; + +COMMENTLINE + : COMMENTTAG WS ~('\n' | '\r')* -> channel(HIDDEN) + ; + +WS + : [ \t\f;]+ -> channel(HIDDEN) + ; + +SEPARATOR + : ', ' -> channel(HIDDEN) + ; + +// case insensitive chars +fragment A + : ('a' | 'A') + ; + +fragment B + : ('b' | 'B') + ; + +fragment C + : ('c' | 'C') + ; + +fragment D + : ('d' | 'D') + ; + +fragment E + : ('e' | 'E') + ; + +fragment F + : ('f' | 'F') + ; + +fragment G + : ('g' | 'G') + ; + +fragment H + : ('h' | 'H') + ; + +fragment I + : ('i' | 'I') + ; + +fragment J + : ('j' | 'J') + ; + +fragment K + : ('k' | 'K') + ; + +fragment L + : ('l' | 'L') + ; + +fragment M + : ('m' | 'M') + ; + +fragment N + : ('n' | 'N') + ; + +fragment O + : ('o' | 'O') + ; + +fragment P + : ('p' | 'P') + ; + +fragment Q + : ('q' | 'Q') + ; + +fragment R + : ('r' | 'R') + ; + +fragment S + : ('s' | 'S') + ; + +fragment T + : ('t' | 'T') + ; + +fragment U + : ('u' | 'U') + ; + +fragment V + : ('v' | 'V') + ; + +fragment W + : ('w' | 'W') + ; + +fragment X + : ('x' | 'X') + ; + +fragment Y + : ('y' | 'Y') + ; + +fragment Z + : ('z' | 'Z') + ; diff --git a/src/Cobol85.interp b/src/Cobol85.interp new file mode 100644 index 0000000..4b3ba59 --- /dev/null +++ b/src/Cobol85.interp @@ -0,0 +1,1736 @@ +token literal 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 +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +'&' +'*' +'**' +':' +',' +'*>CE' +'*>' +'$' +'"' +null +'.' +'=' +'*>EXECCICS' +'*>EXECSQL' +'*>EXECSQLIMS' +'<' +'<=' +'(' +'-' +'>' +'>=' +'<>' +'+' +'\'' +')' +'/' +null +'66' +'77' +'88' +null +null +null +null +null +null +null +null +null +null +', ' + +token symbolic names: +null +ABORT +ACCEPT +ACCESS +ADD +ADDRESS +ADVANCING +AFTER +ALIGNED +ALL +ALPHABET +ALPHABETIC +ALPHABETIC_LOWER +ALPHABETIC_UPPER +ALPHANUMERIC +ALPHANUMERIC_EDITED +ALSO +ALTER +ALTERNATE +AND +ANY +ARE +AREA +AREAS +AS +ASCENDING +ASCII +ASSIGN +ASSOCIATED_DATA +ASSOCIATED_DATA_LENGTH +AT +ATTRIBUTE +AUTHOR +AUTO +AUTO_SKIP +BACKGROUND_COLOR +BACKGROUND_COLOUR +BASIS +BEEP +BEFORE +BEGINNING +BELL +BINARY +BIT +BLANK +BLINK +BLOCK +BOUNDS +BOTTOM +BY +BYFUNCTION +BYTITLE +CALL +CANCEL +CAPABLE +CCSVERSION +CD +CF +CH +CHAINING +CHANGED +CHANNEL +CHARACTER +CHARACTERS +CLASS +CLASS_ID +CLOCK_UNITS +CLOSE +CLOSE_DISPOSITION +COBOL +CODE +CODE_SET +COLLATING +COL +COLUMN +COM_REG +COMMA +COMMITMENT +COMMON +COMMUNICATION +COMP +COMP_1 +COMP_2 +COMP_3 +COMP_4 +COMP_5 +COMPUTATIONAL +COMPUTATIONAL_1 +COMPUTATIONAL_2 +COMPUTATIONAL_3 +COMPUTATIONAL_4 +COMPUTATIONAL_5 +COMPUTE +CONFIGURATION +CONTAINS +CONTENT +CONTINUE +CONTROL +CONTROL_POINT +CONTROLS +CONVENTION +CONVERTING +COPY +CORR +CORRESPONDING +COUNT +CRUNCH +CURRENCY +CURSOR +DATA +DATA_BASE +DATE +DATE_COMPILED +DATE_WRITTEN +DAY +DAY_OF_WEEK +DBCS +DE +DEBUG_CONTENTS +DEBUG_ITEM +DEBUG_LINE +DEBUG_NAME +DEBUG_SUB_1 +DEBUG_SUB_2 +DEBUG_SUB_3 +DEBUGGING +DECIMAL_POINT +DECLARATIVES +DEFAULT +DEFAULT_DISPLAY +DEFINITION +DELETE +DELIMITED +DELIMITER +DEPENDING +DESCENDING +DESTINATION +DETAIL +DFHRESP +DFHVALUE +DISABLE +DISK +DISPLAY +DISPLAY_1 +DIVIDE +DIVISION +DONTCARE +DOUBLE +DOWN +DUPLICATES +DYNAMIC +EBCDIC +EGCS +EGI +ELSE +EMI +EMPTY_CHECK +ENABLE +END +END_ACCEPT +END_ADD +END_CALL +END_COMPUTE +END_DELETE +END_DIVIDE +END_EVALUATE +END_IF +END_MULTIPLY +END_OF_PAGE +END_PERFORM +END_READ +END_RECEIVE +END_RETURN +END_REWRITE +END_SEARCH +END_START +END_STRING +END_SUBTRACT +END_UNSTRING +END_WRITE +ENDING +ENTER +ENTRY +ENTRY_PROCEDURE +ENVIRONMENT +EOP +EQUAL +ERASE +ERROR +EOL +EOS +ESCAPE +ESI +EVALUATE +EVENT +EVERY +EXCEPTION +EXCLUSIVE +EXHIBIT +EXIT +EXPORT +EXTEND +EXTENDED +EXTERNAL +FALSE +FD +FILE +FILE_CONTROL +FILLER +FINAL +FIRST +FOOTING +FOR +FOREGROUND_COLOR +FOREGROUND_COLOUR +FROM +FULL +FUNCTION +FUNCTIONNAME +FUNCTION_POINTER +GENERATE +GOBACK +GIVING +GLOBAL +GO +GREATER +GRID +GROUP +HEADING +HIGHLIGHT +HIGH_VALUE +HIGH_VALUES +I_O +I_O_CONTROL +ID +IDENTIFICATION +IF +IMPLICIT +IMPORT +IN +INDEX +INDEXED +INDICATE +INITIAL +INITIALIZE +INITIATE +INPUT +INPUT_OUTPUT +INSPECT +INSTALLATION +INTEGER +INTO +INVALID +INVOKE +IS +JUST +JUSTIFIED +KANJI +KEPT +KEY +KEYBOARD +LABEL +LANGUAGE +LAST +LB +LD +LEADING +LEFT +LEFTLINE +LENGTH +LENGTH_CHECK +LESS +LIBACCESS +LIBPARAMETER +LIBRARY +LIMIT +LIMITS +LINAGE +LINAGE_COUNTER +LINE +LINES +LINE_COUNTER +LINKAGE +LIST +LOCAL +LOCAL_STORAGE +LOCK +LONG_DATE +LONG_TIME +LOWER +LOWLIGHT +LOW_VALUE +LOW_VALUES +MEMORY +MERGE +MESSAGE +MMDDYYYY +MODE +MODULES +MORE_LABELS +MOVE +MULTIPLE +MULTIPLY +NAMED +NATIONAL +NATIONAL_EDITED +NATIVE +NEGATIVE +NETWORK +NEXT +NO +NO_ECHO +NOT +NULL_ +NULLS +NUMBER +NUMERIC +NUMERIC_DATE +NUMERIC_EDITED +NUMERIC_TIME +OBJECT_COMPUTER +OCCURS +ODT +OF +OFF +OMITTED +ON +OPEN +OPTIONAL +OR +ORDER +ORDERLY +ORGANIZATION +OTHER +OUTPUT +OVERFLOW +OVERLINE +OWN +PACKED_DECIMAL +PADDING +PAGE +PAGE_COUNTER +PASSWORD +PERFORM +PF +PH +PIC +PICTURE +PLUS +POINTER +POSITION +POSITIVE +PORT +PRINTER +PRINTING +PRIVATE +PROCEDURE +PROCEDURE_POINTER +PROCEDURES +PROCEED +PROCESS +PROGRAM +PROGRAM_ID +PROGRAM_LIBRARY +PROMPT +PURGE +QUEUE +QUOTE +QUOTES +RANDOM +READER +REMOTE +RD +REAL +READ +RECEIVE +RECEIVED +RECORD +RECORDING +RECORDS +RECURSIVE +REDEFINES +REEL +REF +REFERENCE +REFERENCES +RELATIVE +RELEASE +REMAINDER +REMARKS +REMOVAL +REMOVE +RENAMES +REPLACE +REPLACING +REPORT +REPORTING +REPORTS +REQUIRED +RERUN +RESERVE +REVERSE_VIDEO +RESET +RETURN +RETURN_CODE +RETURNING +REVERSED +REWIND +REWRITE +RF +RH +RIGHT +ROUNDED +RUN +SAME +SAVE +SCREEN +SD +SEARCH +SECTION +SECURE +SECURITY +SEGMENT +SEGMENT_LIMIT +SELECT +SEND +SENTENCE +SEPARATE +SEQUENCE +SEQUENTIAL +SET +SHARED +SHAREDBYALL +SHAREDBYRUNUNIT +SHARING +SHIFT_IN +SHIFT_OUT +SHORT_DATE +SIGN +SIZE +SORT +SORT_CONTROL +SORT_CORE_SIZE +SORT_FILE_SIZE +SORT_MERGE +SORT_MESSAGE +SORT_MODE_SIZE +SORT_RETURN +SOURCE +SOURCE_COMPUTER +SPACE +SPACES +SPECIAL_NAMES +STANDARD +STANDARD_1 +STANDARD_2 +START +STATUS +STOP +STRING +SUB_QUEUE_1 +SUB_QUEUE_2 +SUB_QUEUE_3 +SUBTRACT +SUM +SUPPRESS +SYMBOL +SYMBOLIC +SYNC +SYNCHRONIZED +TABLE +TALLY +TALLYING +TASK +TAPE +TERMINAL +TERMINATE +TEST +TEXT +THAN +THEN +THREAD +THREAD_LOCAL +THROUGH +THRU +TIME +TIMER +TIMES +TITLE +TO +TODAYS_DATE +TODAYS_NAME +TOP +TRAILING +TRUE +TRUNCATED +TYPE +TYPEDEF +UNDERLINE +UNIT +UNSTRING +UNTIL +UP +UPON +USAGE +USE +USING +VALUE +VALUES +VARYING +VIRTUAL +WAIT +WHEN +WHEN_COMPILED +WITH +WORDS +WORKING_STORAGE +WRITE +YEAR +YYYYMMDD +YYYYDDD +ZERO +ZERO_FILL +ZEROS +ZEROES +AMPCHAR +ASTERISKCHAR +DOUBLEASTERISKCHAR +COLONCHAR +COMMACHAR +COMMENTENTRYTAG +COMMENTTAG +DOLLARCHAR +DOUBLEQUOTE +DOT_FS +DOT +EQUALCHAR +EXECCICSTAG +EXECSQLTAG +EXECSQLIMSTAG +LESSTHANCHAR +LESSTHANOREQUAL +LPARENCHAR +MINUSCHAR +MORETHANCHAR +MORETHANOREQUAL +NOTEQUALCHAR +PLUSCHAR +SINGLEQUOTE +RPARENCHAR +SLASHCHAR +NONNUMERICLITERAL +LEVEL_NUMBER_66 +LEVEL_NUMBER_77 +LEVEL_NUMBER_88 +INTEGERLITERAL +NUMERICLITERAL +IDENTIFIER +NEWLINE +EXECCICSLINE +EXECSQLIMSLINE +EXECSQLLINE +COMMENTENTRYLINE +COMMENTLINE +WS +SEPARATOR + +rule names: +startRule +compilationUnit +programUnit +endProgramStatement +identificationDivision +identificationDivisionBody +programIdParagraph +authorParagraph +installationParagraph +dateWrittenParagraph +dateCompiledParagraph +securityParagraph +remarksParagraph +environmentDivision +environmentDivisionBody +configurationSection +configurationSectionParagraph +sourceComputerParagraph +objectComputerParagraph +objectComputerClause +memorySizeClause +diskSizeClause +collatingSequenceClause +collatingSequenceClauseAlphanumeric +collatingSequenceClauseNational +segmentLimitClause +characterSetClause +specialNamesParagraph +specialNameClause +alphabetClause +alphabetClauseFormat1 +alphabetLiterals +alphabetThrough +alphabetAlso +alphabetClauseFormat2 +channelClause +classClause +classClauseThrough +classClauseFrom +classClauseTo +currencySignClause +decimalPointClause +defaultComputationalSignClause +defaultDisplaySignClause +environmentSwitchNameClause +environmentSwitchNameSpecialNamesStatusPhrase +odtClause +reserveNetworkClause +symbolicCharactersClause +symbolicCharacters +inputOutputSection +inputOutputSectionParagraph +fileControlParagraph +fileControlEntry +selectClause +fileControlClause +assignClause +reserveClause +organizationClause +paddingCharacterClause +recordDelimiterClause +accessModeClause +recordKeyClause +alternateRecordKeyClause +passwordClause +fileStatusClause +relativeKeyClause +ioControlParagraph +ioControlClause +rerunClause +rerunEveryRecords +rerunEveryOf +rerunEveryClock +sameClause +multipleFileClause +multipleFilePosition +commitmentControlClause +dataDivision +dataDivisionSection +fileSection +fileDescriptionEntry +fileDescriptionEntryClause +externalClause +globalClause +blockContainsClause +blockContainsTo +recordContainsClause +recordContainsClauseFormat1 +recordContainsClauseFormat2 +recordContainsClauseFormat3 +recordContainsTo +labelRecordsClause +valueOfClause +valuePair +dataRecordsClause +linageClause +linageAt +linageFootingAt +linageLinesAtTop +linageLinesAtBottom +recordingModeClause +modeStatement +codeSetClause +reportClause +dataBaseSection +dataBaseSectionEntry +workingStorageSection +linkageSection +communicationSection +communicationDescriptionEntry +communicationDescriptionEntryFormat1 +communicationDescriptionEntryFormat2 +communicationDescriptionEntryFormat3 +destinationCountClause +destinationTableClause +endKeyClause +errorKeyClause +messageCountClause +messageDateClause +messageTimeClause +statusKeyClause +symbolicDestinationClause +symbolicQueueClause +symbolicSourceClause +symbolicTerminalClause +symbolicSubQueueClause +textLengthClause +localStorageSection +screenSection +screenDescriptionEntry +screenDescriptionBlankClause +screenDescriptionBellClause +screenDescriptionBlinkClause +screenDescriptionEraseClause +screenDescriptionLightClause +screenDescriptionGridClause +screenDescriptionReverseVideoClause +screenDescriptionUnderlineClause +screenDescriptionSizeClause +screenDescriptionLineClause +screenDescriptionColumnClause +screenDescriptionForegroundColorClause +screenDescriptionBackgroundColorClause +screenDescriptionControlClause +screenDescriptionValueClause +screenDescriptionPictureClause +screenDescriptionFromClause +screenDescriptionToClause +screenDescriptionUsingClause +screenDescriptionUsageClause +screenDescriptionBlankWhenZeroClause +screenDescriptionJustifiedClause +screenDescriptionSignClause +screenDescriptionAutoClause +screenDescriptionSecureClause +screenDescriptionRequiredClause +screenDescriptionPromptClause +screenDescriptionPromptOccursClause +screenDescriptionFullClause +screenDescriptionZeroFillClause +reportSection +reportDescription +reportDescriptionEntry +reportDescriptionGlobalClause +reportDescriptionPageLimitClause +reportDescriptionHeadingClause +reportDescriptionFirstDetailClause +reportDescriptionLastDetailClause +reportDescriptionFootingClause +reportGroupDescriptionEntry +reportGroupDescriptionEntryFormat1 +reportGroupDescriptionEntryFormat2 +reportGroupDescriptionEntryFormat3 +reportGroupBlankWhenZeroClause +reportGroupColumnNumberClause +reportGroupIndicateClause +reportGroupJustifiedClause +reportGroupLineNumberClause +reportGroupLineNumberNextPage +reportGroupLineNumberPlus +reportGroupNextGroupClause +reportGroupNextGroupPlus +reportGroupNextGroupNextPage +reportGroupPictureClause +reportGroupResetClause +reportGroupSignClause +reportGroupSourceClause +reportGroupSumClause +reportGroupTypeClause +reportGroupTypeReportHeading +reportGroupTypePageHeading +reportGroupTypeControlHeading +reportGroupTypeDetail +reportGroupTypeControlFooting +reportGroupUsageClause +reportGroupTypePageFooting +reportGroupTypeReportFooting +reportGroupValueClause +programLibrarySection +libraryDescriptionEntry +libraryDescriptionEntryFormat1 +libraryDescriptionEntryFormat2 +libraryAttributeClauseFormat1 +libraryAttributeClauseFormat2 +libraryAttributeFunction +libraryAttributeParameter +libraryAttributeTitle +libraryEntryProcedureClauseFormat1 +libraryEntryProcedureClauseFormat2 +libraryEntryProcedureForClause +libraryEntryProcedureGivingClause +libraryEntryProcedureUsingClause +libraryEntryProcedureUsingName +libraryEntryProcedureWithClause +libraryEntryProcedureWithName +libraryIsCommonClause +libraryIsGlobalClause +dataDescriptionEntry +dataDescriptionEntryFormat1 +dataDescriptionEntryFormat2 +dataDescriptionEntryFormat3 +dataDescriptionEntryExecSql +dataAlignedClause +dataBlankWhenZeroClause +dataCommonOwnLocalClause +dataExternalClause +dataGlobalClause +dataIntegerStringClause +dataJustifiedClause +dataOccursClause +dataOccursTo +dataOccursSort +dataPictureClause +pictureString +pictureChars +pictureCardinality +dataReceivedByClause +dataRecordAreaClause +dataRedefinesClause +dataRenamesClause +dataSignClause +dataSynchronizedClause +dataThreadLocalClause +dataTypeClause +dataTypeDefClause +dataUsageClause +dataUsingClause +dataValueClause +dataValueInterval +dataValueIntervalFrom +dataValueIntervalTo +dataWithLowerBoundsClause +procedureDivision +procedureDivisionUsingClause +procedureDivisionGivingClause +procedureDivisionUsingParameter +procedureDivisionByReferencePhrase +procedureDivisionByReference +procedureDivisionByValuePhrase +procedureDivisionByValue +procedureDeclaratives +procedureDeclarative +procedureSectionHeader +procedureDivisionBody +procedureSection +paragraphs +paragraph +sentence +statement +acceptStatement +acceptFromDateStatement +acceptFromMnemonicStatement +acceptFromEscapeKeyStatement +acceptMessageCountStatement +addStatement +addToStatement +addToGivingStatement +addCorrespondingStatement +addFrom +addTo +addToGiving +addGiving +alteredGoTo +alterStatement +alterProceedTo +callStatement +callUsingPhrase +callUsingParameter +callByReferencePhrase +callByReference +callByValuePhrase +callByValue +callByContentPhrase +callByContent +callGivingPhrase +cancelStatement +cancelCall +closeStatement +closeFile +closeReelUnitStatement +closeRelativeStatement +closePortFileIOStatement +closePortFileIOUsing +closePortFileIOUsingCloseDisposition +closePortFileIOUsingAssociatedData +closePortFileIOUsingAssociatedDataLength +computeStatement +computeStore +continueStatement +deleteStatement +disableStatement +displayStatement +displayOperand +displayAt +displayUpon +displayWith +divideStatement +divideIntoStatement +divideIntoGivingStatement +divideByGivingStatement +divideGivingPhrase +divideInto +divideGiving +divideRemainder +enableStatement +entryStatement +evaluateStatement +evaluateSelect +evaluateAlsoSelect +evaluateWhenPhrase +evaluateWhen +evaluateCondition +evaluateThrough +evaluateAlsoCondition +evaluateWhenOther +evaluateValue +execCicsStatement +execSqlStatement +execSqlImsStatement +exhibitStatement +exhibitOperand +exitStatement +generateStatement +gobackStatement +goToStatement +goToStatementSimple +goToDependingOnStatement +ifStatement +ifThen +ifElse +initializeStatement +initializeReplacingPhrase +initializeReplacingBy +initiateStatement +inspectStatement +inspectTallyingPhrase +inspectReplacingPhrase +inspectTallyingReplacingPhrase +inspectConvertingPhrase +inspectFor +inspectCharacters +inspectReplacingCharacters +inspectAllLeadings +inspectReplacingAllLeadings +inspectAllLeading +inspectReplacingAllLeading +inspectBy +inspectTo +inspectBeforeAfter +mergeStatement +mergeOnKeyClause +mergeCollatingSequencePhrase +mergeCollatingAlphanumeric +mergeCollatingNational +mergeUsing +mergeOutputProcedurePhrase +mergeOutputThrough +mergeGivingPhrase +mergeGiving +moveStatement +moveToStatement +moveToSendingArea +moveCorrespondingToStatement +moveCorrespondingToSendingArea +multiplyStatement +multiplyRegular +multiplyRegularOperand +multiplyGiving +multiplyGivingOperand +multiplyGivingResult +openStatement +openInputStatement +openInput +openOutputStatement +openOutput +openIOStatement +openExtendStatement +performStatement +performInlineStatement +performProcedureStatement +performType +performTimes +performUntil +performVarying +performVaryingClause +performVaryingPhrase +performAfter +performFrom +performBy +performTestClause +purgeStatement +readStatement +readInto +readWith +readKey +receiveStatement +receiveFromStatement +receiveFrom +receiveIntoStatement +receiveNoData +receiveWithData +receiveBefore +receiveWith +receiveThread +receiveSize +receiveStatus +releaseStatement +returnStatement +returnInto +rewriteStatement +rewriteFrom +searchStatement +searchVarying +searchWhen +sendStatement +sendStatementSync +sendStatementAsync +sendFromPhrase +sendWithPhrase +sendReplacingPhrase +sendAdvancingPhrase +sendAdvancingPage +sendAdvancingLines +sendAdvancingMnemonic +setStatement +setToStatement +setUpDownByStatement +setTo +setToValue +setByValue +sortStatement +sortOnKeyClause +sortDuplicatesPhrase +sortCollatingSequencePhrase +sortCollatingAlphanumeric +sortCollatingNational +sortInputProcedurePhrase +sortInputThrough +sortUsing +sortOutputProcedurePhrase +sortOutputThrough +sortGivingPhrase +sortGiving +startStatement +startKey +stopStatement +stringStatement +stringSendingPhrase +stringSending +stringDelimitedByPhrase +stringForPhrase +stringIntoPhrase +stringWithPointerPhrase +subtractStatement +subtractFromStatement +subtractFromGivingStatement +subtractCorrespondingStatement +subtractSubtrahend +subtractMinuend +subtractMinuendGiving +subtractGiving +subtractMinuendCorresponding +terminateStatement +unstringStatement +unstringSendingPhrase +unstringDelimitedByPhrase +unstringOrAllPhrase +unstringIntoPhrase +unstringInto +unstringDelimiterIn +unstringCountIn +unstringWithPointerPhrase +unstringTallyingPhrase +useStatement +useAfterClause +useAfterOn +useDebugClause +useDebugOn +writeStatement +writeFromPhrase +writeAdvancingPhrase +writeAdvancingPage +writeAdvancingLines +writeAdvancingMnemonic +writeAtEndOfPagePhrase +writeNotAtEndOfPagePhrase +atEndPhrase +notAtEndPhrase +invalidKeyPhrase +notInvalidKeyPhrase +onOverflowPhrase +notOnOverflowPhrase +onSizeErrorPhrase +notOnSizeErrorPhrase +onExceptionClause +notOnExceptionClause +arithmeticExpression +plusMinus +multDivs +multDiv +powers +power +basis +condition +andOrCondition +combinableCondition +simpleCondition +classCondition +conditionNameReference +conditionNameSubscriptReference +relationCondition +relationSignCondition +relationArithmeticComparison +relationCombinedComparison +relationCombinedCondition +relationalOperator +abbreviation +identifier +tableCall +functionCall +referenceModifier +characterPosition +length +subscript_ +argument +qualifiedDataName +qualifiedDataNameFormat1 +qualifiedDataNameFormat2 +qualifiedDataNameFormat3 +qualifiedDataNameFormat4 +qualifiedInData +inData +inFile +inMnemonic +inSection +inLibrary +inTable +alphabetName +assignmentName +basisName +cdName +className +computerName +conditionName +dataName +dataDescName +environmentName +fileName +functionName +indexName +languageName +libraryName +localName +mnemonicName +paragraphName +procedureName +programName +recordName +reportName +routineName +screenName +sectionName +systemName +symbolicCharacter +textName +cobolWord +literal +booleanLiteral +numericLiteral +integerLiteral +cicsDfhRespLiteral +cicsDfhValueLiteral +figurativeConstant +specialRegister +commentEntry + + +atn: +[4, 1, 565, 6288, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, 2, 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, 315, 7, 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, 2, 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, 7, 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, 2, 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, 7, 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, 2, 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, 7, 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, 355, 2, 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, 360, 7, 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, 364, 2, 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, 369, 7, 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, 373, 2, 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, 378, 7, 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, 382, 2, 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, 387, 7, 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, 391, 2, 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, 396, 7, 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, 400, 2, 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, 405, 7, 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, 409, 2, 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, 414, 7, 414, 2, 415, 7, 415, 2, 416, 7, 416, 2, 417, 7, 417, 2, 418, 7, 418, 2, 419, 7, 419, 2, 420, 7, 420, 2, 421, 7, 421, 2, 422, 7, 422, 2, 423, 7, 423, 2, 424, 7, 424, 2, 425, 7, 425, 2, 426, 7, 426, 2, 427, 7, 427, 2, 428, 7, 428, 2, 429, 7, 429, 2, 430, 7, 430, 2, 431, 7, 431, 2, 432, 7, 432, 2, 433, 7, 433, 2, 434, 7, 434, 2, 435, 7, 435, 2, 436, 7, 436, 2, 437, 7, 437, 2, 438, 7, 438, 2, 439, 7, 439, 2, 440, 7, 440, 2, 441, 7, 441, 2, 442, 7, 442, 2, 443, 7, 443, 2, 444, 7, 444, 2, 445, 7, 445, 2, 446, 7, 446, 2, 447, 7, 447, 2, 448, 7, 448, 2, 449, 7, 449, 2, 450, 7, 450, 2, 451, 7, 451, 2, 452, 7, 452, 2, 453, 7, 453, 2, 454, 7, 454, 2, 455, 7, 455, 2, 456, 7, 456, 2, 457, 7, 457, 2, 458, 7, 458, 2, 459, 7, 459, 2, 460, 7, 460, 2, 461, 7, 461, 2, 462, 7, 462, 2, 463, 7, 463, 2, 464, 7, 464, 2, 465, 7, 465, 2, 466, 7, 466, 2, 467, 7, 467, 2, 468, 7, 468, 2, 469, 7, 469, 2, 470, 7, 470, 2, 471, 7, 471, 2, 472, 7, 472, 2, 473, 7, 473, 2, 474, 7, 474, 2, 475, 7, 475, 2, 476, 7, 476, 2, 477, 7, 477, 2, 478, 7, 478, 2, 479, 7, 479, 2, 480, 7, 480, 2, 481, 7, 481, 2, 482, 7, 482, 2, 483, 7, 483, 2, 484, 7, 484, 2, 485, 7, 485, 2, 486, 7, 486, 2, 487, 7, 487, 2, 488, 7, 488, 2, 489, 7, 489, 2, 490, 7, 490, 2, 491, 7, 491, 2, 492, 7, 492, 2, 493, 7, 493, 2, 494, 7, 494, 2, 495, 7, 495, 2, 496, 7, 496, 2, 497, 7, 497, 2, 498, 7, 498, 2, 499, 7, 499, 2, 500, 7, 500, 2, 501, 7, 501, 2, 502, 7, 502, 2, 503, 7, 503, 2, 504, 7, 504, 2, 505, 7, 505, 2, 506, 7, 506, 2, 507, 7, 507, 2, 508, 7, 508, 2, 509, 7, 509, 2, 510, 7, 510, 2, 511, 7, 511, 2, 512, 7, 512, 2, 513, 7, 513, 2, 514, 7, 514, 2, 515, 7, 515, 2, 516, 7, 516, 2, 517, 7, 517, 2, 518, 7, 518, 2, 519, 7, 519, 2, 520, 7, 520, 2, 521, 7, 521, 2, 522, 7, 522, 2, 523, 7, 523, 2, 524, 7, 524, 2, 525, 7, 525, 2, 526, 7, 526, 2, 527, 7, 527, 2, 528, 7, 528, 2, 529, 7, 529, 2, 530, 7, 530, 2, 531, 7, 531, 2, 532, 7, 532, 2, 533, 7, 533, 2, 534, 7, 534, 2, 535, 7, 535, 2, 536, 7, 536, 2, 537, 7, 537, 2, 538, 7, 538, 2, 539, 7, 539, 2, 540, 7, 540, 2, 541, 7, 541, 2, 542, 7, 542, 2, 543, 7, 543, 2, 544, 7, 544, 2, 545, 7, 545, 2, 546, 7, 546, 2, 547, 7, 547, 2, 548, 7, 548, 2, 549, 7, 549, 2, 550, 7, 550, 2, 551, 7, 551, 2, 552, 7, 552, 2, 553, 7, 553, 2, 554, 7, 554, 2, 555, 7, 555, 2, 556, 7, 556, 2, 557, 7, 557, 2, 558, 7, 558, 2, 559, 7, 559, 2, 560, 7, 560, 2, 561, 7, 561, 2, 562, 7, 562, 2, 563, 7, 563, 2, 564, 7, 564, 2, 565, 7, 565, 2, 566, 7, 566, 2, 567, 7, 567, 2, 568, 7, 568, 2, 569, 7, 569, 2, 570, 7, 570, 2, 571, 7, 571, 2, 572, 7, 572, 2, 573, 7, 573, 2, 574, 7, 574, 2, 575, 7, 575, 2, 576, 7, 576, 2, 577, 7, 577, 2, 578, 7, 578, 2, 579, 7, 579, 2, 580, 7, 580, 2, 581, 7, 581, 2, 582, 7, 582, 2, 583, 7, 583, 2, 584, 7, 584, 2, 585, 7, 585, 2, 586, 7, 586, 2, 587, 7, 587, 2, 588, 7, 588, 2, 589, 7, 589, 2, 590, 7, 590, 2, 591, 7, 591, 2, 592, 7, 592, 2, 593, 7, 593, 2, 594, 7, 594, 1, 0, 1, 0, 1, 0, 1, 1, 4, 1, 1195, 8, 1, 11, 1, 12, 1, 1196, 1, 2, 1, 2, 3, 2, 1201, 8, 2, 1, 2, 3, 2, 1204, 8, 2, 1, 2, 3, 2, 1207, 8, 2, 1, 2, 5, 2, 1210, 8, 2, 10, 2, 12, 2, 1213, 9, 2, 1, 2, 3, 2, 1216, 8, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 5, 4, 1228, 8, 4, 10, 4, 12, 4, 1231, 9, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 1239, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 1245, 8, 6, 1, 6, 1, 6, 3, 6, 1249, 8, 6, 3, 6, 1251, 8, 6, 1, 6, 3, 6, 1254, 8, 6, 1, 6, 3, 6, 1257, 8, 6, 1, 7, 1, 7, 1, 7, 3, 7, 1262, 8, 7, 1, 8, 1, 8, 1, 8, 3, 8, 1267, 8, 8, 1, 9, 1, 9, 1, 9, 3, 9, 1272, 8, 9, 1, 10, 1, 10, 1, 10, 3, 10, 1277, 8, 10, 1, 11, 1, 11, 1, 11, 3, 11, 1282, 8, 11, 1, 12, 1, 12, 1, 12, 3, 12, 1287, 8, 12, 1, 13, 1, 13, 1, 13, 1, 13, 5, 13, 1293, 8, 13, 10, 13, 12, 13, 1296, 9, 13, 1, 14, 1, 14, 1, 14, 3, 14, 1301, 8, 14, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 1307, 8, 15, 10, 15, 12, 15, 1310, 9, 15, 1, 16, 1, 16, 1, 16, 3, 16, 1315, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 3, 17, 1321, 8, 17, 1, 17, 1, 17, 3, 17, 1325, 8, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 5, 18, 1333, 8, 18, 10, 18, 12, 18, 1336, 9, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 1345, 8, 19, 1, 20, 1, 20, 3, 20, 1349, 8, 20, 1, 20, 1, 20, 3, 20, 1353, 8, 20, 1, 20, 3, 20, 1356, 8, 20, 1, 21, 1, 21, 3, 21, 1360, 8, 21, 1, 21, 3, 21, 1363, 8, 21, 1, 21, 1, 21, 3, 21, 1367, 8, 21, 1, 21, 3, 21, 1370, 8, 21, 1, 22, 3, 22, 1373, 8, 22, 1, 22, 3, 22, 1376, 8, 22, 1, 22, 1, 22, 3, 22, 1380, 8, 22, 1, 22, 4, 22, 1383, 8, 22, 11, 22, 12, 22, 1384, 1, 22, 3, 22, 1388, 8, 22, 1, 22, 3, 22, 1391, 8, 22, 1, 23, 3, 23, 1394, 8, 23, 1, 23, 1, 23, 3, 23, 1398, 8, 23, 1, 23, 1, 23, 1, 24, 3, 24, 1403, 8, 24, 1, 24, 1, 24, 3, 24, 1407, 8, 24, 1, 24, 1, 24, 1, 25, 1, 25, 3, 25, 1413, 8, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 4, 27, 1424, 8, 27, 11, 27, 12, 27, 1425, 1, 27, 1, 27, 3, 27, 1430, 8, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 1443, 8, 28, 1, 29, 1, 29, 3, 29, 1447, 8, 29, 1, 30, 1, 30, 1, 30, 1, 30, 3, 30, 1453, 8, 30, 1, 30, 3, 30, 1456, 8, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 4, 30, 1465, 8, 30, 11, 30, 12, 30, 1466, 3, 30, 1469, 8, 30, 1, 31, 1, 31, 1, 31, 4, 31, 1474, 8, 31, 11, 31, 12, 31, 1475, 3, 31, 1478, 8, 31, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 4, 33, 1485, 8, 33, 11, 33, 12, 33, 1486, 1, 34, 1, 34, 1, 34, 3, 34, 1492, 8, 34, 1, 34, 1, 34, 3, 34, 1496, 8, 34, 1, 34, 1, 34, 1, 34, 3, 34, 1501, 8, 34, 1, 35, 1, 35, 1, 35, 3, 35, 1506, 8, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 3, 36, 1513, 8, 36, 1, 36, 3, 36, 1516, 8, 36, 1, 36, 3, 36, 1519, 8, 36, 1, 36, 4, 36, 1522, 8, 36, 11, 36, 12, 36, 1523, 1, 37, 1, 37, 1, 37, 3, 37, 1529, 8, 37, 1, 38, 1, 38, 3, 38, 1533, 8, 38, 1, 39, 1, 39, 3, 39, 1537, 8, 39, 1, 40, 1, 40, 3, 40, 1541, 8, 40, 1, 40, 3, 40, 1544, 8, 40, 1, 40, 1, 40, 3, 40, 1548, 8, 40, 1, 40, 1, 40, 1, 40, 3, 40, 1553, 8, 40, 1, 41, 1, 41, 3, 41, 1557, 8, 41, 1, 41, 1, 41, 1, 42, 1, 42, 3, 42, 1563, 8, 42, 1, 42, 1, 42, 3, 42, 1567, 8, 42, 3, 42, 1569, 8, 42, 1, 42, 3, 42, 1572, 8, 42, 1, 42, 1, 42, 3, 42, 1576, 8, 42, 1, 43, 1, 43, 1, 43, 3, 43, 1581, 8, 43, 3, 43, 1583, 8, 43, 1, 43, 1, 43, 1, 43, 3, 43, 1588, 8, 43, 3, 43, 1590, 8, 43, 1, 44, 1, 44, 3, 44, 1594, 8, 44, 1, 44, 1, 44, 3, 44, 1598, 8, 44, 1, 44, 3, 44, 1601, 8, 44, 1, 45, 1, 45, 3, 45, 1605, 8, 45, 1, 45, 3, 45, 1608, 8, 45, 1, 45, 1, 45, 1, 45, 3, 45, 1613, 8, 45, 1, 45, 3, 45, 1616, 8, 45, 1, 45, 3, 45, 1619, 8, 45, 1, 45, 1, 45, 3, 45, 1623, 8, 45, 1, 45, 3, 45, 1626, 8, 45, 1, 45, 1, 45, 1, 45, 3, 45, 1631, 8, 45, 1, 45, 3, 45, 1634, 8, 45, 1, 45, 3, 45, 1637, 8, 45, 3, 45, 1639, 8, 45, 1, 46, 1, 46, 3, 46, 1643, 8, 46, 1, 46, 1, 46, 1, 47, 1, 47, 3, 47, 1649, 8, 47, 1, 47, 3, 47, 1652, 8, 47, 1, 47, 3, 47, 1655, 8, 47, 1, 47, 1, 47, 3, 47, 1659, 8, 47, 1, 48, 1, 48, 3, 48, 1663, 8, 48, 1, 48, 3, 48, 1666, 8, 48, 1, 48, 3, 48, 1669, 8, 48, 1, 48, 4, 48, 1672, 8, 48, 11, 48, 12, 48, 1673, 1, 48, 1, 48, 3, 48, 1678, 8, 48, 1, 49, 4, 49, 1681, 8, 49, 11, 49, 12, 49, 1682, 1, 49, 3, 49, 1686, 8, 49, 1, 49, 4, 49, 1689, 8, 49, 11, 49, 12, 49, 1690, 1, 50, 1, 50, 1, 50, 1, 50, 5, 50, 1697, 8, 50, 10, 50, 12, 50, 1700, 9, 50, 1, 51, 1, 51, 3, 51, 1704, 8, 51, 1, 52, 1, 52, 3, 52, 1708, 8, 52, 1, 52, 5, 52, 1711, 8, 52, 10, 52, 12, 52, 1714, 9, 52, 1, 52, 1, 52, 1, 53, 1, 53, 5, 53, 1720, 8, 53, 10, 53, 12, 53, 1723, 9, 53, 1, 54, 1, 54, 3, 54, 1727, 8, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 1742, 8, 55, 1, 56, 1, 56, 3, 56, 1746, 8, 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, 1759, 8, 56, 1, 57, 1, 57, 1, 57, 3, 57, 1764, 8, 57, 1, 57, 3, 57, 1767, 8, 57, 1, 57, 3, 57, 1770, 8, 57, 1, 58, 1, 58, 3, 58, 1774, 8, 58, 3, 58, 1776, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 1783, 8, 58, 1, 58, 1, 58, 1, 59, 1, 59, 3, 59, 1789, 8, 59, 1, 59, 3, 59, 1792, 8, 59, 1, 59, 1, 59, 3, 59, 1796, 8, 59, 1, 60, 1, 60, 1, 60, 3, 60, 1801, 8, 60, 1, 60, 1, 60, 1, 60, 3, 60, 1806, 8, 60, 1, 61, 1, 61, 3, 61, 1810, 8, 61, 1, 61, 3, 61, 1813, 8, 61, 1, 61, 1, 61, 1, 62, 1, 62, 3, 62, 1819, 8, 62, 1, 62, 3, 62, 1822, 8, 62, 1, 62, 1, 62, 3, 62, 1826, 8, 62, 1, 62, 3, 62, 1829, 8, 62, 1, 62, 3, 62, 1832, 8, 62, 1, 63, 1, 63, 1, 63, 3, 63, 1837, 8, 63, 1, 63, 3, 63, 1840, 8, 63, 1, 63, 1, 63, 3, 63, 1844, 8, 63, 1, 63, 3, 63, 1847, 8, 63, 1, 63, 3, 63, 1850, 8, 63, 1, 64, 1, 64, 3, 64, 1854, 8, 64, 1, 64, 1, 64, 1, 65, 3, 65, 1859, 8, 65, 1, 65, 1, 65, 3, 65, 1863, 8, 65, 1, 65, 1, 65, 3, 65, 1867, 8, 65, 1, 66, 1, 66, 3, 66, 1871, 8, 66, 1, 66, 3, 66, 1874, 8, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 3, 67, 1883, 8, 67, 1, 67, 5, 67, 1886, 8, 67, 10, 67, 12, 67, 1889, 9, 67, 1, 67, 3, 67, 1892, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 1898, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 1904, 8, 69, 3, 69, 1906, 8, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 1912, 8, 69, 1, 70, 1, 70, 1, 70, 1, 71, 3, 71, 1918, 8, 71, 1, 71, 3, 71, 1921, 8, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 3, 72, 1929, 8, 72, 1, 73, 1, 73, 3, 73, 1933, 8, 73, 1, 73, 3, 73, 1936, 8, 73, 1, 73, 3, 73, 1939, 8, 73, 1, 73, 4, 73, 1942, 8, 73, 11, 73, 12, 73, 1943, 1, 74, 1, 74, 1, 74, 3, 74, 1949, 8, 74, 1, 74, 3, 74, 1952, 8, 74, 1, 74, 4, 74, 1955, 8, 74, 11, 74, 12, 74, 1956, 1, 75, 1, 75, 1, 75, 3, 75, 1962, 8, 75, 1, 76, 1, 76, 1, 76, 3, 76, 1967, 8, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, 1975, 8, 77, 10, 77, 12, 77, 1978, 9, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 1989, 8, 78, 1, 79, 1, 79, 1, 79, 1, 79, 5, 79, 1995, 8, 79, 10, 79, 12, 79, 1998, 9, 79, 1, 80, 1, 80, 1, 80, 3, 80, 2003, 8, 80, 1, 80, 5, 80, 2006, 8, 80, 10, 80, 12, 80, 2009, 9, 80, 1, 80, 1, 80, 5, 80, 2013, 8, 80, 10, 80, 12, 80, 2016, 9, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 2029, 8, 81, 1, 82, 3, 82, 2032, 8, 82, 1, 82, 1, 82, 1, 83, 3, 83, 2037, 8, 83, 1, 83, 1, 83, 1, 84, 1, 84, 3, 84, 2043, 8, 84, 1, 84, 1, 84, 3, 84, 2047, 8, 84, 1, 84, 3, 84, 2050, 8, 84, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 2059, 8, 86, 1, 87, 3, 87, 2062, 8, 87, 1, 87, 1, 87, 3, 87, 2066, 8, 87, 1, 88, 3, 88, 2069, 8, 88, 1, 88, 1, 88, 3, 88, 2073, 8, 88, 1, 88, 3, 88, 2076, 8, 88, 1, 88, 3, 88, 2079, 8, 88, 1, 88, 1, 88, 3, 88, 2083, 8, 88, 1, 88, 3, 88, 2086, 8, 88, 3, 88, 2088, 8, 88, 1, 88, 1, 88, 3, 88, 2092, 8, 88, 1, 88, 3, 88, 2095, 8, 88, 1, 89, 3, 89, 2098, 8, 89, 1, 89, 1, 89, 1, 89, 3, 89, 2103, 8, 89, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 3, 91, 2111, 8, 91, 1, 91, 1, 91, 3, 91, 2115, 8, 91, 3, 91, 2117, 8, 91, 1, 91, 1, 91, 1, 91, 4, 91, 2122, 8, 91, 11, 91, 12, 91, 2123, 3, 91, 2126, 8, 91, 1, 92, 1, 92, 1, 92, 4, 92, 2131, 8, 92, 11, 92, 12, 92, 2132, 1, 93, 1, 93, 3, 93, 2137, 8, 93, 1, 93, 1, 93, 3, 93, 2141, 8, 93, 1, 94, 1, 94, 1, 94, 3, 94, 2146, 8, 94, 1, 94, 1, 94, 3, 94, 2150, 8, 94, 3, 94, 2152, 8, 94, 1, 94, 4, 94, 2155, 8, 94, 11, 94, 12, 94, 2156, 1, 95, 1, 95, 3, 95, 2161, 8, 95, 1, 95, 1, 95, 3, 95, 2165, 8, 95, 1, 95, 3, 95, 2168, 8, 95, 1, 95, 5, 95, 2171, 8, 95, 10, 95, 12, 95, 2174, 9, 95, 1, 96, 1, 96, 1, 96, 3, 96, 2179, 8, 96, 1, 97, 3, 97, 2182, 8, 97, 1, 97, 1, 97, 3, 97, 2186, 8, 97, 1, 97, 1, 97, 3, 97, 2190, 8, 97, 1, 98, 3, 98, 2193, 8, 98, 1, 98, 3, 98, 2196, 8, 98, 1, 98, 1, 98, 1, 98, 3, 98, 2201, 8, 98, 1, 99, 3, 99, 2204, 8, 99, 1, 99, 3, 99, 2207, 8, 99, 1, 99, 1, 99, 1, 99, 3, 99, 2212, 8, 99, 1, 100, 1, 100, 3, 100, 2216, 8, 100, 1, 100, 3, 100, 2219, 8, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 102, 1, 102, 3, 102, 2227, 8, 102, 1, 102, 1, 102, 1, 103, 1, 103, 3, 103, 2233, 8, 103, 1, 103, 1, 103, 3, 103, 2237, 8, 103, 3, 103, 2239, 8, 103, 1, 103, 4, 103, 2242, 8, 103, 11, 103, 12, 103, 2243, 1, 104, 1, 104, 1, 104, 1, 104, 5, 104, 2250, 8, 104, 10, 104, 12, 104, 2253, 9, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 5, 106, 2264, 8, 106, 10, 106, 12, 106, 2267, 9, 106, 1, 107, 1, 107, 1, 107, 1, 107, 5, 107, 2273, 8, 107, 10, 107, 12, 107, 2276, 9, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 5, 108, 2283, 8, 108, 10, 108, 12, 108, 2286, 9, 108, 1, 109, 1, 109, 1, 109, 3, 109, 2291, 8, 109, 1, 110, 1, 110, 1, 110, 3, 110, 2296, 8, 110, 1, 110, 3, 110, 2299, 8, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 2311, 8, 110, 1, 110, 5, 110, 2314, 8, 110, 10, 110, 12, 110, 2317, 9, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 3, 111, 2324, 8, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 5, 111, 2333, 8, 111, 10, 111, 12, 111, 2336, 9, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 3, 112, 2343, 8, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2353, 8, 112, 1, 112, 5, 112, 2356, 8, 112, 10, 112, 12, 112, 2359, 9, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 3, 113, 2366, 8, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 4, 114, 2378, 8, 114, 11, 114, 12, 114, 2379, 3, 114, 2382, 8, 114, 1, 115, 1, 115, 1, 115, 3, 115, 2387, 8, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 3, 116, 2394, 8, 116, 1, 116, 1, 116, 1, 117, 3, 117, 2399, 8, 117, 1, 117, 1, 117, 3, 117, 2403, 8, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 3, 118, 2410, 8, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 3, 119, 2417, 8, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 3, 120, 2424, 8, 120, 1, 120, 1, 120, 1, 121, 3, 121, 2429, 8, 121, 1, 121, 1, 121, 3, 121, 2433, 8, 121, 1, 121, 1, 121, 1, 122, 3, 122, 2438, 8, 122, 1, 122, 1, 122, 3, 122, 2442, 8, 122, 1, 122, 1, 122, 1, 123, 3, 123, 2447, 8, 123, 1, 123, 1, 123, 3, 123, 2451, 8, 123, 1, 123, 1, 123, 1, 124, 3, 124, 2456, 8, 124, 1, 124, 1, 124, 3, 124, 2460, 8, 124, 1, 124, 1, 124, 1, 125, 3, 125, 2465, 8, 125, 1, 125, 1, 125, 3, 125, 2469, 8, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 3, 126, 2476, 8, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 2487, 8, 127, 1, 127, 5, 127, 2490, 8, 127, 10, 127, 12, 127, 2493, 9, 127, 1, 128, 1, 128, 1, 128, 1, 128, 5, 128, 2499, 8, 128, 10, 128, 12, 128, 2502, 9, 128, 1, 129, 1, 129, 1, 129, 3, 129, 2507, 8, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 2527, 8, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 2539, 8, 129, 10, 129, 12, 129, 2542, 9, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 137, 1, 137, 1, 138, 1, 138, 3, 138, 2566, 8, 138, 1, 138, 1, 138, 3, 138, 2570, 8, 138, 1, 139, 1, 139, 3, 139, 2574, 8, 139, 1, 139, 3, 139, 2577, 8, 139, 1, 139, 3, 139, 2580, 8, 139, 1, 139, 1, 139, 3, 139, 2584, 8, 139, 1, 140, 1, 140, 3, 140, 2588, 8, 140, 1, 140, 3, 140, 2591, 8, 140, 1, 140, 3, 140, 2594, 8, 140, 1, 140, 1, 140, 3, 140, 2598, 8, 140, 1, 141, 1, 141, 3, 141, 2602, 8, 141, 1, 141, 1, 141, 3, 141, 2606, 8, 141, 1, 142, 1, 142, 3, 142, 2610, 8, 142, 1, 142, 1, 142, 3, 142, 2614, 8, 142, 1, 143, 1, 143, 3, 143, 2618, 8, 143, 1, 143, 1, 143, 1, 144, 1, 144, 3, 144, 2624, 8, 144, 1, 144, 1, 144, 1, 145, 1, 145, 3, 145, 2630, 8, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 3, 146, 2637, 8, 146, 1, 146, 3, 146, 2640, 8, 146, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 3, 149, 2650, 8, 149, 1, 149, 1, 149, 1, 150, 1, 150, 3, 150, 2656, 8, 150, 1, 150, 1, 150, 1, 151, 1, 151, 3, 151, 2662, 8, 151, 1, 152, 1, 152, 3, 152, 2666, 8, 152, 3, 152, 2668, 8, 152, 1, 152, 1, 152, 1, 152, 3, 152, 2673, 8, 152, 3, 152, 2675, 8, 152, 1, 153, 1, 153, 1, 154, 1, 154, 1, 155, 1, 155, 1, 156, 1, 156, 3, 156, 2685, 8, 156, 1, 156, 3, 156, 2688, 8, 156, 1, 156, 1, 156, 3, 156, 2692, 8, 156, 1, 156, 3, 156, 2695, 8, 156, 1, 157, 1, 157, 1, 157, 3, 157, 2700, 8, 157, 1, 158, 1, 158, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 160, 5, 160, 2710, 8, 160, 10, 160, 12, 160, 2713, 9, 160, 1, 161, 1, 161, 4, 161, 2717, 8, 161, 11, 161, 12, 161, 2718, 1, 162, 1, 162, 1, 162, 3, 162, 2724, 8, 162, 1, 162, 1, 162, 3, 162, 2728, 8, 162, 1, 162, 3, 162, 2731, 8, 162, 1, 162, 3, 162, 2734, 8, 162, 1, 162, 3, 162, 2737, 8, 162, 3, 162, 2739, 8, 162, 1, 162, 1, 162, 1, 163, 3, 163, 2744, 8, 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 3, 164, 2751, 8, 164, 1, 164, 1, 164, 3, 164, 2755, 8, 164, 3, 164, 2757, 8, 164, 1, 164, 1, 164, 3, 164, 2761, 8, 164, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 3, 169, 2780, 8, 169, 1, 170, 1, 170, 1, 170, 3, 170, 2785, 8, 170, 1, 170, 3, 170, 2788, 8, 170, 1, 170, 1, 170, 3, 170, 2792, 8, 170, 1, 170, 1, 170, 1, 171, 1, 171, 3, 171, 2798, 8, 171, 1, 171, 3, 171, 2801, 8, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 3, 172, 2808, 8, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 2821, 8, 172, 1, 172, 5, 172, 2824, 8, 172, 10, 172, 12, 172, 2827, 9, 172, 1, 172, 1, 172, 1, 173, 1, 173, 3, 173, 2833, 8, 173, 1, 173, 1, 173, 1, 174, 1, 174, 3, 174, 2839, 8, 174, 1, 174, 3, 174, 2842, 8, 174, 1, 174, 1, 174, 1, 175, 1, 175, 3, 175, 2848, 8, 175, 1, 176, 1, 176, 3, 176, 2852, 8, 176, 1, 177, 3, 177, 2855, 8, 177, 1, 177, 3, 177, 2858, 8, 177, 1, 177, 3, 177, 2861, 8, 177, 1, 177, 1, 177, 3, 177, 2865, 8, 177, 1, 178, 1, 178, 3, 178, 2869, 8, 178, 1, 178, 1, 178, 3, 178, 2873, 8, 178, 1, 179, 1, 179, 1, 179, 1, 180, 1, 180, 1, 180, 3, 180, 2881, 8, 180, 1, 180, 1, 180, 1, 180, 3, 180, 2886, 8, 180, 1, 181, 1, 181, 1, 181, 1, 182, 1, 182, 1, 182, 1, 183, 1, 183, 3, 183, 2896, 8, 183, 1, 183, 1, 183, 1, 184, 1, 184, 3, 184, 2902, 8, 184, 1, 184, 1, 184, 3, 184, 2906, 8, 184, 1, 185, 1, 185, 3, 185, 2910, 8, 185, 1, 185, 1, 185, 1, 185, 3, 185, 2915, 8, 185, 1, 186, 1, 186, 3, 186, 2919, 8, 186, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 3, 187, 2926, 8, 187, 1, 187, 5, 187, 2929, 8, 187, 10, 187, 12, 187, 2932, 9, 187, 1, 187, 1, 187, 1, 187, 3, 187, 2937, 8, 187, 1, 187, 5, 187, 2940, 8, 187, 10, 187, 12, 187, 2943, 9, 187, 3, 187, 2945, 8, 187, 1, 188, 1, 188, 3, 188, 2949, 8, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 3, 188, 2958, 8, 188, 1, 189, 1, 189, 1, 189, 3, 189, 2963, 8, 189, 1, 190, 1, 190, 1, 190, 3, 190, 2968, 8, 190, 1, 191, 1, 191, 1, 191, 3, 191, 2973, 8, 191, 1, 191, 1, 191, 3, 191, 2977, 8, 191, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 3, 193, 2984, 8, 193, 1, 193, 1, 193, 3, 193, 2988, 8, 193, 1, 194, 1, 194, 3, 194, 2992, 8, 194, 3, 194, 2994, 8, 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, 195, 3, 195, 3001, 8, 195, 1, 196, 1, 196, 1, 196, 3, 196, 3006, 8, 196, 1, 197, 1, 197, 3, 197, 3010, 8, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 1, 198, 5, 198, 3018, 8, 198, 10, 198, 12, 198, 3021, 9, 198, 1, 199, 1, 199, 3, 199, 3025, 8, 199, 1, 200, 1, 200, 1, 200, 1, 200, 3, 200, 3031, 8, 200, 1, 200, 3, 200, 3034, 8, 200, 1, 201, 1, 201, 1, 201, 1, 201, 3, 201, 3040, 8, 201, 1, 201, 3, 201, 3043, 8, 201, 1, 201, 1, 201, 5, 201, 3047, 8, 201, 10, 201, 12, 201, 3050, 9, 201, 1, 202, 1, 202, 1, 202, 3, 202, 3055, 8, 202, 1, 202, 3, 202, 3058, 8, 202, 1, 203, 1, 203, 3, 203, 3062, 8, 203, 1, 203, 1, 203, 3, 203, 3066, 8, 203, 1, 203, 3, 203, 3069, 8, 203, 1, 203, 3, 203, 3072, 8, 203, 1, 203, 3, 203, 3075, 8, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 205, 1, 205, 3, 205, 3083, 8, 205, 1, 205, 1, 205, 1, 206, 1, 206, 3, 206, 3089, 8, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 207, 3, 207, 3096, 8, 207, 1, 208, 1, 208, 1, 208, 3, 208, 3101, 8, 208, 1, 208, 3, 208, 3104, 8, 208, 1, 208, 3, 208, 3107, 8, 208, 1, 208, 3, 208, 3110, 8, 208, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 4, 211, 3120, 8, 211, 11, 211, 12, 211, 3121, 1, 212, 1, 212, 3, 212, 3126, 8, 212, 1, 213, 1, 213, 4, 213, 3130, 8, 213, 11, 213, 12, 213, 3131, 1, 214, 1, 214, 3, 214, 3136, 8, 214, 1, 215, 3, 215, 3139, 8, 215, 1, 215, 1, 215, 1, 216, 3, 216, 3144, 8, 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, 217, 1, 217, 3, 217, 3152, 8, 217, 1, 218, 1, 218, 1, 218, 3, 218, 3157, 8, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 5, 218, 3180, 8, 218, 10, 218, 12, 218, 3183, 9, 218, 1, 218, 1, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 221, 4, 221, 3198, 8, 221, 11, 221, 12, 221, 3199, 1, 221, 3, 221, 3203, 8, 221, 1, 222, 1, 222, 1, 223, 1, 223, 3, 223, 3209, 8, 223, 1, 223, 1, 223, 1, 224, 1, 224, 1, 225, 3, 225, 3216, 8, 225, 1, 225, 1, 225, 1, 225, 3, 225, 3221, 8, 225, 1, 226, 3, 226, 3224, 8, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 228, 1, 228, 3, 228, 3232, 8, 228, 1, 229, 1, 229, 1, 229, 3, 229, 3237, 8, 229, 1, 229, 3, 229, 3240, 8, 229, 1, 229, 1, 229, 3, 229, 3244, 8, 229, 1, 229, 3, 229, 3247, 8, 229, 1, 229, 5, 229, 3250, 8, 229, 10, 229, 12, 229, 3253, 9, 229, 1, 229, 1, 229, 3, 229, 3257, 8, 229, 1, 229, 3, 229, 3260, 8, 229, 1, 229, 4, 229, 3263, 8, 229, 11, 229, 12, 229, 3264, 3, 229, 3267, 8, 229, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 3, 231, 3274, 8, 231, 1, 231, 3, 231, 3277, 8, 231, 1, 231, 4, 231, 3280, 8, 231, 11, 231, 12, 231, 3281, 1, 232, 1, 232, 3, 232, 3286, 8, 232, 1, 232, 1, 232, 1, 233, 4, 233, 3291, 8, 233, 11, 233, 12, 233, 3292, 1, 233, 3, 233, 3296, 8, 233, 4, 233, 3298, 8, 233, 11, 233, 12, 233, 3299, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 3, 234, 3318, 8, 234, 1, 235, 1, 235, 1, 235, 1, 235, 1, 236, 3, 236, 3325, 8, 236, 1, 236, 3, 236, 3328, 8, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 1, 239, 3, 239, 3342, 8, 239, 1, 240, 1, 240, 3, 240, 3346, 8, 240, 3, 240, 3348, 8, 240, 1, 240, 1, 240, 1, 240, 3, 240, 3353, 8, 240, 3, 240, 3355, 8, 240, 1, 241, 1, 241, 3, 241, 3359, 8, 241, 1, 242, 3, 242, 3362, 8, 242, 1, 242, 1, 242, 1, 243, 1, 243, 3, 243, 3368, 8, 243, 1, 243, 1, 243, 1, 244, 3, 244, 3373, 8, 244, 1, 244, 1, 244, 1, 245, 1, 245, 3, 245, 3379, 8, 245, 3, 245, 3381, 8, 245, 1, 245, 1, 245, 3, 245, 3385, 8, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 3, 245, 3416, 8, 245, 1, 246, 1, 246, 1, 246, 3, 246, 3421, 8, 246, 1, 246, 1, 246, 3, 246, 3425, 8, 246, 1, 247, 1, 247, 3, 247, 3429, 8, 247, 1, 247, 1, 247, 3, 247, 3433, 8, 247, 3, 247, 3435, 8, 247, 1, 247, 1, 247, 3, 247, 3439, 8, 247, 1, 247, 5, 247, 3442, 8, 247, 10, 247, 12, 247, 3445, 9, 247, 1, 248, 1, 248, 3, 248, 3449, 8, 248, 1, 249, 1, 249, 3, 249, 3453, 8, 249, 1, 250, 1, 250, 1, 250, 1, 251, 3, 251, 3459, 8, 251, 1, 251, 1, 251, 1, 251, 1, 252, 1, 252, 1, 252, 3, 252, 3467, 8, 252, 1, 252, 3, 252, 3470, 8, 252, 1, 252, 1, 252, 3, 252, 3474, 8, 252, 1, 252, 1, 252, 1, 253, 1, 253, 4, 253, 3480, 8, 253, 11, 253, 12, 253, 3481, 1, 254, 1, 254, 1, 254, 1, 255, 1, 255, 3, 255, 3489, 8, 255, 1, 256, 3, 256, 3492, 8, 256, 1, 256, 3, 256, 3495, 8, 256, 1, 256, 4, 256, 3498, 8, 256, 11, 256, 12, 256, 3499, 1, 257, 3, 257, 3503, 8, 257, 1, 257, 1, 257, 3, 257, 3507, 8, 257, 1, 257, 3, 257, 3510, 8, 257, 1, 258, 3, 258, 3513, 8, 258, 1, 258, 1, 258, 4, 258, 3517, 8, 258, 11, 258, 12, 258, 3518, 1, 259, 1, 259, 1, 259, 3, 259, 3524, 8, 259, 1, 260, 1, 260, 1, 260, 4, 260, 3529, 8, 260, 11, 260, 12, 260, 3530, 1, 260, 1, 260, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 3, 262, 3546, 8, 262, 1, 263, 1, 263, 5, 263, 3550, 8, 263, 10, 263, 12, 263, 3553, 9, 263, 1, 264, 1, 264, 1, 264, 1, 264, 1, 265, 5, 265, 3560, 8, 265, 10, 265, 12, 265, 3563, 9, 265, 1, 265, 5, 265, 3566, 8, 265, 10, 265, 12, 265, 3569, 9, 265, 1, 266, 1, 266, 1, 266, 1, 266, 5, 266, 3575, 8, 266, 10, 266, 12, 266, 3578, 9, 266, 3, 266, 3580, 8, 266, 1, 267, 5, 267, 3583, 8, 267, 10, 267, 12, 267, 3586, 9, 267, 1, 267, 1, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 3, 268, 3639, 8, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 3647, 8, 269, 1, 269, 3, 269, 3650, 8, 269, 1, 269, 3, 269, 3653, 8, 269, 1, 269, 3, 269, 3656, 8, 269, 1, 270, 1, 270, 1, 270, 3, 270, 3661, 8, 270, 1, 270, 1, 270, 3, 270, 3665, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 3672, 8, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 3678, 8, 270, 1, 271, 1, 271, 1, 271, 1, 272, 1, 272, 1, 272, 1, 272, 1, 273, 3, 273, 3688, 8, 273, 1, 273, 1, 273, 1, 274, 1, 274, 1, 274, 1, 274, 3, 274, 3696, 8, 274, 1, 274, 3, 274, 3699, 8, 274, 1, 274, 3, 274, 3702, 8, 274, 1, 274, 3, 274, 3705, 8, 274, 1, 275, 4, 275, 3708, 8, 275, 11, 275, 12, 275, 3709, 1, 275, 1, 275, 4, 275, 3714, 8, 275, 11, 275, 12, 275, 3715, 1, 276, 4, 276, 3719, 8, 276, 11, 276, 12, 276, 3720, 1, 276, 1, 276, 4, 276, 3725, 8, 276, 11, 276, 12, 276, 3726, 3, 276, 3729, 8, 276, 1, 276, 1, 276, 4, 276, 3733, 8, 276, 11, 276, 12, 276, 3734, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 278, 1, 278, 3, 278, 3744, 8, 278, 1, 279, 1, 279, 3, 279, 3748, 8, 279, 1, 280, 1, 280, 3, 280, 3752, 8, 280, 1, 281, 1, 281, 3, 281, 3756, 8, 281, 1, 282, 1, 282, 3, 282, 3760, 8, 282, 1, 282, 1, 282, 1, 283, 1, 283, 4, 283, 3766, 8, 283, 11, 283, 12, 283, 3767, 1, 284, 1, 284, 1, 284, 1, 284, 3, 284, 3774, 8, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 3, 285, 3781, 8, 285, 1, 285, 3, 285, 3784, 8, 285, 1, 285, 3, 285, 3787, 8, 285, 1, 285, 3, 285, 3790, 8, 285, 1, 285, 3, 285, 3793, 8, 285, 1, 285, 3, 285, 3796, 8, 285, 1, 285, 3, 285, 3799, 8, 285, 1, 286, 1, 286, 4, 286, 3803, 8, 286, 11, 286, 12, 286, 3804, 1, 287, 1, 287, 1, 287, 3, 287, 3810, 8, 287, 1, 288, 3, 288, 3813, 8, 288, 1, 288, 3, 288, 3816, 8, 288, 1, 288, 4, 288, 3819, 8, 288, 11, 288, 12, 288, 3820, 1, 289, 1, 289, 1, 289, 1, 289, 3, 289, 3827, 8, 289, 1, 289, 1, 289, 1, 289, 3, 289, 3832, 8, 289, 1, 289, 3, 289, 3835, 8, 289, 1, 290, 3, 290, 3838, 8, 290, 1, 290, 1, 290, 4, 290, 3842, 8, 290, 11, 290, 12, 290, 3843, 1, 291, 1, 291, 1, 291, 1, 291, 3, 291, 3850, 8, 291, 3, 291, 3852, 8, 291, 1, 291, 1, 291, 3, 291, 3856, 8, 291, 1, 292, 3, 292, 3859, 8, 292, 1, 292, 1, 292, 4, 292, 3863, 8, 292, 11, 292, 12, 292, 3864, 1, 293, 1, 293, 1, 293, 1, 293, 3, 293, 3871, 8, 293, 3, 293, 3873, 8, 293, 1, 293, 1, 293, 1, 293, 3, 293, 3878, 8, 293, 1, 294, 1, 294, 1, 294, 1, 295, 1, 295, 4, 295, 3885, 8, 295, 11, 295, 12, 295, 3886, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 3, 296, 3894, 8, 296, 1, 297, 1, 297, 4, 297, 3898, 8, 297, 11, 297, 12, 297, 3899, 1, 298, 1, 298, 1, 298, 1, 298, 3, 298, 3906, 8, 298, 1, 299, 1, 299, 3, 299, 3910, 8, 299, 1, 299, 3, 299, 3913, 8, 299, 1, 299, 3, 299, 3916, 8, 299, 1, 299, 1, 299, 1, 299, 3, 299, 3921, 8, 299, 3, 299, 3923, 8, 299, 1, 300, 3, 300, 3926, 8, 300, 1, 300, 1, 300, 1, 300, 3, 300, 3931, 8, 300, 1, 301, 3, 301, 3934, 8, 301, 1, 301, 1, 301, 1, 301, 1, 301, 3, 301, 3940, 8, 301, 1, 301, 1, 301, 4, 301, 3944, 8, 301, 11, 301, 12, 301, 3945, 3, 301, 3948, 8, 301, 1, 302, 1, 302, 1, 302, 3, 302, 3953, 8, 302, 1, 303, 1, 303, 3, 303, 3957, 8, 303, 1, 303, 1, 303, 1, 304, 1, 304, 1, 304, 3, 304, 3964, 8, 304, 1, 305, 1, 305, 3, 305, 3968, 8, 305, 1, 305, 1, 305, 3, 305, 3972, 8, 305, 1, 306, 1, 306, 4, 306, 3976, 8, 306, 11, 306, 12, 306, 3977, 1, 306, 1, 306, 1, 306, 3, 306, 3983, 8, 306, 1, 306, 3, 306, 3986, 8, 306, 1, 306, 3, 306, 3989, 8, 306, 1, 307, 1, 307, 3, 307, 3993, 8, 307, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, 3, 309, 4000, 8, 309, 1, 309, 3, 309, 4003, 8, 309, 1, 309, 3, 309, 4006, 8, 309, 1, 309, 3, 309, 4009, 8, 309, 1, 310, 1, 310, 1, 310, 3, 310, 4014, 8, 310, 1, 310, 1, 310, 1, 310, 3, 310, 4019, 8, 310, 1, 310, 1, 310, 3, 310, 4023, 8, 310, 1, 310, 1, 310, 1, 310, 3, 310, 4028, 8, 310, 1, 311, 1, 311, 4, 311, 4032, 8, 311, 11, 311, 12, 311, 4033, 1, 311, 3, 311, 4037, 8, 311, 1, 311, 3, 311, 4040, 8, 311, 1, 311, 3, 311, 4043, 8, 311, 1, 312, 1, 312, 3, 312, 4047, 8, 312, 1, 313, 1, 313, 1, 313, 3, 313, 4052, 8, 313, 1, 314, 1, 314, 1, 314, 3, 314, 4057, 8, 314, 1, 315, 3, 315, 4060, 8, 315, 1, 315, 1, 315, 1, 315, 1, 316, 1, 316, 1, 316, 3, 316, 4068, 8, 316, 1, 316, 1, 316, 1, 316, 3, 316, 4073, 8, 316, 1, 316, 3, 316, 4076, 8, 316, 1, 316, 3, 316, 4079, 8, 316, 1, 316, 3, 316, 4082, 8, 316, 1, 316, 3, 316, 4085, 8, 316, 1, 317, 1, 317, 4, 317, 4089, 8, 317, 11, 317, 12, 317, 4090, 1, 318, 1, 318, 1, 318, 3, 318, 4096, 8, 318, 1, 318, 3, 318, 4099, 8, 318, 1, 319, 1, 319, 1, 319, 3, 319, 4104, 8, 319, 1, 319, 3, 319, 4107, 8, 319, 1, 320, 1, 320, 4, 320, 4111, 8, 320, 11, 320, 12, 320, 4112, 1, 321, 1, 321, 3, 321, 4117, 8, 321, 1, 322, 1, 322, 3, 322, 4121, 8, 322, 1, 323, 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 3, 324, 4129, 8, 324, 1, 324, 1, 324, 1, 324, 3, 324, 4134, 8, 324, 1, 324, 1, 324, 3, 324, 4138, 8, 324, 1, 324, 1, 324, 1, 324, 3, 324, 4143, 8, 324, 1, 325, 1, 325, 1, 325, 1, 325, 4, 325, 4149, 8, 325, 11, 325, 12, 325, 4150, 3, 325, 4153, 8, 325, 1, 326, 1, 326, 1, 326, 5, 326, 4158, 8, 326, 10, 326, 12, 326, 4161, 9, 326, 1, 326, 4, 326, 4164, 8, 326, 11, 326, 12, 326, 4165, 1, 326, 3, 326, 4169, 8, 326, 1, 326, 3, 326, 4172, 8, 326, 1, 327, 1, 327, 1, 327, 1, 327, 3, 327, 4178, 8, 327, 1, 328, 1, 328, 1, 328, 1, 329, 4, 329, 4184, 8, 329, 11, 329, 12, 329, 4185, 1, 329, 5, 329, 4189, 8, 329, 10, 329, 12, 329, 4192, 9, 329, 1, 330, 1, 330, 1, 330, 5, 330, 4197, 8, 330, 10, 330, 12, 330, 4200, 9, 330, 1, 331, 1, 331, 3, 331, 4204, 8, 331, 1, 331, 1, 331, 3, 331, 4208, 8, 331, 1, 331, 1, 331, 3, 331, 4212, 8, 331, 1, 332, 1, 332, 1, 332, 1, 333, 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, 5, 334, 4223, 8, 334, 10, 334, 12, 334, 4226, 9, 334, 1, 335, 1, 335, 1, 335, 3, 335, 4231, 8, 335, 1, 336, 4, 336, 4234, 8, 336, 11, 336, 12, 336, 4235, 1, 337, 4, 337, 4239, 8, 337, 11, 337, 12, 337, 4240, 1, 338, 4, 338, 4244, 8, 338, 11, 338, 12, 338, 4245, 1, 339, 1, 339, 3, 339, 4250, 8, 339, 1, 339, 3, 339, 4253, 8, 339, 1, 339, 4, 339, 4256, 8, 339, 11, 339, 12, 339, 4257, 1, 340, 1, 340, 3, 340, 4262, 8, 340, 1, 341, 1, 341, 3, 341, 4266, 8, 341, 1, 342, 1, 342, 1, 342, 1, 343, 1, 343, 1, 344, 1, 344, 3, 344, 4275, 8, 344, 1, 344, 1, 344, 3, 344, 4279, 8, 344, 1, 345, 1, 345, 1, 346, 1, 346, 4, 346, 4285, 8, 346, 11, 346, 12, 346, 4286, 1, 346, 1, 346, 3, 346, 4291, 8, 346, 1, 346, 3, 346, 4294, 8, 346, 3, 346, 4296, 8, 346, 1, 347, 1, 347, 1, 347, 1, 347, 3, 347, 4302, 8, 347, 1, 347, 3, 347, 4305, 8, 347, 1, 348, 3, 348, 4308, 8, 348, 1, 348, 1, 348, 1, 348, 5, 348, 4313, 8, 348, 10, 348, 12, 348, 4316, 9, 348, 3, 348, 4318, 8, 348, 1, 349, 1, 349, 1, 349, 1, 349, 5, 349, 4324, 8, 349, 10, 349, 12, 349, 4327, 9, 349, 3, 349, 4329, 8, 349, 1, 350, 1, 350, 4, 350, 4333, 8, 350, 11, 350, 12, 350, 4334, 1, 350, 3, 350, 4338, 8, 350, 1, 351, 1, 351, 4, 351, 4342, 8, 351, 11, 351, 12, 351, 4343, 1, 352, 1, 352, 3, 352, 4348, 8, 352, 1, 352, 1, 352, 1, 352, 3, 352, 4353, 8, 352, 1, 353, 1, 353, 4, 353, 4357, 8, 353, 11, 353, 12, 353, 4358, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 3, 354, 4367, 8, 354, 1, 355, 1, 355, 4, 355, 4371, 8, 355, 11, 355, 12, 355, 4372, 1, 356, 1, 356, 1, 356, 4, 356, 4378, 8, 356, 11, 356, 12, 356, 4379, 1, 357, 1, 357, 4, 357, 4384, 8, 357, 11, 357, 12, 357, 4385, 1, 357, 4, 357, 4389, 8, 357, 11, 357, 12, 357, 4390, 1, 358, 1, 358, 1, 358, 3, 358, 4396, 8, 358, 1, 358, 1, 358, 5, 358, 4400, 8, 358, 10, 358, 12, 358, 4403, 9, 358, 1, 359, 1, 359, 1, 359, 1, 359, 4, 359, 4409, 8, 359, 11, 359, 12, 359, 4410, 1, 360, 1, 360, 5, 360, 4415, 8, 360, 10, 360, 12, 360, 4418, 9, 360, 1, 361, 1, 361, 1, 361, 5, 361, 4423, 8, 361, 10, 361, 12, 361, 4426, 9, 361, 1, 362, 1, 362, 4, 362, 4430, 8, 362, 11, 362, 12, 362, 4431, 1, 363, 1, 363, 4, 363, 4436, 8, 363, 11, 363, 12, 363, 4437, 1, 364, 1, 364, 3, 364, 4442, 8, 364, 1, 364, 5, 364, 4445, 8, 364, 10, 364, 12, 364, 4448, 9, 364, 1, 365, 1, 365, 3, 365, 4452, 8, 365, 1, 365, 1, 365, 5, 365, 4456, 8, 365, 10, 365, 12, 365, 4459, 9, 365, 1, 366, 1, 366, 1, 366, 3, 366, 4464, 8, 366, 1, 367, 1, 367, 1, 367, 3, 367, 4469, 8, 367, 1, 368, 1, 368, 3, 368, 4473, 8, 368, 1, 368, 1, 368, 3, 368, 4477, 8, 368, 1, 369, 1, 369, 1, 369, 4, 369, 4482, 8, 369, 11, 369, 12, 369, 4483, 1, 369, 3, 369, 4487, 8, 369, 1, 369, 5, 369, 4490, 8, 369, 10, 369, 12, 369, 4493, 9, 369, 1, 369, 3, 369, 4496, 8, 369, 1, 369, 5, 369, 4499, 8, 369, 10, 369, 12, 369, 4502, 9, 369, 1, 370, 3, 370, 4505, 8, 370, 1, 370, 1, 370, 3, 370, 4509, 8, 370, 1, 370, 4, 370, 4512, 8, 370, 11, 370, 12, 370, 4513, 1, 371, 3, 371, 4517, 8, 371, 1, 371, 1, 371, 3, 371, 4521, 8, 371, 1, 371, 4, 371, 4524, 8, 371, 11, 371, 12, 371, 4525, 1, 371, 3, 371, 4529, 8, 371, 1, 371, 3, 371, 4532, 8, 371, 1, 372, 3, 372, 4535, 8, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 373, 3, 373, 4542, 8, 373, 1, 373, 1, 373, 3, 373, 4546, 8, 373, 1, 373, 1, 373, 1, 374, 1, 374, 4, 374, 4552, 8, 374, 11, 374, 12, 374, 4553, 1, 375, 1, 375, 1, 375, 3, 375, 4559, 8, 375, 1, 375, 1, 375, 3, 375, 4563, 8, 375, 1, 376, 1, 376, 1, 376, 1, 377, 1, 377, 4, 377, 4570, 8, 377, 11, 377, 12, 377, 4571, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 3, 378, 4584, 8, 378, 1, 379, 1, 379, 3, 379, 4588, 8, 379, 1, 379, 1, 379, 3, 379, 4592, 8, 379, 1, 380, 1, 380, 1, 380, 4, 380, 4597, 8, 380, 11, 380, 12, 380, 4598, 1, 381, 1, 381, 3, 381, 4603, 8, 381, 1, 382, 1, 382, 1, 382, 1, 382, 4, 382, 4609, 8, 382, 11, 382, 12, 382, 4610, 1, 383, 1, 383, 1, 384, 1, 384, 1, 384, 3, 384, 4618, 8, 384, 1, 384, 1, 384, 1, 384, 3, 384, 4623, 8, 384, 1, 384, 3, 384, 4626, 8, 384, 1, 384, 3, 384, 4629, 8, 384, 1, 384, 3, 384, 4632, 8, 384, 1, 385, 4, 385, 4635, 8, 385, 11, 385, 12, 385, 4636, 1, 386, 1, 386, 3, 386, 4641, 8, 386, 1, 387, 1, 387, 1, 387, 4, 387, 4646, 8, 387, 11, 387, 12, 387, 4647, 1, 388, 1, 388, 3, 388, 4652, 8, 388, 1, 389, 1, 389, 3, 389, 4656, 8, 389, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 4, 390, 4663, 8, 390, 11, 390, 12, 390, 4664, 1, 391, 1, 391, 4, 391, 4669, 8, 391, 11, 391, 12, 391, 4670, 1, 392, 1, 392, 1, 392, 3, 392, 4676, 8, 392, 1, 392, 1, 392, 3, 392, 4680, 8, 392, 1, 393, 1, 393, 4, 393, 4684, 8, 393, 11, 393, 12, 393, 4685, 1, 394, 1, 394, 3, 394, 4690, 8, 394, 1, 394, 1, 394, 3, 394, 4694, 8, 394, 1, 395, 1, 395, 4, 395, 4698, 8, 395, 11, 395, 12, 395, 4699, 1, 396, 1, 396, 4, 396, 4704, 8, 396, 11, 396, 12, 396, 4705, 1, 397, 1, 397, 1, 397, 3, 397, 4711, 8, 397, 1, 398, 3, 398, 4714, 8, 398, 1, 398, 5, 398, 4717, 8, 398, 10, 398, 12, 398, 4720, 9, 398, 1, 398, 1, 398, 1, 399, 1, 399, 1, 399, 3, 399, 4727, 8, 399, 1, 399, 3, 399, 4730, 8, 399, 1, 400, 1, 400, 1, 400, 3, 400, 4735, 8, 400, 1, 401, 1, 401, 3, 401, 4739, 8, 401, 1, 401, 1, 401, 1, 402, 3, 402, 4744, 8, 402, 1, 402, 1, 402, 1, 402, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 3, 403, 4754, 8, 403, 3, 403, 4756, 8, 403, 1, 404, 1, 404, 1, 404, 5, 404, 4761, 8, 404, 10, 404, 12, 404, 4764, 9, 404, 1, 405, 1, 405, 3, 405, 4768, 8, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 406, 1, 406, 1, 406, 1, 407, 1, 407, 1, 407, 1, 407, 3, 407, 4781, 8, 407, 1, 408, 1, 408, 1, 408, 1, 408, 3, 408, 4787, 8, 408, 1, 409, 3, 409, 4790, 8, 409, 1, 409, 1, 409, 1, 409, 1, 410, 1, 410, 4, 410, 4797, 8, 410, 11, 410, 12, 410, 4798, 1, 411, 1, 411, 1, 411, 3, 411, 4804, 8, 411, 1, 411, 3, 411, 4807, 8, 411, 1, 411, 3, 411, 4810, 8, 411, 1, 411, 3, 411, 4813, 8, 411, 1, 411, 3, 411, 4816, 8, 411, 1, 411, 3, 411, 4819, 8, 411, 1, 411, 3, 411, 4822, 8, 411, 1, 411, 3, 411, 4825, 8, 411, 1, 411, 3, 411, 4828, 8, 411, 1, 411, 3, 411, 4831, 8, 411, 1, 412, 1, 412, 1, 412, 1, 413, 3, 413, 4837, 8, 413, 1, 413, 1, 413, 1, 413, 3, 413, 4842, 8, 413, 1, 414, 1, 414, 3, 414, 4846, 8, 414, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, 3, 415, 4853, 8, 415, 1, 415, 3, 415, 4856, 8, 415, 1, 415, 3, 415, 4859, 8, 415, 1, 415, 3, 415, 4862, 8, 415, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 5, 416, 4872, 8, 416, 10, 416, 12, 416, 4875, 9, 416, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 3, 417, 4883, 8, 417, 1, 418, 1, 418, 1, 418, 3, 418, 4888, 8, 418, 1, 418, 1, 418, 3, 418, 4892, 8, 418, 1, 418, 3, 418, 4895, 8, 418, 1, 419, 1, 419, 1, 419, 5, 419, 4900, 8, 419, 10, 419, 12, 419, 4903, 9, 419, 1, 420, 1, 420, 1, 420, 5, 420, 4908, 8, 420, 10, 420, 12, 420, 4911, 9, 420, 1, 421, 1, 421, 3, 421, 4915, 8, 421, 1, 421, 1, 421, 3, 421, 4919, 8, 421, 1, 422, 3, 422, 4922, 8, 422, 1, 422, 1, 422, 1, 422, 1, 423, 1, 423, 3, 423, 4929, 8, 423, 1, 423, 1, 423, 1, 424, 1, 424, 3, 424, 4935, 8, 424, 1, 424, 1, 424, 3, 424, 4939, 8, 424, 1, 425, 1, 425, 3, 425, 4943, 8, 425, 1, 425, 1, 425, 1, 426, 1, 426, 1, 426, 1, 426, 3, 426, 4951, 8, 426, 1, 427, 1, 427, 1, 427, 3, 427, 4956, 8, 427, 1, 427, 3, 427, 4959, 8, 427, 1, 427, 1, 427, 3, 427, 4963, 8, 427, 1, 427, 3, 427, 4966, 8, 427, 1, 428, 1, 428, 1, 428, 1, 429, 1, 429, 1, 429, 3, 429, 4974, 8, 429, 1, 429, 3, 429, 4977, 8, 429, 1, 429, 3, 429, 4980, 8, 429, 1, 429, 3, 429, 4983, 8, 429, 1, 430, 1, 430, 1, 430, 1, 431, 1, 431, 3, 431, 4990, 8, 431, 1, 431, 1, 431, 3, 431, 4994, 8, 431, 1, 431, 3, 431, 4997, 8, 431, 1, 431, 4, 431, 5000, 8, 431, 11, 431, 12, 431, 5001, 1, 431, 3, 431, 5005, 8, 431, 1, 432, 1, 432, 1, 432, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 5, 433, 5015, 8, 433, 10, 433, 12, 433, 5018, 9, 433, 3, 433, 5020, 8, 433, 1, 434, 1, 434, 1, 434, 3, 434, 5025, 8, 434, 1, 434, 3, 434, 5028, 8, 434, 1, 434, 3, 434, 5031, 8, 434, 1, 435, 1, 435, 3, 435, 5035, 8, 435, 1, 435, 3, 435, 5038, 8, 435, 1, 435, 3, 435, 5041, 8, 435, 1, 435, 3, 435, 5044, 8, 435, 1, 435, 3, 435, 5047, 8, 435, 1, 436, 1, 436, 1, 436, 1, 436, 1, 437, 1, 437, 1, 437, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 3, 438, 5061, 8, 438, 1, 439, 1, 439, 3, 439, 5065, 8, 439, 1, 440, 1, 440, 3, 440, 5069, 8, 440, 1, 440, 1, 440, 1, 440, 3, 440, 5074, 8, 440, 1, 441, 1, 441, 1, 442, 1, 442, 3, 442, 5080, 8, 442, 1, 442, 3, 442, 5083, 8, 442, 1, 443, 1, 443, 1, 444, 1, 444, 4, 444, 5089, 8, 444, 11, 444, 12, 444, 5090, 1, 444, 3, 444, 5094, 8, 444, 1, 445, 4, 445, 5097, 8, 445, 11, 445, 12, 445, 5098, 1, 445, 1, 445, 4, 445, 5103, 8, 445, 11, 445, 12, 445, 5104, 1, 446, 4, 446, 5108, 8, 446, 11, 446, 12, 446, 5109, 1, 446, 1, 446, 1, 446, 1, 446, 3, 446, 5116, 8, 446, 1, 446, 1, 446, 1, 447, 1, 447, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 5127, 8, 448, 1, 448, 1, 448, 3, 448, 5131, 8, 448, 1, 449, 1, 449, 3, 449, 5135, 8, 449, 1, 450, 1, 450, 1, 450, 4, 450, 5140, 8, 450, 11, 450, 12, 450, 5141, 1, 450, 3, 450, 5145, 8, 450, 1, 450, 3, 450, 5148, 8, 450, 1, 450, 3, 450, 5151, 8, 450, 1, 450, 5, 450, 5154, 8, 450, 10, 450, 12, 450, 5157, 9, 450, 1, 450, 3, 450, 5160, 8, 450, 1, 450, 5, 450, 5163, 8, 450, 10, 450, 12, 450, 5166, 9, 450, 1, 451, 3, 451, 5169, 8, 451, 1, 451, 1, 451, 3, 451, 5173, 8, 451, 1, 451, 4, 451, 5176, 8, 451, 11, 451, 12, 451, 5177, 1, 452, 3, 452, 5181, 8, 452, 1, 452, 1, 452, 3, 452, 5185, 8, 452, 1, 452, 3, 452, 5188, 8, 452, 1, 453, 3, 453, 5191, 8, 453, 1, 453, 1, 453, 3, 453, 5195, 8, 453, 1, 453, 4, 453, 5198, 8, 453, 11, 453, 12, 453, 5199, 1, 453, 3, 453, 5203, 8, 453, 1, 453, 3, 453, 5206, 8, 453, 1, 454, 3, 454, 5209, 8, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 455, 3, 455, 5216, 8, 455, 1, 455, 1, 455, 3, 455, 5220, 8, 455, 1, 455, 1, 455, 1, 456, 1, 456, 1, 456, 3, 456, 5227, 8, 456, 1, 456, 1, 456, 3, 456, 5231, 8, 456, 1, 457, 1, 457, 1, 457, 1, 458, 1, 458, 4, 458, 5238, 8, 458, 11, 458, 12, 458, 5239, 1, 459, 1, 459, 1, 459, 3, 459, 5245, 8, 459, 1, 459, 1, 459, 3, 459, 5249, 8, 459, 1, 460, 1, 460, 1, 460, 1, 461, 1, 461, 4, 461, 5256, 8, 461, 11, 461, 12, 461, 5257, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 3, 462, 5270, 8, 462, 1, 463, 1, 463, 1, 463, 3, 463, 5275, 8, 463, 1, 463, 3, 463, 5278, 8, 463, 1, 463, 3, 463, 5281, 8, 463, 1, 463, 3, 463, 5284, 8, 463, 1, 464, 1, 464, 3, 464, 5288, 8, 464, 1, 464, 1, 464, 3, 464, 5292, 8, 464, 1, 464, 1, 464, 1, 464, 3, 464, 5297, 8, 464, 1, 464, 1, 464, 1, 464, 1, 464, 3, 464, 5303, 8, 464, 1, 464, 1, 464, 1, 464, 1, 464, 3, 464, 5309, 8, 464, 1, 464, 1, 464, 1, 464, 3, 464, 5314, 8, 464, 1, 464, 3, 464, 5317, 8, 464, 1, 464, 1, 464, 1, 465, 1, 465, 1, 465, 3, 465, 5324, 8, 465, 1, 466, 1, 466, 4, 466, 5328, 8, 466, 11, 466, 12, 466, 5329, 1, 466, 1, 466, 3, 466, 5334, 8, 466, 1, 466, 3, 466, 5337, 8, 466, 1, 466, 3, 466, 5340, 8, 466, 1, 466, 3, 466, 5343, 8, 466, 1, 467, 4, 467, 5346, 8, 467, 11, 467, 12, 467, 5347, 1, 467, 1, 467, 3, 467, 5352, 8, 467, 1, 468, 1, 468, 3, 468, 5356, 8, 468, 1, 469, 1, 469, 3, 469, 5360, 8, 469, 1, 469, 1, 469, 1, 469, 3, 469, 5365, 8, 469, 1, 470, 1, 470, 1, 470, 3, 470, 5370, 8, 470, 1, 471, 1, 471, 1, 471, 1, 472, 3, 472, 5376, 8, 472, 1, 472, 1, 472, 1, 472, 1, 473, 1, 473, 1, 473, 1, 473, 3, 473, 5385, 8, 473, 1, 473, 3, 473, 5388, 8, 473, 1, 473, 3, 473, 5391, 8, 473, 1, 473, 3, 473, 5394, 8, 473, 1, 474, 4, 474, 5397, 8, 474, 11, 474, 12, 474, 5398, 1, 474, 1, 474, 4, 474, 5403, 8, 474, 11, 474, 12, 474, 5404, 1, 475, 4, 475, 5408, 8, 475, 11, 475, 12, 475, 5409, 1, 475, 1, 475, 1, 475, 1, 475, 4, 475, 5416, 8, 475, 11, 475, 12, 475, 5417, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 477, 1, 477, 3, 477, 5427, 8, 477, 1, 478, 1, 478, 3, 478, 5431, 8, 478, 1, 479, 1, 479, 3, 479, 5435, 8, 479, 1, 480, 1, 480, 3, 480, 5439, 8, 480, 1, 481, 1, 481, 3, 481, 5443, 8, 481, 1, 482, 1, 482, 1, 482, 1, 483, 1, 483, 1, 483, 1, 483, 3, 483, 5452, 8, 483, 1, 483, 3, 483, 5455, 8, 483, 1, 483, 3, 483, 5458, 8, 483, 1, 483, 3, 483, 5461, 8, 483, 1, 483, 3, 483, 5464, 8, 483, 1, 484, 1, 484, 1, 484, 5, 484, 5469, 8, 484, 10, 484, 12, 484, 5472, 9, 484, 3, 484, 5474, 8, 484, 1, 485, 1, 485, 3, 485, 5478, 8, 485, 1, 485, 3, 485, 5481, 8, 485, 1, 485, 1, 485, 3, 485, 5485, 8, 485, 1, 486, 1, 486, 3, 486, 5489, 8, 486, 1, 486, 1, 486, 3, 486, 5493, 8, 486, 1, 487, 1, 487, 4, 487, 5497, 8, 487, 11, 487, 12, 487, 5498, 1, 488, 1, 488, 3, 488, 5503, 8, 488, 1, 488, 3, 488, 5506, 8, 488, 1, 489, 1, 489, 3, 489, 5510, 8, 489, 1, 489, 1, 489, 1, 490, 1, 490, 3, 490, 5516, 8, 490, 1, 490, 1, 490, 1, 491, 3, 491, 5521, 8, 491, 1, 491, 1, 491, 1, 491, 1, 492, 1, 492, 3, 492, 5528, 8, 492, 1, 492, 1, 492, 1, 493, 1, 493, 1, 493, 3, 493, 5535, 8, 493, 1, 494, 3, 494, 5538, 8, 494, 1, 494, 1, 494, 3, 494, 5542, 8, 494, 1, 494, 1, 494, 1, 494, 3, 494, 5547, 8, 494, 1, 494, 1, 494, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 4, 495, 5556, 8, 495, 11, 495, 12, 495, 5557, 3, 495, 5560, 8, 495, 1, 496, 3, 496, 5563, 8, 496, 1, 496, 1, 496, 3, 496, 5567, 8, 496, 1, 496, 4, 496, 5570, 8, 496, 11, 496, 12, 496, 5571, 1, 497, 1, 497, 1, 497, 1, 497, 3, 497, 5578, 8, 497, 1, 497, 3, 497, 5581, 8, 497, 1, 497, 1, 497, 1, 497, 3, 497, 5586, 8, 497, 1, 498, 1, 498, 1, 498, 3, 498, 5591, 8, 498, 1, 498, 3, 498, 5594, 8, 498, 1, 498, 3, 498, 5597, 8, 498, 1, 498, 3, 498, 5600, 8, 498, 1, 498, 3, 498, 5603, 8, 498, 1, 498, 3, 498, 5606, 8, 498, 1, 498, 3, 498, 5609, 8, 498, 1, 499, 1, 499, 1, 499, 3, 499, 5614, 8, 499, 1, 500, 1, 500, 3, 500, 5618, 8, 500, 1, 500, 1, 500, 1, 500, 3, 500, 5623, 8, 500, 1, 501, 1, 501, 1, 502, 1, 502, 3, 502, 5629, 8, 502, 1, 502, 3, 502, 5632, 8, 502, 1, 503, 1, 503, 1, 504, 3, 504, 5637, 8, 504, 1, 504, 1, 504, 5, 504, 5641, 8, 504, 10, 504, 12, 504, 5644, 9, 504, 1, 505, 1, 505, 3, 505, 5648, 8, 505, 1, 505, 1, 505, 5, 505, 5652, 8, 505, 10, 505, 12, 505, 5655, 9, 505, 1, 506, 3, 506, 5658, 8, 506, 1, 506, 1, 506, 5, 506, 5662, 8, 506, 10, 506, 12, 506, 5665, 9, 506, 1, 507, 1, 507, 3, 507, 5669, 8, 507, 1, 507, 1, 507, 5, 507, 5673, 8, 507, 10, 507, 12, 507, 5676, 9, 507, 1, 508, 1, 508, 3, 508, 5680, 8, 508, 1, 508, 5, 508, 5683, 8, 508, 10, 508, 12, 508, 5686, 9, 508, 1, 509, 1, 509, 1, 509, 3, 509, 5691, 8, 509, 1, 509, 5, 509, 5694, 8, 509, 10, 509, 12, 509, 5697, 9, 509, 1, 510, 3, 510, 5700, 8, 510, 1, 510, 1, 510, 5, 510, 5704, 8, 510, 10, 510, 12, 510, 5707, 9, 510, 1, 511, 1, 511, 3, 511, 5711, 8, 511, 1, 511, 1, 511, 5, 511, 5715, 8, 511, 10, 511, 12, 511, 5718, 9, 511, 1, 512, 3, 512, 5721, 8, 512, 1, 512, 1, 512, 1, 512, 5, 512, 5726, 8, 512, 10, 512, 12, 512, 5729, 9, 512, 1, 513, 1, 513, 3, 513, 5733, 8, 513, 1, 513, 1, 513, 1, 513, 5, 513, 5738, 8, 513, 10, 513, 12, 513, 5741, 9, 513, 1, 514, 3, 514, 5744, 8, 514, 1, 514, 1, 514, 5, 514, 5748, 8, 514, 10, 514, 12, 514, 5751, 9, 514, 1, 515, 1, 515, 3, 515, 5755, 8, 515, 1, 515, 1, 515, 5, 515, 5759, 8, 515, 10, 515, 12, 515, 5762, 9, 515, 1, 516, 1, 516, 5, 516, 5766, 8, 516, 10, 516, 12, 516, 5769, 9, 516, 1, 517, 1, 517, 1, 517, 1, 518, 1, 518, 5, 518, 5776, 8, 518, 10, 518, 12, 518, 5779, 9, 518, 1, 519, 1, 519, 1, 519, 1, 520, 3, 520, 5785, 8, 520, 1, 520, 1, 520, 5, 520, 5789, 8, 520, 10, 520, 12, 520, 5792, 9, 520, 1, 521, 1, 521, 1, 521, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 3, 522, 5803, 8, 522, 1, 523, 1, 523, 5, 523, 5807, 8, 523, 10, 523, 12, 523, 5810, 9, 523, 1, 524, 1, 524, 1, 524, 4, 524, 5815, 8, 524, 11, 524, 12, 524, 5816, 3, 524, 5819, 8, 524, 1, 525, 3, 525, 5822, 8, 525, 1, 525, 1, 525, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 3, 526, 5833, 8, 526, 1, 527, 1, 527, 3, 527, 5837, 8, 527, 1, 527, 3, 527, 5840, 8, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 3, 527, 5849, 8, 527, 1, 528, 1, 528, 5, 528, 5853, 8, 528, 10, 528, 12, 528, 5856, 9, 528, 1, 528, 3, 528, 5859, 8, 528, 1, 528, 5, 528, 5862, 8, 528, 10, 528, 12, 528, 5865, 9, 528, 1, 528, 5, 528, 5868, 8, 528, 10, 528, 12, 528, 5871, 9, 528, 3, 528, 5873, 8, 528, 1, 529, 1, 529, 1, 529, 3, 529, 5878, 8, 529, 1, 529, 5, 529, 5881, 8, 529, 10, 529, 12, 529, 5884, 9, 529, 1, 529, 1, 529, 1, 530, 1, 530, 1, 530, 3, 530, 5891, 8, 530, 1, 531, 1, 531, 3, 531, 5895, 8, 531, 1, 531, 3, 531, 5898, 8, 531, 1, 531, 1, 531, 1, 532, 1, 532, 1, 532, 1, 532, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 534, 1, 534, 1, 534, 4, 534, 5915, 8, 534, 11, 534, 12, 534, 5916, 1, 535, 3, 535, 5920, 8, 535, 1, 535, 3, 535, 5923, 8, 535, 1, 535, 1, 535, 3, 535, 5927, 8, 535, 1, 535, 1, 535, 1, 535, 3, 535, 5932, 8, 535, 1, 535, 1, 535, 1, 535, 3, 535, 5937, 8, 535, 1, 535, 3, 535, 5940, 8, 535, 1, 535, 1, 535, 1, 535, 3, 535, 5945, 8, 535, 1, 535, 1, 535, 1, 535, 3, 535, 5950, 8, 535, 1, 535, 1, 535, 1, 535, 3, 535, 5955, 8, 535, 1, 535, 1, 535, 1, 535, 3, 535, 5960, 8, 535, 1, 535, 3, 535, 5963, 8, 535, 1, 536, 3, 536, 5966, 8, 536, 1, 536, 3, 536, 5969, 8, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 3, 536, 5977, 8, 536, 1, 537, 1, 537, 1, 537, 1, 537, 3, 537, 5983, 8, 537, 1, 538, 1, 538, 1, 538, 1, 538, 3, 538, 5989, 8, 538, 1, 538, 5, 538, 5992, 8, 538, 10, 538, 12, 538, 5995, 9, 538, 1, 538, 1, 538, 5, 538, 5999, 8, 538, 10, 538, 12, 538, 6002, 9, 538, 1, 538, 3, 538, 6005, 8, 538, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 3, 539, 6012, 8, 539, 1, 539, 5, 539, 6015, 8, 539, 10, 539, 12, 539, 6018, 9, 539, 1, 539, 1, 539, 5, 539, 6022, 8, 539, 10, 539, 12, 539, 6025, 9, 539, 1, 539, 3, 539, 6028, 8, 539, 1, 540, 1, 540, 1, 540, 1, 540, 3, 540, 6034, 8, 540, 1, 540, 1, 540, 1, 541, 1, 541, 1, 542, 1, 542, 1, 543, 1, 543, 1, 543, 1, 543, 3, 543, 6046, 8, 543, 1, 543, 1, 543, 3, 543, 6050, 8, 543, 1, 543, 3, 543, 6053, 8, 543, 1, 544, 1, 544, 1, 544, 1, 544, 3, 544, 6059, 8, 544, 1, 544, 1, 544, 3, 544, 6063, 8, 544, 1, 544, 3, 544, 6066, 8, 544, 1, 545, 1, 545, 1, 545, 1, 545, 3, 545, 6072, 8, 545, 1, 546, 1, 546, 3, 546, 6076, 8, 546, 1, 546, 4, 546, 6079, 8, 546, 11, 546, 12, 546, 6080, 1, 546, 3, 546, 6084, 8, 546, 1, 546, 3, 546, 6087, 8, 546, 1, 547, 1, 547, 1, 547, 1, 548, 1, 548, 1, 548, 1, 549, 1, 549, 1, 549, 1, 550, 1, 550, 3, 550, 6100, 8, 550, 1, 551, 1, 551, 1, 551, 1, 552, 1, 552, 1, 552, 1, 553, 1, 553, 1, 553, 1, 554, 1, 554, 1, 554, 1, 555, 1, 555, 1, 555, 1, 556, 1, 556, 1, 556, 1, 557, 1, 557, 1, 558, 1, 558, 1, 559, 1, 559, 1, 560, 1, 560, 1, 561, 1, 561, 1, 562, 1, 562, 1, 563, 1, 563, 1, 564, 1, 564, 1, 565, 1, 565, 1, 565, 3, 565, 6139, 8, 565, 1, 566, 1, 566, 1, 567, 1, 567, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 3, 568, 6151, 8, 568, 1, 569, 1, 569, 1, 570, 1, 570, 1, 571, 1, 571, 1, 572, 1, 572, 1, 573, 1, 573, 1, 574, 1, 574, 3, 574, 6165, 8, 574, 1, 575, 1, 575, 3, 575, 6169, 8, 575, 1, 575, 3, 575, 6172, 8, 575, 1, 576, 1, 576, 3, 576, 6176, 8, 576, 1, 577, 1, 577, 1, 578, 1, 578, 1, 579, 1, 579, 1, 580, 1, 580, 1, 581, 1, 581, 3, 581, 6188, 8, 581, 1, 582, 1, 582, 1, 583, 1, 583, 1, 584, 1, 584, 1, 585, 1, 585, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 3, 586, 6204, 8, 586, 1, 587, 1, 587, 1, 588, 1, 588, 1, 588, 3, 588, 6211, 8, 588, 1, 589, 1, 589, 1, 590, 1, 590, 1, 590, 1, 590, 3, 590, 6219, 8, 590, 1, 590, 1, 590, 1, 591, 1, 591, 1, 591, 1, 591, 3, 591, 6227, 8, 591, 1, 591, 1, 591, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 3, 592, 6246, 8, 592, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 3, 593, 6263, 8, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 3, 593, 6281, 8, 593, 1, 594, 4, 594, 6284, 8, 594, 11, 594, 12, 594, 6285, 1, 594, 0, 0, 595, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 650, 652, 654, 656, 658, 660, 662, 664, 666, 668, 670, 672, 674, 676, 678, 680, 682, 684, 686, 688, 690, 692, 694, 696, 698, 700, 702, 704, 706, 708, 710, 712, 714, 716, 718, 720, 722, 724, 726, 728, 730, 732, 734, 736, 738, 740, 742, 744, 746, 748, 750, 752, 754, 756, 758, 760, 762, 764, 766, 768, 770, 772, 774, 776, 778, 780, 782, 784, 786, 788, 790, 792, 794, 796, 798, 800, 802, 804, 806, 808, 810, 812, 814, 816, 818, 820, 822, 824, 826, 828, 830, 832, 834, 836, 838, 840, 842, 844, 846, 848, 850, 852, 854, 856, 858, 860, 862, 864, 866, 868, 870, 872, 874, 876, 878, 880, 882, 884, 886, 888, 890, 892, 894, 896, 898, 900, 902, 904, 906, 908, 910, 912, 914, 916, 918, 920, 922, 924, 926, 928, 930, 932, 934, 936, 938, 940, 942, 944, 946, 948, 950, 952, 954, 956, 958, 960, 962, 964, 966, 968, 970, 972, 974, 976, 978, 980, 982, 984, 986, 988, 990, 992, 994, 996, 998, 1000, 1002, 1004, 1006, 1008, 1010, 1012, 1014, 1016, 1018, 1020, 1022, 1024, 1026, 1028, 1030, 1032, 1034, 1036, 1038, 1040, 1042, 1044, 1046, 1048, 1050, 1052, 1054, 1056, 1058, 1060, 1062, 1064, 1066, 1068, 1070, 1072, 1074, 1076, 1078, 1080, 1082, 1084, 1086, 1088, 1090, 1092, 1094, 1096, 1098, 1100, 1102, 1104, 1106, 1108, 1110, 1112, 1114, 1116, 1118, 1120, 1122, 1124, 1126, 1128, 1130, 1132, 1134, 1136, 1138, 1140, 1142, 1144, 1146, 1148, 1150, 1152, 1154, 1156, 1158, 1160, 1162, 1164, 1166, 1168, 1170, 1172, 1174, 1176, 1178, 1180, 1182, 1184, 1186, 1188, 0, 70, 1, 0, 234, 235, 5, 0, 78, 78, 130, 130, 243, 243, 274, 274, 380, 380, 3, 0, 63, 63, 298, 298, 515, 515, 2, 0, 298, 298, 515, 515, 1, 0, 483, 484, 2, 0, 14, 14, 304, 304, 2, 0, 80, 80, 86, 86, 2, 0, 266, 266, 493, 493, 2, 0, 21, 21, 254, 254, 1, 0, 22, 23, 3, 0, 241, 241, 386, 386, 429, 429, 4, 0, 150, 150, 197, 197, 369, 369, 429, 429, 2, 0, 382, 382, 499, 499, 3, 0, 377, 377, 440, 440, 444, 444, 2, 0, 205, 205, 417, 417, 2, 0, 63, 63, 379, 379, 1, 0, 460, 462, 2, 0, 279, 279, 416, 416, 2, 0, 38, 38, 41, 41, 1, 0, 189, 190, 2, 0, 229, 229, 290, 290, 3, 0, 226, 226, 268, 268, 336, 336, 3, 0, 348, 348, 543, 543, 547, 547, 1, 0, 73, 74, 1, 0, 213, 214, 1, 0, 35, 36, 1, 0, 346, 347, 1, 0, 142, 143, 1, 0, 255, 256, 1, 0, 33, 34, 2, 0, 311, 311, 420, 420, 2, 0, 156, 156, 398, 398, 2, 0, 216, 216, 270, 270, 1, 0, 279, 280, 2, 0, 117, 117, 137, 137, 3, 0, 146, 146, 355, 355, 432, 433, 1, 0, 50, 51, 2, 0, 553, 553, 555, 555, 2, 0, 521, 521, 523, 524, 3, 0, 78, 78, 284, 284, 337, 337, 2, 0, 250, 250, 459, 459, 2, 0, 25, 25, 135, 135, 2, 0, 95, 95, 383, 384, 1, 0, 468, 469, 2, 0, 267, 267, 411, 411, 4, 0, 287, 288, 317, 317, 319, 319, 437, 437, 2, 0, 202, 202, 495, 495, 2, 0, 100, 100, 262, 262, 2, 0, 59, 59, 506, 506, 2, 0, 222, 222, 405, 405, 1, 0, 103, 104, 2, 0, 1, 1, 331, 331, 2, 0, 186, 186, 536, 536, 7, 0, 11, 11, 14, 15, 116, 116, 152, 152, 304, 305, 316, 316, 318, 318, 2, 0, 9, 9, 266, 266, 3, 0, 9, 9, 210, 210, 266, 266, 2, 0, 7, 7, 39, 39, 2, 0, 258, 258, 310, 310, 2, 0, 295, 295, 422, 422, 2, 0, 48, 48, 492, 492, 2, 0, 188, 188, 196, 196, 2, 0, 168, 168, 185, 185, 2, 0, 543, 543, 547, 547, 2, 0, 526, 526, 550, 550, 2, 0, 19, 19, 329, 329, 3, 0, 307, 307, 351, 351, 521, 521, 2, 0, 239, 239, 323, 323, 85, 0, 1, 1, 24, 24, 26, 26, 28, 29, 31, 31, 33, 36, 38, 38, 41, 43, 45, 45, 47, 47, 54, 55, 60, 61, 68, 69, 77, 77, 98, 98, 100, 100, 106, 106, 108, 108, 128, 130, 138, 139, 141, 141, 146, 147, 151, 151, 156, 156, 181, 181, 183, 183, 187, 187, 189, 191, 194, 194, 197, 197, 200, 200, 202, 202, 213, 214, 216, 216, 218, 219, 226, 226, 229, 229, 237, 238, 250, 250, 258, 258, 260, 260, 262, 262, 264, 265, 268, 268, 270, 270, 272, 274, 283, 284, 287, 290, 296, 296, 303, 305, 308, 308, 311, 311, 317, 317, 319, 319, 322, 322, 331, 331, 336, 337, 342, 342, 352, 353, 355, 355, 360, 361, 364, 364, 370, 371, 373, 373, 376, 376, 380, 380, 383, 383, 391, 391, 398, 398, 401, 401, 415, 415, 420, 420, 431, 434, 437, 437, 466, 466, 473, 473, 481, 482, 486, 486, 490, 491, 495, 495, 497, 498, 510, 511, 518, 520, 522, 522, 557, 557, 2, 0, 204, 204, 494, 494, 1, 0, 552, 555, 7059, 0, 1190, 1, 0, 0, 0, 2, 1194, 1, 0, 0, 0, 4, 1198, 1, 0, 0, 0, 6, 1217, 1, 0, 0, 0, 8, 1222, 1, 0, 0, 0, 10, 1238, 1, 0, 0, 0, 12, 1240, 1, 0, 0, 0, 14, 1258, 1, 0, 0, 0, 16, 1263, 1, 0, 0, 0, 18, 1268, 1, 0, 0, 0, 20, 1273, 1, 0, 0, 0, 22, 1278, 1, 0, 0, 0, 24, 1283, 1, 0, 0, 0, 26, 1288, 1, 0, 0, 0, 28, 1300, 1, 0, 0, 0, 30, 1302, 1, 0, 0, 0, 32, 1314, 1, 0, 0, 0, 34, 1316, 1, 0, 0, 0, 36, 1328, 1, 0, 0, 0, 38, 1344, 1, 0, 0, 0, 40, 1346, 1, 0, 0, 0, 42, 1357, 1, 0, 0, 0, 44, 1372, 1, 0, 0, 0, 46, 1393, 1, 0, 0, 0, 48, 1402, 1, 0, 0, 0, 50, 1410, 1, 0, 0, 0, 52, 1416, 1, 0, 0, 0, 54, 1420, 1, 0, 0, 0, 56, 1442, 1, 0, 0, 0, 58, 1446, 1, 0, 0, 0, 60, 1448, 1, 0, 0, 0, 62, 1470, 1, 0, 0, 0, 64, 1479, 1, 0, 0, 0, 66, 1482, 1, 0, 0, 0, 68, 1488, 1, 0, 0, 0, 70, 1502, 1, 0, 0, 0, 72, 1509, 1, 0, 0, 0, 74, 1525, 1, 0, 0, 0, 76, 1532, 1, 0, 0, 0, 78, 1536, 1, 0, 0, 0, 80, 1538, 1, 0, 0, 0, 82, 1554, 1, 0, 0, 0, 84, 1560, 1, 0, 0, 0, 86, 1577, 1, 0, 0, 0, 88, 1600, 1, 0, 0, 0, 90, 1638, 1, 0, 0, 0, 92, 1640, 1, 0, 0, 0, 94, 1646, 1, 0, 0, 0, 96, 1660, 1, 0, 0, 0, 98, 1680, 1, 0, 0, 0, 100, 1692, 1, 0, 0, 0, 102, 1703, 1, 0, 0, 0, 104, 1705, 1, 0, 0, 0, 106, 1717, 1, 0, 0, 0, 108, 1724, 1, 0, 0, 0, 110, 1741, 1, 0, 0, 0, 112, 1743, 1, 0, 0, 0, 114, 1760, 1, 0, 0, 0, 116, 1775, 1, 0, 0, 0, 118, 1786, 1, 0, 0, 0, 120, 1797, 1, 0, 0, 0, 122, 1807, 1, 0, 0, 0, 124, 1816, 1, 0, 0, 0, 126, 1833, 1, 0, 0, 0, 128, 1851, 1, 0, 0, 0, 130, 1858, 1, 0, 0, 0, 132, 1868, 1, 0, 0, 0, 134, 1877, 1, 0, 0, 0, 136, 1897, 1, 0, 0, 0, 138, 1899, 1, 0, 0, 0, 140, 1913, 1, 0, 0, 0, 142, 1917, 1, 0, 0, 0, 144, 1926, 1, 0, 0, 0, 146, 1930, 1, 0, 0, 0, 148, 1945, 1, 0, 0, 0, 150, 1958, 1, 0, 0, 0, 152, 1963, 1, 0, 0, 0, 154, 1970, 1, 0, 0, 0, 156, 1988, 1, 0, 0, 0, 158, 1990, 1, 0, 0, 0, 160, 1999, 1, 0, 0, 0, 162, 2028, 1, 0, 0, 0, 164, 2031, 1, 0, 0, 0, 166, 2036, 1, 0, 0, 0, 168, 2040, 1, 0, 0, 0, 170, 2051, 1, 0, 0, 0, 172, 2054, 1, 0, 0, 0, 174, 2061, 1, 0, 0, 0, 176, 2068, 1, 0, 0, 0, 178, 2097, 1, 0, 0, 0, 180, 2104, 1, 0, 0, 0, 182, 2107, 1, 0, 0, 0, 184, 2127, 1, 0, 0, 0, 186, 2134, 1, 0, 0, 0, 188, 2142, 1, 0, 0, 0, 190, 2158, 1, 0, 0, 0, 192, 2178, 1, 0, 0, 0, 194, 2181, 1, 0, 0, 0, 196, 2192, 1, 0, 0, 0, 198, 2203, 1, 0, 0, 0, 200, 2213, 1, 0, 0, 0, 202, 2222, 1, 0, 0, 0, 204, 2224, 1, 0, 0, 0, 206, 2238, 1, 0, 0, 0, 208, 2245, 1, 0, 0, 0, 210, 2254, 1, 0, 0, 0, 212, 2259, 1, 0, 0, 0, 214, 2268, 1, 0, 0, 0, 216, 2277, 1, 0, 0, 0, 218, 2290, 1, 0, 0, 0, 220, 2292, 1, 0, 0, 0, 222, 2320, 1, 0, 0, 0, 224, 2339, 1, 0, 0, 0, 226, 2362, 1, 0, 0, 0, 228, 2369, 1, 0, 0, 0, 230, 2383, 1, 0, 0, 0, 232, 2390, 1, 0, 0, 0, 234, 2398, 1, 0, 0, 0, 236, 2406, 1, 0, 0, 0, 238, 2413, 1, 0, 0, 0, 240, 2420, 1, 0, 0, 0, 242, 2428, 1, 0, 0, 0, 244, 2437, 1, 0, 0, 0, 246, 2446, 1, 0, 0, 0, 248, 2455, 1, 0, 0, 0, 250, 2464, 1, 0, 0, 0, 252, 2472, 1, 0, 0, 0, 254, 2479, 1, 0, 0, 0, 256, 2494, 1, 0, 0, 0, 258, 2503, 1, 0, 0, 0, 260, 2545, 1, 0, 0, 0, 262, 2548, 1, 0, 0, 0, 264, 2550, 1, 0, 0, 0, 266, 2552, 1, 0, 0, 0, 268, 2555, 1, 0, 0, 0, 270, 2557, 1, 0, 0, 0, 272, 2559, 1, 0, 0, 0, 274, 2561, 1, 0, 0, 0, 276, 2563, 1, 0, 0, 0, 278, 2571, 1, 0, 0, 0, 280, 2585, 1, 0, 0, 0, 282, 2599, 1, 0, 0, 0, 284, 2607, 1, 0, 0, 0, 286, 2615, 1, 0, 0, 0, 288, 2621, 1, 0, 0, 0, 290, 2627, 1, 0, 0, 0, 292, 2633, 1, 0, 0, 0, 294, 2641, 1, 0, 0, 0, 296, 2644, 1, 0, 0, 0, 298, 2647, 1, 0, 0, 0, 300, 2653, 1, 0, 0, 0, 302, 2659, 1, 0, 0, 0, 304, 2667, 1, 0, 0, 0, 306, 2676, 1, 0, 0, 0, 308, 2678, 1, 0, 0, 0, 310, 2680, 1, 0, 0, 0, 312, 2682, 1, 0, 0, 0, 314, 2696, 1, 0, 0, 0, 316, 2701, 1, 0, 0, 0, 318, 2703, 1, 0, 0, 0, 320, 2705, 1, 0, 0, 0, 322, 2714, 1, 0, 0, 0, 324, 2720, 1, 0, 0, 0, 326, 2743, 1, 0, 0, 0, 328, 2747, 1, 0, 0, 0, 330, 2762, 1, 0, 0, 0, 332, 2765, 1, 0, 0, 0, 334, 2769, 1, 0, 0, 0, 336, 2773, 1, 0, 0, 0, 338, 2779, 1, 0, 0, 0, 340, 2781, 1, 0, 0, 0, 342, 2795, 1, 0, 0, 0, 344, 2805, 1, 0, 0, 0, 346, 2830, 1, 0, 0, 0, 348, 2836, 1, 0, 0, 0, 350, 2845, 1, 0, 0, 0, 352, 2849, 1, 0, 0, 0, 354, 2854, 1, 0, 0, 0, 356, 2866, 1, 0, 0, 0, 358, 2874, 1, 0, 0, 0, 360, 2877, 1, 0, 0, 0, 362, 2887, 1, 0, 0, 0, 364, 2890, 1, 0, 0, 0, 366, 2893, 1, 0, 0, 0, 368, 2899, 1, 0, 0, 0, 370, 2907, 1, 0, 0, 0, 372, 2916, 1, 0, 0, 0, 374, 2922, 1, 0, 0, 0, 376, 2946, 1, 0, 0, 0, 378, 2962, 1, 0, 0, 0, 380, 2967, 1, 0, 0, 0, 382, 2972, 1, 0, 0, 0, 384, 2978, 1, 0, 0, 0, 386, 2983, 1, 0, 0, 0, 388, 2993, 1, 0, 0, 0, 390, 3000, 1, 0, 0, 0, 392, 3005, 1, 0, 0, 0, 394, 3007, 1, 0, 0, 0, 396, 3013, 1, 0, 0, 0, 398, 3024, 1, 0, 0, 0, 400, 3026, 1, 0, 0, 0, 402, 3035, 1, 0, 0, 0, 404, 3051, 1, 0, 0, 0, 406, 3059, 1, 0, 0, 0, 408, 3076, 1, 0, 0, 0, 410, 3080, 1, 0, 0, 0, 412, 3086, 1, 0, 0, 0, 414, 3092, 1, 0, 0, 0, 416, 3097, 1, 0, 0, 0, 418, 3111, 1, 0, 0, 0, 420, 3114, 1, 0, 0, 0, 422, 3117, 1, 0, 0, 0, 424, 3125, 1, 0, 0, 0, 426, 3127, 1, 0, 0, 0, 428, 3135, 1, 0, 0, 0, 430, 3138, 1, 0, 0, 0, 432, 3143, 1, 0, 0, 0, 434, 3151, 1, 0, 0, 0, 436, 3153, 1, 0, 0, 0, 438, 3186, 1, 0, 0, 0, 440, 3191, 1, 0, 0, 0, 442, 3197, 1, 0, 0, 0, 444, 3204, 1, 0, 0, 0, 446, 3206, 1, 0, 0, 0, 448, 3212, 1, 0, 0, 0, 450, 3215, 1, 0, 0, 0, 452, 3223, 1, 0, 0, 0, 454, 3227, 1, 0, 0, 0, 456, 3229, 1, 0, 0, 0, 458, 3233, 1, 0, 0, 0, 460, 3268, 1, 0, 0, 0, 462, 3271, 1, 0, 0, 0, 464, 3283, 1, 0, 0, 0, 466, 3297, 1, 0, 0, 0, 468, 3317, 1, 0, 0, 0, 470, 3319, 1, 0, 0, 0, 472, 3324, 1, 0, 0, 0, 474, 3331, 1, 0, 0, 0, 476, 3334, 1, 0, 0, 0, 478, 3337, 1, 0, 0, 0, 480, 3347, 1, 0, 0, 0, 482, 3356, 1, 0, 0, 0, 484, 3361, 1, 0, 0, 0, 486, 3365, 1, 0, 0, 0, 488, 3372, 1, 0, 0, 0, 490, 3380, 1, 0, 0, 0, 492, 3417, 1, 0, 0, 0, 494, 3434, 1, 0, 0, 0, 496, 3446, 1, 0, 0, 0, 498, 3452, 1, 0, 0, 0, 500, 3454, 1, 0, 0, 0, 502, 3458, 1, 0, 0, 0, 504, 3463, 1, 0, 0, 0, 506, 3477, 1, 0, 0, 0, 508, 3483, 1, 0, 0, 0, 510, 3488, 1, 0, 0, 0, 512, 3494, 1, 0, 0, 0, 514, 3509, 1, 0, 0, 0, 516, 3512, 1, 0, 0, 0, 518, 3523, 1, 0, 0, 0, 520, 3525, 1, 0, 0, 0, 522, 3536, 1, 0, 0, 0, 524, 3542, 1, 0, 0, 0, 526, 3547, 1, 0, 0, 0, 528, 3554, 1, 0, 0, 0, 530, 3561, 1, 0, 0, 0, 532, 3570, 1, 0, 0, 0, 534, 3584, 1, 0, 0, 0, 536, 3638, 1, 0, 0, 0, 538, 3640, 1, 0, 0, 0, 540, 3657, 1, 0, 0, 0, 542, 3679, 1, 0, 0, 0, 544, 3682, 1, 0, 0, 0, 546, 3687, 1, 0, 0, 0, 548, 3691, 1, 0, 0, 0, 550, 3707, 1, 0, 0, 0, 552, 3718, 1, 0, 0, 0, 554, 3736, 1, 0, 0, 0, 556, 3743, 1, 0, 0, 0, 558, 3745, 1, 0, 0, 0, 560, 3751, 1, 0, 0, 0, 562, 3753, 1, 0, 0, 0, 564, 3757, 1, 0, 0, 0, 566, 3763, 1, 0, 0, 0, 568, 3769, 1, 0, 0, 0, 570, 3777, 1, 0, 0, 0, 572, 3800, 1, 0, 0, 0, 574, 3809, 1, 0, 0, 0, 576, 3815, 1, 0, 0, 0, 578, 3834, 1, 0, 0, 0, 580, 3837, 1, 0, 0, 0, 582, 3851, 1, 0, 0, 0, 584, 3858, 1, 0, 0, 0, 586, 3877, 1, 0, 0, 0, 588, 3879, 1, 0, 0, 0, 590, 3882, 1, 0, 0, 0, 592, 3893, 1, 0, 0, 0, 594, 3895, 1, 0, 0, 0, 596, 3901, 1, 0, 0, 0, 598, 3907, 1, 0, 0, 0, 600, 3925, 1, 0, 0, 0, 602, 3939, 1, 0, 0, 0, 604, 3952, 1, 0, 0, 0, 606, 3954, 1, 0, 0, 0, 608, 3960, 1, 0, 0, 0, 610, 3965, 1, 0, 0, 0, 612, 3973, 1, 0, 0, 0, 614, 3990, 1, 0, 0, 0, 616, 3994, 1, 0, 0, 0, 618, 3996, 1, 0, 0, 0, 620, 4010, 1, 0, 0, 0, 622, 4029, 1, 0, 0, 0, 624, 4046, 1, 0, 0, 0, 626, 4048, 1, 0, 0, 0, 628, 4053, 1, 0, 0, 0, 630, 4059, 1, 0, 0, 0, 632, 4064, 1, 0, 0, 0, 634, 4086, 1, 0, 0, 0, 636, 4092, 1, 0, 0, 0, 638, 4100, 1, 0, 0, 0, 640, 4108, 1, 0, 0, 0, 642, 4114, 1, 0, 0, 0, 644, 4118, 1, 0, 0, 0, 646, 4122, 1, 0, 0, 0, 648, 4125, 1, 0, 0, 0, 650, 4144, 1, 0, 0, 0, 652, 4154, 1, 0, 0, 0, 654, 4177, 1, 0, 0, 0, 656, 4179, 1, 0, 0, 0, 658, 4183, 1, 0, 0, 0, 660, 4193, 1, 0, 0, 0, 662, 4211, 1, 0, 0, 0, 664, 4213, 1, 0, 0, 0, 666, 4216, 1, 0, 0, 0, 668, 4219, 1, 0, 0, 0, 670, 4230, 1, 0, 0, 0, 672, 4233, 1, 0, 0, 0, 674, 4238, 1, 0, 0, 0, 676, 4243, 1, 0, 0, 0, 678, 4247, 1, 0, 0, 0, 680, 4261, 1, 0, 0, 0, 682, 4263, 1, 0, 0, 0, 684, 4267, 1, 0, 0, 0, 686, 4270, 1, 0, 0, 0, 688, 4272, 1, 0, 0, 0, 690, 4280, 1, 0, 0, 0, 692, 4295, 1, 0, 0, 0, 694, 4297, 1, 0, 0, 0, 696, 4307, 1, 0, 0, 0, 698, 4319, 1, 0, 0, 0, 700, 4330, 1, 0, 0, 0, 702, 4339, 1, 0, 0, 0, 704, 4345, 1, 0, 0, 0, 706, 4354, 1, 0, 0, 0, 708, 4360, 1, 0, 0, 0, 710, 4368, 1, 0, 0, 0, 712, 4374, 1, 0, 0, 0, 714, 4381, 1, 0, 0, 0, 716, 4392, 1, 0, 0, 0, 718, 4404, 1, 0, 0, 0, 720, 4412, 1, 0, 0, 0, 722, 4419, 1, 0, 0, 0, 724, 4427, 1, 0, 0, 0, 726, 4433, 1, 0, 0, 0, 728, 4441, 1, 0, 0, 0, 730, 4451, 1, 0, 0, 0, 732, 4460, 1, 0, 0, 0, 734, 4465, 1, 0, 0, 0, 736, 4470, 1, 0, 0, 0, 738, 4478, 1, 0, 0, 0, 740, 4504, 1, 0, 0, 0, 742, 4516, 1, 0, 0, 0, 744, 4534, 1, 0, 0, 0, 746, 4541, 1, 0, 0, 0, 748, 4549, 1, 0, 0, 0, 750, 4555, 1, 0, 0, 0, 752, 4564, 1, 0, 0, 0, 754, 4567, 1, 0, 0, 0, 756, 4573, 1, 0, 0, 0, 758, 4585, 1, 0, 0, 0, 760, 4593, 1, 0, 0, 0, 762, 4602, 1, 0, 0, 0, 764, 4604, 1, 0, 0, 0, 766, 4612, 1, 0, 0, 0, 768, 4614, 1, 0, 0, 0, 770, 4634, 1, 0, 0, 0, 772, 4638, 1, 0, 0, 0, 774, 4642, 1, 0, 0, 0, 776, 4651, 1, 0, 0, 0, 778, 4653, 1, 0, 0, 0, 780, 4657, 1, 0, 0, 0, 782, 4666, 1, 0, 0, 0, 784, 4672, 1, 0, 0, 0, 786, 4681, 1, 0, 0, 0, 788, 4687, 1, 0, 0, 0, 790, 4695, 1, 0, 0, 0, 792, 4701, 1, 0, 0, 0, 794, 4707, 1, 0, 0, 0, 796, 4713, 1, 0, 0, 0, 798, 4723, 1, 0, 0, 0, 800, 4734, 1, 0, 0, 0, 802, 4738, 1, 0, 0, 0, 804, 4743, 1, 0, 0, 0, 806, 4755, 1, 0, 0, 0, 808, 4757, 1, 0, 0, 0, 810, 4767, 1, 0, 0, 0, 812, 4773, 1, 0, 0, 0, 814, 4776, 1, 0, 0, 0, 816, 4782, 1, 0, 0, 0, 818, 4789, 1, 0, 0, 0, 820, 4794, 1, 0, 0, 0, 822, 4800, 1, 0, 0, 0, 824, 4832, 1, 0, 0, 0, 826, 4836, 1, 0, 0, 0, 828, 4843, 1, 0, 0, 0, 830, 4849, 1, 0, 0, 0, 832, 4863, 1, 0, 0, 0, 834, 4882, 1, 0, 0, 0, 836, 4884, 1, 0, 0, 0, 838, 4896, 1, 0, 0, 0, 840, 4904, 1, 0, 0, 0, 842, 4912, 1, 0, 0, 0, 844, 4921, 1, 0, 0, 0, 846, 4926, 1, 0, 0, 0, 848, 4932, 1, 0, 0, 0, 850, 4940, 1, 0, 0, 0, 852, 4946, 1, 0, 0, 0, 854, 4952, 1, 0, 0, 0, 856, 4967, 1, 0, 0, 0, 858, 4970, 1, 0, 0, 0, 860, 4984, 1, 0, 0, 0, 862, 4987, 1, 0, 0, 0, 864, 5006, 1, 0, 0, 0, 866, 5009, 1, 0, 0, 0, 868, 5021, 1, 0, 0, 0, 870, 5034, 1, 0, 0, 0, 872, 5048, 1, 0, 0, 0, 874, 5052, 1, 0, 0, 0, 876, 5055, 1, 0, 0, 0, 878, 5062, 1, 0, 0, 0, 880, 5066, 1, 0, 0, 0, 882, 5075, 1, 0, 0, 0, 884, 5079, 1, 0, 0, 0, 886, 5084, 1, 0, 0, 0, 888, 5086, 1, 0, 0, 0, 890, 5096, 1, 0, 0, 0, 892, 5107, 1, 0, 0, 0, 894, 5119, 1, 0, 0, 0, 896, 5130, 1, 0, 0, 0, 898, 5134, 1, 0, 0, 0, 900, 5136, 1, 0, 0, 0, 902, 5168, 1, 0, 0, 0, 904, 5180, 1, 0, 0, 0, 906, 5190, 1, 0, 0, 0, 908, 5208, 1, 0, 0, 0, 910, 5215, 1, 0, 0, 0, 912, 5223, 1, 0, 0, 0, 914, 5232, 1, 0, 0, 0, 916, 5235, 1, 0, 0, 0, 918, 5241, 1, 0, 0, 0, 920, 5250, 1, 0, 0, 0, 922, 5253, 1, 0, 0, 0, 924, 5259, 1, 0, 0, 0, 926, 5271, 1, 0, 0, 0, 928, 5285, 1, 0, 0, 0, 930, 5320, 1, 0, 0, 0, 932, 5325, 1, 0, 0, 0, 934, 5345, 1, 0, 0, 0, 936, 5355, 1, 0, 0, 0, 938, 5357, 1, 0, 0, 0, 940, 5366, 1, 0, 0, 0, 942, 5371, 1, 0, 0, 0, 944, 5375, 1, 0, 0, 0, 946, 5380, 1, 0, 0, 0, 948, 5396, 1, 0, 0, 0, 950, 5407, 1, 0, 0, 0, 952, 5419, 1, 0, 0, 0, 954, 5426, 1, 0, 0, 0, 956, 5428, 1, 0, 0, 0, 958, 5434, 1, 0, 0, 0, 960, 5436, 1, 0, 0, 0, 962, 5440, 1, 0, 0, 0, 964, 5444, 1, 0, 0, 0, 966, 5447, 1, 0, 0, 0, 968, 5465, 1, 0, 0, 0, 970, 5475, 1, 0, 0, 0, 972, 5486, 1, 0, 0, 0, 974, 5494, 1, 0, 0, 0, 976, 5500, 1, 0, 0, 0, 978, 5507, 1, 0, 0, 0, 980, 5513, 1, 0, 0, 0, 982, 5520, 1, 0, 0, 0, 984, 5525, 1, 0, 0, 0, 986, 5531, 1, 0, 0, 0, 988, 5537, 1, 0, 0, 0, 990, 5559, 1, 0, 0, 0, 992, 5562, 1, 0, 0, 0, 994, 5585, 1, 0, 0, 0, 996, 5587, 1, 0, 0, 0, 998, 5610, 1, 0, 0, 0, 1000, 5615, 1, 0, 0, 0, 1002, 5624, 1, 0, 0, 0, 1004, 5628, 1, 0, 0, 0, 1006, 5633, 1, 0, 0, 0, 1008, 5636, 1, 0, 0, 0, 1010, 5645, 1, 0, 0, 0, 1012, 5657, 1, 0, 0, 0, 1014, 5666, 1, 0, 0, 0, 1016, 5677, 1, 0, 0, 0, 1018, 5687, 1, 0, 0, 0, 1020, 5699, 1, 0, 0, 0, 1022, 5708, 1, 0, 0, 0, 1024, 5720, 1, 0, 0, 0, 1026, 5730, 1, 0, 0, 0, 1028, 5743, 1, 0, 0, 0, 1030, 5752, 1, 0, 0, 0, 1032, 5763, 1, 0, 0, 0, 1034, 5770, 1, 0, 0, 0, 1036, 5773, 1, 0, 0, 0, 1038, 5780, 1, 0, 0, 0, 1040, 5784, 1, 0, 0, 0, 1042, 5793, 1, 0, 0, 0, 1044, 5802, 1, 0, 0, 0, 1046, 5804, 1, 0, 0, 0, 1048, 5811, 1, 0, 0, 0, 1050, 5821, 1, 0, 0, 0, 1052, 5832, 1, 0, 0, 0, 1054, 5834, 1, 0, 0, 0, 1056, 5850, 1, 0, 0, 0, 1058, 5874, 1, 0, 0, 0, 1060, 5890, 1, 0, 0, 0, 1062, 5892, 1, 0, 0, 0, 1064, 5901, 1, 0, 0, 0, 1066, 5905, 1, 0, 0, 0, 1068, 5911, 1, 0, 0, 0, 1070, 5919, 1, 0, 0, 0, 1072, 5965, 1, 0, 0, 0, 1074, 5982, 1, 0, 0, 0, 1076, 5984, 1, 0, 0, 0, 1078, 6006, 1, 0, 0, 0, 1080, 6029, 1, 0, 0, 0, 1082, 6037, 1, 0, 0, 0, 1084, 6039, 1, 0, 0, 0, 1086, 6052, 1, 0, 0, 0, 1088, 6065, 1, 0, 0, 0, 1090, 6071, 1, 0, 0, 0, 1092, 6075, 1, 0, 0, 0, 1094, 6088, 1, 0, 0, 0, 1096, 6091, 1, 0, 0, 0, 1098, 6094, 1, 0, 0, 0, 1100, 6099, 1, 0, 0, 0, 1102, 6101, 1, 0, 0, 0, 1104, 6104, 1, 0, 0, 0, 1106, 6107, 1, 0, 0, 0, 1108, 6110, 1, 0, 0, 0, 1110, 6113, 1, 0, 0, 0, 1112, 6116, 1, 0, 0, 0, 1114, 6119, 1, 0, 0, 0, 1116, 6121, 1, 0, 0, 0, 1118, 6123, 1, 0, 0, 0, 1120, 6125, 1, 0, 0, 0, 1122, 6127, 1, 0, 0, 0, 1124, 6129, 1, 0, 0, 0, 1126, 6131, 1, 0, 0, 0, 1128, 6133, 1, 0, 0, 0, 1130, 6138, 1, 0, 0, 0, 1132, 6140, 1, 0, 0, 0, 1134, 6142, 1, 0, 0, 0, 1136, 6150, 1, 0, 0, 0, 1138, 6152, 1, 0, 0, 0, 1140, 6154, 1, 0, 0, 0, 1142, 6156, 1, 0, 0, 0, 1144, 6158, 1, 0, 0, 0, 1146, 6160, 1, 0, 0, 0, 1148, 6164, 1, 0, 0, 0, 1150, 6171, 1, 0, 0, 0, 1152, 6175, 1, 0, 0, 0, 1154, 6177, 1, 0, 0, 0, 1156, 6179, 1, 0, 0, 0, 1158, 6181, 1, 0, 0, 0, 1160, 6183, 1, 0, 0, 0, 1162, 6187, 1, 0, 0, 0, 1164, 6189, 1, 0, 0, 0, 1166, 6191, 1, 0, 0, 0, 1168, 6193, 1, 0, 0, 0, 1170, 6195, 1, 0, 0, 0, 1172, 6203, 1, 0, 0, 0, 1174, 6205, 1, 0, 0, 0, 1176, 6210, 1, 0, 0, 0, 1178, 6212, 1, 0, 0, 0, 1180, 6214, 1, 0, 0, 0, 1182, 6222, 1, 0, 0, 0, 1184, 6245, 1, 0, 0, 0, 1186, 6280, 1, 0, 0, 0, 1188, 6283, 1, 0, 0, 0, 1190, 1191, 3, 2, 1, 0, 1191, 1192, 5, 0, 0, 1, 1192, 1, 1, 0, 0, 0, 1193, 1195, 3, 4, 2, 0, 1194, 1193, 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 1194, 1, 0, 0, 0, 1196, 1197, 1, 0, 0, 0, 1197, 3, 1, 0, 0, 0, 1198, 1200, 3, 8, 4, 0, 1199, 1201, 3, 26, 13, 0, 1200, 1199, 1, 0, 0, 0, 1200, 1201, 1, 0, 0, 0, 1201, 1203, 1, 0, 0, 0, 1202, 1204, 3, 154, 77, 0, 1203, 1202, 1, 0, 0, 0, 1203, 1204, 1, 0, 0, 0, 1204, 1206, 1, 0, 0, 0, 1205, 1207, 3, 504, 252, 0, 1206, 1205, 1, 0, 0, 0, 1206, 1207, 1, 0, 0, 0, 1207, 1211, 1, 0, 0, 0, 1208, 1210, 3, 4, 2, 0, 1209, 1208, 1, 0, 0, 0, 1210, 1213, 1, 0, 0, 0, 1211, 1209, 1, 0, 0, 0, 1211, 1212, 1, 0, 0, 0, 1212, 1215, 1, 0, 0, 0, 1213, 1211, 1, 0, 0, 0, 1214, 1216, 3, 6, 3, 0, 1215, 1214, 1, 0, 0, 0, 1215, 1216, 1, 0, 0, 0, 1216, 5, 1, 0, 0, 0, 1217, 1218, 5, 158, 0, 0, 1218, 1219, 5, 361, 0, 0, 1219, 1220, 3, 1152, 576, 0, 1220, 1221, 5, 534, 0, 0, 1221, 7, 1, 0, 0, 0, 1222, 1223, 7, 0, 0, 0, 1223, 1224, 5, 145, 0, 0, 1224, 1225, 5, 534, 0, 0, 1225, 1229, 3, 12, 6, 0, 1226, 1228, 3, 10, 5, 0, 1227, 1226, 1, 0, 0, 0, 1228, 1231, 1, 0, 0, 0, 1229, 1227, 1, 0, 0, 0, 1229, 1230, 1, 0, 0, 0, 1230, 9, 1, 0, 0, 0, 1231, 1229, 1, 0, 0, 0, 1232, 1239, 3, 14, 7, 0, 1233, 1239, 3, 16, 8, 0, 1234, 1239, 3, 18, 9, 0, 1235, 1239, 3, 20, 10, 0, 1236, 1239, 3, 22, 11, 0, 1237, 1239, 3, 24, 12, 0, 1238, 1232, 1, 0, 0, 0, 1238, 1233, 1, 0, 0, 0, 1238, 1234, 1, 0, 0, 0, 1238, 1235, 1, 0, 0, 0, 1238, 1236, 1, 0, 0, 0, 1238, 1237, 1, 0, 0, 0, 1239, 11, 1, 0, 0, 0, 1240, 1241, 5, 362, 0, 0, 1241, 1242, 5, 534, 0, 0, 1242, 1250, 3, 1152, 576, 0, 1243, 1245, 5, 254, 0, 0, 1244, 1243, 1, 0, 0, 0, 1244, 1245, 1, 0, 0, 0, 1245, 1246, 1, 0, 0, 0, 1246, 1248, 7, 1, 0, 0, 1247, 1249, 5, 361, 0, 0, 1248, 1247, 1, 0, 0, 0, 1248, 1249, 1, 0, 0, 0, 1249, 1251, 1, 0, 0, 0, 1250, 1244, 1, 0, 0, 0, 1250, 1251, 1, 0, 0, 0, 1251, 1253, 1, 0, 0, 0, 1252, 1254, 5, 534, 0, 0, 1253, 1252, 1, 0, 0, 0, 1253, 1254, 1, 0, 0, 0, 1254, 1256, 1, 0, 0, 0, 1255, 1257, 3, 1188, 594, 0, 1256, 1255, 1, 0, 0, 0, 1256, 1257, 1, 0, 0, 0, 1257, 13, 1, 0, 0, 0, 1258, 1259, 5, 32, 0, 0, 1259, 1261, 5, 534, 0, 0, 1260, 1262, 3, 1188, 594, 0, 1261, 1260, 1, 0, 0, 0, 1261, 1262, 1, 0, 0, 0, 1262, 15, 1, 0, 0, 0, 1263, 1264, 5, 249, 0, 0, 1264, 1266, 5, 534, 0, 0, 1265, 1267, 3, 1188, 594, 0, 1266, 1265, 1, 0, 0, 0, 1266, 1267, 1, 0, 0, 0, 1267, 17, 1, 0, 0, 0, 1268, 1269, 5, 113, 0, 0, 1269, 1271, 5, 534, 0, 0, 1270, 1272, 3, 1188, 594, 0, 1271, 1270, 1, 0, 0, 0, 1271, 1272, 1, 0, 0, 0, 1272, 19, 1, 0, 0, 0, 1273, 1274, 5, 112, 0, 0, 1274, 1276, 5, 534, 0, 0, 1275, 1277, 3, 1188, 594, 0, 1276, 1275, 1, 0, 0, 0, 1276, 1277, 1, 0, 0, 0, 1277, 21, 1, 0, 0, 0, 1278, 1279, 5, 421, 0, 0, 1279, 1281, 5, 534, 0, 0, 1280, 1282, 3, 1188, 594, 0, 1281, 1280, 1, 0, 0, 0, 1281, 1282, 1, 0, 0, 0, 1282, 23, 1, 0, 0, 0, 1283, 1284, 5, 389, 0, 0, 1284, 1286, 5, 534, 0, 0, 1285, 1287, 3, 1188, 594, 0, 1286, 1285, 1, 0, 0, 0, 1286, 1287, 1, 0, 0, 0, 1287, 25, 1, 0, 0, 0, 1288, 1289, 5, 184, 0, 0, 1289, 1290, 5, 145, 0, 0, 1290, 1294, 5, 534, 0, 0, 1291, 1293, 3, 28, 14, 0, 1292, 1291, 1, 0, 0, 0, 1293, 1296, 1, 0, 0, 0, 1294, 1292, 1, 0, 0, 0, 1294, 1295, 1, 0, 0, 0, 1295, 27, 1, 0, 0, 0, 1296, 1294, 1, 0, 0, 0, 1297, 1301, 3, 30, 15, 0, 1298, 1301, 3, 54, 27, 0, 1299, 1301, 3, 100, 50, 0, 1300, 1297, 1, 0, 0, 0, 1300, 1298, 1, 0, 0, 0, 1300, 1299, 1, 0, 0, 0, 1301, 29, 1, 0, 0, 0, 1302, 1303, 5, 93, 0, 0, 1303, 1304, 5, 419, 0, 0, 1304, 1308, 5, 534, 0, 0, 1305, 1307, 3, 32, 16, 0, 1306, 1305, 1, 0, 0, 0, 1307, 1310, 1, 0, 0, 0, 1308, 1306, 1, 0, 0, 0, 1308, 1309, 1, 0, 0, 0, 1309, 31, 1, 0, 0, 0, 1310, 1308, 1, 0, 0, 0, 1311, 1315, 3, 34, 17, 0, 1312, 1315, 3, 36, 18, 0, 1313, 1315, 3, 54, 27, 0, 1314, 1311, 1, 0, 0, 0, 1314, 1312, 1, 0, 0, 0, 1314, 1313, 1, 0, 0, 0, 1315, 33, 1, 0, 0, 0, 1316, 1317, 5, 449, 0, 0, 1317, 1318, 5, 534, 0, 0, 1318, 1324, 3, 1124, 562, 0, 1319, 1321, 5, 514, 0, 0, 1320, 1319, 1, 0, 0, 0, 1320, 1321, 1, 0, 0, 0, 1321, 1322, 1, 0, 0, 0, 1322, 1323, 5, 125, 0, 0, 1323, 1325, 5, 297, 0, 0, 1324, 1320, 1, 0, 0, 0, 1324, 1325, 1, 0, 0, 0, 1325, 1326, 1, 0, 0, 0, 1326, 1327, 5, 534, 0, 0, 1327, 35, 1, 0, 0, 0, 1328, 1329, 5, 320, 0, 0, 1329, 1330, 5, 534, 0, 0, 1330, 1334, 3, 1124, 562, 0, 1331, 1333, 3, 38, 19, 0, 1332, 1331, 1, 0, 0, 0, 1333, 1336, 1, 0, 0, 0, 1334, 1332, 1, 0, 0, 0, 1334, 1335, 1, 0, 0, 0, 1335, 1337, 1, 0, 0, 0, 1336, 1334, 1, 0, 0, 0, 1337, 1338, 5, 534, 0, 0, 1338, 37, 1, 0, 0, 0, 1339, 1345, 3, 40, 20, 0, 1340, 1345, 3, 42, 21, 0, 1341, 1345, 3, 44, 22, 0, 1342, 1345, 3, 50, 25, 0, 1343, 1345, 3, 52, 26, 0, 1344, 1339, 1, 0, 0, 0, 1344, 1340, 1, 0, 0, 0, 1344, 1341, 1, 0, 0, 0, 1344, 1342, 1, 0, 0, 0, 1344, 1343, 1, 0, 0, 0, 1345, 39, 1, 0, 0, 0, 1346, 1348, 5, 293, 0, 0, 1347, 1349, 5, 439, 0, 0, 1348, 1347, 1, 0, 0, 0, 1348, 1349, 1, 0, 0, 0, 1349, 1352, 1, 0, 0, 0, 1350, 1353, 3, 1178, 589, 0, 1351, 1353, 3, 1170, 585, 0, 1352, 1350, 1, 0, 0, 0, 1352, 1351, 1, 0, 0, 0, 1353, 1355, 1, 0, 0, 0, 1354, 1356, 7, 2, 0, 0, 1355, 1354, 1, 0, 0, 0, 1355, 1356, 1, 0, 0, 0, 1356, 41, 1, 0, 0, 0, 1357, 1359, 5, 141, 0, 0, 1358, 1360, 5, 439, 0, 0, 1359, 1358, 1, 0, 0, 0, 1359, 1360, 1, 0, 0, 0, 1360, 1362, 1, 0, 0, 0, 1361, 1363, 5, 254, 0, 0, 1362, 1361, 1, 0, 0, 0, 1362, 1363, 1, 0, 0, 0, 1363, 1366, 1, 0, 0, 0, 1364, 1367, 3, 1178, 589, 0, 1365, 1367, 3, 1170, 585, 0, 1366, 1364, 1, 0, 0, 0, 1366, 1365, 1, 0, 0, 0, 1367, 1369, 1, 0, 0, 0, 1368, 1370, 7, 3, 0, 0, 1369, 1368, 1, 0, 0, 0, 1369, 1370, 1, 0, 0, 0, 1370, 43, 1, 0, 0, 0, 1371, 1373, 5, 361, 0, 0, 1372, 1371, 1, 0, 0, 0, 1372, 1373, 1, 0, 0, 0, 1373, 1375, 1, 0, 0, 0, 1374, 1376, 5, 72, 0, 0, 1375, 1374, 1, 0, 0, 0, 1375, 1376, 1, 0, 0, 0, 1376, 1377, 1, 0, 0, 0, 1377, 1379, 5, 428, 0, 0, 1378, 1380, 5, 254, 0, 0, 1379, 1378, 1, 0, 0, 0, 1379, 1380, 1, 0, 0, 0, 1380, 1382, 1, 0, 0, 0, 1381, 1383, 3, 1114, 557, 0, 1382, 1381, 1, 0, 0, 0, 1383, 1384, 1, 0, 0, 0, 1384, 1382, 1, 0, 0, 0, 1384, 1385, 1, 0, 0, 0, 1385, 1387, 1, 0, 0, 0, 1386, 1388, 3, 46, 23, 0, 1387, 1386, 1, 0, 0, 0, 1387, 1388, 1, 0, 0, 0, 1388, 1390, 1, 0, 0, 0, 1389, 1391, 3, 48, 24, 0, 1390, 1389, 1, 0, 0, 0, 1390, 1391, 1, 0, 0, 0, 1391, 45, 1, 0, 0, 0, 1392, 1394, 5, 212, 0, 0, 1393, 1392, 1, 0, 0, 0, 1393, 1394, 1, 0, 0, 0, 1394, 1395, 1, 0, 0, 0, 1395, 1397, 5, 14, 0, 0, 1396, 1398, 5, 254, 0, 0, 1397, 1396, 1, 0, 0, 0, 1397, 1398, 1, 0, 0, 0, 1398, 1399, 1, 0, 0, 0, 1399, 1400, 3, 1114, 557, 0, 1400, 47, 1, 0, 0, 0, 1401, 1403, 5, 212, 0, 0, 1402, 1401, 1, 0, 0, 0, 1402, 1403, 1, 0, 0, 0, 1403, 1404, 1, 0, 0, 0, 1404, 1406, 5, 304, 0, 0, 1405, 1407, 5, 254, 0, 0, 1406, 1405, 1, 0, 0, 0, 1406, 1407, 1, 0, 0, 0, 1407, 1408, 1, 0, 0, 0, 1408, 1409, 3, 1114, 557, 0, 1409, 49, 1, 0, 0, 0, 1410, 1412, 5, 423, 0, 0, 1411, 1413, 5, 254, 0, 0, 1412, 1411, 1, 0, 0, 0, 1412, 1413, 1, 0, 0, 0, 1413, 1414, 1, 0, 0, 0, 1414, 1415, 3, 1178, 589, 0, 1415, 51, 1, 0, 0, 0, 1416, 1417, 5, 62, 0, 0, 1417, 1418, 5, 430, 0, 0, 1418, 1419, 5, 534, 0, 0, 1419, 53, 1, 0, 0, 0, 1420, 1421, 5, 452, 0, 0, 1421, 1429, 5, 534, 0, 0, 1422, 1424, 3, 56, 28, 0, 1423, 1422, 1, 0, 0, 0, 1424, 1425, 1, 0, 0, 0, 1425, 1423, 1, 0, 0, 0, 1425, 1426, 1, 0, 0, 0, 1426, 1427, 1, 0, 0, 0, 1427, 1428, 5, 534, 0, 0, 1428, 1430, 1, 0, 0, 0, 1429, 1423, 1, 0, 0, 0, 1429, 1430, 1, 0, 0, 0, 1430, 55, 1, 0, 0, 0, 1431, 1443, 3, 70, 35, 0, 1432, 1443, 3, 92, 46, 0, 1433, 1443, 3, 58, 29, 0, 1434, 1443, 3, 72, 36, 0, 1435, 1443, 3, 80, 40, 0, 1436, 1443, 3, 82, 41, 0, 1437, 1443, 3, 96, 48, 0, 1438, 1443, 3, 88, 44, 0, 1439, 1443, 3, 86, 43, 0, 1440, 1443, 3, 84, 42, 0, 1441, 1443, 3, 94, 47, 0, 1442, 1431, 1, 0, 0, 0, 1442, 1432, 1, 0, 0, 0, 1442, 1433, 1, 0, 0, 0, 1442, 1434, 1, 0, 0, 0, 1442, 1435, 1, 0, 0, 0, 1442, 1436, 1, 0, 0, 0, 1442, 1437, 1, 0, 0, 0, 1442, 1438, 1, 0, 0, 0, 1442, 1439, 1, 0, 0, 0, 1442, 1440, 1, 0, 0, 0, 1442, 1441, 1, 0, 0, 0, 1443, 57, 1, 0, 0, 0, 1444, 1447, 3, 60, 30, 0, 1445, 1447, 3, 68, 34, 0, 1446, 1444, 1, 0, 0, 0, 1446, 1445, 1, 0, 0, 0, 1447, 59, 1, 0, 0, 0, 1448, 1449, 5, 10, 0, 0, 1449, 1452, 3, 1114, 557, 0, 1450, 1451, 5, 212, 0, 0, 1451, 1453, 5, 14, 0, 0, 1452, 1450, 1, 0, 0, 0, 1452, 1453, 1, 0, 0, 0, 1453, 1455, 1, 0, 0, 0, 1454, 1456, 5, 254, 0, 0, 1455, 1454, 1, 0, 0, 0, 1455, 1456, 1, 0, 0, 0, 1456, 1468, 1, 0, 0, 0, 1457, 1469, 5, 151, 0, 0, 1458, 1469, 5, 26, 0, 0, 1459, 1469, 5, 454, 0, 0, 1460, 1469, 5, 455, 0, 0, 1461, 1469, 5, 306, 0, 0, 1462, 1469, 3, 1170, 585, 0, 1463, 1465, 3, 62, 31, 0, 1464, 1463, 1, 0, 0, 0, 1465, 1466, 1, 0, 0, 0, 1466, 1464, 1, 0, 0, 0, 1466, 1467, 1, 0, 0, 0, 1467, 1469, 1, 0, 0, 0, 1468, 1457, 1, 0, 0, 0, 1468, 1458, 1, 0, 0, 0, 1468, 1459, 1, 0, 0, 0, 1468, 1460, 1, 0, 0, 0, 1468, 1461, 1, 0, 0, 0, 1468, 1462, 1, 0, 0, 0, 1468, 1464, 1, 0, 0, 0, 1469, 61, 1, 0, 0, 0, 1470, 1477, 3, 1172, 586, 0, 1471, 1478, 3, 64, 32, 0, 1472, 1474, 3, 66, 33, 0, 1473, 1472, 1, 0, 0, 0, 1474, 1475, 1, 0, 0, 0, 1475, 1473, 1, 0, 0, 0, 1475, 1476, 1, 0, 0, 0, 1476, 1478, 1, 0, 0, 0, 1477, 1471, 1, 0, 0, 0, 1477, 1473, 1, 0, 0, 0, 1477, 1478, 1, 0, 0, 0, 1478, 63, 1, 0, 0, 0, 1479, 1480, 7, 4, 0, 0, 1480, 1481, 3, 1172, 586, 0, 1481, 65, 1, 0, 0, 0, 1482, 1484, 5, 16, 0, 0, 1483, 1485, 3, 1172, 586, 0, 1484, 1483, 1, 0, 0, 0, 1485, 1486, 1, 0, 0, 0, 1486, 1484, 1, 0, 0, 0, 1486, 1487, 1, 0, 0, 0, 1487, 67, 1, 0, 0, 0, 1488, 1489, 5, 10, 0, 0, 1489, 1491, 3, 1114, 557, 0, 1490, 1492, 5, 212, 0, 0, 1491, 1490, 1, 0, 0, 0, 1491, 1492, 1, 0, 0, 0, 1492, 1493, 1, 0, 0, 0, 1493, 1495, 5, 304, 0, 0, 1494, 1496, 5, 254, 0, 0, 1495, 1494, 1, 0, 0, 0, 1495, 1496, 1, 0, 0, 0, 1496, 1500, 1, 0, 0, 0, 1497, 1501, 5, 306, 0, 0, 1498, 1499, 5, 55, 0, 0, 1499, 1501, 3, 1172, 586, 0, 1500, 1497, 1, 0, 0, 0, 1500, 1498, 1, 0, 0, 0, 1501, 69, 1, 0, 0, 0, 1502, 1503, 5, 61, 0, 0, 1503, 1505, 3, 1178, 589, 0, 1504, 1506, 5, 254, 0, 0, 1505, 1504, 1, 0, 0, 0, 1505, 1506, 1, 0, 0, 0, 1506, 1507, 1, 0, 0, 0, 1507, 1508, 3, 1146, 573, 0, 1508, 71, 1, 0, 0, 0, 1509, 1510, 5, 64, 0, 0, 1510, 1515, 3, 1122, 561, 0, 1511, 1513, 5, 212, 0, 0, 1512, 1511, 1, 0, 0, 0, 1512, 1513, 1, 0, 0, 0, 1513, 1514, 1, 0, 0, 0, 1514, 1516, 7, 5, 0, 0, 1515, 1512, 1, 0, 0, 0, 1515, 1516, 1, 0, 0, 0, 1516, 1518, 1, 0, 0, 0, 1517, 1519, 5, 254, 0, 0, 1518, 1517, 1, 0, 0, 0, 1518, 1519, 1, 0, 0, 0, 1519, 1521, 1, 0, 0, 0, 1520, 1522, 3, 74, 37, 0, 1521, 1520, 1, 0, 0, 0, 1522, 1523, 1, 0, 0, 0, 1523, 1521, 1, 0, 0, 0, 1523, 1524, 1, 0, 0, 0, 1524, 73, 1, 0, 0, 0, 1525, 1528, 3, 76, 38, 0, 1526, 1527, 7, 4, 0, 0, 1527, 1529, 3, 78, 39, 0, 1528, 1526, 1, 0, 0, 0, 1528, 1529, 1, 0, 0, 0, 1529, 75, 1, 0, 0, 0, 1530, 1533, 3, 1074, 537, 0, 1531, 1533, 3, 1172, 586, 0, 1532, 1530, 1, 0, 0, 0, 1532, 1531, 1, 0, 0, 0, 1533, 77, 1, 0, 0, 0, 1534, 1537, 3, 1074, 537, 0, 1535, 1537, 3, 1172, 586, 0, 1536, 1534, 1, 0, 0, 0, 1536, 1535, 1, 0, 0, 0, 1537, 79, 1, 0, 0, 0, 1538, 1540, 5, 107, 0, 0, 1539, 1541, 5, 438, 0, 0, 1540, 1539, 1, 0, 0, 0, 1540, 1541, 1, 0, 0, 0, 1541, 1543, 1, 0, 0, 0, 1542, 1544, 5, 254, 0, 0, 1543, 1542, 1, 0, 0, 0, 1543, 1544, 1, 0, 0, 0, 1544, 1545, 1, 0, 0, 0, 1545, 1552, 3, 1172, 586, 0, 1546, 1548, 5, 514, 0, 0, 1547, 1546, 1, 0, 0, 0, 1547, 1548, 1, 0, 0, 0, 1548, 1549, 1, 0, 0, 0, 1549, 1550, 5, 347, 0, 0, 1550, 1551, 5, 466, 0, 0, 1551, 1553, 3, 1172, 586, 0, 1552, 1547, 1, 0, 0, 0, 1552, 1553, 1, 0, 0, 0, 1553, 81, 1, 0, 0, 0, 1554, 1556, 5, 126, 0, 0, 1555, 1557, 5, 254, 0, 0, 1556, 1555, 1, 0, 0, 0, 1556, 1557, 1, 0, 0, 0, 1557, 1558, 1, 0, 0, 0, 1558, 1559, 5, 76, 0, 0, 1559, 83, 1, 0, 0, 0, 1560, 1562, 5, 128, 0, 0, 1561, 1563, 7, 6, 0, 0, 1562, 1561, 1, 0, 0, 0, 1562, 1563, 1, 0, 0, 0, 1563, 1568, 1, 0, 0, 0, 1564, 1566, 5, 438, 0, 0, 1565, 1567, 5, 254, 0, 0, 1566, 1565, 1, 0, 0, 0, 1566, 1567, 1, 0, 0, 0, 1567, 1569, 1, 0, 0, 0, 1568, 1564, 1, 0, 0, 0, 1568, 1569, 1, 0, 0, 0, 1569, 1571, 1, 0, 0, 0, 1570, 1572, 7, 7, 0, 0, 1571, 1570, 1, 0, 0, 0, 1571, 1572, 1, 0, 0, 0, 1572, 1573, 1, 0, 0, 0, 1573, 1575, 5, 427, 0, 0, 1574, 1576, 5, 62, 0, 0, 1575, 1574, 1, 0, 0, 0, 1575, 1576, 1, 0, 0, 0, 1576, 85, 1, 0, 0, 0, 1577, 1582, 5, 129, 0, 0, 1578, 1580, 5, 438, 0, 0, 1579, 1581, 5, 254, 0, 0, 1580, 1579, 1, 0, 0, 0, 1580, 1581, 1, 0, 0, 0, 1581, 1583, 1, 0, 0, 0, 1582, 1578, 1, 0, 0, 0, 1582, 1583, 1, 0, 0, 0, 1583, 1584, 1, 0, 0, 0, 1584, 1589, 7, 7, 0, 0, 1585, 1587, 5, 427, 0, 0, 1586, 1588, 5, 62, 0, 0, 1587, 1586, 1, 0, 0, 0, 1587, 1588, 1, 0, 0, 0, 1588, 1590, 1, 0, 0, 0, 1589, 1585, 1, 0, 0, 0, 1589, 1590, 1, 0, 0, 0, 1590, 87, 1, 0, 0, 0, 1591, 1593, 3, 1132, 566, 0, 1592, 1594, 5, 254, 0, 0, 1593, 1592, 1, 0, 0, 0, 1593, 1594, 1, 0, 0, 0, 1594, 1595, 1, 0, 0, 0, 1595, 1597, 3, 1146, 573, 0, 1596, 1598, 3, 90, 45, 0, 1597, 1596, 1, 0, 0, 0, 1597, 1598, 1, 0, 0, 0, 1598, 1601, 1, 0, 0, 0, 1599, 1601, 3, 90, 45, 0, 1600, 1591, 1, 0, 0, 0, 1600, 1599, 1, 0, 0, 0, 1601, 89, 1, 0, 0, 0, 1602, 1604, 5, 326, 0, 0, 1603, 1605, 5, 457, 0, 0, 1604, 1603, 1, 0, 0, 0, 1604, 1605, 1, 0, 0, 0, 1605, 1607, 1, 0, 0, 0, 1606, 1608, 5, 254, 0, 0, 1607, 1606, 1, 0, 0, 0, 1607, 1608, 1, 0, 0, 0, 1608, 1609, 1, 0, 0, 0, 1609, 1618, 3, 1046, 523, 0, 1610, 1612, 5, 324, 0, 0, 1611, 1613, 5, 457, 0, 0, 1612, 1611, 1, 0, 0, 0, 1612, 1613, 1, 0, 0, 0, 1613, 1615, 1, 0, 0, 0, 1614, 1616, 5, 254, 0, 0, 1615, 1614, 1, 0, 0, 0, 1615, 1616, 1, 0, 0, 0, 1616, 1617, 1, 0, 0, 0, 1617, 1619, 3, 1046, 523, 0, 1618, 1610, 1, 0, 0, 0, 1618, 1619, 1, 0, 0, 0, 1619, 1639, 1, 0, 0, 0, 1620, 1622, 5, 324, 0, 0, 1621, 1623, 5, 457, 0, 0, 1622, 1621, 1, 0, 0, 0, 1622, 1623, 1, 0, 0, 0, 1623, 1625, 1, 0, 0, 0, 1624, 1626, 5, 254, 0, 0, 1625, 1624, 1, 0, 0, 0, 1625, 1626, 1, 0, 0, 0, 1626, 1627, 1, 0, 0, 0, 1627, 1636, 3, 1046, 523, 0, 1628, 1630, 5, 326, 0, 0, 1629, 1631, 5, 457, 0, 0, 1630, 1629, 1, 0, 0, 0, 1630, 1631, 1, 0, 0, 0, 1631, 1633, 1, 0, 0, 0, 1632, 1634, 5, 254, 0, 0, 1633, 1632, 1, 0, 0, 0, 1633, 1634, 1, 0, 0, 0, 1634, 1635, 1, 0, 0, 0, 1635, 1637, 3, 1046, 523, 0, 1636, 1628, 1, 0, 0, 0, 1636, 1637, 1, 0, 0, 0, 1637, 1639, 1, 0, 0, 0, 1638, 1602, 1, 0, 0, 0, 1638, 1620, 1, 0, 0, 0, 1639, 91, 1, 0, 0, 0, 1640, 1642, 5, 322, 0, 0, 1641, 1643, 5, 254, 0, 0, 1642, 1641, 1, 0, 0, 0, 1642, 1643, 1, 0, 0, 0, 1643, 1644, 1, 0, 0, 0, 1644, 1645, 3, 1146, 573, 0, 1645, 93, 1, 0, 0, 0, 1646, 1648, 5, 400, 0, 0, 1647, 1649, 5, 515, 0, 0, 1648, 1647, 1, 0, 0, 0, 1648, 1649, 1, 0, 0, 0, 1649, 1651, 1, 0, 0, 0, 1650, 1652, 5, 283, 0, 0, 1651, 1650, 1, 0, 0, 0, 1651, 1652, 1, 0, 0, 0, 1652, 1654, 1, 0, 0, 0, 1653, 1655, 5, 254, 0, 0, 1654, 1653, 1, 0, 0, 0, 1654, 1655, 1, 0, 0, 0, 1655, 1656, 1, 0, 0, 0, 1656, 1658, 5, 308, 0, 0, 1657, 1659, 5, 54, 0, 0, 1658, 1657, 1, 0, 0, 0, 1658, 1659, 1, 0, 0, 0, 1659, 95, 1, 0, 0, 0, 1660, 1662, 5, 467, 0, 0, 1661, 1663, 5, 63, 0, 0, 1662, 1661, 1, 0, 0, 0, 1662, 1663, 1, 0, 0, 0, 1663, 1668, 1, 0, 0, 0, 1664, 1666, 5, 212, 0, 0, 1665, 1664, 1, 0, 0, 0, 1665, 1666, 1, 0, 0, 0, 1666, 1667, 1, 0, 0, 0, 1667, 1669, 7, 5, 0, 0, 1668, 1665, 1, 0, 0, 0, 1668, 1669, 1, 0, 0, 0, 1669, 1671, 1, 0, 0, 0, 1670, 1672, 3, 98, 49, 0, 1671, 1670, 1, 0, 0, 0, 1672, 1673, 1, 0, 0, 0, 1673, 1671, 1, 0, 0, 0, 1673, 1674, 1, 0, 0, 0, 1674, 1677, 1, 0, 0, 0, 1675, 1676, 5, 239, 0, 0, 1676, 1678, 3, 1114, 557, 0, 1677, 1675, 1, 0, 0, 0, 1677, 1678, 1, 0, 0, 0, 1678, 97, 1, 0, 0, 0, 1679, 1681, 3, 1166, 583, 0, 1680, 1679, 1, 0, 0, 0, 1681, 1682, 1, 0, 0, 0, 1682, 1680, 1, 0, 0, 0, 1682, 1683, 1, 0, 0, 0, 1683, 1685, 1, 0, 0, 0, 1684, 1686, 7, 8, 0, 0, 1685, 1684, 1, 0, 0, 0, 1685, 1686, 1, 0, 0, 0, 1686, 1688, 1, 0, 0, 0, 1687, 1689, 3, 1178, 589, 0, 1688, 1687, 1, 0, 0, 0, 1689, 1690, 1, 0, 0, 0, 1690, 1688, 1, 0, 0, 0, 1690, 1691, 1, 0, 0, 0, 1691, 99, 1, 0, 0, 0, 1692, 1693, 5, 247, 0, 0, 1693, 1694, 5, 419, 0, 0, 1694, 1698, 5, 534, 0, 0, 1695, 1697, 3, 102, 51, 0, 1696, 1695, 1, 0, 0, 0, 1697, 1700, 1, 0, 0, 0, 1698, 1696, 1, 0, 0, 0, 1698, 1699, 1, 0, 0, 0, 1699, 101, 1, 0, 0, 0, 1700, 1698, 1, 0, 0, 0, 1701, 1704, 3, 104, 52, 0, 1702, 1704, 3, 134, 67, 0, 1703, 1701, 1, 0, 0, 0, 1703, 1702, 1, 0, 0, 0, 1704, 103, 1, 0, 0, 0, 1705, 1712, 5, 207, 0, 0, 1706, 1708, 5, 534, 0, 0, 1707, 1706, 1, 0, 0, 0, 1707, 1708, 1, 0, 0, 0, 1708, 1709, 1, 0, 0, 0, 1709, 1711, 3, 106, 53, 0, 1710, 1707, 1, 0, 0, 0, 1711, 1714, 1, 0, 0, 0, 1712, 1710, 1, 0, 0, 0, 1712, 1713, 1, 0, 0, 0, 1713, 1715, 1, 0, 0, 0, 1714, 1712, 1, 0, 0, 0, 1715, 1716, 5, 534, 0, 0, 1716, 105, 1, 0, 0, 0, 1717, 1721, 3, 108, 54, 0, 1718, 1720, 3, 110, 55, 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, 107, 1, 0, 0, 0, 1723, 1721, 1, 0, 0, 0, 1724, 1726, 5, 424, 0, 0, 1725, 1727, 5, 328, 0, 0, 1726, 1725, 1, 0, 0, 0, 1726, 1727, 1, 0, 0, 0, 1727, 1728, 1, 0, 0, 0, 1728, 1729, 3, 1134, 567, 0, 1729, 109, 1, 0, 0, 0, 1730, 1742, 3, 112, 56, 0, 1731, 1742, 3, 114, 57, 0, 1732, 1742, 3, 116, 58, 0, 1733, 1742, 3, 118, 59, 0, 1734, 1742, 3, 120, 60, 0, 1735, 1742, 3, 122, 61, 0, 1736, 1742, 3, 124, 62, 0, 1737, 1742, 3, 126, 63, 0, 1738, 1742, 3, 130, 65, 0, 1739, 1742, 3, 128, 64, 0, 1740, 1742, 3, 132, 66, 0, 1741, 1730, 1, 0, 0, 0, 1741, 1731, 1, 0, 0, 0, 1741, 1732, 1, 0, 0, 0, 1741, 1733, 1, 0, 0, 0, 1741, 1734, 1, 0, 0, 0, 1741, 1735, 1, 0, 0, 0, 1741, 1736, 1, 0, 0, 0, 1741, 1737, 1, 0, 0, 0, 1741, 1738, 1, 0, 0, 0, 1741, 1739, 1, 0, 0, 0, 1741, 1740, 1, 0, 0, 0, 1742, 111, 1, 0, 0, 0, 1743, 1745, 5, 27, 0, 0, 1744, 1746, 5, 489, 0, 0, 1745, 1744, 1, 0, 0, 0, 1745, 1746, 1, 0, 0, 0, 1746, 1758, 1, 0, 0, 0, 1747, 1759, 5, 141, 0, 0, 1748, 1759, 5, 142, 0, 0, 1749, 1759, 5, 260, 0, 0, 1750, 1759, 5, 352, 0, 0, 1751, 1759, 5, 353, 0, 0, 1752, 1759, 5, 370, 0, 0, 1753, 1759, 5, 371, 0, 0, 1754, 1759, 5, 474, 0, 0, 1755, 1759, 5, 510, 0, 0, 1756, 1759, 3, 1116, 558, 0, 1757, 1759, 3, 1172, 586, 0, 1758, 1747, 1, 0, 0, 0, 1758, 1748, 1, 0, 0, 0, 1758, 1749, 1, 0, 0, 0, 1758, 1750, 1, 0, 0, 0, 1758, 1751, 1, 0, 0, 0, 1758, 1752, 1, 0, 0, 0, 1758, 1753, 1, 0, 0, 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, 113, 1, 0, 0, 0, 1760, 1763, 5, 400, 0, 0, 1761, 1764, 5, 310, 0, 0, 1762, 1764, 3, 1178, 589, 0, 1763, 1761, 1, 0, 0, 0, 1763, 1762, 1, 0, 0, 0, 1764, 1766, 1, 0, 0, 0, 1765, 1767, 5, 18, 0, 0, 1766, 1765, 1, 0, 0, 0, 1766, 1767, 1, 0, 0, 0, 1767, 1769, 1, 0, 0, 0, 1768, 1770, 7, 9, 0, 0, 1769, 1768, 1, 0, 0, 0, 1769, 1770, 1, 0, 0, 0, 1770, 115, 1, 0, 0, 0, 1771, 1773, 5, 332, 0, 0, 1772, 1774, 5, 254, 0, 0, 1773, 1772, 1, 0, 0, 0, 1773, 1774, 1, 0, 0, 0, 1774, 1776, 1, 0, 0, 0, 1775, 1771, 1, 0, 0, 0, 1775, 1776, 1, 0, 0, 0, 1776, 1782, 1, 0, 0, 0, 1777, 1783, 5, 279, 0, 0, 1778, 1779, 5, 377, 0, 0, 1779, 1783, 5, 42, 0, 0, 1780, 1783, 5, 377, 0, 0, 1781, 1783, 5, 42, 0, 0, 1782, 1777, 1, 0, 0, 0, 1782, 1778, 1, 0, 0, 0, 1782, 1780, 1, 0, 0, 0, 1782, 1781, 1, 0, 0, 0, 1782, 1783, 1, 0, 0, 0, 1783, 1784, 1, 0, 0, 0, 1784, 1785, 7, 10, 0, 0, 1785, 117, 1, 0, 0, 0, 1786, 1788, 5, 339, 0, 0, 1787, 1789, 5, 62, 0, 0, 1788, 1787, 1, 0, 0, 0, 1788, 1789, 1, 0, 0, 0, 1789, 1791, 1, 0, 0, 0, 1790, 1792, 5, 254, 0, 0, 1791, 1790, 1, 0, 0, 0, 1791, 1792, 1, 0, 0, 0, 1792, 1795, 1, 0, 0, 0, 1793, 1796, 3, 1090, 545, 0, 1794, 1796, 3, 1172, 586, 0, 1795, 1793, 1, 0, 0, 0, 1795, 1794, 1, 0, 0, 0, 1796, 119, 1, 0, 0, 0, 1797, 1798, 5, 377, 0, 0, 1798, 1800, 5, 133, 0, 0, 1799, 1801, 5, 254, 0, 0, 1800, 1799, 1, 0, 0, 0, 1800, 1801, 1, 0, 0, 0, 1801, 1805, 1, 0, 0, 0, 1802, 1806, 5, 454, 0, 0, 1803, 1806, 5, 237, 0, 0, 1804, 1806, 3, 1116, 558, 0, 1805, 1802, 1, 0, 0, 0, 1805, 1803, 1, 0, 0, 0, 1805, 1804, 1, 0, 0, 0, 1806, 121, 1, 0, 0, 0, 1807, 1809, 5, 3, 0, 0, 1808, 1810, 5, 297, 0, 0, 1809, 1808, 1, 0, 0, 0, 1809, 1810, 1, 0, 0, 0, 1810, 1812, 1, 0, 0, 0, 1811, 1813, 5, 254, 0, 0, 1812, 1811, 1, 0, 0, 0, 1812, 1813, 1, 0, 0, 0, 1813, 1814, 1, 0, 0, 0, 1814, 1815, 7, 11, 0, 0, 1815, 123, 1, 0, 0, 0, 1816, 1818, 5, 377, 0, 0, 1817, 1819, 5, 259, 0, 0, 1818, 1817, 1, 0, 0, 0, 1818, 1819, 1, 0, 0, 0, 1819, 1821, 1, 0, 0, 0, 1820, 1822, 5, 254, 0, 0, 1821, 1820, 1, 0, 0, 0, 1821, 1822, 1, 0, 0, 0, 1822, 1823, 1, 0, 0, 0, 1823, 1825, 3, 1090, 545, 0, 1824, 1826, 3, 128, 64, 0, 1825, 1824, 1, 0, 0, 0, 1825, 1826, 1, 0, 0, 0, 1826, 1831, 1, 0, 0, 0, 1827, 1829, 5, 514, 0, 0, 1828, 1827, 1, 0, 0, 0, 1828, 1829, 1, 0, 0, 0, 1829, 1830, 1, 0, 0, 0, 1830, 1832, 5, 149, 0, 0, 1831, 1828, 1, 0, 0, 0, 1831, 1832, 1, 0, 0, 0, 1832, 125, 1, 0, 0, 0, 1833, 1834, 5, 18, 0, 0, 1834, 1836, 5, 377, 0, 0, 1835, 1837, 5, 259, 0, 0, 1836, 1835, 1, 0, 0, 0, 1836, 1837, 1, 0, 0, 0, 1837, 1839, 1, 0, 0, 0, 1838, 1840, 5, 254, 0, 0, 1839, 1838, 1, 0, 0, 0, 1839, 1840, 1, 0, 0, 0, 1840, 1841, 1, 0, 0, 0, 1841, 1843, 3, 1090, 545, 0, 1842, 1844, 3, 128, 64, 0, 1843, 1842, 1, 0, 0, 0, 1843, 1844, 1, 0, 0, 0, 1844, 1849, 1, 0, 0, 0, 1845, 1847, 5, 514, 0, 0, 1846, 1845, 1, 0, 0, 0, 1846, 1847, 1, 0, 0, 0, 1847, 1848, 1, 0, 0, 0, 1848, 1850, 5, 149, 0, 0, 1849, 1846, 1, 0, 0, 0, 1849, 1850, 1, 0, 0, 0, 1850, 127, 1, 0, 0, 0, 1851, 1853, 5, 342, 0, 0, 1852, 1854, 5, 254, 0, 0, 1853, 1852, 1, 0, 0, 0, 1853, 1854, 1, 0, 0, 0, 1854, 1855, 1, 0, 0, 0, 1855, 1856, 3, 1128, 564, 0, 1856, 129, 1, 0, 0, 0, 1857, 1859, 5, 206, 0, 0, 1858, 1857, 1, 0, 0, 0, 1858, 1859, 1, 0, 0, 0, 1859, 1860, 1, 0, 0, 0, 1860, 1862, 5, 457, 0, 0, 1861, 1863, 5, 254, 0, 0, 1862, 1861, 1, 0, 0, 0, 1862, 1863, 1, 0, 0, 0, 1863, 1864, 1, 0, 0, 0, 1864, 1866, 3, 1090, 545, 0, 1865, 1867, 3, 1090, 545, 0, 1866, 1865, 1, 0, 0, 0, 1866, 1867, 1, 0, 0, 0, 1867, 131, 1, 0, 0, 0, 1868, 1870, 5, 386, 0, 0, 1869, 1871, 5, 259, 0, 0, 1870, 1869, 1, 0, 0, 0, 1870, 1871, 1, 0, 0, 0, 1871, 1873, 1, 0, 0, 0, 1872, 1874, 5, 254, 0, 0, 1873, 1872, 1, 0, 0, 0, 1873, 1874, 1, 0, 0, 0, 1874, 1875, 1, 0, 0, 0, 1875, 1876, 3, 1090, 545, 0, 1876, 133, 1, 0, 0, 0, 1877, 1878, 5, 233, 0, 0, 1878, 1882, 5, 534, 0, 0, 1879, 1880, 3, 1134, 567, 0, 1880, 1881, 5, 534, 0, 0, 1881, 1883, 1, 0, 0, 0, 1882, 1879, 1, 0, 0, 0, 1882, 1883, 1, 0, 0, 0, 1883, 1891, 1, 0, 0, 0, 1884, 1886, 3, 136, 68, 0, 1885, 1884, 1, 0, 0, 0, 1886, 1889, 1, 0, 0, 0, 1887, 1885, 1, 0, 0, 0, 1887, 1888, 1, 0, 0, 0, 1888, 1890, 1, 0, 0, 0, 1889, 1887, 1, 0, 0, 0, 1890, 1892, 5, 534, 0, 0, 1891, 1887, 1, 0, 0, 0, 1891, 1892, 1, 0, 0, 0, 1892, 135, 1, 0, 0, 0, 1893, 1898, 3, 138, 69, 0, 1894, 1898, 3, 146, 73, 0, 1895, 1898, 3, 148, 74, 0, 1896, 1898, 3, 152, 76, 0, 1897, 1893, 1, 0, 0, 0, 1897, 1894, 1, 0, 0, 0, 1897, 1895, 1, 0, 0, 0, 1897, 1896, 1, 0, 0, 0, 1898, 137, 1, 0, 0, 0, 1899, 1905, 5, 399, 0, 0, 1900, 1903, 5, 326, 0, 0, 1901, 1904, 3, 1116, 558, 0, 1902, 1904, 3, 1134, 567, 0, 1903, 1901, 1, 0, 0, 0, 1903, 1902, 1, 0, 0, 0, 1904, 1906, 1, 0, 0, 0, 1905, 1900, 1, 0, 0, 0, 1905, 1906, 1, 0, 0, 0, 1906, 1907, 1, 0, 0, 0, 1907, 1911, 5, 195, 0, 0, 1908, 1912, 3, 140, 70, 0, 1909, 1912, 3, 142, 71, 0, 1910, 1912, 3, 144, 72, 0, 1911, 1908, 1, 0, 0, 0, 1911, 1909, 1, 0, 0, 0, 1911, 1910, 1, 0, 0, 0, 1912, 139, 1, 0, 0, 0, 1913, 1914, 3, 1178, 589, 0, 1914, 1915, 5, 379, 0, 0, 1915, 141, 1, 0, 0, 0, 1916, 1918, 5, 158, 0, 0, 1917, 1916, 1, 0, 0, 0, 1917, 1918, 1, 0, 0, 0, 1918, 1920, 1, 0, 0, 0, 1919, 1921, 5, 323, 0, 0, 1920, 1919, 1, 0, 0, 0, 1920, 1921, 1, 0, 0, 0, 1921, 1922, 1, 0, 0, 0, 1922, 1923, 7, 12, 0, 0, 1923, 1924, 5, 323, 0, 0, 1924, 1925, 3, 1134, 567, 0, 1925, 143, 1, 0, 0, 0, 1926, 1928, 3, 1178, 589, 0, 1927, 1929, 5, 66, 0, 0, 1928, 1927, 1, 0, 0, 0, 1928, 1929, 1, 0, 0, 0, 1929, 145, 1, 0, 0, 0, 1930, 1932, 5, 414, 0, 0, 1931, 1933, 7, 13, 0, 0, 1932, 1931, 1, 0, 0, 0, 1932, 1933, 1, 0, 0, 0, 1933, 1935, 1, 0, 0, 0, 1934, 1936, 5, 22, 0, 0, 1935, 1934, 1, 0, 0, 0, 1935, 1936, 1, 0, 0, 0, 1936, 1938, 1, 0, 0, 0, 1937, 1939, 5, 212, 0, 0, 1938, 1937, 1, 0, 0, 0, 1938, 1939, 1, 0, 0, 0, 1939, 1941, 1, 0, 0, 0, 1940, 1942, 3, 1134, 567, 0, 1941, 1940, 1, 0, 0, 0, 1942, 1943, 1, 0, 0, 0, 1943, 1941, 1, 0, 0, 0, 1943, 1944, 1, 0, 0, 0, 1944, 147, 1, 0, 0, 0, 1945, 1946, 5, 301, 0, 0, 1946, 1948, 5, 206, 0, 0, 1947, 1949, 5, 474, 0, 0, 1948, 1947, 1, 0, 0, 0, 1948, 1949, 1, 0, 0, 0, 1949, 1951, 1, 0, 0, 0, 1950, 1952, 5, 94, 0, 0, 1951, 1950, 1, 0, 0, 0, 1951, 1952, 1, 0, 0, 0, 1952, 1954, 1, 0, 0, 0, 1953, 1955, 3, 150, 75, 0, 1954, 1953, 1, 0, 0, 0, 1955, 1956, 1, 0, 0, 0, 1956, 1954, 1, 0, 0, 0, 1956, 1957, 1, 0, 0, 0, 1957, 149, 1, 0, 0, 0, 1958, 1961, 3, 1134, 567, 0, 1959, 1960, 5, 350, 0, 0, 1960, 1962, 3, 1178, 589, 0, 1961, 1959, 1, 0, 0, 0, 1961, 1962, 1, 0, 0, 0, 1962, 151, 1, 0, 0, 0, 1963, 1964, 5, 77, 0, 0, 1964, 1966, 5, 97, 0, 0, 1965, 1967, 5, 212, 0, 0, 1966, 1965, 1, 0, 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, 1968, 1, 0, 0, 0, 1968, 1969, 3, 1134, 567, 0, 1969, 153, 1, 0, 0, 0, 1970, 1971, 5, 109, 0, 0, 1971, 1972, 5, 145, 0, 0, 1972, 1976, 5, 534, 0, 0, 1973, 1975, 3, 156, 78, 0, 1974, 1973, 1, 0, 0, 0, 1975, 1978, 1, 0, 0, 0, 1976, 1974, 1, 0, 0, 0, 1976, 1977, 1, 0, 0, 0, 1977, 155, 1, 0, 0, 0, 1978, 1976, 1, 0, 0, 0, 1979, 1989, 3, 158, 79, 0, 1980, 1989, 3, 208, 104, 0, 1981, 1989, 3, 212, 106, 0, 1982, 1989, 3, 214, 107, 0, 1983, 1989, 3, 216, 108, 0, 1984, 1989, 3, 254, 127, 0, 1985, 1989, 3, 256, 128, 0, 1986, 1989, 3, 320, 160, 0, 1987, 1989, 3, 396, 198, 0, 1988, 1979, 1, 0, 0, 0, 1988, 1980, 1, 0, 0, 0, 1988, 1981, 1, 0, 0, 0, 1988, 1982, 1, 0, 0, 0, 1988, 1983, 1, 0, 0, 0, 1988, 1984, 1, 0, 0, 0, 1988, 1985, 1, 0, 0, 0, 1988, 1986, 1, 0, 0, 0, 1988, 1987, 1, 0, 0, 0, 1989, 157, 1, 0, 0, 0, 1990, 1991, 5, 206, 0, 0, 1991, 1992, 5, 419, 0, 0, 1992, 1996, 5, 534, 0, 0, 1993, 1995, 3, 160, 80, 0, 1994, 1993, 1, 0, 0, 0, 1995, 1998, 1, 0, 0, 0, 1996, 1994, 1, 0, 0, 0, 1996, 1997, 1, 0, 0, 0, 1997, 159, 1, 0, 0, 0, 1998, 1996, 1, 0, 0, 0, 1999, 2000, 7, 14, 0, 0, 2000, 2007, 3, 1134, 567, 0, 2001, 2003, 5, 534, 0, 0, 2002, 2001, 1, 0, 0, 0, 2002, 2003, 1, 0, 0, 0, 2003, 2004, 1, 0, 0, 0, 2004, 2006, 3, 162, 81, 0, 2005, 2002, 1, 0, 0, 0, 2006, 2009, 1, 0, 0, 0, 2007, 2005, 1, 0, 0, 0, 2007, 2008, 1, 0, 0, 0, 2008, 2010, 1, 0, 0, 0, 2009, 2007, 1, 0, 0, 0, 2010, 2014, 5, 534, 0, 0, 2011, 2013, 3, 434, 217, 0, 2012, 2011, 1, 0, 0, 0, 2013, 2016, 1, 0, 0, 0, 2014, 2012, 1, 0, 0, 0, 2014, 2015, 1, 0, 0, 0, 2015, 161, 1, 0, 0, 0, 2016, 2014, 1, 0, 0, 0, 2017, 2029, 3, 164, 82, 0, 2018, 2029, 3, 166, 83, 0, 2019, 2029, 3, 168, 84, 0, 2020, 2029, 3, 172, 86, 0, 2021, 2029, 3, 182, 91, 0, 2022, 2029, 3, 184, 92, 0, 2023, 2029, 3, 188, 94, 0, 2024, 2029, 3, 190, 95, 0, 2025, 2029, 3, 204, 102, 0, 2026, 2029, 3, 206, 103, 0, 2027, 2029, 3, 200, 100, 0, 2028, 2017, 1, 0, 0, 0, 2028, 2018, 1, 0, 0, 0, 2028, 2019, 1, 0, 0, 0, 2028, 2020, 1, 0, 0, 0, 2028, 2021, 1, 0, 0, 0, 2028, 2022, 1, 0, 0, 0, 2028, 2023, 1, 0, 0, 0, 2028, 2024, 1, 0, 0, 0, 2028, 2025, 1, 0, 0, 0, 2028, 2026, 1, 0, 0, 0, 2028, 2027, 1, 0, 0, 0, 2029, 163, 1, 0, 0, 0, 2030, 2032, 5, 254, 0, 0, 2031, 2030, 1, 0, 0, 0, 2031, 2032, 1, 0, 0, 0, 2032, 2033, 1, 0, 0, 0, 2033, 2034, 5, 203, 0, 0, 2034, 165, 1, 0, 0, 0, 2035, 2037, 5, 254, 0, 0, 2036, 2035, 1, 0, 0, 0, 2036, 2037, 1, 0, 0, 0, 2037, 2038, 1, 0, 0, 0, 2038, 2039, 5, 223, 0, 0, 2039, 167, 1, 0, 0, 0, 2040, 2042, 5, 46, 0, 0, 2041, 2043, 5, 94, 0, 0, 2042, 2041, 1, 0, 0, 0, 2042, 2043, 1, 0, 0, 0, 2043, 2044, 1, 0, 0, 0, 2044, 2046, 3, 1178, 589, 0, 2045, 2047, 3, 170, 85, 0, 2046, 2045, 1, 0, 0, 0, 2046, 2047, 1, 0, 0, 0, 2047, 2049, 1, 0, 0, 0, 2048, 2050, 7, 15, 0, 0, 2049, 2048, 1, 0, 0, 0, 2049, 2050, 1, 0, 0, 0, 2050, 169, 1, 0, 0, 0, 2051, 2052, 5, 489, 0, 0, 2052, 2053, 3, 1178, 589, 0, 2053, 171, 1, 0, 0, 0, 2054, 2058, 5, 377, 0, 0, 2055, 2059, 3, 174, 87, 0, 2056, 2059, 3, 176, 88, 0, 2057, 2059, 3, 178, 89, 0, 2058, 2055, 1, 0, 0, 0, 2058, 2056, 1, 0, 0, 0, 2058, 2057, 1, 0, 0, 0, 2059, 173, 1, 0, 0, 0, 2060, 2062, 5, 94, 0, 0, 2061, 2060, 1, 0, 0, 0, 2061, 2062, 1, 0, 0, 0, 2062, 2063, 1, 0, 0, 0, 2063, 2065, 3, 1178, 589, 0, 2064, 2066, 5, 63, 0, 0, 2065, 2064, 1, 0, 0, 0, 2065, 2066, 1, 0, 0, 0, 2066, 175, 1, 0, 0, 0, 2067, 2069, 5, 254, 0, 0, 2068, 2067, 1, 0, 0, 0, 2068, 2069, 1, 0, 0, 0, 2069, 2070, 1, 0, 0, 0, 2070, 2072, 5, 509, 0, 0, 2071, 2073, 5, 239, 0, 0, 2072, 2071, 1, 0, 0, 0, 2072, 2073, 1, 0, 0, 0, 2073, 2075, 1, 0, 0, 0, 2074, 2076, 5, 439, 0, 0, 2075, 2074, 1, 0, 0, 0, 2075, 2076, 1, 0, 0, 0, 2076, 2087, 1, 0, 0, 0, 2077, 2079, 5, 215, 0, 0, 2078, 2077, 1, 0, 0, 0, 2078, 2079, 1, 0, 0, 0, 2079, 2080, 1, 0, 0, 0, 2080, 2082, 3, 1178, 589, 0, 2081, 2083, 3, 180, 90, 0, 2082, 2081, 1, 0, 0, 0, 2082, 2083, 1, 0, 0, 0, 2083, 2085, 1, 0, 0, 0, 2084, 2086, 5, 63, 0, 0, 2085, 2084, 1, 0, 0, 0, 2085, 2086, 1, 0, 0, 0, 2086, 2088, 1, 0, 0, 0, 2087, 2078, 1, 0, 0, 0, 2087, 2088, 1, 0, 0, 0, 2088, 2094, 1, 0, 0, 0, 2089, 2091, 5, 134, 0, 0, 2090, 2092, 5, 326, 0, 0, 2091, 2090, 1, 0, 0, 0, 2091, 2092, 1, 0, 0, 0, 2092, 2093, 1, 0, 0, 0, 2093, 2095, 3, 1090, 545, 0, 2094, 2089, 1, 0, 0, 0, 2094, 2095, 1, 0, 0, 0, 2095, 177, 1, 0, 0, 0, 2096, 2098, 5, 94, 0, 0, 2097, 2096, 1, 0, 0, 0, 2097, 2098, 1, 0, 0, 0, 2098, 2099, 1, 0, 0, 0, 2099, 2100, 3, 1178, 589, 0, 2100, 2102, 3, 180, 90, 0, 2101, 2103, 5, 63, 0, 0, 2102, 2101, 1, 0, 0, 0, 2102, 2103, 1, 0, 0, 0, 2103, 179, 1, 0, 0, 0, 2104, 2105, 5, 489, 0, 0, 2105, 2106, 3, 1178, 589, 0, 2106, 181, 1, 0, 0, 0, 2107, 2116, 5, 261, 0, 0, 2108, 2110, 5, 377, 0, 0, 2109, 2111, 5, 254, 0, 0, 2110, 2109, 1, 0, 0, 0, 2110, 2111, 1, 0, 0, 0, 2111, 2117, 1, 0, 0, 0, 2112, 2114, 5, 379, 0, 0, 2113, 2115, 5, 21, 0, 0, 2114, 2113, 1, 0, 0, 0, 2114, 2115, 1, 0, 0, 0, 2115, 2117, 1, 0, 0, 0, 2116, 2108, 1, 0, 0, 0, 2116, 2112, 1, 0, 0, 0, 2117, 2125, 1, 0, 0, 0, 2118, 2126, 5, 325, 0, 0, 2119, 2126, 5, 453, 0, 0, 2120, 2122, 3, 1128, 564, 0, 2121, 2120, 1, 0, 0, 0, 2122, 2123, 1, 0, 0, 0, 2123, 2121, 1, 0, 0, 0, 2123, 2124, 1, 0, 0, 0, 2124, 2126, 1, 0, 0, 0, 2125, 2118, 1, 0, 0, 0, 2125, 2119, 1, 0, 0, 0, 2125, 2121, 1, 0, 0, 0, 2126, 183, 1, 0, 0, 0, 2127, 2128, 5, 507, 0, 0, 2128, 2130, 5, 323, 0, 0, 2129, 2131, 3, 186, 93, 0, 2130, 2129, 1, 0, 0, 0, 2131, 2132, 1, 0, 0, 0, 2132, 2130, 1, 0, 0, 0, 2132, 2133, 1, 0, 0, 0, 2133, 185, 1, 0, 0, 0, 2134, 2136, 3, 1164, 582, 0, 2135, 2137, 5, 254, 0, 0, 2136, 2135, 1, 0, 0, 0, 2136, 2137, 1, 0, 0, 0, 2137, 2140, 1, 0, 0, 0, 2138, 2141, 3, 1090, 545, 0, 2139, 2141, 3, 1172, 586, 0, 2140, 2138, 1, 0, 0, 0, 2140, 2139, 1, 0, 0, 0, 2141, 187, 1, 0, 0, 0, 2142, 2151, 5, 109, 0, 0, 2143, 2145, 5, 377, 0, 0, 2144, 2146, 5, 254, 0, 0, 2145, 2144, 1, 0, 0, 0, 2145, 2146, 1, 0, 0, 0, 2146, 2152, 1, 0, 0, 0, 2147, 2149, 5, 379, 0, 0, 2148, 2150, 5, 21, 0, 0, 2149, 2148, 1, 0, 0, 0, 2149, 2150, 1, 0, 0, 0, 2150, 2152, 1, 0, 0, 0, 2151, 2143, 1, 0, 0, 0, 2151, 2147, 1, 0, 0, 0, 2152, 2154, 1, 0, 0, 0, 2153, 2155, 3, 1128, 564, 0, 2154, 2153, 1, 0, 0, 0, 2155, 2156, 1, 0, 0, 0, 2156, 2154, 1, 0, 0, 0, 2156, 2157, 1, 0, 0, 0, 2157, 189, 1, 0, 0, 0, 2158, 2160, 5, 277, 0, 0, 2159, 2161, 5, 254, 0, 0, 2160, 2159, 1, 0, 0, 0, 2160, 2161, 1, 0, 0, 0, 2161, 2164, 1, 0, 0, 0, 2162, 2165, 3, 1128, 564, 0, 2163, 2165, 3, 1178, 589, 0, 2164, 2162, 1, 0, 0, 0, 2164, 2163, 1, 0, 0, 0, 2165, 2167, 1, 0, 0, 0, 2166, 2168, 5, 280, 0, 0, 2167, 2166, 1, 0, 0, 0, 2167, 2168, 1, 0, 0, 0, 2168, 2172, 1, 0, 0, 0, 2169, 2171, 3, 192, 96, 0, 2170, 2169, 1, 0, 0, 0, 2171, 2174, 1, 0, 0, 0, 2172, 2170, 1, 0, 0, 0, 2172, 2173, 1, 0, 0, 0, 2173, 191, 1, 0, 0, 0, 2174, 2172, 1, 0, 0, 0, 2175, 2179, 3, 194, 97, 0, 2176, 2179, 3, 196, 98, 0, 2177, 2179, 3, 198, 99, 0, 2178, 2175, 1, 0, 0, 0, 2178, 2176, 1, 0, 0, 0, 2178, 2177, 1, 0, 0, 0, 2179, 193, 1, 0, 0, 0, 2180, 2182, 5, 514, 0, 0, 2181, 2180, 1, 0, 0, 0, 2181, 2182, 1, 0, 0, 0, 2182, 2183, 1, 0, 0, 0, 2183, 2185, 5, 211, 0, 0, 2184, 2186, 5, 30, 0, 0, 2185, 2184, 1, 0, 0, 0, 2185, 2186, 1, 0, 0, 0, 2186, 2189, 1, 0, 0, 0, 2187, 2190, 3, 1128, 564, 0, 2188, 2190, 3, 1178, 589, 0, 2189, 2187, 1, 0, 0, 0, 2189, 2188, 1, 0, 0, 0, 2190, 195, 1, 0, 0, 0, 2191, 2193, 5, 280, 0, 0, 2192, 2191, 1, 0, 0, 0, 2192, 2193, 1, 0, 0, 0, 2193, 2195, 1, 0, 0, 0, 2194, 2196, 5, 30, 0, 0, 2195, 2194, 1, 0, 0, 0, 2195, 2196, 1, 0, 0, 0, 2196, 2197, 1, 0, 0, 0, 2197, 2200, 5, 492, 0, 0, 2198, 2201, 3, 1128, 564, 0, 2199, 2201, 3, 1178, 589, 0, 2200, 2198, 1, 0, 0, 0, 2200, 2199, 1, 0, 0, 0, 2201, 197, 1, 0, 0, 0, 2202, 2204, 5, 280, 0, 0, 2203, 2202, 1, 0, 0, 0, 2203, 2204, 1, 0, 0, 0, 2204, 2206, 1, 0, 0, 0, 2205, 2207, 5, 30, 0, 0, 2206, 2205, 1, 0, 0, 0, 2206, 2207, 1, 0, 0, 0, 2207, 2208, 1, 0, 0, 0, 2208, 2211, 5, 48, 0, 0, 2209, 2212, 3, 1128, 564, 0, 2210, 2212, 3, 1178, 589, 0, 2211, 2209, 1, 0, 0, 0, 2211, 2210, 1, 0, 0, 0, 2212, 199, 1, 0, 0, 0, 2213, 2215, 5, 378, 0, 0, 2214, 2216, 5, 297, 0, 0, 2215, 2214, 1, 0, 0, 0, 2215, 2216, 1, 0, 0, 0, 2216, 2218, 1, 0, 0, 0, 2217, 2219, 5, 254, 0, 0, 2218, 2217, 1, 0, 0, 0, 2218, 2219, 1, 0, 0, 0, 2219, 2220, 1, 0, 0, 0, 2220, 2221, 3, 202, 101, 0, 2221, 201, 1, 0, 0, 0, 2222, 2223, 3, 1170, 585, 0, 2223, 203, 1, 0, 0, 0, 2224, 2226, 5, 71, 0, 0, 2225, 2227, 5, 254, 0, 0, 2226, 2225, 1, 0, 0, 0, 2226, 2227, 1, 0, 0, 0, 2227, 2228, 1, 0, 0, 0, 2228, 2229, 3, 1114, 557, 0, 2229, 205, 1, 0, 0, 0, 2230, 2232, 5, 395, 0, 0, 2231, 2233, 5, 254, 0, 0, 2232, 2231, 1, 0, 0, 0, 2232, 2233, 1, 0, 0, 0, 2233, 2239, 1, 0, 0, 0, 2234, 2236, 5, 397, 0, 0, 2235, 2237, 5, 21, 0, 0, 2236, 2235, 1, 0, 0, 0, 2236, 2237, 1, 0, 0, 0, 2237, 2239, 1, 0, 0, 0, 2238, 2230, 1, 0, 0, 0, 2238, 2234, 1, 0, 0, 0, 2239, 2241, 1, 0, 0, 0, 2240, 2242, 3, 1156, 578, 0, 2241, 2240, 1, 0, 0, 0, 2242, 2243, 1, 0, 0, 0, 2243, 2241, 1, 0, 0, 0, 2243, 2244, 1, 0, 0, 0, 2244, 207, 1, 0, 0, 0, 2245, 2246, 5, 110, 0, 0, 2246, 2247, 5, 419, 0, 0, 2247, 2251, 5, 534, 0, 0, 2248, 2250, 3, 210, 105, 0, 2249, 2248, 1, 0, 0, 0, 2250, 2253, 1, 0, 0, 0, 2251, 2249, 1, 0, 0, 0, 2251, 2252, 1, 0, 0, 0, 2252, 209, 1, 0, 0, 0, 2253, 2251, 1, 0, 0, 0, 2254, 2255, 3, 1178, 589, 0, 2255, 2256, 3, 1172, 586, 0, 2256, 2257, 5, 253, 0, 0, 2257, 2258, 3, 1172, 586, 0, 2258, 211, 1, 0, 0, 0, 2259, 2260, 5, 516, 0, 0, 2260, 2261, 5, 419, 0, 0, 2261, 2265, 5, 534, 0, 0, 2262, 2264, 3, 434, 217, 0, 2263, 2262, 1, 0, 0, 0, 2264, 2267, 1, 0, 0, 0, 2265, 2263, 1, 0, 0, 0, 2265, 2266, 1, 0, 0, 0, 2266, 213, 1, 0, 0, 0, 2267, 2265, 1, 0, 0, 0, 2268, 2269, 5, 282, 0, 0, 2269, 2270, 5, 419, 0, 0, 2270, 2274, 5, 534, 0, 0, 2271, 2273, 3, 434, 217, 0, 2272, 2271, 1, 0, 0, 0, 2273, 2276, 1, 0, 0, 0, 2274, 2272, 1, 0, 0, 0, 2274, 2275, 1, 0, 0, 0, 2275, 215, 1, 0, 0, 0, 2276, 2274, 1, 0, 0, 0, 2277, 2278, 5, 79, 0, 0, 2278, 2279, 5, 419, 0, 0, 2279, 2284, 5, 534, 0, 0, 2280, 2283, 3, 218, 109, 0, 2281, 2283, 3, 434, 217, 0, 2282, 2280, 1, 0, 0, 0, 2282, 2281, 1, 0, 0, 0, 2283, 2286, 1, 0, 0, 0, 2284, 2282, 1, 0, 0, 0, 2284, 2285, 1, 0, 0, 0, 2285, 217, 1, 0, 0, 0, 2286, 2284, 1, 0, 0, 0, 2287, 2291, 3, 220, 110, 0, 2288, 2291, 3, 222, 111, 0, 2289, 2291, 3, 224, 112, 0, 2290, 2287, 1, 0, 0, 0, 2290, 2288, 1, 0, 0, 0, 2290, 2289, 1, 0, 0, 0, 2291, 219, 1, 0, 0, 0, 2292, 2293, 5, 56, 0, 0, 2293, 2295, 3, 1120, 560, 0, 2294, 2296, 5, 212, 0, 0, 2295, 2294, 1, 0, 0, 0, 2295, 2296, 1, 0, 0, 0, 2296, 2298, 1, 0, 0, 0, 2297, 2299, 5, 243, 0, 0, 2298, 2297, 1, 0, 0, 0, 2298, 2299, 1, 0, 0, 0, 2299, 2300, 1, 0, 0, 0, 2300, 2315, 5, 246, 0, 0, 2301, 2311, 3, 244, 122, 0, 2302, 2311, 3, 250, 125, 0, 2303, 2311, 3, 236, 118, 0, 2304, 2311, 3, 238, 119, 0, 2305, 2311, 3, 246, 123, 0, 2306, 2311, 3, 252, 126, 0, 2307, 2311, 3, 230, 115, 0, 2308, 2311, 3, 240, 120, 0, 2309, 2311, 3, 234, 117, 0, 2310, 2301, 1, 0, 0, 0, 2310, 2302, 1, 0, 0, 0, 2310, 2303, 1, 0, 0, 0, 2310, 2304, 1, 0, 0, 0, 2310, 2305, 1, 0, 0, 0, 2310, 2306, 1, 0, 0, 0, 2310, 2307, 1, 0, 0, 0, 2310, 2308, 1, 0, 0, 0, 2310, 2309, 1, 0, 0, 0, 2311, 2314, 1, 0, 0, 0, 2312, 2314, 3, 1130, 565, 0, 2313, 2310, 1, 0, 0, 0, 2313, 2312, 1, 0, 0, 0, 2314, 2317, 1, 0, 0, 0, 2315, 2313, 1, 0, 0, 0, 2315, 2316, 1, 0, 0, 0, 2316, 2318, 1, 0, 0, 0, 2317, 2315, 1, 0, 0, 0, 2318, 2319, 5, 534, 0, 0, 2319, 221, 1, 0, 0, 0, 2320, 2321, 5, 56, 0, 0, 2321, 2323, 3, 1120, 560, 0, 2322, 2324, 5, 212, 0, 0, 2323, 2322, 1, 0, 0, 0, 2323, 2324, 1, 0, 0, 0, 2324, 2325, 1, 0, 0, 0, 2325, 2334, 5, 334, 0, 0, 2326, 2333, 3, 226, 113, 0, 2327, 2333, 3, 252, 126, 0, 2328, 2333, 3, 240, 120, 0, 2329, 2333, 3, 228, 114, 0, 2330, 2333, 3, 232, 116, 0, 2331, 2333, 3, 242, 121, 0, 2332, 2326, 1, 0, 0, 0, 2332, 2327, 1, 0, 0, 0, 2332, 2328, 1, 0, 0, 0, 2332, 2329, 1, 0, 0, 0, 2332, 2330, 1, 0, 0, 0, 2332, 2331, 1, 0, 0, 0, 2333, 2336, 1, 0, 0, 0, 2334, 2332, 1, 0, 0, 0, 2334, 2335, 1, 0, 0, 0, 2335, 2337, 1, 0, 0, 0, 2336, 2334, 1, 0, 0, 0, 2337, 2338, 5, 534, 0, 0, 2338, 223, 1, 0, 0, 0, 2339, 2340, 5, 56, 0, 0, 2340, 2342, 3, 1120, 560, 0, 2341, 2343, 5, 212, 0, 0, 2342, 2341, 1, 0, 0, 0, 2342, 2343, 1, 0, 0, 0, 2343, 2344, 1, 0, 0, 0, 2344, 2345, 5, 243, 0, 0, 2345, 2357, 5, 232, 0, 0, 2346, 2353, 3, 236, 118, 0, 2347, 2353, 3, 238, 119, 0, 2348, 2353, 3, 248, 124, 0, 2349, 2353, 3, 252, 126, 0, 2350, 2353, 3, 230, 115, 0, 2351, 2353, 3, 240, 120, 0, 2352, 2346, 1, 0, 0, 0, 2352, 2347, 1, 0, 0, 0, 2352, 2348, 1, 0, 0, 0, 2352, 2349, 1, 0, 0, 0, 2352, 2350, 1, 0, 0, 0, 2352, 2351, 1, 0, 0, 0, 2353, 2356, 1, 0, 0, 0, 2354, 2356, 3, 1130, 565, 0, 2355, 2352, 1, 0, 0, 0, 2355, 2354, 1, 0, 0, 0, 2356, 2359, 1, 0, 0, 0, 2357, 2355, 1, 0, 0, 0, 2357, 2358, 1, 0, 0, 0, 2358, 2360, 1, 0, 0, 0, 2359, 2357, 1, 0, 0, 0, 2360, 2361, 5, 534, 0, 0, 2361, 225, 1, 0, 0, 0, 2362, 2363, 5, 136, 0, 0, 2363, 2365, 5, 105, 0, 0, 2364, 2366, 5, 254, 0, 0, 2365, 2364, 1, 0, 0, 0, 2365, 2366, 1, 0, 0, 0, 2366, 2367, 1, 0, 0, 0, 2367, 2368, 3, 1130, 565, 0, 2368, 227, 1, 0, 0, 0, 2369, 2370, 5, 136, 0, 0, 2370, 2371, 5, 470, 0, 0, 2371, 2372, 5, 321, 0, 0, 2372, 2373, 3, 1178, 589, 0, 2373, 2381, 5, 487, 0, 0, 2374, 2375, 5, 241, 0, 0, 2375, 2377, 5, 49, 0, 0, 2376, 2378, 3, 1138, 569, 0, 2377, 2376, 1, 0, 0, 0, 2378, 2379, 1, 0, 0, 0, 2379, 2377, 1, 0, 0, 0, 2379, 2380, 1, 0, 0, 0, 2380, 2382, 1, 0, 0, 0, 2381, 2374, 1, 0, 0, 0, 2381, 2382, 1, 0, 0, 0, 2382, 229, 1, 0, 0, 0, 2383, 2384, 5, 158, 0, 0, 2384, 2386, 5, 259, 0, 0, 2385, 2387, 5, 254, 0, 0, 2386, 2385, 1, 0, 0, 0, 2386, 2387, 1, 0, 0, 0, 2387, 2388, 1, 0, 0, 0, 2388, 2389, 3, 1130, 565, 0, 2389, 231, 1, 0, 0, 0, 2390, 2391, 5, 188, 0, 0, 2391, 2393, 5, 259, 0, 0, 2392, 2394, 5, 254, 0, 0, 2393, 2392, 1, 0, 0, 0, 2393, 2394, 1, 0, 0, 0, 2394, 2395, 1, 0, 0, 0, 2395, 2396, 3, 1130, 565, 0, 2396, 233, 1, 0, 0, 0, 2397, 2399, 5, 295, 0, 0, 2398, 2397, 1, 0, 0, 0, 2398, 2399, 1, 0, 0, 0, 2399, 2400, 1, 0, 0, 0, 2400, 2402, 5, 105, 0, 0, 2401, 2403, 5, 254, 0, 0, 2402, 2401, 1, 0, 0, 0, 2402, 2403, 1, 0, 0, 0, 2403, 2404, 1, 0, 0, 0, 2404, 2405, 3, 1130, 565, 0, 2405, 235, 1, 0, 0, 0, 2406, 2407, 5, 295, 0, 0, 2407, 2409, 5, 111, 0, 0, 2408, 2410, 5, 254, 0, 0, 2409, 2408, 1, 0, 0, 0, 2409, 2410, 1, 0, 0, 0, 2410, 2411, 1, 0, 0, 0, 2411, 2412, 3, 1130, 565, 0, 2412, 237, 1, 0, 0, 0, 2413, 2414, 5, 295, 0, 0, 2414, 2416, 5, 485, 0, 0, 2415, 2417, 5, 254, 0, 0, 2416, 2415, 1, 0, 0, 0, 2416, 2417, 1, 0, 0, 0, 2417, 2418, 1, 0, 0, 0, 2418, 2419, 3, 1130, 565, 0, 2419, 239, 1, 0, 0, 0, 2420, 2421, 5, 457, 0, 0, 2421, 2423, 5, 259, 0, 0, 2422, 2424, 5, 254, 0, 0, 2423, 2422, 1, 0, 0, 0, 2423, 2424, 1, 0, 0, 0, 2424, 2425, 1, 0, 0, 0, 2425, 2426, 3, 1130, 565, 0, 2426, 241, 1, 0, 0, 0, 2427, 2429, 5, 467, 0, 0, 2428, 2427, 1, 0, 0, 0, 2428, 2429, 1, 0, 0, 0, 2429, 2430, 1, 0, 0, 0, 2430, 2432, 5, 136, 0, 0, 2431, 2433, 5, 254, 0, 0, 2432, 2431, 1, 0, 0, 0, 2432, 2433, 1, 0, 0, 0, 2433, 2434, 1, 0, 0, 0, 2434, 2435, 3, 1130, 565, 0, 2435, 243, 1, 0, 0, 0, 2436, 2438, 5, 467, 0, 0, 2437, 2436, 1, 0, 0, 0, 2437, 2438, 1, 0, 0, 0, 2438, 2439, 1, 0, 0, 0, 2439, 2441, 5, 366, 0, 0, 2440, 2442, 5, 254, 0, 0, 2441, 2440, 1, 0, 0, 0, 2441, 2442, 1, 0, 0, 0, 2442, 2443, 1, 0, 0, 0, 2443, 2444, 3, 1130, 565, 0, 2444, 245, 1, 0, 0, 0, 2445, 2447, 5, 467, 0, 0, 2446, 2445, 1, 0, 0, 0, 2446, 2447, 1, 0, 0, 0, 2447, 2448, 1, 0, 0, 0, 2448, 2450, 5, 448, 0, 0, 2449, 2451, 5, 254, 0, 0, 2450, 2449, 1, 0, 0, 0, 2450, 2451, 1, 0, 0, 0, 2451, 2452, 1, 0, 0, 0, 2452, 2453, 3, 1130, 565, 0, 2453, 247, 1, 0, 0, 0, 2454, 2456, 5, 467, 0, 0, 2455, 2454, 1, 0, 0, 0, 2455, 2456, 1, 0, 0, 0, 2456, 2457, 1, 0, 0, 0, 2457, 2459, 5, 475, 0, 0, 2458, 2460, 5, 254, 0, 0, 2459, 2458, 1, 0, 0, 0, 2459, 2460, 1, 0, 0, 0, 2460, 2461, 1, 0, 0, 0, 2461, 2462, 3, 1130, 565, 0, 2462, 249, 1, 0, 0, 0, 2463, 2465, 5, 467, 0, 0, 2464, 2463, 1, 0, 0, 0, 2464, 2465, 1, 0, 0, 0, 2465, 2466, 1, 0, 0, 0, 2466, 2468, 7, 16, 0, 0, 2467, 2469, 5, 254, 0, 0, 2468, 2467, 1, 0, 0, 0, 2468, 2469, 1, 0, 0, 0, 2469, 2470, 1, 0, 0, 0, 2470, 2471, 3, 1130, 565, 0, 2471, 251, 1, 0, 0, 0, 2472, 2473, 5, 478, 0, 0, 2473, 2475, 5, 269, 0, 0, 2474, 2476, 5, 254, 0, 0, 2475, 2474, 1, 0, 0, 0, 2475, 2476, 1, 0, 0, 0, 2476, 2477, 1, 0, 0, 0, 2477, 2478, 3, 1130, 565, 0, 2478, 253, 1, 0, 0, 0, 2479, 2480, 5, 285, 0, 0, 2480, 2481, 5, 419, 0, 0, 2481, 2486, 5, 534, 0, 0, 2482, 2483, 5, 265, 0, 0, 2483, 2484, 3, 1144, 572, 0, 2484, 2485, 5, 534, 0, 0, 2485, 2487, 1, 0, 0, 0, 2486, 2482, 1, 0, 0, 0, 2486, 2487, 1, 0, 0, 0, 2487, 2491, 1, 0, 0, 0, 2488, 2490, 3, 434, 217, 0, 2489, 2488, 1, 0, 0, 0, 2490, 2493, 1, 0, 0, 0, 2491, 2489, 1, 0, 0, 0, 2491, 2492, 1, 0, 0, 0, 2492, 255, 1, 0, 0, 0, 2493, 2491, 1, 0, 0, 0, 2494, 2495, 5, 416, 0, 0, 2495, 2496, 5, 419, 0, 0, 2496, 2500, 5, 534, 0, 0, 2497, 2499, 3, 258, 129, 0, 2498, 2497, 1, 0, 0, 0, 2499, 2502, 1, 0, 0, 0, 2500, 2498, 1, 0, 0, 0, 2500, 2501, 1, 0, 0, 0, 2501, 257, 1, 0, 0, 0, 2502, 2500, 1, 0, 0, 0, 2503, 2506, 5, 555, 0, 0, 2504, 2507, 5, 208, 0, 0, 2505, 2507, 3, 1160, 580, 0, 2506, 2504, 1, 0, 0, 0, 2506, 2505, 1, 0, 0, 0, 2506, 2507, 1, 0, 0, 0, 2507, 2540, 1, 0, 0, 0, 2508, 2539, 3, 260, 130, 0, 2509, 2539, 3, 262, 131, 0, 2510, 2539, 3, 264, 132, 0, 2511, 2539, 3, 266, 133, 0, 2512, 2539, 3, 268, 134, 0, 2513, 2539, 3, 270, 135, 0, 2514, 2539, 3, 272, 136, 0, 2515, 2539, 3, 274, 137, 0, 2516, 2539, 3, 276, 138, 0, 2517, 2539, 3, 278, 139, 0, 2518, 2539, 3, 280, 140, 0, 2519, 2539, 3, 282, 141, 0, 2520, 2539, 3, 284, 142, 0, 2521, 2539, 3, 286, 143, 0, 2522, 2539, 3, 288, 144, 0, 2523, 2539, 3, 290, 145, 0, 2524, 2527, 3, 292, 146, 0, 2525, 2527, 3, 296, 148, 0, 2526, 2524, 1, 0, 0, 0, 2526, 2525, 1, 0, 0, 0, 2527, 2539, 1, 0, 0, 0, 2528, 2539, 3, 298, 149, 0, 2529, 2539, 3, 300, 150, 0, 2530, 2539, 3, 302, 151, 0, 2531, 2539, 3, 304, 152, 0, 2532, 2539, 3, 306, 153, 0, 2533, 2539, 3, 308, 154, 0, 2534, 2539, 3, 310, 155, 0, 2535, 2539, 3, 312, 156, 0, 2536, 2539, 3, 316, 158, 0, 2537, 2539, 3, 318, 159, 0, 2538, 2508, 1, 0, 0, 0, 2538, 2509, 1, 0, 0, 0, 2538, 2510, 1, 0, 0, 0, 2538, 2511, 1, 0, 0, 0, 2538, 2512, 1, 0, 0, 0, 2538, 2513, 1, 0, 0, 0, 2538, 2514, 1, 0, 0, 0, 2538, 2515, 1, 0, 0, 0, 2538, 2516, 1, 0, 0, 0, 2538, 2517, 1, 0, 0, 0, 2538, 2518, 1, 0, 0, 0, 2538, 2519, 1, 0, 0, 0, 2538, 2520, 1, 0, 0, 0, 2538, 2521, 1, 0, 0, 0, 2538, 2522, 1, 0, 0, 0, 2538, 2523, 1, 0, 0, 0, 2538, 2526, 1, 0, 0, 0, 2538, 2528, 1, 0, 0, 0, 2538, 2529, 1, 0, 0, 0, 2538, 2530, 1, 0, 0, 0, 2538, 2531, 1, 0, 0, 0, 2538, 2532, 1, 0, 0, 0, 2538, 2533, 1, 0, 0, 0, 2538, 2534, 1, 0, 0, 0, 2538, 2535, 1, 0, 0, 0, 2538, 2536, 1, 0, 0, 0, 2538, 2537, 1, 0, 0, 0, 2539, 2542, 1, 0, 0, 0, 2540, 2538, 1, 0, 0, 0, 2540, 2541, 1, 0, 0, 0, 2541, 2543, 1, 0, 0, 0, 2542, 2540, 1, 0, 0, 0, 2543, 2544, 5, 534, 0, 0, 2544, 259, 1, 0, 0, 0, 2545, 2546, 5, 44, 0, 0, 2546, 2547, 7, 17, 0, 0, 2547, 261, 1, 0, 0, 0, 2548, 2549, 7, 18, 0, 0, 2549, 263, 1, 0, 0, 0, 2550, 2551, 5, 45, 0, 0, 2551, 265, 1, 0, 0, 0, 2552, 2553, 5, 187, 0, 0, 2553, 2554, 7, 19, 0, 0, 2554, 267, 1, 0, 0, 0, 2555, 2556, 7, 20, 0, 0, 2556, 269, 1, 0, 0, 0, 2557, 2558, 7, 21, 0, 0, 2558, 271, 1, 0, 0, 0, 2559, 2560, 5, 401, 0, 0, 2560, 273, 1, 0, 0, 0, 2561, 2562, 5, 498, 0, 0, 2562, 275, 1, 0, 0, 0, 2563, 2565, 5, 439, 0, 0, 2564, 2566, 5, 254, 0, 0, 2565, 2564, 1, 0, 0, 0, 2565, 2566, 1, 0, 0, 0, 2566, 2569, 1, 0, 0, 0, 2567, 2570, 3, 1074, 537, 0, 2568, 2570, 3, 1178, 589, 0, 2569, 2567, 1, 0, 0, 0, 2569, 2568, 1, 0, 0, 0, 2570, 277, 1, 0, 0, 0, 2571, 2579, 5, 279, 0, 0, 2572, 2574, 5, 315, 0, 0, 2573, 2572, 1, 0, 0, 0, 2573, 2574, 1, 0, 0, 0, 2574, 2576, 1, 0, 0, 0, 2575, 2577, 5, 254, 0, 0, 2576, 2575, 1, 0, 0, 0, 2576, 2577, 1, 0, 0, 0, 2577, 2578, 1, 0, 0, 0, 2578, 2580, 7, 22, 0, 0, 2579, 2573, 1, 0, 0, 0, 2579, 2580, 1, 0, 0, 0, 2580, 2583, 1, 0, 0, 0, 2581, 2584, 3, 1074, 537, 0, 2582, 2584, 3, 1178, 589, 0, 2583, 2581, 1, 0, 0, 0, 2583, 2582, 1, 0, 0, 0, 2584, 279, 1, 0, 0, 0, 2585, 2593, 7, 23, 0, 0, 2586, 2588, 5, 315, 0, 0, 2587, 2586, 1, 0, 0, 0, 2587, 2588, 1, 0, 0, 0, 2588, 2590, 1, 0, 0, 0, 2589, 2591, 5, 254, 0, 0, 2590, 2589, 1, 0, 0, 0, 2590, 2591, 1, 0, 0, 0, 2591, 2592, 1, 0, 0, 0, 2592, 2594, 7, 22, 0, 0, 2593, 2587, 1, 0, 0, 0, 2593, 2594, 1, 0, 0, 0, 2594, 2597, 1, 0, 0, 0, 2595, 2598, 3, 1074, 537, 0, 2596, 2598, 3, 1178, 589, 0, 2597, 2595, 1, 0, 0, 0, 2597, 2596, 1, 0, 0, 0, 2598, 281, 1, 0, 0, 0, 2599, 2601, 7, 24, 0, 0, 2600, 2602, 5, 254, 0, 0, 2601, 2600, 1, 0, 0, 0, 2601, 2602, 1, 0, 0, 0, 2602, 2605, 1, 0, 0, 0, 2603, 2606, 3, 1074, 537, 0, 2604, 2606, 3, 1178, 589, 0, 2605, 2603, 1, 0, 0, 0, 2605, 2604, 1, 0, 0, 0, 2606, 283, 1, 0, 0, 0, 2607, 2609, 7, 25, 0, 0, 2608, 2610, 5, 254, 0, 0, 2609, 2608, 1, 0, 0, 0, 2609, 2610, 1, 0, 0, 0, 2610, 2613, 1, 0, 0, 0, 2611, 2614, 3, 1074, 537, 0, 2612, 2614, 3, 1178, 589, 0, 2613, 2611, 1, 0, 0, 0, 2613, 2612, 1, 0, 0, 0, 2614, 285, 1, 0, 0, 0, 2615, 2617, 5, 97, 0, 0, 2616, 2618, 5, 254, 0, 0, 2617, 2616, 1, 0, 0, 0, 2617, 2618, 1, 0, 0, 0, 2618, 2619, 1, 0, 0, 0, 2619, 2620, 3, 1074, 537, 0, 2620, 287, 1, 0, 0, 0, 2621, 2623, 5, 507, 0, 0, 2622, 2624, 5, 254, 0, 0, 2623, 2622, 1, 0, 0, 0, 2623, 2624, 1, 0, 0, 0, 2624, 2625, 1, 0, 0, 0, 2625, 2626, 3, 1172, 586, 0, 2626, 289, 1, 0, 0, 0, 2627, 2629, 7, 26, 0, 0, 2628, 2630, 5, 254, 0, 0, 2629, 2628, 1, 0, 0, 0, 2629, 2630, 1, 0, 0, 0, 2630, 2631, 1, 0, 0, 0, 2631, 2632, 3, 466, 233, 0, 2632, 291, 1, 0, 0, 0, 2633, 2636, 5, 215, 0, 0, 2634, 2637, 3, 1074, 537, 0, 2635, 2637, 3, 1172, 586, 0, 2636, 2634, 1, 0, 0, 0, 2636, 2635, 1, 0, 0, 0, 2637, 2639, 1, 0, 0, 0, 2638, 2640, 3, 294, 147, 0, 2639, 2638, 1, 0, 0, 0, 2639, 2640, 1, 0, 0, 0, 2640, 293, 1, 0, 0, 0, 2641, 2642, 5, 489, 0, 0, 2642, 2643, 3, 1074, 537, 0, 2643, 295, 1, 0, 0, 0, 2644, 2645, 5, 506, 0, 0, 2645, 2646, 3, 1074, 537, 0, 2646, 297, 1, 0, 0, 0, 2647, 2649, 5, 504, 0, 0, 2648, 2650, 5, 254, 0, 0, 2649, 2648, 1, 0, 0, 0, 2649, 2650, 1, 0, 0, 0, 2650, 2651, 1, 0, 0, 0, 2651, 2652, 7, 27, 0, 0, 2652, 299, 1, 0, 0, 0, 2653, 2655, 5, 44, 0, 0, 2654, 2656, 5, 512, 0, 0, 2655, 2654, 1, 0, 0, 0, 2655, 2656, 1, 0, 0, 0, 2656, 2657, 1, 0, 0, 0, 2657, 2658, 5, 521, 0, 0, 2658, 301, 1, 0, 0, 0, 2659, 2661, 7, 28, 0, 0, 2660, 2662, 5, 411, 0, 0, 2661, 2660, 1, 0, 0, 0, 2661, 2662, 1, 0, 0, 0, 2662, 303, 1, 0, 0, 0, 2663, 2665, 5, 438, 0, 0, 2664, 2666, 5, 254, 0, 0, 2665, 2664, 1, 0, 0, 0, 2665, 2666, 1, 0, 0, 0, 2666, 2668, 1, 0, 0, 0, 2667, 2663, 1, 0, 0, 0, 2667, 2668, 1, 0, 0, 0, 2668, 2669, 1, 0, 0, 0, 2669, 2674, 7, 7, 0, 0, 2670, 2672, 5, 427, 0, 0, 2671, 2673, 5, 62, 0, 0, 2672, 2671, 1, 0, 0, 0, 2672, 2673, 1, 0, 0, 0, 2673, 2675, 1, 0, 0, 0, 2674, 2670, 1, 0, 0, 0, 2674, 2675, 1, 0, 0, 0, 2675, 305, 1, 0, 0, 0, 2676, 2677, 7, 29, 0, 0, 2677, 307, 1, 0, 0, 0, 2678, 2679, 7, 30, 0, 0, 2679, 309, 1, 0, 0, 0, 2680, 2681, 7, 31, 0, 0, 2681, 311, 1, 0, 0, 0, 2682, 2684, 5, 364, 0, 0, 2683, 2685, 5, 62, 0, 0, 2684, 2683, 1, 0, 0, 0, 2684, 2685, 1, 0, 0, 0, 2685, 2687, 1, 0, 0, 0, 2686, 2688, 5, 254, 0, 0, 2687, 2686, 1, 0, 0, 0, 2687, 2688, 1, 0, 0, 0, 2688, 2691, 1, 0, 0, 0, 2689, 2692, 3, 1074, 537, 0, 2690, 2692, 3, 1172, 586, 0, 2691, 2689, 1, 0, 0, 0, 2691, 2690, 1, 0, 0, 0, 2692, 2694, 1, 0, 0, 0, 2693, 2695, 3, 314, 157, 0, 2694, 2693, 1, 0, 0, 0, 2694, 2695, 1, 0, 0, 0, 2695, 313, 1, 0, 0, 0, 2696, 2697, 5, 321, 0, 0, 2697, 2699, 3, 1178, 589, 0, 2698, 2700, 5, 487, 0, 0, 2699, 2698, 1, 0, 0, 0, 2699, 2700, 1, 0, 0, 0, 2700, 315, 1, 0, 0, 0, 2701, 2702, 7, 32, 0, 0, 2702, 317, 1, 0, 0, 0, 2703, 2704, 5, 522, 0, 0, 2704, 319, 1, 0, 0, 0, 2705, 2706, 5, 395, 0, 0, 2706, 2707, 5, 419, 0, 0, 2707, 2711, 5, 534, 0, 0, 2708, 2710, 3, 322, 161, 0, 2709, 2708, 1, 0, 0, 0, 2710, 2713, 1, 0, 0, 0, 2711, 2709, 1, 0, 0, 0, 2711, 2712, 1, 0, 0, 0, 2712, 321, 1, 0, 0, 0, 2713, 2711, 1, 0, 0, 0, 2714, 2716, 3, 324, 162, 0, 2715, 2717, 3, 338, 169, 0, 2716, 2715, 1, 0, 0, 0, 2717, 2718, 1, 0, 0, 0, 2718, 2716, 1, 0, 0, 0, 2718, 2719, 1, 0, 0, 0, 2719, 323, 1, 0, 0, 0, 2720, 2721, 5, 372, 0, 0, 2721, 2723, 3, 1156, 578, 0, 2722, 2724, 3, 326, 163, 0, 2723, 2722, 1, 0, 0, 0, 2723, 2724, 1, 0, 0, 0, 2724, 2738, 1, 0, 0, 0, 2725, 2727, 3, 328, 164, 0, 2726, 2728, 3, 330, 165, 0, 2727, 2726, 1, 0, 0, 0, 2727, 2728, 1, 0, 0, 0, 2728, 2730, 1, 0, 0, 0, 2729, 2731, 3, 332, 166, 0, 2730, 2729, 1, 0, 0, 0, 2730, 2731, 1, 0, 0, 0, 2731, 2733, 1, 0, 0, 0, 2732, 2734, 3, 334, 167, 0, 2733, 2732, 1, 0, 0, 0, 2733, 2734, 1, 0, 0, 0, 2734, 2736, 1, 0, 0, 0, 2735, 2737, 3, 336, 168, 0, 2736, 2735, 1, 0, 0, 0, 2736, 2737, 1, 0, 0, 0, 2737, 2739, 1, 0, 0, 0, 2738, 2725, 1, 0, 0, 0, 2738, 2739, 1, 0, 0, 0, 2739, 2740, 1, 0, 0, 0, 2740, 2741, 5, 534, 0, 0, 2741, 325, 1, 0, 0, 0, 2742, 2744, 5, 254, 0, 0, 2743, 2742, 1, 0, 0, 0, 2743, 2744, 1, 0, 0, 0, 2744, 2745, 1, 0, 0, 0, 2745, 2746, 5, 223, 0, 0, 2746, 327, 1, 0, 0, 0, 2747, 2756, 5, 340, 0, 0, 2748, 2750, 5, 275, 0, 0, 2749, 2751, 5, 254, 0, 0, 2750, 2749, 1, 0, 0, 0, 2750, 2751, 1, 0, 0, 0, 2751, 2757, 1, 0, 0, 0, 2752, 2754, 5, 276, 0, 0, 2753, 2755, 5, 21, 0, 0, 2754, 2753, 1, 0, 0, 0, 2754, 2755, 1, 0, 0, 0, 2755, 2757, 1, 0, 0, 0, 2756, 2748, 1, 0, 0, 0, 2756, 2752, 1, 0, 0, 0, 2756, 2757, 1, 0, 0, 0, 2757, 2758, 1, 0, 0, 0, 2758, 2760, 3, 1178, 589, 0, 2759, 2761, 7, 33, 0, 0, 2760, 2759, 1, 0, 0, 0, 2760, 2761, 1, 0, 0, 0, 2761, 329, 1, 0, 0, 0, 2762, 2763, 5, 228, 0, 0, 2763, 2764, 3, 1178, 589, 0, 2764, 331, 1, 0, 0, 0, 2765, 2766, 5, 210, 0, 0, 2766, 2767, 5, 137, 0, 0, 2767, 2768, 3, 1178, 589, 0, 2768, 333, 1, 0, 0, 0, 2769, 2770, 5, 263, 0, 0, 2770, 2771, 5, 137, 0, 0, 2771, 2772, 3, 1178, 589, 0, 2772, 335, 1, 0, 0, 0, 2773, 2774, 5, 211, 0, 0, 2774, 2775, 3, 1178, 589, 0, 2775, 337, 1, 0, 0, 0, 2776, 2780, 3, 340, 170, 0, 2777, 2780, 3, 342, 171, 0, 2778, 2780, 3, 344, 172, 0, 2779, 2776, 1, 0, 0, 0, 2779, 2777, 1, 0, 0, 0, 2779, 2778, 1, 0, 0, 0, 2780, 339, 1, 0, 0, 0, 2781, 2782, 3, 1178, 589, 0, 2782, 2784, 3, 1128, 564, 0, 2783, 2785, 3, 354, 177, 0, 2784, 2783, 1, 0, 0, 0, 2784, 2785, 1, 0, 0, 0, 2785, 2787, 1, 0, 0, 0, 2786, 2788, 3, 360, 180, 0, 2787, 2786, 1, 0, 0, 0, 2787, 2788, 1, 0, 0, 0, 2788, 2789, 1, 0, 0, 0, 2789, 2791, 3, 376, 188, 0, 2790, 2792, 3, 388, 194, 0, 2791, 2790, 1, 0, 0, 0, 2791, 2792, 1, 0, 0, 0, 2792, 2793, 1, 0, 0, 0, 2793, 2794, 5, 534, 0, 0, 2794, 341, 1, 0, 0, 0, 2795, 2797, 3, 1178, 589, 0, 2796, 2798, 3, 1128, 564, 0, 2797, 2796, 1, 0, 0, 0, 2797, 2798, 1, 0, 0, 0, 2798, 2800, 1, 0, 0, 0, 2799, 2801, 3, 354, 177, 0, 2800, 2799, 1, 0, 0, 0, 2800, 2801, 1, 0, 0, 0, 2801, 2802, 1, 0, 0, 0, 2802, 2803, 3, 388, 194, 0, 2803, 2804, 5, 534, 0, 0, 2804, 343, 1, 0, 0, 0, 2805, 2807, 3, 1178, 589, 0, 2806, 2808, 3, 1128, 564, 0, 2807, 2806, 1, 0, 0, 0, 2807, 2808, 1, 0, 0, 0, 2808, 2825, 1, 0, 0, 0, 2809, 2824, 3, 366, 183, 0, 2810, 2824, 3, 388, 194, 0, 2811, 2824, 3, 370, 185, 0, 2812, 2824, 3, 352, 176, 0, 2813, 2824, 3, 346, 173, 0, 2814, 2824, 3, 354, 177, 0, 2815, 2824, 3, 348, 174, 0, 2816, 2821, 3, 372, 186, 0, 2817, 2821, 3, 394, 197, 0, 2818, 2821, 3, 374, 187, 0, 2819, 2821, 3, 368, 184, 0, 2820, 2816, 1, 0, 0, 0, 2820, 2817, 1, 0, 0, 0, 2820, 2818, 1, 0, 0, 0, 2820, 2819, 1, 0, 0, 0, 2821, 2824, 1, 0, 0, 0, 2822, 2824, 3, 350, 175, 0, 2823, 2809, 1, 0, 0, 0, 2823, 2810, 1, 0, 0, 0, 2823, 2811, 1, 0, 0, 0, 2823, 2812, 1, 0, 0, 0, 2823, 2813, 1, 0, 0, 0, 2823, 2814, 1, 0, 0, 0, 2823, 2815, 1, 0, 0, 0, 2823, 2820, 1, 0, 0, 0, 2823, 2822, 1, 0, 0, 0, 2824, 2827, 1, 0, 0, 0, 2825, 2823, 1, 0, 0, 0, 2825, 2826, 1, 0, 0, 0, 2826, 2828, 1, 0, 0, 0, 2827, 2825, 1, 0, 0, 0, 2828, 2829, 5, 534, 0, 0, 2829, 345, 1, 0, 0, 0, 2830, 2832, 5, 44, 0, 0, 2831, 2833, 5, 512, 0, 0, 2832, 2831, 1, 0, 0, 0, 2832, 2833, 1, 0, 0, 0, 2833, 2834, 1, 0, 0, 0, 2834, 2835, 5, 521, 0, 0, 2835, 347, 1, 0, 0, 0, 2836, 2838, 5, 74, 0, 0, 2837, 2839, 5, 315, 0, 0, 2838, 2837, 1, 0, 0, 0, 2838, 2839, 1, 0, 0, 0, 2839, 2841, 1, 0, 0, 0, 2840, 2842, 5, 254, 0, 0, 2841, 2840, 1, 0, 0, 0, 2841, 2842, 1, 0, 0, 0, 2842, 2843, 1, 0, 0, 0, 2843, 2844, 3, 1178, 589, 0, 2844, 349, 1, 0, 0, 0, 2845, 2847, 5, 227, 0, 0, 2846, 2848, 5, 242, 0, 0, 2847, 2846, 1, 0, 0, 0, 2847, 2848, 1, 0, 0, 0, 2848, 351, 1, 0, 0, 0, 2849, 2851, 7, 28, 0, 0, 2850, 2852, 5, 411, 0, 0, 2851, 2850, 1, 0, 0, 0, 2851, 2852, 1, 0, 0, 0, 2852, 353, 1, 0, 0, 0, 2853, 2855, 5, 279, 0, 0, 2854, 2853, 1, 0, 0, 0, 2854, 2855, 1, 0, 0, 0, 2855, 2857, 1, 0, 0, 0, 2856, 2858, 5, 315, 0, 0, 2857, 2856, 1, 0, 0, 0, 2857, 2858, 1, 0, 0, 0, 2858, 2860, 1, 0, 0, 0, 2859, 2861, 5, 254, 0, 0, 2860, 2859, 1, 0, 0, 0, 2860, 2861, 1, 0, 0, 0, 2861, 2864, 1, 0, 0, 0, 2862, 2865, 3, 356, 178, 0, 2863, 2865, 3, 358, 179, 0, 2864, 2862, 1, 0, 0, 0, 2864, 2863, 1, 0, 0, 0, 2865, 355, 1, 0, 0, 0, 2866, 2872, 3, 1178, 589, 0, 2867, 2869, 5, 326, 0, 0, 2868, 2867, 1, 0, 0, 0, 2868, 2869, 1, 0, 0, 0, 2869, 2870, 1, 0, 0, 0, 2870, 2871, 5, 309, 0, 0, 2871, 2873, 5, 340, 0, 0, 2872, 2868, 1, 0, 0, 0, 2872, 2873, 1, 0, 0, 0, 2873, 357, 1, 0, 0, 0, 2874, 2875, 5, 348, 0, 0, 2875, 2876, 3, 1178, 589, 0, 2876, 359, 1, 0, 0, 0, 2877, 2878, 5, 309, 0, 0, 2878, 2880, 5, 227, 0, 0, 2879, 2881, 5, 254, 0, 0, 2880, 2879, 1, 0, 0, 0, 2880, 2881, 1, 0, 0, 0, 2881, 2885, 1, 0, 0, 0, 2882, 2886, 3, 1178, 589, 0, 2883, 2886, 3, 364, 182, 0, 2884, 2886, 3, 362, 181, 0, 2885, 2882, 1, 0, 0, 0, 2885, 2883, 1, 0, 0, 0, 2885, 2884, 1, 0, 0, 0, 2886, 361, 1, 0, 0, 0, 2887, 2888, 5, 348, 0, 0, 2888, 2889, 3, 1178, 589, 0, 2889, 363, 1, 0, 0, 0, 2890, 2891, 5, 309, 0, 0, 2891, 2892, 5, 340, 0, 0, 2892, 365, 1, 0, 0, 0, 2893, 2895, 7, 26, 0, 0, 2894, 2896, 5, 254, 0, 0, 2895, 2894, 1, 0, 0, 0, 2895, 2896, 1, 0, 0, 0, 2896, 2897, 1, 0, 0, 0, 2897, 2898, 3, 466, 233, 0, 2898, 367, 1, 0, 0, 0, 2899, 2901, 5, 402, 0, 0, 2900, 2902, 5, 326, 0, 0, 2901, 2900, 1, 0, 0, 0, 2901, 2902, 1, 0, 0, 0, 2902, 2905, 1, 0, 0, 0, 2903, 2906, 5, 209, 0, 0, 2904, 2906, 3, 1128, 564, 0, 2905, 2903, 1, 0, 0, 0, 2905, 2904, 1, 0, 0, 0, 2906, 369, 1, 0, 0, 0, 2907, 2909, 5, 438, 0, 0, 2908, 2910, 5, 254, 0, 0, 2909, 2908, 1, 0, 0, 0, 2909, 2910, 1, 0, 0, 0, 2910, 2911, 1, 0, 0, 0, 2911, 2912, 7, 7, 0, 0, 2912, 2914, 5, 427, 0, 0, 2913, 2915, 5, 62, 0, 0, 2914, 2913, 1, 0, 0, 0, 2914, 2915, 1, 0, 0, 0, 2915, 371, 1, 0, 0, 0, 2916, 2918, 5, 448, 0, 0, 2917, 2919, 5, 254, 0, 0, 2918, 2917, 1, 0, 0, 0, 2918, 2919, 1, 0, 0, 0, 2919, 2920, 1, 0, 0, 0, 2920, 2921, 3, 1074, 537, 0, 2921, 373, 1, 0, 0, 0, 2922, 2923, 5, 464, 0, 0, 2923, 2930, 3, 1074, 537, 0, 2924, 2926, 5, 529, 0, 0, 2925, 2924, 1, 0, 0, 0, 2925, 2926, 1, 0, 0, 0, 2926, 2927, 1, 0, 0, 0, 2927, 2929, 3, 1074, 537, 0, 2928, 2925, 1, 0, 0, 0, 2929, 2932, 1, 0, 0, 0, 2930, 2928, 1, 0, 0, 0, 2930, 2931, 1, 0, 0, 0, 2931, 2944, 1, 0, 0, 0, 2932, 2930, 1, 0, 0, 0, 2933, 2934, 5, 503, 0, 0, 2934, 2941, 3, 1128, 564, 0, 2935, 2937, 5, 529, 0, 0, 2936, 2935, 1, 0, 0, 0, 2936, 2937, 1, 0, 0, 0, 2937, 2938, 1, 0, 0, 0, 2938, 2940, 3, 1128, 564, 0, 2939, 2936, 1, 0, 0, 0, 2940, 2943, 1, 0, 0, 0, 2941, 2939, 1, 0, 0, 0, 2941, 2942, 1, 0, 0, 0, 2942, 2945, 1, 0, 0, 0, 2943, 2941, 1, 0, 0, 0, 2944, 2933, 1, 0, 0, 0, 2944, 2945, 1, 0, 0, 0, 2945, 375, 1, 0, 0, 0, 2946, 2948, 5, 496, 0, 0, 2947, 2949, 5, 254, 0, 0, 2948, 2947, 1, 0, 0, 0, 2948, 2949, 1, 0, 0, 0, 2949, 2957, 1, 0, 0, 0, 2950, 2958, 3, 378, 189, 0, 2951, 2958, 3, 380, 190, 0, 2952, 2958, 3, 382, 191, 0, 2953, 2958, 3, 384, 192, 0, 2954, 2958, 3, 386, 193, 0, 2955, 2958, 3, 390, 195, 0, 2956, 2958, 3, 392, 196, 0, 2957, 2950, 1, 0, 0, 0, 2957, 2951, 1, 0, 0, 0, 2957, 2952, 1, 0, 0, 0, 2957, 2953, 1, 0, 0, 0, 2957, 2954, 1, 0, 0, 0, 2957, 2955, 1, 0, 0, 0, 2957, 2956, 1, 0, 0, 0, 2958, 377, 1, 0, 0, 0, 2959, 2960, 5, 395, 0, 0, 2960, 2963, 5, 228, 0, 0, 2961, 2963, 5, 410, 0, 0, 2962, 2959, 1, 0, 0, 0, 2962, 2961, 1, 0, 0, 0, 2963, 379, 1, 0, 0, 0, 2964, 2965, 5, 340, 0, 0, 2965, 2968, 5, 228, 0, 0, 2966, 2968, 5, 345, 0, 0, 2967, 2964, 1, 0, 0, 0, 2967, 2966, 1, 0, 0, 0, 2968, 381, 1, 0, 0, 0, 2969, 2970, 5, 97, 0, 0, 2970, 2973, 5, 228, 0, 0, 2971, 2973, 5, 58, 0, 0, 2972, 2969, 1, 0, 0, 0, 2972, 2971, 1, 0, 0, 0, 2973, 2976, 1, 0, 0, 0, 2974, 2977, 5, 209, 0, 0, 2975, 2977, 3, 1128, 564, 0, 2976, 2974, 1, 0, 0, 0, 2976, 2975, 1, 0, 0, 0, 2977, 383, 1, 0, 0, 0, 2978, 2979, 7, 34, 0, 0, 2979, 385, 1, 0, 0, 0, 2980, 2981, 5, 97, 0, 0, 2981, 2984, 5, 211, 0, 0, 2982, 2984, 5, 57, 0, 0, 2983, 2980, 1, 0, 0, 0, 2983, 2982, 1, 0, 0, 0, 2984, 2987, 1, 0, 0, 0, 2985, 2988, 5, 209, 0, 0, 2986, 2988, 3, 1128, 564, 0, 2987, 2985, 1, 0, 0, 0, 2987, 2986, 1, 0, 0, 0, 2988, 387, 1, 0, 0, 0, 2989, 2991, 5, 504, 0, 0, 2990, 2992, 5, 254, 0, 0, 2991, 2990, 1, 0, 0, 0, 2991, 2992, 1, 0, 0, 0, 2992, 2994, 1, 0, 0, 0, 2993, 2989, 1, 0, 0, 0, 2993, 2994, 1, 0, 0, 0, 2994, 2995, 1, 0, 0, 0, 2995, 2996, 7, 27, 0, 0, 2996, 389, 1, 0, 0, 0, 2997, 2998, 5, 340, 0, 0, 2998, 3001, 5, 211, 0, 0, 2999, 3001, 5, 344, 0, 0, 3000, 2997, 1, 0, 0, 0, 3000, 2999, 1, 0, 0, 0, 3001, 391, 1, 0, 0, 0, 3002, 3003, 5, 395, 0, 0, 3003, 3006, 5, 211, 0, 0, 3004, 3006, 5, 409, 0, 0, 3005, 3002, 1, 0, 0, 0, 3005, 3004, 1, 0, 0, 0, 3006, 393, 1, 0, 0, 0, 3007, 3009, 5, 507, 0, 0, 3008, 3010, 5, 254, 0, 0, 3009, 3008, 1, 0, 0, 0, 3009, 3010, 1, 0, 0, 0, 3010, 3011, 1, 0, 0, 0, 3011, 3012, 3, 1172, 586, 0, 3012, 395, 1, 0, 0, 0, 3013, 3014, 5, 363, 0, 0, 3014, 3015, 5, 419, 0, 0, 3015, 3019, 5, 534, 0, 0, 3016, 3018, 3, 398, 199, 0, 3017, 3016, 1, 0, 0, 0, 3018, 3021, 1, 0, 0, 0, 3019, 3017, 1, 0, 0, 0, 3019, 3020, 1, 0, 0, 0, 3020, 397, 1, 0, 0, 0, 3021, 3019, 1, 0, 0, 0, 3022, 3025, 3, 400, 200, 0, 3023, 3025, 3, 402, 201, 0, 3024, 3022, 1, 0, 0, 0, 3024, 3023, 1, 0, 0, 0, 3025, 399, 1, 0, 0, 0, 3026, 3027, 5, 265, 0, 0, 3027, 3028, 3, 1142, 571, 0, 3028, 3030, 5, 200, 0, 0, 3029, 3031, 3, 404, 202, 0, 3030, 3029, 1, 0, 0, 0, 3030, 3031, 1, 0, 0, 0, 3031, 3033, 1, 0, 0, 0, 3032, 3034, 3, 414, 207, 0, 3033, 3032, 1, 0, 0, 0, 3033, 3034, 1, 0, 0, 0, 3034, 401, 1, 0, 0, 0, 3035, 3036, 5, 264, 0, 0, 3036, 3037, 3, 1142, 571, 0, 3037, 3039, 5, 238, 0, 0, 3038, 3040, 3, 432, 216, 0, 3039, 3038, 1, 0, 0, 0, 3039, 3040, 1, 0, 0, 0, 3040, 3042, 1, 0, 0, 0, 3041, 3043, 3, 430, 215, 0, 3042, 3041, 1, 0, 0, 0, 3042, 3043, 1, 0, 0, 0, 3043, 3048, 1, 0, 0, 0, 3044, 3047, 3, 406, 203, 0, 3045, 3047, 3, 416, 208, 0, 3046, 3044, 1, 0, 0, 0, 3046, 3045, 1, 0, 0, 0, 3047, 3050, 1, 0, 0, 0, 3048, 3046, 1, 0, 0, 0, 3048, 3049, 1, 0, 0, 0, 3049, 403, 1, 0, 0, 0, 3050, 3048, 1, 0, 0, 0, 3051, 3057, 5, 31, 0, 0, 3052, 3054, 5, 434, 0, 0, 3053, 3055, 5, 254, 0, 0, 3054, 3053, 1, 0, 0, 0, 3054, 3055, 1, 0, 0, 0, 3055, 3056, 1, 0, 0, 0, 3056, 3058, 7, 35, 0, 0, 3057, 3052, 1, 0, 0, 0, 3057, 3058, 1, 0, 0, 0, 3058, 405, 1, 0, 0, 0, 3059, 3061, 5, 31, 0, 0, 3060, 3062, 3, 408, 204, 0, 3061, 3060, 1, 0, 0, 0, 3061, 3062, 1, 0, 0, 0, 3062, 3068, 1, 0, 0, 0, 3063, 3065, 5, 272, 0, 0, 3064, 3066, 5, 254, 0, 0, 3065, 3064, 1, 0, 0, 0, 3065, 3066, 1, 0, 0, 0, 3066, 3067, 1, 0, 0, 0, 3067, 3069, 7, 36, 0, 0, 3068, 3063, 1, 0, 0, 0, 3068, 3069, 1, 0, 0, 0, 3069, 3071, 1, 0, 0, 0, 3070, 3072, 3, 410, 205, 0, 3071, 3070, 1, 0, 0, 0, 3071, 3072, 1, 0, 0, 0, 3072, 3074, 1, 0, 0, 0, 3073, 3075, 3, 412, 206, 0, 3074, 3073, 1, 0, 0, 0, 3074, 3075, 1, 0, 0, 0, 3075, 407, 1, 0, 0, 0, 3076, 3077, 5, 218, 0, 0, 3077, 3078, 5, 254, 0, 0, 3078, 3079, 3, 1172, 586, 0, 3079, 409, 1, 0, 0, 0, 3080, 3082, 5, 273, 0, 0, 3081, 3083, 5, 254, 0, 0, 3082, 3081, 1, 0, 0, 0, 3082, 3083, 1, 0, 0, 0, 3083, 3084, 1, 0, 0, 0, 3084, 3085, 3, 1172, 586, 0, 3085, 411, 1, 0, 0, 0, 3086, 3088, 5, 488, 0, 0, 3087, 3089, 5, 254, 0, 0, 3088, 3087, 1, 0, 0, 0, 3088, 3089, 1, 0, 0, 0, 3089, 3090, 1, 0, 0, 0, 3090, 3091, 3, 1172, 586, 0, 3091, 413, 1, 0, 0, 0, 3092, 3093, 5, 183, 0, 0, 3093, 3095, 3, 1152, 576, 0, 3094, 3096, 3, 418, 209, 0, 3095, 3094, 1, 0, 0, 0, 3095, 3096, 1, 0, 0, 0, 3096, 415, 1, 0, 0, 0, 3097, 3098, 5, 183, 0, 0, 3098, 3100, 3, 1152, 576, 0, 3099, 3101, 3, 418, 209, 0, 3100, 3099, 1, 0, 0, 0, 3100, 3101, 1, 0, 0, 0, 3101, 3103, 1, 0, 0, 0, 3102, 3104, 3, 426, 213, 0, 3103, 3102, 1, 0, 0, 0, 3103, 3104, 1, 0, 0, 0, 3104, 3106, 1, 0, 0, 0, 3105, 3107, 3, 422, 211, 0, 3106, 3105, 1, 0, 0, 0, 3106, 3107, 1, 0, 0, 0, 3107, 3109, 1, 0, 0, 0, 3108, 3110, 3, 420, 210, 0, 3109, 3108, 1, 0, 0, 0, 3109, 3110, 1, 0, 0, 0, 3110, 417, 1, 0, 0, 0, 3111, 3112, 5, 212, 0, 0, 3112, 3113, 3, 1172, 586, 0, 3113, 419, 1, 0, 0, 0, 3114, 3115, 5, 222, 0, 0, 3115, 3116, 3, 1128, 564, 0, 3116, 421, 1, 0, 0, 0, 3117, 3119, 5, 506, 0, 0, 3118, 3120, 3, 424, 212, 0, 3119, 3118, 1, 0, 0, 0, 3120, 3121, 1, 0, 0, 0, 3121, 3119, 1, 0, 0, 0, 3121, 3122, 1, 0, 0, 0, 3122, 423, 1, 0, 0, 0, 3123, 3126, 3, 1128, 564, 0, 3124, 3126, 3, 1134, 567, 0, 3125, 3123, 1, 0, 0, 0, 3125, 3124, 1, 0, 0, 0, 3126, 425, 1, 0, 0, 0, 3127, 3129, 5, 514, 0, 0, 3128, 3130, 3, 428, 214, 0, 3129, 3128, 1, 0, 0, 0, 3130, 3131, 1, 0, 0, 0, 3131, 3129, 1, 0, 0, 0, 3131, 3132, 1, 0, 0, 0, 3132, 427, 1, 0, 0, 0, 3133, 3136, 3, 1144, 572, 0, 3134, 3136, 3, 1134, 567, 0, 3135, 3133, 1, 0, 0, 0, 3135, 3134, 1, 0, 0, 0, 3136, 429, 1, 0, 0, 0, 3137, 3139, 5, 254, 0, 0, 3138, 3137, 1, 0, 0, 0, 3138, 3139, 1, 0, 0, 0, 3139, 3140, 1, 0, 0, 0, 3140, 3141, 5, 78, 0, 0, 3141, 431, 1, 0, 0, 0, 3142, 3144, 5, 254, 0, 0, 3143, 3142, 1, 0, 0, 0, 3143, 3144, 1, 0, 0, 0, 3144, 3145, 1, 0, 0, 0, 3145, 3146, 5, 223, 0, 0, 3146, 433, 1, 0, 0, 0, 3147, 3152, 3, 436, 218, 0, 3148, 3152, 3, 438, 219, 0, 3149, 3152, 3, 440, 220, 0, 3150, 3152, 3, 442, 221, 0, 3151, 3147, 1, 0, 0, 0, 3151, 3148, 1, 0, 0, 0, 3151, 3149, 1, 0, 0, 0, 3151, 3150, 1, 0, 0, 0, 3152, 435, 1, 0, 0, 0, 3153, 3156, 7, 37, 0, 0, 3154, 3157, 5, 208, 0, 0, 3155, 3157, 3, 1128, 564, 0, 3156, 3154, 1, 0, 0, 0, 3156, 3155, 1, 0, 0, 0, 3156, 3157, 1, 0, 0, 0, 3157, 3181, 1, 0, 0, 0, 3158, 3180, 3, 476, 238, 0, 3159, 3180, 3, 454, 227, 0, 3160, 3180, 3, 450, 225, 0, 3161, 3180, 3, 452, 226, 0, 3162, 3180, 3, 488, 244, 0, 3163, 3180, 3, 484, 242, 0, 3164, 3180, 3, 464, 232, 0, 3165, 3180, 3, 448, 224, 0, 3166, 3180, 3, 486, 243, 0, 3167, 3180, 3, 492, 246, 0, 3168, 3180, 3, 490, 245, 0, 3169, 3180, 3, 494, 247, 0, 3170, 3180, 3, 472, 236, 0, 3171, 3180, 3, 458, 229, 0, 3172, 3180, 3, 480, 240, 0, 3173, 3180, 3, 482, 241, 0, 3174, 3180, 3, 456, 228, 0, 3175, 3180, 3, 446, 223, 0, 3176, 3180, 3, 502, 251, 0, 3177, 3180, 3, 444, 222, 0, 3178, 3180, 3, 474, 237, 0, 3179, 3158, 1, 0, 0, 0, 3179, 3159, 1, 0, 0, 0, 3179, 3160, 1, 0, 0, 0, 3179, 3161, 1, 0, 0, 0, 3179, 3162, 1, 0, 0, 0, 3179, 3163, 1, 0, 0, 0, 3179, 3164, 1, 0, 0, 0, 3179, 3165, 1, 0, 0, 0, 3179, 3166, 1, 0, 0, 0, 3179, 3167, 1, 0, 0, 0, 3179, 3168, 1, 0, 0, 0, 3179, 3169, 1, 0, 0, 0, 3179, 3170, 1, 0, 0, 0, 3179, 3171, 1, 0, 0, 0, 3179, 3172, 1, 0, 0, 0, 3179, 3173, 1, 0, 0, 0, 3179, 3174, 1, 0, 0, 0, 3179, 3175, 1, 0, 0, 0, 3179, 3176, 1, 0, 0, 0, 3179, 3177, 1, 0, 0, 0, 3179, 3178, 1, 0, 0, 0, 3180, 3183, 1, 0, 0, 0, 3181, 3179, 1, 0, 0, 0, 3181, 3182, 1, 0, 0, 0, 3182, 3184, 1, 0, 0, 0, 3183, 3181, 1, 0, 0, 0, 3184, 3185, 5, 534, 0, 0, 3185, 437, 1, 0, 0, 0, 3186, 3187, 5, 552, 0, 0, 3187, 3188, 3, 1128, 564, 0, 3188, 3189, 3, 478, 239, 0, 3189, 3190, 5, 534, 0, 0, 3190, 439, 1, 0, 0, 0, 3191, 3192, 5, 554, 0, 0, 3192, 3193, 3, 1126, 563, 0, 3193, 3194, 3, 494, 247, 0, 3194, 3195, 5, 534, 0, 0, 3195, 441, 1, 0, 0, 0, 3196, 3198, 5, 561, 0, 0, 3197, 3196, 1, 0, 0, 0, 3198, 3199, 1, 0, 0, 0, 3199, 3197, 1, 0, 0, 0, 3199, 3200, 1, 0, 0, 0, 3200, 3202, 1, 0, 0, 0, 3201, 3203, 5, 534, 0, 0, 3202, 3201, 1, 0, 0, 0, 3202, 3203, 1, 0, 0, 0, 3203, 443, 1, 0, 0, 0, 3204, 3205, 5, 8, 0, 0, 3205, 445, 1, 0, 0, 0, 3206, 3208, 5, 44, 0, 0, 3207, 3209, 5, 512, 0, 0, 3208, 3207, 1, 0, 0, 0, 3208, 3209, 1, 0, 0, 0, 3209, 3210, 1, 0, 0, 0, 3210, 3211, 7, 38, 0, 0, 3211, 447, 1, 0, 0, 0, 3212, 3213, 7, 39, 0, 0, 3213, 449, 1, 0, 0, 0, 3214, 3216, 5, 254, 0, 0, 3215, 3214, 1, 0, 0, 0, 3215, 3216, 1, 0, 0, 0, 3216, 3217, 1, 0, 0, 0, 3217, 3220, 5, 203, 0, 0, 3218, 3219, 5, 49, 0, 0, 3219, 3221, 3, 1172, 586, 0, 3220, 3218, 1, 0, 0, 0, 3220, 3221, 1, 0, 0, 0, 3221, 451, 1, 0, 0, 0, 3222, 3224, 5, 254, 0, 0, 3223, 3222, 1, 0, 0, 0, 3223, 3224, 1, 0, 0, 0, 3224, 3225, 1, 0, 0, 0, 3225, 3226, 5, 223, 0, 0, 3226, 453, 1, 0, 0, 0, 3227, 3228, 7, 40, 0, 0, 3228, 455, 1, 0, 0, 0, 3229, 3231, 7, 28, 0, 0, 3230, 3232, 5, 411, 0, 0, 3231, 3230, 1, 0, 0, 0, 3231, 3232, 1, 0, 0, 0, 3232, 457, 1, 0, 0, 0, 3233, 3234, 5, 321, 0, 0, 3234, 3236, 3, 1178, 589, 0, 3235, 3237, 3, 460, 230, 0, 3236, 3235, 1, 0, 0, 0, 3236, 3237, 1, 0, 0, 0, 3237, 3239, 1, 0, 0, 0, 3238, 3240, 5, 487, 0, 0, 3239, 3238, 1, 0, 0, 0, 3239, 3240, 1, 0, 0, 0, 3240, 3246, 1, 0, 0, 0, 3241, 3243, 5, 134, 0, 0, 3242, 3244, 5, 326, 0, 0, 3243, 3242, 1, 0, 0, 0, 3243, 3244, 1, 0, 0, 0, 3244, 3245, 1, 0, 0, 0, 3245, 3247, 3, 1090, 545, 0, 3246, 3241, 1, 0, 0, 0, 3246, 3247, 1, 0, 0, 0, 3247, 3251, 1, 0, 0, 0, 3248, 3250, 3, 462, 231, 0, 3249, 3248, 1, 0, 0, 0, 3250, 3253, 1, 0, 0, 0, 3251, 3249, 1, 0, 0, 0, 3251, 3252, 1, 0, 0, 0, 3252, 3266, 1, 0, 0, 0, 3253, 3251, 1, 0, 0, 0, 3254, 3256, 5, 241, 0, 0, 3255, 3257, 5, 49, 0, 0, 3256, 3255, 1, 0, 0, 0, 3256, 3257, 1, 0, 0, 0, 3257, 3259, 1, 0, 0, 0, 3258, 3260, 5, 284, 0, 0, 3259, 3258, 1, 0, 0, 0, 3259, 3260, 1, 0, 0, 0, 3260, 3262, 1, 0, 0, 0, 3261, 3263, 3, 1138, 569, 0, 3262, 3261, 1, 0, 0, 0, 3263, 3264, 1, 0, 0, 0, 3264, 3262, 1, 0, 0, 0, 3264, 3265, 1, 0, 0, 0, 3265, 3267, 1, 0, 0, 0, 3266, 3254, 1, 0, 0, 0, 3266, 3267, 1, 0, 0, 0, 3267, 459, 1, 0, 0, 0, 3268, 3269, 5, 489, 0, 0, 3269, 3270, 3, 1178, 589, 0, 3270, 461, 1, 0, 0, 0, 3271, 3273, 7, 41, 0, 0, 3272, 3274, 5, 259, 0, 0, 3273, 3272, 1, 0, 0, 0, 3273, 3274, 1, 0, 0, 0, 3274, 3276, 1, 0, 0, 0, 3275, 3277, 5, 254, 0, 0, 3276, 3275, 1, 0, 0, 0, 3276, 3277, 1, 0, 0, 0, 3277, 3279, 1, 0, 0, 0, 3278, 3280, 3, 1090, 545, 0, 3279, 3278, 1, 0, 0, 0, 3280, 3281, 1, 0, 0, 0, 3281, 3279, 1, 0, 0, 0, 3281, 3282, 1, 0, 0, 0, 3282, 463, 1, 0, 0, 0, 3283, 3285, 7, 26, 0, 0, 3284, 3286, 5, 254, 0, 0, 3285, 3284, 1, 0, 0, 0, 3285, 3286, 1, 0, 0, 0, 3286, 3287, 1, 0, 0, 0, 3287, 3288, 3, 466, 233, 0, 3288, 465, 1, 0, 0, 0, 3289, 3291, 3, 468, 234, 0, 3290, 3289, 1, 0, 0, 0, 3291, 3292, 1, 0, 0, 0, 3292, 3290, 1, 0, 0, 0, 3292, 3293, 1, 0, 0, 0, 3293, 3295, 1, 0, 0, 0, 3294, 3296, 3, 470, 235, 0, 3295, 3294, 1, 0, 0, 0, 3295, 3296, 1, 0, 0, 0, 3296, 3298, 1, 0, 0, 0, 3297, 3290, 1, 0, 0, 0, 3298, 3299, 1, 0, 0, 0, 3299, 3297, 1, 0, 0, 0, 3299, 3300, 1, 0, 0, 0, 3300, 467, 1, 0, 0, 0, 3301, 3318, 5, 532, 0, 0, 3302, 3318, 5, 557, 0, 0, 3303, 3318, 5, 556, 0, 0, 3304, 3318, 5, 550, 0, 0, 3305, 3318, 5, 529, 0, 0, 3306, 3318, 5, 535, 0, 0, 3307, 3318, 5, 528, 0, 0, 3308, 3318, 5, 526, 0, 0, 3309, 3318, 5, 527, 0, 0, 3310, 3318, 5, 542, 0, 0, 3311, 3318, 5, 549, 0, 0, 3312, 3318, 5, 547, 0, 0, 3313, 3318, 5, 543, 0, 0, 3314, 3318, 5, 540, 0, 0, 3315, 3318, 5, 544, 0, 0, 3316, 3318, 3, 1178, 589, 0, 3317, 3301, 1, 0, 0, 0, 3317, 3302, 1, 0, 0, 0, 3317, 3303, 1, 0, 0, 0, 3317, 3304, 1, 0, 0, 0, 3317, 3305, 1, 0, 0, 0, 3317, 3306, 1, 0, 0, 0, 3317, 3307, 1, 0, 0, 0, 3317, 3308, 1, 0, 0, 0, 3317, 3309, 1, 0, 0, 0, 3317, 3310, 1, 0, 0, 0, 3317, 3311, 1, 0, 0, 0, 3317, 3312, 1, 0, 0, 0, 3317, 3313, 1, 0, 0, 0, 3317, 3314, 1, 0, 0, 0, 3317, 3315, 1, 0, 0, 0, 3317, 3316, 1, 0, 0, 0, 3318, 469, 1, 0, 0, 0, 3319, 3320, 5, 542, 0, 0, 3320, 3321, 3, 1178, 589, 0, 3321, 3322, 5, 549, 0, 0, 3322, 471, 1, 0, 0, 0, 3323, 3325, 5, 376, 0, 0, 3324, 3323, 1, 0, 0, 0, 3324, 3325, 1, 0, 0, 0, 3325, 3327, 1, 0, 0, 0, 3326, 3328, 5, 49, 0, 0, 3327, 3326, 1, 0, 0, 0, 3327, 3328, 1, 0, 0, 0, 3328, 3329, 1, 0, 0, 0, 3329, 3330, 7, 42, 0, 0, 3330, 473, 1, 0, 0, 0, 3331, 3332, 5, 377, 0, 0, 3332, 3333, 5, 22, 0, 0, 3333, 475, 1, 0, 0, 0, 3334, 3335, 5, 381, 0, 0, 3335, 3336, 3, 1128, 564, 0, 3336, 477, 1, 0, 0, 0, 3337, 3338, 5, 392, 0, 0, 3338, 3341, 3, 1090, 545, 0, 3339, 3340, 7, 4, 0, 0, 3340, 3342, 3, 1090, 545, 0, 3341, 3339, 1, 0, 0, 0, 3341, 3342, 1, 0, 0, 0, 3342, 479, 1, 0, 0, 0, 3343, 3345, 5, 438, 0, 0, 3344, 3346, 5, 254, 0, 0, 3345, 3344, 1, 0, 0, 0, 3345, 3346, 1, 0, 0, 0, 3346, 3348, 1, 0, 0, 0, 3347, 3343, 1, 0, 0, 0, 3347, 3348, 1, 0, 0, 0, 3348, 3349, 1, 0, 0, 0, 3349, 3354, 7, 7, 0, 0, 3350, 3352, 5, 427, 0, 0, 3351, 3353, 5, 62, 0, 0, 3352, 3351, 1, 0, 0, 0, 3352, 3353, 1, 0, 0, 0, 3353, 3355, 1, 0, 0, 0, 3354, 3350, 1, 0, 0, 0, 3354, 3355, 1, 0, 0, 0, 3355, 481, 1, 0, 0, 0, 3356, 3358, 7, 43, 0, 0, 3357, 3359, 7, 44, 0, 0, 3358, 3357, 1, 0, 0, 0, 3358, 3359, 1, 0, 0, 0, 3359, 483, 1, 0, 0, 0, 3360, 3362, 5, 254, 0, 0, 3361, 3360, 1, 0, 0, 0, 3361, 3362, 1, 0, 0, 0, 3362, 3363, 1, 0, 0, 0, 3363, 3364, 5, 482, 0, 0, 3364, 485, 1, 0, 0, 0, 3365, 3367, 5, 496, 0, 0, 3366, 3368, 5, 254, 0, 0, 3367, 3366, 1, 0, 0, 0, 3367, 3368, 1, 0, 0, 0, 3368, 3369, 1, 0, 0, 0, 3369, 3370, 7, 45, 0, 0, 3370, 487, 1, 0, 0, 0, 3371, 3373, 5, 254, 0, 0, 3372, 3371, 1, 0, 0, 0, 3372, 3373, 1, 0, 0, 0, 3373, 3374, 1, 0, 0, 0, 3374, 3375, 5, 497, 0, 0, 3375, 489, 1, 0, 0, 0, 3376, 3378, 5, 504, 0, 0, 3377, 3379, 5, 254, 0, 0, 3378, 3377, 1, 0, 0, 0, 3378, 3379, 1, 0, 0, 0, 3379, 3381, 1, 0, 0, 0, 3380, 3376, 1, 0, 0, 0, 3380, 3381, 1, 0, 0, 0, 3381, 3415, 1, 0, 0, 0, 3382, 3384, 5, 42, 0, 0, 3383, 3385, 7, 46, 0, 0, 3384, 3383, 1, 0, 0, 0, 3384, 3385, 1, 0, 0, 0, 3385, 3416, 1, 0, 0, 0, 3386, 3416, 5, 43, 0, 0, 3387, 3416, 5, 80, 0, 0, 3388, 3416, 5, 81, 0, 0, 3389, 3416, 5, 82, 0, 0, 3390, 3416, 5, 83, 0, 0, 3391, 3416, 5, 84, 0, 0, 3392, 3416, 5, 85, 0, 0, 3393, 3416, 5, 86, 0, 0, 3394, 3416, 5, 87, 0, 0, 3395, 3416, 5, 88, 0, 0, 3396, 3416, 5, 89, 0, 0, 3397, 3416, 5, 90, 0, 0, 3398, 3416, 5, 91, 0, 0, 3399, 3416, 5, 98, 0, 0, 3400, 3416, 5, 111, 0, 0, 3401, 3416, 5, 142, 0, 0, 3402, 3416, 5, 143, 0, 0, 3403, 3416, 5, 147, 0, 0, 3404, 3416, 5, 194, 0, 0, 3405, 3416, 5, 219, 0, 0, 3406, 3416, 5, 240, 0, 0, 3407, 3416, 5, 257, 0, 0, 3408, 3416, 5, 286, 0, 0, 3409, 3416, 5, 304, 0, 0, 3410, 3416, 5, 338, 0, 0, 3411, 3416, 5, 349, 0, 0, 3412, 3416, 5, 357, 0, 0, 3413, 3416, 5, 373, 0, 0, 3414, 3416, 5, 473, 0, 0, 3415, 3382, 1, 0, 0, 0, 3415, 3386, 1, 0, 0, 0, 3415, 3387, 1, 0, 0, 0, 3415, 3388, 1, 0, 0, 0, 3415, 3389, 1, 0, 0, 0, 3415, 3390, 1, 0, 0, 0, 3415, 3391, 1, 0, 0, 0, 3415, 3392, 1, 0, 0, 0, 3415, 3393, 1, 0, 0, 0, 3415, 3394, 1, 0, 0, 0, 3415, 3395, 1, 0, 0, 0, 3415, 3396, 1, 0, 0, 0, 3415, 3397, 1, 0, 0, 0, 3415, 3398, 1, 0, 0, 0, 3415, 3399, 1, 0, 0, 0, 3415, 3400, 1, 0, 0, 0, 3415, 3401, 1, 0, 0, 0, 3415, 3402, 1, 0, 0, 0, 3415, 3403, 1, 0, 0, 0, 3415, 3404, 1, 0, 0, 0, 3415, 3405, 1, 0, 0, 0, 3415, 3406, 1, 0, 0, 0, 3415, 3407, 1, 0, 0, 0, 3415, 3408, 1, 0, 0, 0, 3415, 3409, 1, 0, 0, 0, 3415, 3410, 1, 0, 0, 0, 3415, 3411, 1, 0, 0, 0, 3415, 3412, 1, 0, 0, 0, 3415, 3413, 1, 0, 0, 0, 3415, 3414, 1, 0, 0, 0, 3416, 491, 1, 0, 0, 0, 3417, 3418, 5, 506, 0, 0, 3418, 3420, 7, 47, 0, 0, 3419, 3421, 5, 323, 0, 0, 3420, 3419, 1, 0, 0, 0, 3420, 3421, 1, 0, 0, 0, 3421, 3424, 1, 0, 0, 0, 3422, 3425, 3, 1170, 585, 0, 3423, 3425, 3, 1128, 564, 0, 3424, 3422, 1, 0, 0, 0, 3424, 3423, 1, 0, 0, 0, 3425, 493, 1, 0, 0, 0, 3426, 3428, 5, 507, 0, 0, 3427, 3429, 5, 254, 0, 0, 3428, 3427, 1, 0, 0, 0, 3428, 3429, 1, 0, 0, 0, 3429, 3435, 1, 0, 0, 0, 3430, 3432, 5, 508, 0, 0, 3431, 3433, 5, 21, 0, 0, 3432, 3431, 1, 0, 0, 0, 3432, 3433, 1, 0, 0, 0, 3433, 3435, 1, 0, 0, 0, 3434, 3426, 1, 0, 0, 0, 3434, 3430, 1, 0, 0, 0, 3434, 3435, 1, 0, 0, 0, 3435, 3436, 1, 0, 0, 0, 3436, 3443, 3, 496, 248, 0, 3437, 3439, 5, 529, 0, 0, 3438, 3437, 1, 0, 0, 0, 3438, 3439, 1, 0, 0, 0, 3439, 3440, 1, 0, 0, 0, 3440, 3442, 3, 496, 248, 0, 3441, 3438, 1, 0, 0, 0, 3442, 3445, 1, 0, 0, 0, 3443, 3441, 1, 0, 0, 0, 3443, 3444, 1, 0, 0, 0, 3444, 495, 1, 0, 0, 0, 3445, 3443, 1, 0, 0, 0, 3446, 3448, 3, 498, 249, 0, 3447, 3449, 3, 500, 250, 0, 3448, 3447, 1, 0, 0, 0, 3448, 3449, 1, 0, 0, 0, 3449, 497, 1, 0, 0, 0, 3450, 3453, 3, 1172, 586, 0, 3451, 3453, 3, 1170, 585, 0, 3452, 3450, 1, 0, 0, 0, 3452, 3451, 1, 0, 0, 0, 3453, 499, 1, 0, 0, 0, 3454, 3455, 7, 4, 0, 0, 3455, 3456, 3, 1172, 586, 0, 3456, 501, 1, 0, 0, 0, 3457, 3459, 5, 514, 0, 0, 3458, 3457, 1, 0, 0, 0, 3458, 3459, 1, 0, 0, 0, 3459, 3460, 1, 0, 0, 0, 3460, 3461, 5, 289, 0, 0, 3461, 3462, 5, 47, 0, 0, 3462, 503, 1, 0, 0, 0, 3463, 3464, 5, 356, 0, 0, 3464, 3466, 5, 145, 0, 0, 3465, 3467, 3, 506, 253, 0, 3466, 3465, 1, 0, 0, 0, 3466, 3467, 1, 0, 0, 0, 3467, 3469, 1, 0, 0, 0, 3468, 3470, 3, 508, 254, 0, 3469, 3468, 1, 0, 0, 0, 3469, 3470, 1, 0, 0, 0, 3470, 3471, 1, 0, 0, 0, 3471, 3473, 5, 534, 0, 0, 3472, 3474, 3, 520, 260, 0, 3473, 3472, 1, 0, 0, 0, 3473, 3474, 1, 0, 0, 0, 3474, 3475, 1, 0, 0, 0, 3475, 3476, 3, 526, 263, 0, 3476, 505, 1, 0, 0, 0, 3477, 3479, 7, 48, 0, 0, 3478, 3480, 3, 510, 255, 0, 3479, 3478, 1, 0, 0, 0, 3480, 3481, 1, 0, 0, 0, 3481, 3479, 1, 0, 0, 0, 3481, 3482, 1, 0, 0, 0, 3482, 507, 1, 0, 0, 0, 3483, 3484, 7, 49, 0, 0, 3484, 3485, 3, 1128, 564, 0, 3485, 509, 1, 0, 0, 0, 3486, 3489, 3, 512, 256, 0, 3487, 3489, 3, 516, 258, 0, 3488, 3486, 1, 0, 0, 0, 3488, 3487, 1, 0, 0, 0, 3489, 511, 1, 0, 0, 0, 3490, 3492, 5, 49, 0, 0, 3491, 3490, 1, 0, 0, 0, 3491, 3492, 1, 0, 0, 0, 3492, 3493, 1, 0, 0, 0, 3493, 3495, 5, 384, 0, 0, 3494, 3491, 1, 0, 0, 0, 3494, 3495, 1, 0, 0, 0, 3495, 3497, 1, 0, 0, 0, 3496, 3498, 3, 514, 257, 0, 3497, 3496, 1, 0, 0, 0, 3498, 3499, 1, 0, 0, 0, 3499, 3497, 1, 0, 0, 0, 3499, 3500, 1, 0, 0, 0, 3500, 513, 1, 0, 0, 0, 3501, 3503, 5, 328, 0, 0, 3502, 3501, 1, 0, 0, 0, 3502, 3503, 1, 0, 0, 0, 3503, 3506, 1, 0, 0, 0, 3504, 3507, 3, 1074, 537, 0, 3505, 3507, 3, 1134, 567, 0, 3506, 3504, 1, 0, 0, 0, 3506, 3505, 1, 0, 0, 0, 3507, 3510, 1, 0, 0, 0, 3508, 3510, 5, 20, 0, 0, 3509, 3502, 1, 0, 0, 0, 3509, 3508, 1, 0, 0, 0, 3510, 515, 1, 0, 0, 0, 3511, 3513, 5, 49, 0, 0, 3512, 3511, 1, 0, 0, 0, 3512, 3513, 1, 0, 0, 0, 3513, 3514, 1, 0, 0, 0, 3514, 3516, 5, 507, 0, 0, 3515, 3517, 3, 518, 259, 0, 3516, 3515, 1, 0, 0, 0, 3517, 3518, 1, 0, 0, 0, 3518, 3516, 1, 0, 0, 0, 3518, 3519, 1, 0, 0, 0, 3519, 517, 1, 0, 0, 0, 3520, 3524, 3, 1074, 537, 0, 3521, 3524, 3, 1172, 586, 0, 3522, 3524, 5, 20, 0, 0, 3523, 3520, 1, 0, 0, 0, 3523, 3521, 1, 0, 0, 0, 3523, 3522, 1, 0, 0, 0, 3524, 519, 1, 0, 0, 0, 3525, 3526, 5, 127, 0, 0, 3526, 3528, 5, 534, 0, 0, 3527, 3529, 3, 522, 261, 0, 3528, 3527, 1, 0, 0, 0, 3529, 3530, 1, 0, 0, 0, 3530, 3528, 1, 0, 0, 0, 3530, 3531, 1, 0, 0, 0, 3531, 3532, 1, 0, 0, 0, 3532, 3533, 5, 158, 0, 0, 3533, 3534, 5, 127, 0, 0, 3534, 3535, 5, 534, 0, 0, 3535, 521, 1, 0, 0, 0, 3536, 3537, 3, 524, 262, 0, 3537, 3538, 5, 534, 0, 0, 3538, 3539, 3, 986, 493, 0, 3539, 3540, 5, 534, 0, 0, 3540, 3541, 3, 530, 265, 0, 3541, 523, 1, 0, 0, 0, 3542, 3543, 3, 1162, 581, 0, 3543, 3545, 5, 419, 0, 0, 3544, 3546, 3, 1178, 589, 0, 3545, 3544, 1, 0, 0, 0, 3545, 3546, 1, 0, 0, 0, 3546, 525, 1, 0, 0, 0, 3547, 3551, 3, 530, 265, 0, 3548, 3550, 3, 528, 264, 0, 3549, 3548, 1, 0, 0, 0, 3550, 3553, 1, 0, 0, 0, 3551, 3549, 1, 0, 0, 0, 3551, 3552, 1, 0, 0, 0, 3552, 527, 1, 0, 0, 0, 3553, 3551, 1, 0, 0, 0, 3554, 3555, 3, 524, 262, 0, 3555, 3556, 5, 534, 0, 0, 3556, 3557, 3, 530, 265, 0, 3557, 529, 1, 0, 0, 0, 3558, 3560, 3, 534, 267, 0, 3559, 3558, 1, 0, 0, 0, 3560, 3563, 1, 0, 0, 0, 3561, 3559, 1, 0, 0, 0, 3561, 3562, 1, 0, 0, 0, 3562, 3567, 1, 0, 0, 0, 3563, 3561, 1, 0, 0, 0, 3564, 3566, 3, 532, 266, 0, 3565, 3564, 1, 0, 0, 0, 3566, 3569, 1, 0, 0, 0, 3567, 3565, 1, 0, 0, 0, 3567, 3568, 1, 0, 0, 0, 3568, 531, 1, 0, 0, 0, 3569, 3567, 1, 0, 0, 0, 3570, 3571, 3, 1148, 574, 0, 3571, 3579, 5, 534, 0, 0, 3572, 3580, 3, 564, 282, 0, 3573, 3575, 3, 534, 267, 0, 3574, 3573, 1, 0, 0, 0, 3575, 3578, 1, 0, 0, 0, 3576, 3574, 1, 0, 0, 0, 3576, 3577, 1, 0, 0, 0, 3577, 3580, 1, 0, 0, 0, 3578, 3576, 1, 0, 0, 0, 3579, 3572, 1, 0, 0, 0, 3579, 3576, 1, 0, 0, 0, 3580, 533, 1, 0, 0, 0, 3581, 3583, 3, 536, 268, 0, 3582, 3581, 1, 0, 0, 0, 3583, 3586, 1, 0, 0, 0, 3584, 3582, 1, 0, 0, 0, 3584, 3585, 1, 0, 0, 0, 3585, 3587, 1, 0, 0, 0, 3586, 3584, 1, 0, 0, 0, 3587, 3588, 5, 534, 0, 0, 3588, 535, 1, 0, 0, 0, 3589, 3639, 3, 538, 269, 0, 3590, 3639, 3, 548, 274, 0, 3591, 3639, 3, 566, 283, 0, 3592, 3639, 3, 570, 285, 0, 3593, 3639, 3, 590, 295, 0, 3594, 3639, 3, 594, 297, 0, 3595, 3639, 3, 612, 306, 0, 3596, 3639, 3, 616, 308, 0, 3597, 3639, 3, 618, 309, 0, 3598, 3639, 3, 620, 310, 0, 3599, 3639, 3, 622, 311, 0, 3600, 3639, 3, 632, 316, 0, 3601, 3639, 3, 648, 324, 0, 3602, 3639, 3, 650, 325, 0, 3603, 3639, 3, 652, 326, 0, 3604, 3639, 3, 678, 339, 0, 3605, 3639, 3, 672, 336, 0, 3606, 3639, 3, 674, 337, 0, 3607, 3639, 3, 676, 338, 0, 3608, 3639, 3, 682, 341, 0, 3609, 3639, 3, 684, 342, 0, 3610, 3639, 3, 686, 343, 0, 3611, 3639, 3, 688, 344, 0, 3612, 3639, 3, 694, 347, 0, 3613, 3639, 3, 700, 350, 0, 3614, 3639, 3, 706, 353, 0, 3615, 3639, 3, 708, 354, 0, 3616, 3639, 3, 738, 369, 0, 3617, 3639, 3, 758, 379, 0, 3618, 3639, 3, 768, 384, 0, 3619, 3639, 3, 780, 390, 0, 3620, 3639, 3, 794, 397, 0, 3621, 3639, 3, 820, 410, 0, 3622, 3639, 3, 822, 411, 0, 3623, 3639, 3, 830, 415, 0, 3624, 3639, 3, 852, 426, 0, 3625, 3639, 3, 854, 427, 0, 3626, 3639, 3, 858, 429, 0, 3627, 3639, 3, 862, 431, 0, 3628, 3639, 3, 868, 434, 0, 3629, 3639, 3, 888, 444, 0, 3630, 3639, 3, 900, 450, 0, 3631, 3639, 3, 926, 463, 0, 3632, 3639, 3, 930, 465, 0, 3633, 3639, 3, 932, 466, 0, 3634, 3639, 3, 946, 473, 0, 3635, 3639, 3, 964, 482, 0, 3636, 3639, 3, 966, 483, 0, 3637, 3639, 3, 996, 498, 0, 3638, 3589, 1, 0, 0, 0, 3638, 3590, 1, 0, 0, 0, 3638, 3591, 1, 0, 0, 0, 3638, 3592, 1, 0, 0, 0, 3638, 3593, 1, 0, 0, 0, 3638, 3594, 1, 0, 0, 0, 3638, 3595, 1, 0, 0, 0, 3638, 3596, 1, 0, 0, 0, 3638, 3597, 1, 0, 0, 0, 3638, 3598, 1, 0, 0, 0, 3638, 3599, 1, 0, 0, 0, 3638, 3600, 1, 0, 0, 0, 3638, 3601, 1, 0, 0, 0, 3638, 3602, 1, 0, 0, 0, 3638, 3603, 1, 0, 0, 0, 3638, 3604, 1, 0, 0, 0, 3638, 3605, 1, 0, 0, 0, 3638, 3606, 1, 0, 0, 0, 3638, 3607, 1, 0, 0, 0, 3638, 3608, 1, 0, 0, 0, 3638, 3609, 1, 0, 0, 0, 3638, 3610, 1, 0, 0, 0, 3638, 3611, 1, 0, 0, 0, 3638, 3612, 1, 0, 0, 0, 3638, 3613, 1, 0, 0, 0, 3638, 3614, 1, 0, 0, 0, 3638, 3615, 1, 0, 0, 0, 3638, 3616, 1, 0, 0, 0, 3638, 3617, 1, 0, 0, 0, 3638, 3618, 1, 0, 0, 0, 3638, 3619, 1, 0, 0, 0, 3638, 3620, 1, 0, 0, 0, 3638, 3621, 1, 0, 0, 0, 3638, 3622, 1, 0, 0, 0, 3638, 3623, 1, 0, 0, 0, 3638, 3624, 1, 0, 0, 0, 3638, 3625, 1, 0, 0, 0, 3638, 3626, 1, 0, 0, 0, 3638, 3627, 1, 0, 0, 0, 3638, 3628, 1, 0, 0, 0, 3638, 3629, 1, 0, 0, 0, 3638, 3630, 1, 0, 0, 0, 3638, 3631, 1, 0, 0, 0, 3638, 3632, 1, 0, 0, 0, 3638, 3633, 1, 0, 0, 0, 3638, 3634, 1, 0, 0, 0, 3638, 3635, 1, 0, 0, 0, 3638, 3636, 1, 0, 0, 0, 3638, 3637, 1, 0, 0, 0, 3639, 537, 1, 0, 0, 0, 3640, 3641, 5, 2, 0, 0, 3641, 3646, 3, 1074, 537, 0, 3642, 3647, 3, 540, 270, 0, 3643, 3647, 3, 544, 272, 0, 3644, 3647, 3, 542, 271, 0, 3645, 3647, 3, 546, 273, 0, 3646, 3642, 1, 0, 0, 0, 3646, 3643, 1, 0, 0, 0, 3646, 3644, 1, 0, 0, 0, 3646, 3645, 1, 0, 0, 0, 3646, 3647, 1, 0, 0, 0, 3647, 3649, 1, 0, 0, 0, 3648, 3650, 3, 1028, 514, 0, 3649, 3648, 1, 0, 0, 0, 3649, 3650, 1, 0, 0, 0, 3650, 3652, 1, 0, 0, 0, 3651, 3653, 3, 1030, 515, 0, 3652, 3651, 1, 0, 0, 0, 3652, 3653, 1, 0, 0, 0, 3653, 3655, 1, 0, 0, 0, 3654, 3656, 5, 159, 0, 0, 3655, 3654, 1, 0, 0, 0, 3655, 3656, 1, 0, 0, 0, 3656, 539, 1, 0, 0, 0, 3657, 3677, 5, 215, 0, 0, 3658, 3660, 5, 111, 0, 0, 3659, 3661, 5, 519, 0, 0, 3660, 3659, 1, 0, 0, 0, 3660, 3661, 1, 0, 0, 0, 3661, 3678, 1, 0, 0, 0, 3662, 3664, 5, 114, 0, 0, 3663, 3665, 5, 520, 0, 0, 3664, 3663, 1, 0, 0, 0, 3664, 3665, 1, 0, 0, 0, 3665, 3678, 1, 0, 0, 0, 3666, 3678, 5, 115, 0, 0, 3667, 3678, 5, 485, 0, 0, 3668, 3678, 5, 486, 0, 0, 3669, 3671, 5, 490, 0, 0, 3670, 3672, 5, 296, 0, 0, 3671, 3670, 1, 0, 0, 0, 3671, 3672, 1, 0, 0, 0, 3672, 3678, 1, 0, 0, 0, 3673, 3678, 5, 491, 0, 0, 3674, 3678, 5, 518, 0, 0, 3675, 3678, 5, 519, 0, 0, 3676, 3678, 5, 520, 0, 0, 3677, 3658, 1, 0, 0, 0, 3677, 3662, 1, 0, 0, 0, 3677, 3666, 1, 0, 0, 0, 3677, 3667, 1, 0, 0, 0, 3677, 3668, 1, 0, 0, 0, 3677, 3669, 1, 0, 0, 0, 3677, 3673, 1, 0, 0, 0, 3677, 3674, 1, 0, 0, 0, 3677, 3675, 1, 0, 0, 0, 3677, 3676, 1, 0, 0, 0, 3678, 541, 1, 0, 0, 0, 3679, 3680, 5, 215, 0, 0, 3680, 3681, 3, 1146, 573, 0, 3681, 543, 1, 0, 0, 0, 3682, 3683, 5, 215, 0, 0, 3683, 3684, 5, 191, 0, 0, 3684, 3685, 5, 259, 0, 0, 3685, 545, 1, 0, 0, 0, 3686, 3688, 5, 295, 0, 0, 3687, 3686, 1, 0, 0, 0, 3687, 3688, 1, 0, 0, 0, 3688, 3689, 1, 0, 0, 0, 3689, 3690, 5, 105, 0, 0, 3690, 547, 1, 0, 0, 0, 3691, 3695, 5, 4, 0, 0, 3692, 3696, 3, 550, 275, 0, 3693, 3696, 3, 552, 276, 0, 3694, 3696, 3, 554, 277, 0, 3695, 3692, 1, 0, 0, 0, 3695, 3693, 1, 0, 0, 0, 3695, 3694, 1, 0, 0, 0, 3696, 3698, 1, 0, 0, 0, 3697, 3699, 3, 1024, 512, 0, 3698, 3697, 1, 0, 0, 0, 3698, 3699, 1, 0, 0, 0, 3699, 3701, 1, 0, 0, 0, 3700, 3702, 3, 1026, 513, 0, 3701, 3700, 1, 0, 0, 0, 3701, 3702, 1, 0, 0, 0, 3702, 3704, 1, 0, 0, 0, 3703, 3705, 5, 160, 0, 0, 3704, 3703, 1, 0, 0, 0, 3704, 3705, 1, 0, 0, 0, 3705, 549, 1, 0, 0, 0, 3706, 3708, 3, 556, 278, 0, 3707, 3706, 1, 0, 0, 0, 3708, 3709, 1, 0, 0, 0, 3709, 3707, 1, 0, 0, 0, 3709, 3710, 1, 0, 0, 0, 3710, 3711, 1, 0, 0, 0, 3711, 3713, 5, 489, 0, 0, 3712, 3714, 3, 558, 279, 0, 3713, 3712, 1, 0, 0, 0, 3714, 3715, 1, 0, 0, 0, 3715, 3713, 1, 0, 0, 0, 3715, 3716, 1, 0, 0, 0, 3716, 551, 1, 0, 0, 0, 3717, 3719, 3, 556, 278, 0, 3718, 3717, 1, 0, 0, 0, 3719, 3720, 1, 0, 0, 0, 3720, 3718, 1, 0, 0, 0, 3720, 3721, 1, 0, 0, 0, 3721, 3728, 1, 0, 0, 0, 3722, 3724, 5, 489, 0, 0, 3723, 3725, 3, 560, 280, 0, 3724, 3723, 1, 0, 0, 0, 3725, 3726, 1, 0, 0, 0, 3726, 3724, 1, 0, 0, 0, 3726, 3727, 1, 0, 0, 0, 3727, 3729, 1, 0, 0, 0, 3728, 3722, 1, 0, 0, 0, 3728, 3729, 1, 0, 0, 0, 3729, 3730, 1, 0, 0, 0, 3730, 3732, 5, 222, 0, 0, 3731, 3733, 3, 562, 281, 0, 3732, 3731, 1, 0, 0, 0, 3733, 3734, 1, 0, 0, 0, 3734, 3732, 1, 0, 0, 0, 3734, 3735, 1, 0, 0, 0, 3735, 553, 1, 0, 0, 0, 3736, 3737, 7, 50, 0, 0, 3737, 3738, 3, 1074, 537, 0, 3738, 3739, 5, 489, 0, 0, 3739, 3740, 3, 558, 279, 0, 3740, 555, 1, 0, 0, 0, 3741, 3744, 3, 1074, 537, 0, 3742, 3744, 3, 1172, 586, 0, 3743, 3741, 1, 0, 0, 0, 3743, 3742, 1, 0, 0, 0, 3744, 557, 1, 0, 0, 0, 3745, 3747, 3, 1074, 537, 0, 3746, 3748, 5, 412, 0, 0, 3747, 3746, 1, 0, 0, 0, 3747, 3748, 1, 0, 0, 0, 3748, 559, 1, 0, 0, 0, 3749, 3752, 3, 1074, 537, 0, 3750, 3752, 3, 1172, 586, 0, 3751, 3749, 1, 0, 0, 0, 3751, 3750, 1, 0, 0, 0, 3752, 561, 1, 0, 0, 0, 3753, 3755, 3, 1074, 537, 0, 3754, 3756, 5, 412, 0, 0, 3755, 3754, 1, 0, 0, 0, 3755, 3756, 1, 0, 0, 0, 3756, 563, 1, 0, 0, 0, 3757, 3759, 5, 224, 0, 0, 3758, 3760, 5, 489, 0, 0, 3759, 3758, 1, 0, 0, 0, 3759, 3760, 1, 0, 0, 0, 3760, 3761, 1, 0, 0, 0, 3761, 3762, 5, 534, 0, 0, 3762, 565, 1, 0, 0, 0, 3763, 3765, 5, 17, 0, 0, 3764, 3766, 3, 568, 284, 0, 3765, 3764, 1, 0, 0, 0, 3766, 3767, 1, 0, 0, 0, 3767, 3765, 1, 0, 0, 0, 3767, 3768, 1, 0, 0, 0, 3768, 567, 1, 0, 0, 0, 3769, 3770, 3, 1150, 575, 0, 3770, 3773, 5, 489, 0, 0, 3771, 3772, 5, 359, 0, 0, 3772, 3774, 5, 489, 0, 0, 3773, 3771, 1, 0, 0, 0, 3773, 3774, 1, 0, 0, 0, 3774, 3775, 1, 0, 0, 0, 3775, 3776, 3, 1150, 575, 0, 3776, 569, 1, 0, 0, 0, 3777, 3780, 5, 52, 0, 0, 3778, 3781, 3, 1074, 537, 0, 3779, 3781, 3, 1172, 586, 0, 3780, 3778, 1, 0, 0, 0, 3780, 3779, 1, 0, 0, 0, 3781, 3783, 1, 0, 0, 0, 3782, 3784, 3, 572, 286, 0, 3783, 3782, 1, 0, 0, 0, 3783, 3784, 1, 0, 0, 0, 3784, 3786, 1, 0, 0, 0, 3785, 3787, 3, 588, 294, 0, 3786, 3785, 1, 0, 0, 0, 3786, 3787, 1, 0, 0, 0, 3787, 3789, 1, 0, 0, 0, 3788, 3790, 3, 1020, 510, 0, 3789, 3788, 1, 0, 0, 0, 3789, 3790, 1, 0, 0, 0, 3790, 3792, 1, 0, 0, 0, 3791, 3793, 3, 1028, 514, 0, 3792, 3791, 1, 0, 0, 0, 3792, 3793, 1, 0, 0, 0, 3793, 3795, 1, 0, 0, 0, 3794, 3796, 3, 1030, 515, 0, 3795, 3794, 1, 0, 0, 0, 3795, 3796, 1, 0, 0, 0, 3796, 3798, 1, 0, 0, 0, 3797, 3799, 5, 161, 0, 0, 3798, 3797, 1, 0, 0, 0, 3798, 3799, 1, 0, 0, 0, 3799, 571, 1, 0, 0, 0, 3800, 3802, 5, 506, 0, 0, 3801, 3803, 3, 574, 287, 0, 3802, 3801, 1, 0, 0, 0, 3803, 3804, 1, 0, 0, 0, 3804, 3802, 1, 0, 0, 0, 3804, 3805, 1, 0, 0, 0, 3805, 573, 1, 0, 0, 0, 3806, 3810, 3, 576, 288, 0, 3807, 3810, 3, 580, 290, 0, 3808, 3810, 3, 584, 292, 0, 3809, 3806, 1, 0, 0, 0, 3809, 3807, 1, 0, 0, 0, 3809, 3808, 1, 0, 0, 0, 3810, 575, 1, 0, 0, 0, 3811, 3813, 5, 49, 0, 0, 3812, 3811, 1, 0, 0, 0, 3812, 3813, 1, 0, 0, 0, 3813, 3814, 1, 0, 0, 0, 3814, 3816, 5, 384, 0, 0, 3815, 3812, 1, 0, 0, 0, 3815, 3816, 1, 0, 0, 0, 3816, 3818, 1, 0, 0, 0, 3817, 3819, 3, 578, 289, 0, 3818, 3817, 1, 0, 0, 0, 3819, 3820, 1, 0, 0, 0, 3820, 3818, 1, 0, 0, 0, 3820, 3821, 1, 0, 0, 0, 3821, 577, 1, 0, 0, 0, 3822, 3823, 5, 5, 0, 0, 3823, 3827, 5, 323, 0, 0, 3824, 3827, 5, 250, 0, 0, 3825, 3827, 5, 459, 0, 0, 3826, 3822, 1, 0, 0, 0, 3826, 3824, 1, 0, 0, 0, 3826, 3825, 1, 0, 0, 0, 3826, 3827, 1, 0, 0, 0, 3827, 3828, 1, 0, 0, 0, 3828, 3832, 3, 1074, 537, 0, 3829, 3832, 3, 1172, 586, 0, 3830, 3832, 3, 1134, 567, 0, 3831, 3826, 1, 0, 0, 0, 3831, 3829, 1, 0, 0, 0, 3831, 3830, 1, 0, 0, 0, 3832, 3835, 1, 0, 0, 0, 3833, 3835, 5, 325, 0, 0, 3834, 3831, 1, 0, 0, 0, 3834, 3833, 1, 0, 0, 0, 3835, 579, 1, 0, 0, 0, 3836, 3838, 5, 49, 0, 0, 3837, 3836, 1, 0, 0, 0, 3837, 3838, 1, 0, 0, 0, 3838, 3839, 1, 0, 0, 0, 3839, 3841, 5, 507, 0, 0, 3840, 3842, 3, 582, 291, 0, 3841, 3840, 1, 0, 0, 0, 3842, 3843, 1, 0, 0, 0, 3843, 3841, 1, 0, 0, 0, 3843, 3844, 1, 0, 0, 0, 3844, 581, 1, 0, 0, 0, 3845, 3846, 5, 5, 0, 0, 3846, 3852, 5, 323, 0, 0, 3847, 3849, 5, 269, 0, 0, 3848, 3850, 5, 323, 0, 0, 3849, 3848, 1, 0, 0, 0, 3849, 3850, 1, 0, 0, 0, 3850, 3852, 1, 0, 0, 0, 3851, 3845, 1, 0, 0, 0, 3851, 3847, 1, 0, 0, 0, 3851, 3852, 1, 0, 0, 0, 3852, 3855, 1, 0, 0, 0, 3853, 3856, 3, 1074, 537, 0, 3854, 3856, 3, 1172, 586, 0, 3855, 3853, 1, 0, 0, 0, 3855, 3854, 1, 0, 0, 0, 3856, 583, 1, 0, 0, 0, 3857, 3859, 5, 49, 0, 0, 3858, 3857, 1, 0, 0, 0, 3858, 3859, 1, 0, 0, 0, 3859, 3860, 1, 0, 0, 0, 3860, 3862, 5, 95, 0, 0, 3861, 3863, 3, 586, 293, 0, 3862, 3861, 1, 0, 0, 0, 3863, 3864, 1, 0, 0, 0, 3864, 3862, 1, 0, 0, 0, 3864, 3865, 1, 0, 0, 0, 3865, 585, 1, 0, 0, 0, 3866, 3867, 5, 5, 0, 0, 3867, 3873, 5, 323, 0, 0, 3868, 3870, 5, 269, 0, 0, 3869, 3871, 5, 323, 0, 0, 3870, 3869, 1, 0, 0, 0, 3870, 3871, 1, 0, 0, 0, 3871, 3873, 1, 0, 0, 0, 3872, 3866, 1, 0, 0, 0, 3872, 3868, 1, 0, 0, 0, 3872, 3873, 1, 0, 0, 0, 3873, 3874, 1, 0, 0, 0, 3874, 3878, 3, 1074, 537, 0, 3875, 3878, 3, 1172, 586, 0, 3876, 3878, 5, 325, 0, 0, 3877, 3872, 1, 0, 0, 0, 3877, 3875, 1, 0, 0, 0, 3877, 3876, 1, 0, 0, 0, 3878, 587, 1, 0, 0, 0, 3879, 3880, 7, 49, 0, 0, 3880, 3881, 3, 1074, 537, 0, 3881, 589, 1, 0, 0, 0, 3882, 3884, 5, 53, 0, 0, 3883, 3885, 3, 592, 296, 0, 3884, 3883, 1, 0, 0, 0, 3885, 3886, 1, 0, 0, 0, 3886, 3884, 1, 0, 0, 0, 3886, 3887, 1, 0, 0, 0, 3887, 591, 1, 0, 0, 0, 3888, 3889, 3, 1142, 571, 0, 3889, 3890, 7, 36, 0, 0, 3890, 3894, 1, 0, 0, 0, 3891, 3894, 3, 1074, 537, 0, 3892, 3894, 3, 1172, 586, 0, 3893, 3888, 1, 0, 0, 0, 3893, 3891, 1, 0, 0, 0, 3893, 3892, 1, 0, 0, 0, 3894, 593, 1, 0, 0, 0, 3895, 3897, 5, 67, 0, 0, 3896, 3898, 3, 596, 298, 0, 3897, 3896, 1, 0, 0, 0, 3898, 3899, 1, 0, 0, 0, 3899, 3897, 1, 0, 0, 0, 3899, 3900, 1, 0, 0, 0, 3900, 595, 1, 0, 0, 0, 3901, 3905, 3, 1134, 567, 0, 3902, 3906, 3, 598, 299, 0, 3903, 3906, 3, 600, 300, 0, 3904, 3906, 3, 602, 301, 0, 3905, 3902, 1, 0, 0, 0, 3905, 3903, 1, 0, 0, 0, 3905, 3904, 1, 0, 0, 0, 3905, 3906, 1, 0, 0, 0, 3906, 597, 1, 0, 0, 0, 3907, 3912, 7, 12, 0, 0, 3908, 3910, 5, 212, 0, 0, 3909, 3908, 1, 0, 0, 0, 3909, 3910, 1, 0, 0, 0, 3910, 3911, 1, 0, 0, 0, 3911, 3913, 5, 390, 0, 0, 3912, 3909, 1, 0, 0, 0, 3912, 3913, 1, 0, 0, 0, 3913, 3922, 1, 0, 0, 0, 3914, 3916, 5, 514, 0, 0, 3915, 3914, 1, 0, 0, 0, 3915, 3916, 1, 0, 0, 0, 3916, 3920, 1, 0, 0, 0, 3917, 3918, 5, 310, 0, 0, 3918, 3921, 5, 407, 0, 0, 3919, 3921, 5, 286, 0, 0, 3920, 3917, 1, 0, 0, 0, 3920, 3919, 1, 0, 0, 0, 3921, 3923, 1, 0, 0, 0, 3922, 3915, 1, 0, 0, 0, 3922, 3923, 1, 0, 0, 0, 3923, 599, 1, 0, 0, 0, 3924, 3926, 5, 514, 0, 0, 3925, 3924, 1, 0, 0, 0, 3925, 3926, 1, 0, 0, 0, 3926, 3930, 1, 0, 0, 0, 3927, 3928, 5, 310, 0, 0, 3928, 3931, 5, 407, 0, 0, 3929, 3931, 5, 286, 0, 0, 3930, 3927, 1, 0, 0, 0, 3930, 3929, 1, 0, 0, 0, 3931, 601, 1, 0, 0, 0, 3932, 3934, 5, 514, 0, 0, 3933, 3932, 1, 0, 0, 0, 3933, 3934, 1, 0, 0, 0, 3934, 3935, 1, 0, 0, 0, 3935, 3936, 5, 310, 0, 0, 3936, 3940, 5, 511, 0, 0, 3937, 3938, 5, 514, 0, 0, 3938, 3940, 5, 511, 0, 0, 3939, 3933, 1, 0, 0, 0, 3939, 3937, 1, 0, 0, 0, 3940, 3947, 1, 0, 0, 0, 3941, 3943, 5, 506, 0, 0, 3942, 3944, 3, 604, 302, 0, 3943, 3942, 1, 0, 0, 0, 3944, 3945, 1, 0, 0, 0, 3945, 3943, 1, 0, 0, 0, 3945, 3946, 1, 0, 0, 0, 3946, 3948, 1, 0, 0, 0, 3947, 3941, 1, 0, 0, 0, 3947, 3948, 1, 0, 0, 0, 3948, 603, 1, 0, 0, 0, 3949, 3953, 3, 606, 303, 0, 3950, 3953, 3, 608, 304, 0, 3951, 3953, 3, 610, 305, 0, 3952, 3949, 1, 0, 0, 0, 3952, 3950, 1, 0, 0, 0, 3952, 3951, 1, 0, 0, 0, 3953, 605, 1, 0, 0, 0, 3954, 3956, 5, 68, 0, 0, 3955, 3957, 5, 323, 0, 0, 3956, 3955, 1, 0, 0, 0, 3956, 3957, 1, 0, 0, 0, 3957, 3958, 1, 0, 0, 0, 3958, 3959, 7, 51, 0, 0, 3959, 607, 1, 0, 0, 0, 3960, 3963, 5, 28, 0, 0, 3961, 3964, 3, 1074, 537, 0, 3962, 3964, 3, 1178, 589, 0, 3963, 3961, 1, 0, 0, 0, 3963, 3962, 1, 0, 0, 0, 3964, 609, 1, 0, 0, 0, 3965, 3967, 5, 29, 0, 0, 3966, 3968, 5, 323, 0, 0, 3967, 3966, 1, 0, 0, 0, 3967, 3968, 1, 0, 0, 0, 3968, 3971, 1, 0, 0, 0, 3969, 3972, 3, 1074, 537, 0, 3970, 3972, 3, 1178, 589, 0, 3971, 3969, 1, 0, 0, 0, 3971, 3970, 1, 0, 0, 0, 3972, 611, 1, 0, 0, 0, 3973, 3975, 5, 92, 0, 0, 3974, 3976, 3, 614, 307, 0, 3975, 3974, 1, 0, 0, 0, 3976, 3977, 1, 0, 0, 0, 3977, 3975, 1, 0, 0, 0, 3977, 3978, 1, 0, 0, 0, 3978, 3979, 1, 0, 0, 0, 3979, 3980, 7, 52, 0, 0, 3980, 3982, 3, 1032, 516, 0, 3981, 3983, 3, 1024, 512, 0, 3982, 3981, 1, 0, 0, 0, 3982, 3983, 1, 0, 0, 0, 3983, 3985, 1, 0, 0, 0, 3984, 3986, 3, 1026, 513, 0, 3985, 3984, 1, 0, 0, 0, 3985, 3986, 1, 0, 0, 0, 3986, 3988, 1, 0, 0, 0, 3987, 3989, 5, 162, 0, 0, 3988, 3987, 1, 0, 0, 0, 3988, 3989, 1, 0, 0, 0, 3989, 613, 1, 0, 0, 0, 3990, 3992, 3, 1074, 537, 0, 3991, 3993, 5, 412, 0, 0, 3992, 3991, 1, 0, 0, 0, 3992, 3993, 1, 0, 0, 0, 3993, 615, 1, 0, 0, 0, 3994, 3995, 5, 96, 0, 0, 3995, 617, 1, 0, 0, 0, 3996, 3997, 5, 131, 0, 0, 3997, 3999, 3, 1134, 567, 0, 3998, 4000, 5, 377, 0, 0, 3999, 3998, 1, 0, 0, 0, 3999, 4000, 1, 0, 0, 0, 4000, 4002, 1, 0, 0, 0, 4001, 4003, 3, 1016, 508, 0, 4002, 4001, 1, 0, 0, 0, 4002, 4003, 1, 0, 0, 0, 4003, 4005, 1, 0, 0, 0, 4004, 4006, 3, 1018, 509, 0, 4005, 4004, 1, 0, 0, 0, 4005, 4006, 1, 0, 0, 0, 4006, 4008, 1, 0, 0, 0, 4007, 4009, 5, 163, 0, 0, 4008, 4007, 1, 0, 0, 0, 4008, 4009, 1, 0, 0, 0, 4009, 619, 1, 0, 0, 0, 4010, 4018, 5, 140, 0, 0, 4011, 4013, 5, 246, 0, 0, 4012, 4014, 5, 475, 0, 0, 4013, 4012, 1, 0, 0, 0, 4013, 4014, 1, 0, 0, 0, 4014, 4019, 1, 0, 0, 0, 4015, 4016, 5, 232, 0, 0, 4016, 4019, 5, 475, 0, 0, 4017, 4019, 5, 334, 0, 0, 4018, 4011, 1, 0, 0, 0, 4018, 4015, 1, 0, 0, 0, 4018, 4017, 1, 0, 0, 0, 4019, 4020, 1, 0, 0, 0, 4020, 4022, 3, 1120, 560, 0, 4021, 4023, 5, 514, 0, 0, 4022, 4021, 1, 0, 0, 0, 4022, 4023, 1, 0, 0, 0, 4023, 4024, 1, 0, 0, 0, 4024, 4027, 5, 259, 0, 0, 4025, 4028, 3, 1074, 537, 0, 4026, 4028, 3, 1172, 586, 0, 4027, 4025, 1, 0, 0, 0, 4027, 4026, 1, 0, 0, 0, 4028, 621, 1, 0, 0, 0, 4029, 4031, 5, 142, 0, 0, 4030, 4032, 3, 624, 312, 0, 4031, 4030, 1, 0, 0, 0, 4032, 4033, 1, 0, 0, 0, 4033, 4031, 1, 0, 0, 0, 4033, 4034, 1, 0, 0, 0, 4034, 4036, 1, 0, 0, 0, 4035, 4037, 3, 626, 313, 0, 4036, 4035, 1, 0, 0, 0, 4036, 4037, 1, 0, 0, 0, 4037, 4039, 1, 0, 0, 0, 4038, 4040, 3, 628, 314, 0, 4039, 4038, 1, 0, 0, 0, 4039, 4040, 1, 0, 0, 0, 4040, 4042, 1, 0, 0, 0, 4041, 4043, 3, 630, 315, 0, 4042, 4041, 1, 0, 0, 0, 4042, 4043, 1, 0, 0, 0, 4043, 623, 1, 0, 0, 0, 4044, 4047, 3, 1074, 537, 0, 4045, 4047, 3, 1172, 586, 0, 4046, 4044, 1, 0, 0, 0, 4046, 4045, 1, 0, 0, 0, 4047, 625, 1, 0, 0, 0, 4048, 4051, 5, 30, 0, 0, 4049, 4052, 3, 1074, 537, 0, 4050, 4052, 3, 1172, 586, 0, 4051, 4049, 1, 0, 0, 0, 4051, 4050, 1, 0, 0, 0, 4052, 627, 1, 0, 0, 0, 4053, 4056, 5, 503, 0, 0, 4054, 4057, 3, 1146, 573, 0, 4055, 4057, 3, 1132, 566, 0, 4056, 4054, 1, 0, 0, 0, 4056, 4055, 1, 0, 0, 0, 4057, 629, 1, 0, 0, 0, 4058, 4060, 5, 514, 0, 0, 4059, 4058, 1, 0, 0, 0, 4059, 4060, 1, 0, 0, 0, 4060, 4061, 1, 0, 0, 0, 4061, 4062, 5, 310, 0, 0, 4062, 4063, 5, 6, 0, 0, 4063, 631, 1, 0, 0, 0, 4064, 4067, 5, 144, 0, 0, 4065, 4068, 3, 1074, 537, 0, 4066, 4068, 3, 1172, 586, 0, 4067, 4065, 1, 0, 0, 0, 4067, 4066, 1, 0, 0, 0, 4068, 4072, 1, 0, 0, 0, 4069, 4073, 3, 634, 317, 0, 4070, 4073, 3, 636, 318, 0, 4071, 4073, 3, 638, 319, 0, 4072, 4069, 1, 0, 0, 0, 4072, 4070, 1, 0, 0, 0, 4072, 4071, 1, 0, 0, 0, 4073, 4075, 1, 0, 0, 0, 4074, 4076, 3, 646, 323, 0, 4075, 4074, 1, 0, 0, 0, 4075, 4076, 1, 0, 0, 0, 4076, 4078, 1, 0, 0, 0, 4077, 4079, 3, 1024, 512, 0, 4078, 4077, 1, 0, 0, 0, 4078, 4079, 1, 0, 0, 0, 4079, 4081, 1, 0, 0, 0, 4080, 4082, 3, 1026, 513, 0, 4081, 4080, 1, 0, 0, 0, 4081, 4082, 1, 0, 0, 0, 4082, 4084, 1, 0, 0, 0, 4083, 4085, 5, 164, 0, 0, 4084, 4083, 1, 0, 0, 0, 4084, 4085, 1, 0, 0, 0, 4085, 633, 1, 0, 0, 0, 4086, 4088, 5, 251, 0, 0, 4087, 4089, 3, 642, 321, 0, 4088, 4087, 1, 0, 0, 0, 4089, 4090, 1, 0, 0, 0, 4090, 4088, 1, 0, 0, 0, 4090, 4091, 1, 0, 0, 0, 4091, 635, 1, 0, 0, 0, 4092, 4095, 5, 251, 0, 0, 4093, 4096, 3, 1074, 537, 0, 4094, 4096, 3, 1172, 586, 0, 4095, 4093, 1, 0, 0, 0, 4095, 4094, 1, 0, 0, 0, 4096, 4098, 1, 0, 0, 0, 4097, 4099, 3, 640, 320, 0, 4098, 4097, 1, 0, 0, 0, 4098, 4099, 1, 0, 0, 0, 4099, 637, 1, 0, 0, 0, 4100, 4103, 5, 49, 0, 0, 4101, 4104, 3, 1074, 537, 0, 4102, 4104, 3, 1172, 586, 0, 4103, 4101, 1, 0, 0, 0, 4103, 4102, 1, 0, 0, 0, 4104, 4106, 1, 0, 0, 0, 4105, 4107, 3, 640, 320, 0, 4106, 4105, 1, 0, 0, 0, 4106, 4107, 1, 0, 0, 0, 4107, 639, 1, 0, 0, 0, 4108, 4110, 5, 222, 0, 0, 4109, 4111, 3, 644, 322, 0, 4110, 4109, 1, 0, 0, 0, 4111, 4112, 1, 0, 0, 0, 4112, 4110, 1, 0, 0, 0, 4112, 4113, 1, 0, 0, 0, 4113, 641, 1, 0, 0, 0, 4114, 4116, 3, 1074, 537, 0, 4115, 4117, 5, 412, 0, 0, 4116, 4115, 1, 0, 0, 0, 4116, 4117, 1, 0, 0, 0, 4117, 643, 1, 0, 0, 0, 4118, 4120, 3, 1074, 537, 0, 4119, 4121, 5, 412, 0, 0, 4120, 4119, 1, 0, 0, 0, 4120, 4121, 1, 0, 0, 0, 4121, 645, 1, 0, 0, 0, 4122, 4123, 5, 388, 0, 0, 4123, 4124, 3, 1074, 537, 0, 4124, 647, 1, 0, 0, 0, 4125, 4133, 5, 157, 0, 0, 4126, 4128, 5, 246, 0, 0, 4127, 4129, 5, 475, 0, 0, 4128, 4127, 1, 0, 0, 0, 4128, 4129, 1, 0, 0, 0, 4129, 4134, 1, 0, 0, 0, 4130, 4131, 5, 232, 0, 0, 4131, 4134, 5, 475, 0, 0, 4132, 4134, 5, 334, 0, 0, 4133, 4126, 1, 0, 0, 0, 4133, 4130, 1, 0, 0, 0, 4133, 4132, 1, 0, 0, 0, 4134, 4135, 1, 0, 0, 0, 4135, 4137, 3, 1120, 560, 0, 4136, 4138, 5, 514, 0, 0, 4137, 4136, 1, 0, 0, 0, 4137, 4138, 1, 0, 0, 0, 4138, 4139, 1, 0, 0, 0, 4139, 4142, 5, 259, 0, 0, 4140, 4143, 3, 1172, 586, 0, 4141, 4143, 3, 1074, 537, 0, 4142, 4140, 1, 0, 0, 0, 4142, 4141, 1, 0, 0, 0, 4143, 649, 1, 0, 0, 0, 4144, 4145, 5, 182, 0, 0, 4145, 4152, 3, 1172, 586, 0, 4146, 4148, 5, 506, 0, 0, 4147, 4149, 3, 1074, 537, 0, 4148, 4147, 1, 0, 0, 0, 4149, 4150, 1, 0, 0, 0, 4150, 4148, 1, 0, 0, 0, 4150, 4151, 1, 0, 0, 0, 4151, 4153, 1, 0, 0, 0, 4152, 4146, 1, 0, 0, 0, 4152, 4153, 1, 0, 0, 0, 4153, 651, 1, 0, 0, 0, 4154, 4155, 5, 193, 0, 0, 4155, 4159, 3, 654, 327, 0, 4156, 4158, 3, 656, 328, 0, 4157, 4156, 1, 0, 0, 0, 4158, 4161, 1, 0, 0, 0, 4159, 4157, 1, 0, 0, 0, 4159, 4160, 1, 0, 0, 0, 4160, 4163, 1, 0, 0, 0, 4161, 4159, 1, 0, 0, 0, 4162, 4164, 3, 658, 329, 0, 4163, 4162, 1, 0, 0, 0, 4164, 4165, 1, 0, 0, 0, 4165, 4163, 1, 0, 0, 0, 4165, 4166, 1, 0, 0, 0, 4166, 4168, 1, 0, 0, 0, 4167, 4169, 3, 668, 334, 0, 4168, 4167, 1, 0, 0, 0, 4168, 4169, 1, 0, 0, 0, 4169, 4171, 1, 0, 0, 0, 4170, 4172, 5, 165, 0, 0, 4171, 4170, 1, 0, 0, 0, 4171, 4172, 1, 0, 0, 0, 4172, 653, 1, 0, 0, 0, 4173, 4178, 3, 1074, 537, 0, 4174, 4178, 3, 1172, 586, 0, 4175, 4178, 3, 1032, 516, 0, 4176, 4178, 3, 1046, 523, 0, 4177, 4173, 1, 0, 0, 0, 4177, 4174, 1, 0, 0, 0, 4177, 4175, 1, 0, 0, 0, 4177, 4176, 1, 0, 0, 0, 4178, 655, 1, 0, 0, 0, 4179, 4180, 5, 16, 0, 0, 4180, 4181, 3, 654, 327, 0, 4181, 657, 1, 0, 0, 0, 4182, 4184, 3, 660, 330, 0, 4183, 4182, 1, 0, 0, 0, 4184, 4185, 1, 0, 0, 0, 4185, 4183, 1, 0, 0, 0, 4185, 4186, 1, 0, 0, 0, 4186, 4190, 1, 0, 0, 0, 4187, 4189, 3, 536, 268, 0, 4188, 4187, 1, 0, 0, 0, 4189, 4192, 1, 0, 0, 0, 4190, 4188, 1, 0, 0, 0, 4190, 4191, 1, 0, 0, 0, 4191, 659, 1, 0, 0, 0, 4192, 4190, 1, 0, 0, 0, 4193, 4194, 5, 512, 0, 0, 4194, 4198, 3, 662, 331, 0, 4195, 4197, 3, 666, 333, 0, 4196, 4195, 1, 0, 0, 0, 4197, 4200, 1, 0, 0, 0, 4198, 4196, 1, 0, 0, 0, 4198, 4199, 1, 0, 0, 0, 4199, 661, 1, 0, 0, 0, 4200, 4198, 1, 0, 0, 0, 4201, 4212, 5, 20, 0, 0, 4202, 4204, 5, 312, 0, 0, 4203, 4202, 1, 0, 0, 0, 4203, 4204, 1, 0, 0, 0, 4204, 4205, 1, 0, 0, 0, 4205, 4207, 3, 670, 335, 0, 4206, 4208, 3, 664, 332, 0, 4207, 4206, 1, 0, 0, 0, 4207, 4208, 1, 0, 0, 0, 4208, 4212, 1, 0, 0, 0, 4209, 4212, 3, 1046, 523, 0, 4210, 4212, 3, 1174, 587, 0, 4211, 4201, 1, 0, 0, 0, 4211, 4203, 1, 0, 0, 0, 4211, 4209, 1, 0, 0, 0, 4211, 4210, 1, 0, 0, 0, 4212, 663, 1, 0, 0, 0, 4213, 4214, 7, 4, 0, 0, 4214, 4215, 3, 670, 335, 0, 4215, 665, 1, 0, 0, 0, 4216, 4217, 5, 16, 0, 0, 4217, 4218, 3, 662, 331, 0, 4218, 667, 1, 0, 0, 0, 4219, 4220, 5, 512, 0, 0, 4220, 4224, 5, 333, 0, 0, 4221, 4223, 3, 536, 268, 0, 4222, 4221, 1, 0, 0, 0, 4223, 4226, 1, 0, 0, 0, 4224, 4222, 1, 0, 0, 0, 4224, 4225, 1, 0, 0, 0, 4225, 669, 1, 0, 0, 0, 4226, 4224, 1, 0, 0, 0, 4227, 4231, 3, 1074, 537, 0, 4228, 4231, 3, 1172, 586, 0, 4229, 4231, 3, 1032, 516, 0, 4230, 4227, 1, 0, 0, 0, 4230, 4228, 1, 0, 0, 0, 4230, 4229, 1, 0, 0, 0, 4231, 671, 1, 0, 0, 0, 4232, 4234, 5, 559, 0, 0, 4233, 4232, 1, 0, 0, 0, 4234, 4235, 1, 0, 0, 0, 4235, 4233, 1, 0, 0, 0, 4235, 4236, 1, 0, 0, 0, 4236, 673, 1, 0, 0, 0, 4237, 4239, 5, 561, 0, 0, 4238, 4237, 1, 0, 0, 0, 4239, 4240, 1, 0, 0, 0, 4240, 4238, 1, 0, 0, 0, 4240, 4241, 1, 0, 0, 0, 4241, 675, 1, 0, 0, 0, 4242, 4244, 5, 560, 0, 0, 4243, 4242, 1, 0, 0, 0, 4244, 4245, 1, 0, 0, 0, 4245, 4243, 1, 0, 0, 0, 4245, 4246, 1, 0, 0, 0, 4246, 677, 1, 0, 0, 0, 4247, 4249, 5, 198, 0, 0, 4248, 4250, 5, 303, 0, 0, 4249, 4248, 1, 0, 0, 0, 4249, 4250, 1, 0, 0, 0, 4250, 4252, 1, 0, 0, 0, 4251, 4253, 5, 60, 0, 0, 4252, 4251, 1, 0, 0, 0, 4252, 4253, 1, 0, 0, 0, 4253, 4255, 1, 0, 0, 0, 4254, 4256, 3, 680, 340, 0, 4255, 4254, 1, 0, 0, 0, 4256, 4257, 1, 0, 0, 0, 4257, 4255, 1, 0, 0, 0, 4257, 4258, 1, 0, 0, 0, 4258, 679, 1, 0, 0, 0, 4259, 4262, 3, 1074, 537, 0, 4260, 4262, 3, 1172, 586, 0, 4261, 4259, 1, 0, 0, 0, 4261, 4260, 1, 0, 0, 0, 4262, 681, 1, 0, 0, 0, 4263, 4265, 5, 199, 0, 0, 4264, 4266, 5, 361, 0, 0, 4265, 4264, 1, 0, 0, 0, 4265, 4266, 1, 0, 0, 0, 4266, 683, 1, 0, 0, 0, 4267, 4268, 5, 220, 0, 0, 4268, 4269, 3, 1156, 578, 0, 4269, 685, 1, 0, 0, 0, 4270, 4271, 5, 221, 0, 0, 4271, 687, 1, 0, 0, 0, 4272, 4274, 5, 224, 0, 0, 4273, 4275, 5, 489, 0, 0, 4274, 4273, 1, 0, 0, 0, 4274, 4275, 1, 0, 0, 0, 4275, 4278, 1, 0, 0, 0, 4276, 4279, 3, 690, 345, 0, 4277, 4279, 3, 692, 346, 0, 4278, 4276, 1, 0, 0, 0, 4278, 4277, 1, 0, 0, 0, 4279, 689, 1, 0, 0, 0, 4280, 4281, 3, 1150, 575, 0, 4281, 691, 1, 0, 0, 0, 4282, 4296, 5, 299, 0, 0, 4283, 4285, 3, 1150, 575, 0, 4284, 4283, 1, 0, 0, 0, 4285, 4286, 1, 0, 0, 0, 4286, 4284, 1, 0, 0, 0, 4286, 4287, 1, 0, 0, 0, 4287, 4293, 1, 0, 0, 0, 4288, 4290, 5, 134, 0, 0, 4289, 4291, 5, 326, 0, 0, 4290, 4289, 1, 0, 0, 0, 4290, 4291, 1, 0, 0, 0, 4291, 4292, 1, 0, 0, 0, 4292, 4294, 3, 1074, 537, 0, 4293, 4288, 1, 0, 0, 0, 4293, 4294, 1, 0, 0, 0, 4294, 4296, 1, 0, 0, 0, 4295, 4282, 1, 0, 0, 0, 4295, 4284, 1, 0, 0, 0, 4296, 693, 1, 0, 0, 0, 4297, 4298, 5, 236, 0, 0, 4298, 4299, 3, 1046, 523, 0, 4299, 4301, 3, 696, 348, 0, 4300, 4302, 3, 698, 349, 0, 4301, 4300, 1, 0, 0, 0, 4301, 4302, 1, 0, 0, 0, 4302, 4304, 1, 0, 0, 0, 4303, 4305, 5, 166, 0, 0, 4304, 4303, 1, 0, 0, 0, 4304, 4305, 1, 0, 0, 0, 4305, 695, 1, 0, 0, 0, 4306, 4308, 5, 480, 0, 0, 4307, 4306, 1, 0, 0, 0, 4307, 4308, 1, 0, 0, 0, 4308, 4317, 1, 0, 0, 0, 4309, 4310, 5, 309, 0, 0, 4310, 4318, 5, 426, 0, 0, 4311, 4313, 3, 536, 268, 0, 4312, 4311, 1, 0, 0, 0, 4313, 4316, 1, 0, 0, 0, 4314, 4312, 1, 0, 0, 0, 4314, 4315, 1, 0, 0, 0, 4315, 4318, 1, 0, 0, 0, 4316, 4314, 1, 0, 0, 0, 4317, 4309, 1, 0, 0, 0, 4317, 4314, 1, 0, 0, 0, 4318, 697, 1, 0, 0, 0, 4319, 4328, 5, 154, 0, 0, 4320, 4321, 5, 309, 0, 0, 4321, 4329, 5, 426, 0, 0, 4322, 4324, 3, 536, 268, 0, 4323, 4322, 1, 0, 0, 0, 4324, 4327, 1, 0, 0, 0, 4325, 4323, 1, 0, 0, 0, 4325, 4326, 1, 0, 0, 0, 4326, 4329, 1, 0, 0, 0, 4327, 4325, 1, 0, 0, 0, 4328, 4320, 1, 0, 0, 0, 4328, 4325, 1, 0, 0, 0, 4329, 699, 1, 0, 0, 0, 4330, 4332, 5, 244, 0, 0, 4331, 4333, 3, 1074, 537, 0, 4332, 4331, 1, 0, 0, 0, 4333, 4334, 1, 0, 0, 0, 4334, 4332, 1, 0, 0, 0, 4334, 4335, 1, 0, 0, 0, 4335, 4337, 1, 0, 0, 0, 4336, 4338, 3, 702, 351, 0, 4337, 4336, 1, 0, 0, 0, 4337, 4338, 1, 0, 0, 0, 4338, 701, 1, 0, 0, 0, 4339, 4341, 5, 394, 0, 0, 4340, 4342, 3, 704, 352, 0, 4341, 4340, 1, 0, 0, 0, 4342, 4343, 1, 0, 0, 0, 4343, 4341, 1, 0, 0, 0, 4343, 4344, 1, 0, 0, 0, 4344, 703, 1, 0, 0, 0, 4345, 4347, 7, 53, 0, 0, 4346, 4348, 5, 109, 0, 0, 4347, 4346, 1, 0, 0, 0, 4347, 4348, 1, 0, 0, 0, 4348, 4349, 1, 0, 0, 0, 4349, 4352, 5, 49, 0, 0, 4350, 4353, 3, 1074, 537, 0, 4351, 4353, 3, 1172, 586, 0, 4352, 4350, 1, 0, 0, 0, 4352, 4351, 1, 0, 0, 0, 4353, 705, 1, 0, 0, 0, 4354, 4356, 5, 245, 0, 0, 4355, 4357, 3, 1156, 578, 0, 4356, 4355, 1, 0, 0, 0, 4357, 4358, 1, 0, 0, 0, 4358, 4356, 1, 0, 0, 0, 4358, 4359, 1, 0, 0, 0, 4359, 707, 1, 0, 0, 0, 4360, 4361, 5, 248, 0, 0, 4361, 4366, 3, 1074, 537, 0, 4362, 4367, 3, 710, 355, 0, 4363, 4367, 3, 712, 356, 0, 4364, 4367, 3, 714, 357, 0, 4365, 4367, 3, 716, 358, 0, 4366, 4362, 1, 0, 0, 0, 4366, 4363, 1, 0, 0, 0, 4366, 4364, 1, 0, 0, 0, 4366, 4365, 1, 0, 0, 0, 4367, 709, 1, 0, 0, 0, 4368, 4370, 5, 472, 0, 0, 4369, 4371, 3, 718, 359, 0, 4370, 4369, 1, 0, 0, 0, 4371, 4372, 1, 0, 0, 0, 4372, 4370, 1, 0, 0, 0, 4372, 4373, 1, 0, 0, 0, 4373, 711, 1, 0, 0, 0, 4374, 4377, 5, 394, 0, 0, 4375, 4378, 3, 722, 361, 0, 4376, 4378, 3, 726, 363, 0, 4377, 4375, 1, 0, 0, 0, 4377, 4376, 1, 0, 0, 0, 4378, 4379, 1, 0, 0, 0, 4379, 4377, 1, 0, 0, 0, 4379, 4380, 1, 0, 0, 0, 4380, 713, 1, 0, 0, 0, 4381, 4383, 5, 472, 0, 0, 4382, 4384, 3, 718, 359, 0, 4383, 4382, 1, 0, 0, 0, 4384, 4385, 1, 0, 0, 0, 4385, 4383, 1, 0, 0, 0, 4385, 4386, 1, 0, 0, 0, 4386, 4388, 1, 0, 0, 0, 4387, 4389, 3, 712, 356, 0, 4388, 4387, 1, 0, 0, 0, 4389, 4390, 1, 0, 0, 0, 4390, 4388, 1, 0, 0, 0, 4390, 4391, 1, 0, 0, 0, 4391, 715, 1, 0, 0, 0, 4392, 4395, 5, 101, 0, 0, 4393, 4396, 3, 1074, 537, 0, 4394, 4396, 3, 1172, 586, 0, 4395, 4393, 1, 0, 0, 0, 4395, 4394, 1, 0, 0, 0, 4396, 4397, 1, 0, 0, 0, 4397, 4401, 3, 734, 367, 0, 4398, 4400, 3, 736, 368, 0, 4399, 4398, 1, 0, 0, 0, 4400, 4403, 1, 0, 0, 0, 4401, 4399, 1, 0, 0, 0, 4401, 4402, 1, 0, 0, 0, 4402, 717, 1, 0, 0, 0, 4403, 4401, 1, 0, 0, 0, 4404, 4405, 3, 1074, 537, 0, 4405, 4408, 5, 212, 0, 0, 4406, 4409, 3, 720, 360, 0, 4407, 4409, 3, 724, 362, 0, 4408, 4406, 1, 0, 0, 0, 4408, 4407, 1, 0, 0, 0, 4409, 4410, 1, 0, 0, 0, 4410, 4408, 1, 0, 0, 0, 4410, 4411, 1, 0, 0, 0, 4411, 719, 1, 0, 0, 0, 4412, 4416, 5, 63, 0, 0, 4413, 4415, 3, 736, 368, 0, 4414, 4413, 1, 0, 0, 0, 4415, 4418, 1, 0, 0, 0, 4416, 4414, 1, 0, 0, 0, 4416, 4417, 1, 0, 0, 0, 4417, 721, 1, 0, 0, 0, 4418, 4416, 1, 0, 0, 0, 4419, 4420, 5, 63, 0, 0, 4420, 4424, 3, 732, 366, 0, 4421, 4423, 3, 736, 368, 0, 4422, 4421, 1, 0, 0, 0, 4423, 4426, 1, 0, 0, 0, 4424, 4422, 1, 0, 0, 0, 4424, 4425, 1, 0, 0, 0, 4425, 723, 1, 0, 0, 0, 4426, 4424, 1, 0, 0, 0, 4427, 4429, 7, 54, 0, 0, 4428, 4430, 3, 728, 364, 0, 4429, 4428, 1, 0, 0, 0, 4430, 4431, 1, 0, 0, 0, 4431, 4429, 1, 0, 0, 0, 4431, 4432, 1, 0, 0, 0, 4432, 725, 1, 0, 0, 0, 4433, 4435, 7, 55, 0, 0, 4434, 4436, 3, 730, 365, 0, 4435, 4434, 1, 0, 0, 0, 4436, 4437, 1, 0, 0, 0, 4437, 4435, 1, 0, 0, 0, 4437, 4438, 1, 0, 0, 0, 4438, 727, 1, 0, 0, 0, 4439, 4442, 3, 1074, 537, 0, 4440, 4442, 3, 1172, 586, 0, 4441, 4439, 1, 0, 0, 0, 4441, 4440, 1, 0, 0, 0, 4442, 4446, 1, 0, 0, 0, 4443, 4445, 3, 736, 368, 0, 4444, 4443, 1, 0, 0, 0, 4445, 4448, 1, 0, 0, 0, 4446, 4444, 1, 0, 0, 0, 4446, 4447, 1, 0, 0, 0, 4447, 729, 1, 0, 0, 0, 4448, 4446, 1, 0, 0, 0, 4449, 4452, 3, 1074, 537, 0, 4450, 4452, 3, 1172, 586, 0, 4451, 4449, 1, 0, 0, 0, 4451, 4450, 1, 0, 0, 0, 4452, 4453, 1, 0, 0, 0, 4453, 4457, 3, 732, 366, 0, 4454, 4456, 3, 736, 368, 0, 4455, 4454, 1, 0, 0, 0, 4456, 4459, 1, 0, 0, 0, 4457, 4455, 1, 0, 0, 0, 4457, 4458, 1, 0, 0, 0, 4458, 731, 1, 0, 0, 0, 4459, 4457, 1, 0, 0, 0, 4460, 4463, 5, 49, 0, 0, 4461, 4464, 3, 1074, 537, 0, 4462, 4464, 3, 1172, 586, 0, 4463, 4461, 1, 0, 0, 0, 4463, 4462, 1, 0, 0, 0, 4464, 733, 1, 0, 0, 0, 4465, 4468, 5, 489, 0, 0, 4466, 4469, 3, 1074, 537, 0, 4467, 4469, 3, 1172, 586, 0, 4468, 4466, 1, 0, 0, 0, 4468, 4467, 1, 0, 0, 0, 4469, 735, 1, 0, 0, 0, 4470, 4472, 7, 56, 0, 0, 4471, 4473, 5, 243, 0, 0, 4472, 4471, 1, 0, 0, 0, 4472, 4473, 1, 0, 0, 0, 4473, 4476, 1, 0, 0, 0, 4474, 4477, 3, 1074, 537, 0, 4475, 4477, 3, 1172, 586, 0, 4476, 4474, 1, 0, 0, 0, 4476, 4475, 1, 0, 0, 0, 4477, 737, 1, 0, 0, 0, 4478, 4479, 5, 294, 0, 0, 4479, 4481, 3, 1134, 567, 0, 4480, 4482, 3, 740, 370, 0, 4481, 4480, 1, 0, 0, 0, 4482, 4483, 1, 0, 0, 0, 4483, 4481, 1, 0, 0, 0, 4483, 4484, 1, 0, 0, 0, 4484, 4486, 1, 0, 0, 0, 4485, 4487, 3, 742, 371, 0, 4486, 4485, 1, 0, 0, 0, 4486, 4487, 1, 0, 0, 0, 4487, 4491, 1, 0, 0, 0, 4488, 4490, 3, 748, 374, 0, 4489, 4488, 1, 0, 0, 0, 4490, 4493, 1, 0, 0, 0, 4491, 4489, 1, 0, 0, 0, 4491, 4492, 1, 0, 0, 0, 4492, 4495, 1, 0, 0, 0, 4493, 4491, 1, 0, 0, 0, 4494, 4496, 3, 750, 375, 0, 4495, 4494, 1, 0, 0, 0, 4495, 4496, 1, 0, 0, 0, 4496, 4500, 1, 0, 0, 0, 4497, 4499, 3, 754, 377, 0, 4498, 4497, 1, 0, 0, 0, 4499, 4502, 1, 0, 0, 0, 4500, 4498, 1, 0, 0, 0, 4500, 4501, 1, 0, 0, 0, 4501, 739, 1, 0, 0, 0, 4502, 4500, 1, 0, 0, 0, 4503, 4505, 5, 326, 0, 0, 4504, 4503, 1, 0, 0, 0, 4504, 4505, 1, 0, 0, 0, 4505, 4506, 1, 0, 0, 0, 4506, 4508, 7, 41, 0, 0, 4507, 4509, 5, 259, 0, 0, 4508, 4507, 1, 0, 0, 0, 4508, 4509, 1, 0, 0, 0, 4509, 4511, 1, 0, 0, 0, 4510, 4512, 3, 1090, 545, 0, 4511, 4510, 1, 0, 0, 0, 4512, 4513, 1, 0, 0, 0, 4513, 4511, 1, 0, 0, 0, 4513, 4514, 1, 0, 0, 0, 4514, 741, 1, 0, 0, 0, 4515, 4517, 5, 72, 0, 0, 4516, 4515, 1, 0, 0, 0, 4516, 4517, 1, 0, 0, 0, 4517, 4518, 1, 0, 0, 0, 4518, 4520, 5, 428, 0, 0, 4519, 4521, 5, 254, 0, 0, 4520, 4519, 1, 0, 0, 0, 4520, 4521, 1, 0, 0, 0, 4521, 4523, 1, 0, 0, 0, 4522, 4524, 3, 1114, 557, 0, 4523, 4522, 1, 0, 0, 0, 4524, 4525, 1, 0, 0, 0, 4525, 4523, 1, 0, 0, 0, 4525, 4526, 1, 0, 0, 0, 4526, 4528, 1, 0, 0, 0, 4527, 4529, 3, 744, 372, 0, 4528, 4527, 1, 0, 0, 0, 4528, 4529, 1, 0, 0, 0, 4529, 4531, 1, 0, 0, 0, 4530, 4532, 3, 746, 373, 0, 4531, 4530, 1, 0, 0, 0, 4531, 4532, 1, 0, 0, 0, 4532, 743, 1, 0, 0, 0, 4533, 4535, 5, 212, 0, 0, 4534, 4533, 1, 0, 0, 0, 4534, 4535, 1, 0, 0, 0, 4535, 4536, 1, 0, 0, 0, 4536, 4537, 5, 14, 0, 0, 4537, 4538, 5, 254, 0, 0, 4538, 4539, 3, 1114, 557, 0, 4539, 745, 1, 0, 0, 0, 4540, 4542, 5, 212, 0, 0, 4541, 4540, 1, 0, 0, 0, 4541, 4542, 1, 0, 0, 0, 4542, 4543, 1, 0, 0, 0, 4543, 4545, 5, 304, 0, 0, 4544, 4546, 5, 254, 0, 0, 4545, 4544, 1, 0, 0, 0, 4545, 4546, 1, 0, 0, 0, 4546, 4547, 1, 0, 0, 0, 4547, 4548, 3, 1114, 557, 0, 4548, 747, 1, 0, 0, 0, 4549, 4551, 5, 506, 0, 0, 4550, 4552, 3, 1134, 567, 0, 4551, 4550, 1, 0, 0, 0, 4552, 4553, 1, 0, 0, 0, 4553, 4551, 1, 0, 0, 0, 4553, 4554, 1, 0, 0, 0, 4554, 749, 1, 0, 0, 0, 4555, 4556, 5, 334, 0, 0, 4556, 4558, 5, 356, 0, 0, 4557, 4559, 5, 254, 0, 0, 4558, 4557, 1, 0, 0, 0, 4558, 4559, 1, 0, 0, 0, 4559, 4560, 1, 0, 0, 0, 4560, 4562, 3, 1150, 575, 0, 4561, 4563, 3, 752, 376, 0, 4562, 4561, 1, 0, 0, 0, 4562, 4563, 1, 0, 0, 0, 4563, 751, 1, 0, 0, 0, 4564, 4565, 7, 4, 0, 0, 4565, 4566, 3, 1150, 575, 0, 4566, 753, 1, 0, 0, 0, 4567, 4569, 5, 222, 0, 0, 4568, 4570, 3, 756, 378, 0, 4569, 4568, 1, 0, 0, 0, 4570, 4571, 1, 0, 0, 0, 4571, 4569, 1, 0, 0, 0, 4571, 4572, 1, 0, 0, 0, 4572, 755, 1, 0, 0, 0, 4573, 4583, 3, 1134, 567, 0, 4574, 4584, 5, 286, 0, 0, 4575, 4584, 5, 415, 0, 0, 4576, 4577, 5, 310, 0, 0, 4577, 4584, 5, 407, 0, 0, 4578, 4584, 5, 106, 0, 0, 4579, 4584, 5, 387, 0, 0, 4580, 4581, 5, 514, 0, 0, 4581, 4582, 5, 391, 0, 0, 4582, 4584, 5, 106, 0, 0, 4583, 4574, 1, 0, 0, 0, 4583, 4575, 1, 0, 0, 0, 4583, 4576, 1, 0, 0, 0, 4583, 4578, 1, 0, 0, 0, 4583, 4579, 1, 0, 0, 0, 4583, 4580, 1, 0, 0, 0, 4583, 4584, 1, 0, 0, 0, 4584, 757, 1, 0, 0, 0, 4585, 4587, 5, 300, 0, 0, 4586, 4588, 5, 9, 0, 0, 4587, 4586, 1, 0, 0, 0, 4587, 4588, 1, 0, 0, 0, 4588, 4591, 1, 0, 0, 0, 4589, 4592, 3, 760, 380, 0, 4590, 4592, 3, 764, 382, 0, 4591, 4589, 1, 0, 0, 0, 4591, 4590, 1, 0, 0, 0, 4592, 759, 1, 0, 0, 0, 4593, 4594, 3, 762, 381, 0, 4594, 4596, 5, 489, 0, 0, 4595, 4597, 3, 1074, 537, 0, 4596, 4595, 1, 0, 0, 0, 4597, 4598, 1, 0, 0, 0, 4598, 4596, 1, 0, 0, 0, 4598, 4599, 1, 0, 0, 0, 4599, 761, 1, 0, 0, 0, 4600, 4603, 3, 1074, 537, 0, 4601, 4603, 3, 1172, 586, 0, 4602, 4600, 1, 0, 0, 0, 4602, 4601, 1, 0, 0, 0, 4603, 763, 1, 0, 0, 0, 4604, 4605, 7, 50, 0, 0, 4605, 4606, 3, 766, 383, 0, 4606, 4608, 5, 489, 0, 0, 4607, 4609, 3, 1074, 537, 0, 4608, 4607, 1, 0, 0, 0, 4609, 4610, 1, 0, 0, 0, 4610, 4608, 1, 0, 0, 0, 4610, 4611, 1, 0, 0, 0, 4611, 765, 1, 0, 0, 0, 4612, 4613, 3, 1074, 537, 0, 4613, 767, 1, 0, 0, 0, 4614, 4617, 5, 302, 0, 0, 4615, 4618, 3, 1074, 537, 0, 4616, 4618, 3, 1172, 586, 0, 4617, 4615, 1, 0, 0, 0, 4617, 4616, 1, 0, 0, 0, 4618, 4619, 1, 0, 0, 0, 4619, 4622, 5, 49, 0, 0, 4620, 4623, 3, 770, 385, 0, 4621, 4623, 3, 774, 387, 0, 4622, 4620, 1, 0, 0, 0, 4622, 4621, 1, 0, 0, 0, 4623, 4625, 1, 0, 0, 0, 4624, 4626, 3, 1024, 512, 0, 4625, 4624, 1, 0, 0, 0, 4625, 4626, 1, 0, 0, 0, 4626, 4628, 1, 0, 0, 0, 4627, 4629, 3, 1026, 513, 0, 4628, 4627, 1, 0, 0, 0, 4628, 4629, 1, 0, 0, 0, 4629, 4631, 1, 0, 0, 0, 4630, 4632, 5, 167, 0, 0, 4631, 4630, 1, 0, 0, 0, 4631, 4632, 1, 0, 0, 0, 4632, 769, 1, 0, 0, 0, 4633, 4635, 3, 772, 386, 0, 4634, 4633, 1, 0, 0, 0, 4635, 4636, 1, 0, 0, 0, 4636, 4634, 1, 0, 0, 0, 4636, 4637, 1, 0, 0, 0, 4637, 771, 1, 0, 0, 0, 4638, 4640, 3, 1074, 537, 0, 4639, 4641, 5, 412, 0, 0, 4640, 4639, 1, 0, 0, 0, 4640, 4641, 1, 0, 0, 0, 4641, 773, 1, 0, 0, 0, 4642, 4643, 3, 776, 388, 0, 4643, 4645, 5, 222, 0, 0, 4644, 4646, 3, 778, 389, 0, 4645, 4644, 1, 0, 0, 0, 4646, 4647, 1, 0, 0, 0, 4647, 4645, 1, 0, 0, 0, 4647, 4648, 1, 0, 0, 0, 4648, 775, 1, 0, 0, 0, 4649, 4652, 3, 1074, 537, 0, 4650, 4652, 3, 1172, 586, 0, 4651, 4649, 1, 0, 0, 0, 4651, 4650, 1, 0, 0, 0, 4652, 777, 1, 0, 0, 0, 4653, 4655, 3, 1074, 537, 0, 4654, 4656, 5, 412, 0, 0, 4655, 4654, 1, 0, 0, 0, 4655, 4656, 1, 0, 0, 0, 4656, 779, 1, 0, 0, 0, 4657, 4662, 5, 327, 0, 0, 4658, 4663, 3, 782, 391, 0, 4659, 4663, 3, 786, 393, 0, 4660, 4663, 3, 790, 395, 0, 4661, 4663, 3, 792, 396, 0, 4662, 4658, 1, 0, 0, 0, 4662, 4659, 1, 0, 0, 0, 4662, 4660, 1, 0, 0, 0, 4662, 4661, 1, 0, 0, 0, 4663, 4664, 1, 0, 0, 0, 4664, 4662, 1, 0, 0, 0, 4664, 4665, 1, 0, 0, 0, 4665, 781, 1, 0, 0, 0, 4666, 4668, 5, 246, 0, 0, 4667, 4669, 3, 784, 392, 0, 4668, 4667, 1, 0, 0, 0, 4669, 4670, 1, 0, 0, 0, 4670, 4668, 1, 0, 0, 0, 4670, 4671, 1, 0, 0, 0, 4671, 783, 1, 0, 0, 0, 4672, 4679, 3, 1134, 567, 0, 4673, 4680, 5, 406, 0, 0, 4674, 4676, 5, 514, 0, 0, 4675, 4674, 1, 0, 0, 0, 4675, 4676, 1, 0, 0, 0, 4676, 4677, 1, 0, 0, 0, 4677, 4678, 5, 310, 0, 0, 4678, 4680, 5, 407, 0, 0, 4679, 4673, 1, 0, 0, 0, 4679, 4675, 1, 0, 0, 0, 4679, 4680, 1, 0, 0, 0, 4680, 785, 1, 0, 0, 0, 4681, 4683, 5, 334, 0, 0, 4682, 4684, 3, 788, 394, 0, 4683, 4682, 1, 0, 0, 0, 4684, 4685, 1, 0, 0, 0, 4685, 4683, 1, 0, 0, 0, 4685, 4686, 1, 0, 0, 0, 4686, 787, 1, 0, 0, 0, 4687, 4693, 3, 1134, 567, 0, 4688, 4690, 5, 514, 0, 0, 4689, 4688, 1, 0, 0, 0, 4689, 4690, 1, 0, 0, 0, 4690, 4691, 1, 0, 0, 0, 4691, 4692, 5, 310, 0, 0, 4692, 4694, 5, 407, 0, 0, 4693, 4689, 1, 0, 0, 0, 4693, 4694, 1, 0, 0, 0, 4694, 789, 1, 0, 0, 0, 4695, 4697, 5, 232, 0, 0, 4696, 4698, 3, 1134, 567, 0, 4697, 4696, 1, 0, 0, 0, 4698, 4699, 1, 0, 0, 0, 4699, 4697, 1, 0, 0, 0, 4699, 4700, 1, 0, 0, 0, 4700, 791, 1, 0, 0, 0, 4701, 4703, 5, 201, 0, 0, 4702, 4704, 3, 1134, 567, 0, 4703, 4702, 1, 0, 0, 0, 4704, 4705, 1, 0, 0, 0, 4705, 4703, 1, 0, 0, 0, 4705, 4706, 1, 0, 0, 0, 4706, 793, 1, 0, 0, 0, 4707, 4710, 5, 343, 0, 0, 4708, 4711, 3, 796, 398, 0, 4709, 4711, 3, 798, 399, 0, 4710, 4708, 1, 0, 0, 0, 4710, 4709, 1, 0, 0, 0, 4711, 795, 1, 0, 0, 0, 4712, 4714, 3, 800, 400, 0, 4713, 4712, 1, 0, 0, 0, 4713, 4714, 1, 0, 0, 0, 4714, 4718, 1, 0, 0, 0, 4715, 4717, 3, 536, 268, 0, 4716, 4715, 1, 0, 0, 0, 4717, 4720, 1, 0, 0, 0, 4718, 4716, 1, 0, 0, 0, 4718, 4719, 1, 0, 0, 0, 4719, 4721, 1, 0, 0, 0, 4720, 4718, 1, 0, 0, 0, 4721, 4722, 5, 169, 0, 0, 4722, 797, 1, 0, 0, 0, 4723, 4726, 3, 1150, 575, 0, 4724, 4725, 7, 4, 0, 0, 4725, 4727, 3, 1150, 575, 0, 4726, 4724, 1, 0, 0, 0, 4726, 4727, 1, 0, 0, 0, 4727, 4729, 1, 0, 0, 0, 4728, 4730, 3, 800, 400, 0, 4729, 4728, 1, 0, 0, 0, 4729, 4730, 1, 0, 0, 0, 4730, 799, 1, 0, 0, 0, 4731, 4735, 3, 802, 401, 0, 4732, 4735, 3, 804, 402, 0, 4733, 4735, 3, 806, 403, 0, 4734, 4731, 1, 0, 0, 0, 4734, 4732, 1, 0, 0, 0, 4734, 4733, 1, 0, 0, 0, 4735, 801, 1, 0, 0, 0, 4736, 4739, 3, 1074, 537, 0, 4737, 4739, 3, 1178, 589, 0, 4738, 4736, 1, 0, 0, 0, 4738, 4737, 1, 0, 0, 0, 4739, 4740, 1, 0, 0, 0, 4740, 4741, 5, 487, 0, 0, 4741, 803, 1, 0, 0, 0, 4742, 4744, 3, 818, 409, 0, 4743, 4742, 1, 0, 0, 0, 4743, 4744, 1, 0, 0, 0, 4744, 4745, 1, 0, 0, 0, 4745, 4746, 5, 501, 0, 0, 4746, 4747, 3, 1046, 523, 0, 4747, 805, 1, 0, 0, 0, 4748, 4749, 3, 818, 409, 0, 4749, 4750, 3, 808, 404, 0, 4750, 4756, 1, 0, 0, 0, 4751, 4753, 3, 808, 404, 0, 4752, 4754, 3, 818, 409, 0, 4753, 4752, 1, 0, 0, 0, 4753, 4754, 1, 0, 0, 0, 4754, 4756, 1, 0, 0, 0, 4755, 4748, 1, 0, 0, 0, 4755, 4751, 1, 0, 0, 0, 4756, 807, 1, 0, 0, 0, 4757, 4758, 5, 509, 0, 0, 4758, 4762, 3, 810, 405, 0, 4759, 4761, 3, 812, 406, 0, 4760, 4759, 1, 0, 0, 0, 4761, 4764, 1, 0, 0, 0, 4762, 4760, 1, 0, 0, 0, 4762, 4763, 1, 0, 0, 0, 4763, 809, 1, 0, 0, 0, 4764, 4762, 1, 0, 0, 0, 4765, 4768, 3, 1074, 537, 0, 4766, 4768, 3, 1172, 586, 0, 4767, 4765, 1, 0, 0, 0, 4767, 4766, 1, 0, 0, 0, 4768, 4769, 1, 0, 0, 0, 4769, 4770, 3, 814, 407, 0, 4770, 4771, 3, 816, 408, 0, 4771, 4772, 3, 804, 402, 0, 4772, 811, 1, 0, 0, 0, 4773, 4774, 5, 7, 0, 0, 4774, 4775, 3, 810, 405, 0, 4775, 813, 1, 0, 0, 0, 4776, 4780, 5, 215, 0, 0, 4777, 4781, 3, 1074, 537, 0, 4778, 4781, 3, 1172, 586, 0, 4779, 4781, 3, 1032, 516, 0, 4780, 4777, 1, 0, 0, 0, 4780, 4778, 1, 0, 0, 0, 4780, 4779, 1, 0, 0, 0, 4781, 815, 1, 0, 0, 0, 4782, 4786, 5, 49, 0, 0, 4783, 4787, 3, 1074, 537, 0, 4784, 4787, 3, 1172, 586, 0, 4785, 4787, 3, 1032, 516, 0, 4786, 4783, 1, 0, 0, 0, 4786, 4784, 1, 0, 0, 0, 4786, 4785, 1, 0, 0, 0, 4787, 817, 1, 0, 0, 0, 4788, 4790, 5, 514, 0, 0, 4789, 4788, 1, 0, 0, 0, 4789, 4790, 1, 0, 0, 0, 4790, 4791, 1, 0, 0, 0, 4791, 4792, 5, 477, 0, 0, 4792, 4793, 7, 56, 0, 0, 4793, 819, 1, 0, 0, 0, 4794, 4796, 5, 365, 0, 0, 4795, 4797, 3, 1120, 560, 0, 4796, 4795, 1, 0, 0, 0, 4797, 4798, 1, 0, 0, 0, 4798, 4796, 1, 0, 0, 0, 4798, 4799, 1, 0, 0, 0, 4799, 821, 1, 0, 0, 0, 4800, 4801, 5, 374, 0, 0, 4801, 4803, 3, 1134, 567, 0, 4802, 4804, 5, 309, 0, 0, 4803, 4802, 1, 0, 0, 0, 4803, 4804, 1, 0, 0, 0, 4804, 4806, 1, 0, 0, 0, 4805, 4807, 5, 377, 0, 0, 4806, 4805, 1, 0, 0, 0, 4806, 4807, 1, 0, 0, 0, 4807, 4809, 1, 0, 0, 0, 4808, 4810, 3, 824, 412, 0, 4809, 4808, 1, 0, 0, 0, 4809, 4810, 1, 0, 0, 0, 4810, 4812, 1, 0, 0, 0, 4811, 4813, 3, 826, 413, 0, 4812, 4811, 1, 0, 0, 0, 4812, 4813, 1, 0, 0, 0, 4813, 4815, 1, 0, 0, 0, 4814, 4816, 3, 828, 414, 0, 4815, 4814, 1, 0, 0, 0, 4815, 4816, 1, 0, 0, 0, 4816, 4818, 1, 0, 0, 0, 4817, 4819, 3, 1016, 508, 0, 4818, 4817, 1, 0, 0, 0, 4818, 4819, 1, 0, 0, 0, 4819, 4821, 1, 0, 0, 0, 4820, 4822, 3, 1018, 509, 0, 4821, 4820, 1, 0, 0, 0, 4821, 4822, 1, 0, 0, 0, 4822, 4824, 1, 0, 0, 0, 4823, 4825, 3, 1012, 506, 0, 4824, 4823, 1, 0, 0, 0, 4824, 4825, 1, 0, 0, 0, 4825, 4827, 1, 0, 0, 0, 4826, 4828, 3, 1014, 507, 0, 4827, 4826, 1, 0, 0, 0, 4827, 4828, 1, 0, 0, 0, 4828, 4830, 1, 0, 0, 0, 4829, 4831, 5, 170, 0, 0, 4830, 4829, 1, 0, 0, 0, 4830, 4831, 1, 0, 0, 0, 4831, 823, 1, 0, 0, 0, 4832, 4833, 5, 251, 0, 0, 4833, 4834, 3, 1074, 537, 0, 4834, 825, 1, 0, 0, 0, 4835, 4837, 5, 514, 0, 0, 4836, 4835, 1, 0, 0, 0, 4836, 4837, 1, 0, 0, 0, 4837, 4841, 1, 0, 0, 0, 4838, 4839, 7, 57, 0, 0, 4839, 4842, 5, 286, 0, 0, 4840, 4842, 5, 511, 0, 0, 4841, 4838, 1, 0, 0, 0, 4841, 4840, 1, 0, 0, 0, 4842, 827, 1, 0, 0, 0, 4843, 4845, 5, 259, 0, 0, 4844, 4846, 5, 254, 0, 0, 4845, 4844, 1, 0, 0, 0, 4845, 4846, 1, 0, 0, 0, 4846, 4847, 1, 0, 0, 0, 4847, 4848, 3, 1090, 545, 0, 4848, 829, 1, 0, 0, 0, 4849, 4852, 5, 375, 0, 0, 4850, 4853, 3, 832, 416, 0, 4851, 4853, 3, 836, 418, 0, 4852, 4850, 1, 0, 0, 0, 4852, 4851, 1, 0, 0, 0, 4853, 4855, 1, 0, 0, 0, 4854, 4856, 3, 1028, 514, 0, 4855, 4854, 1, 0, 0, 0, 4855, 4856, 1, 0, 0, 0, 4856, 4858, 1, 0, 0, 0, 4857, 4859, 3, 1030, 515, 0, 4858, 4857, 1, 0, 0, 0, 4858, 4859, 1, 0, 0, 0, 4859, 4861, 1, 0, 0, 0, 4860, 4862, 5, 171, 0, 0, 4861, 4860, 1, 0, 0, 0, 4861, 4862, 1, 0, 0, 0, 4862, 831, 1, 0, 0, 0, 4863, 4864, 3, 1128, 564, 0, 4864, 4865, 5, 215, 0, 0, 4865, 4873, 3, 834, 417, 0, 4866, 4872, 3, 842, 421, 0, 4867, 4872, 3, 844, 422, 0, 4868, 4872, 3, 846, 423, 0, 4869, 4872, 3, 848, 424, 0, 4870, 4872, 3, 850, 425, 0, 4871, 4866, 1, 0, 0, 0, 4871, 4867, 1, 0, 0, 0, 4871, 4868, 1, 0, 0, 0, 4871, 4869, 1, 0, 0, 0, 4871, 4870, 1, 0, 0, 0, 4872, 4875, 1, 0, 0, 0, 4873, 4871, 1, 0, 0, 0, 4873, 4874, 1, 0, 0, 0, 4874, 833, 1, 0, 0, 0, 4875, 4873, 1, 0, 0, 0, 4876, 4877, 5, 481, 0, 0, 4877, 4883, 3, 1128, 564, 0, 4878, 4879, 5, 263, 0, 0, 4879, 4883, 5, 481, 0, 0, 4880, 4881, 5, 20, 0, 0, 4881, 4883, 5, 481, 0, 0, 4882, 4876, 1, 0, 0, 0, 4882, 4878, 1, 0, 0, 0, 4882, 4880, 1, 0, 0, 0, 4883, 835, 1, 0, 0, 0, 4884, 4885, 3, 1120, 560, 0, 4885, 4887, 7, 58, 0, 0, 4886, 4888, 5, 251, 0, 0, 4887, 4886, 1, 0, 0, 0, 4887, 4888, 1, 0, 0, 0, 4888, 4889, 1, 0, 0, 0, 4889, 4891, 3, 1074, 537, 0, 4890, 4892, 3, 838, 419, 0, 4891, 4890, 1, 0, 0, 0, 4891, 4892, 1, 0, 0, 0, 4892, 4894, 1, 0, 0, 0, 4893, 4895, 3, 840, 420, 0, 4894, 4893, 1, 0, 0, 0, 4894, 4895, 1, 0, 0, 0, 4895, 837, 1, 0, 0, 0, 4896, 4897, 5, 310, 0, 0, 4897, 4901, 5, 109, 0, 0, 4898, 4900, 3, 536, 268, 0, 4899, 4898, 1, 0, 0, 0, 4900, 4903, 1, 0, 0, 0, 4901, 4899, 1, 0, 0, 0, 4901, 4902, 1, 0, 0, 0, 4902, 839, 1, 0, 0, 0, 4903, 4901, 1, 0, 0, 0, 4904, 4905, 5, 514, 0, 0, 4905, 4909, 5, 109, 0, 0, 4906, 4908, 3, 536, 268, 0, 4907, 4906, 1, 0, 0, 0, 4908, 4911, 1, 0, 0, 0, 4909, 4907, 1, 0, 0, 0, 4909, 4910, 1, 0, 0, 0, 4910, 841, 1, 0, 0, 0, 4911, 4909, 1, 0, 0, 0, 4912, 4914, 5, 39, 0, 0, 4913, 4915, 5, 485, 0, 0, 4914, 4913, 1, 0, 0, 0, 4914, 4915, 1, 0, 0, 0, 4915, 4918, 1, 0, 0, 0, 4916, 4919, 3, 1176, 588, 0, 4917, 4919, 3, 1074, 537, 0, 4918, 4916, 1, 0, 0, 0, 4918, 4917, 1, 0, 0, 0, 4919, 843, 1, 0, 0, 0, 4920, 4922, 5, 514, 0, 0, 4921, 4920, 1, 0, 0, 0, 4921, 4922, 1, 0, 0, 0, 4922, 4923, 1, 0, 0, 0, 4923, 4924, 5, 310, 0, 0, 4924, 4925, 5, 511, 0, 0, 4925, 845, 1, 0, 0, 0, 4926, 4928, 5, 481, 0, 0, 4927, 4929, 5, 239, 0, 0, 4928, 4927, 1, 0, 0, 0, 4928, 4929, 1, 0, 0, 0, 4929, 4930, 1, 0, 0, 0, 4930, 4931, 3, 1128, 564, 0, 4931, 847, 1, 0, 0, 0, 4932, 4934, 5, 439, 0, 0, 4933, 4935, 5, 239, 0, 0, 4934, 4933, 1, 0, 0, 0, 4934, 4935, 1, 0, 0, 0, 4935, 4938, 1, 0, 0, 0, 4936, 4939, 3, 1176, 588, 0, 4937, 4939, 3, 1074, 537, 0, 4938, 4936, 1, 0, 0, 0, 4938, 4937, 1, 0, 0, 0, 4939, 849, 1, 0, 0, 0, 4940, 4942, 5, 457, 0, 0, 4941, 4943, 5, 239, 0, 0, 4942, 4941, 1, 0, 0, 0, 4942, 4943, 1, 0, 0, 0, 4943, 4944, 1, 0, 0, 0, 4944, 4945, 3, 1074, 537, 0, 4945, 851, 1, 0, 0, 0, 4946, 4947, 5, 387, 0, 0, 4947, 4950, 3, 1154, 577, 0, 4948, 4949, 5, 215, 0, 0, 4949, 4951, 3, 1090, 545, 0, 4950, 4948, 1, 0, 0, 0, 4950, 4951, 1, 0, 0, 0, 4951, 853, 1, 0, 0, 0, 4952, 4953, 5, 403, 0, 0, 4953, 4955, 3, 1134, 567, 0, 4954, 4956, 5, 377, 0, 0, 4955, 4954, 1, 0, 0, 0, 4955, 4956, 1, 0, 0, 0, 4956, 4958, 1, 0, 0, 0, 4957, 4959, 3, 856, 428, 0, 4958, 4957, 1, 0, 0, 0, 4958, 4959, 1, 0, 0, 0, 4959, 4960, 1, 0, 0, 0, 4960, 4962, 3, 1012, 506, 0, 4961, 4963, 3, 1014, 507, 0, 4962, 4961, 1, 0, 0, 0, 4962, 4963, 1, 0, 0, 0, 4963, 4965, 1, 0, 0, 0, 4964, 4966, 5, 172, 0, 0, 4965, 4964, 1, 0, 0, 0, 4965, 4966, 1, 0, 0, 0, 4966, 855, 1, 0, 0, 0, 4967, 4968, 5, 251, 0, 0, 4968, 4969, 3, 1090, 545, 0, 4969, 857, 1, 0, 0, 0, 4970, 4971, 5, 408, 0, 0, 4971, 4973, 3, 1154, 577, 0, 4972, 4974, 3, 860, 430, 0, 4973, 4972, 1, 0, 0, 0, 4973, 4974, 1, 0, 0, 0, 4974, 4976, 1, 0, 0, 0, 4975, 4977, 3, 1016, 508, 0, 4976, 4975, 1, 0, 0, 0, 4976, 4977, 1, 0, 0, 0, 4977, 4979, 1, 0, 0, 0, 4978, 4980, 3, 1018, 509, 0, 4979, 4978, 1, 0, 0, 0, 4979, 4980, 1, 0, 0, 0, 4980, 4982, 1, 0, 0, 0, 4981, 4983, 5, 173, 0, 0, 4982, 4981, 1, 0, 0, 0, 4982, 4983, 1, 0, 0, 0, 4983, 859, 1, 0, 0, 0, 4984, 4985, 5, 215, 0, 0, 4985, 4986, 3, 1074, 537, 0, 4986, 861, 1, 0, 0, 0, 4987, 4989, 5, 418, 0, 0, 4988, 4990, 5, 9, 0, 0, 4989, 4988, 1, 0, 0, 0, 4989, 4990, 1, 0, 0, 0, 4990, 4991, 1, 0, 0, 0, 4991, 4993, 3, 1090, 545, 0, 4992, 4994, 3, 864, 432, 0, 4993, 4992, 1, 0, 0, 0, 4993, 4994, 1, 0, 0, 0, 4994, 4996, 1, 0, 0, 0, 4995, 4997, 3, 1012, 506, 0, 4996, 4995, 1, 0, 0, 0, 4996, 4997, 1, 0, 0, 0, 4997, 4999, 1, 0, 0, 0, 4998, 5000, 3, 866, 433, 0, 4999, 4998, 1, 0, 0, 0, 5000, 5001, 1, 0, 0, 0, 5001, 4999, 1, 0, 0, 0, 5001, 5002, 1, 0, 0, 0, 5002, 5004, 1, 0, 0, 0, 5003, 5005, 5, 174, 0, 0, 5004, 5003, 1, 0, 0, 0, 5004, 5005, 1, 0, 0, 0, 5005, 863, 1, 0, 0, 0, 5006, 5007, 5, 509, 0, 0, 5007, 5008, 3, 1090, 545, 0, 5008, 865, 1, 0, 0, 0, 5009, 5010, 5, 512, 0, 0, 5010, 5019, 3, 1046, 523, 0, 5011, 5012, 5, 309, 0, 0, 5012, 5020, 5, 426, 0, 0, 5013, 5015, 3, 536, 268, 0, 5014, 5013, 1, 0, 0, 0, 5015, 5018, 1, 0, 0, 0, 5016, 5014, 1, 0, 0, 0, 5016, 5017, 1, 0, 0, 0, 5017, 5020, 1, 0, 0, 0, 5018, 5016, 1, 0, 0, 0, 5019, 5011, 1, 0, 0, 0, 5019, 5016, 1, 0, 0, 0, 5020, 867, 1, 0, 0, 0, 5021, 5024, 5, 425, 0, 0, 5022, 5025, 3, 870, 435, 0, 5023, 5025, 3, 872, 436, 0, 5024, 5022, 1, 0, 0, 0, 5024, 5023, 1, 0, 0, 0, 5025, 5027, 1, 0, 0, 0, 5026, 5028, 3, 1028, 514, 0, 5027, 5026, 1, 0, 0, 0, 5027, 5028, 1, 0, 0, 0, 5028, 5030, 1, 0, 0, 0, 5029, 5031, 3, 1030, 515, 0, 5030, 5029, 1, 0, 0, 0, 5030, 5031, 1, 0, 0, 0, 5031, 869, 1, 0, 0, 0, 5032, 5035, 3, 1074, 537, 0, 5033, 5035, 3, 1172, 586, 0, 5034, 5032, 1, 0, 0, 0, 5034, 5033, 1, 0, 0, 0, 5035, 5037, 1, 0, 0, 0, 5036, 5038, 3, 874, 437, 0, 5037, 5036, 1, 0, 0, 0, 5037, 5038, 1, 0, 0, 0, 5038, 5040, 1, 0, 0, 0, 5039, 5041, 3, 876, 438, 0, 5040, 5039, 1, 0, 0, 0, 5040, 5041, 1, 0, 0, 0, 5041, 5043, 1, 0, 0, 0, 5042, 5044, 3, 878, 439, 0, 5043, 5042, 1, 0, 0, 0, 5043, 5044, 1, 0, 0, 0, 5044, 5046, 1, 0, 0, 0, 5045, 5047, 3, 880, 440, 0, 5046, 5045, 1, 0, 0, 0, 5046, 5047, 1, 0, 0, 0, 5047, 871, 1, 0, 0, 0, 5048, 5049, 5, 489, 0, 0, 5049, 5050, 7, 59, 0, 0, 5050, 5051, 3, 1074, 537, 0, 5051, 873, 1, 0, 0, 0, 5052, 5053, 5, 215, 0, 0, 5053, 5054, 3, 1074, 537, 0, 5054, 875, 1, 0, 0, 0, 5055, 5060, 5, 514, 0, 0, 5056, 5061, 5, 153, 0, 0, 5057, 5061, 5, 155, 0, 0, 5058, 5061, 5, 192, 0, 0, 5059, 5061, 3, 1074, 537, 0, 5060, 5056, 1, 0, 0, 0, 5060, 5057, 1, 0, 0, 0, 5060, 5058, 1, 0, 0, 0, 5060, 5059, 1, 0, 0, 0, 5061, 877, 1, 0, 0, 0, 5062, 5064, 5, 394, 0, 0, 5063, 5065, 5, 279, 0, 0, 5064, 5063, 1, 0, 0, 0, 5064, 5065, 1, 0, 0, 0, 5065, 879, 1, 0, 0, 0, 5066, 5068, 7, 56, 0, 0, 5067, 5069, 5, 6, 0, 0, 5068, 5067, 1, 0, 0, 0, 5068, 5069, 1, 0, 0, 0, 5069, 5073, 1, 0, 0, 0, 5070, 5074, 3, 882, 441, 0, 5071, 5074, 3, 884, 442, 0, 5072, 5074, 3, 886, 443, 0, 5073, 5070, 1, 0, 0, 0, 5073, 5071, 1, 0, 0, 0, 5073, 5072, 1, 0, 0, 0, 5074, 881, 1, 0, 0, 0, 5075, 5076, 5, 340, 0, 0, 5076, 883, 1, 0, 0, 0, 5077, 5080, 3, 1074, 537, 0, 5078, 5080, 3, 1172, 586, 0, 5079, 5077, 1, 0, 0, 0, 5079, 5078, 1, 0, 0, 0, 5080, 5082, 1, 0, 0, 0, 5081, 5083, 7, 33, 0, 0, 5082, 5081, 1, 0, 0, 0, 5082, 5083, 1, 0, 0, 0, 5083, 885, 1, 0, 0, 0, 5084, 5085, 3, 1146, 573, 0, 5085, 887, 1, 0, 0, 0, 5086, 5093, 5, 430, 0, 0, 5087, 5089, 3, 890, 445, 0, 5088, 5087, 1, 0, 0, 0, 5089, 5090, 1, 0, 0, 0, 5090, 5088, 1, 0, 0, 0, 5090, 5091, 1, 0, 0, 0, 5091, 5094, 1, 0, 0, 0, 5092, 5094, 3, 892, 446, 0, 5093, 5088, 1, 0, 0, 0, 5093, 5092, 1, 0, 0, 0, 5094, 889, 1, 0, 0, 0, 5095, 5097, 3, 894, 447, 0, 5096, 5095, 1, 0, 0, 0, 5097, 5098, 1, 0, 0, 0, 5098, 5096, 1, 0, 0, 0, 5098, 5099, 1, 0, 0, 0, 5099, 5100, 1, 0, 0, 0, 5100, 5102, 5, 489, 0, 0, 5101, 5103, 3, 896, 448, 0, 5102, 5101, 1, 0, 0, 0, 5103, 5104, 1, 0, 0, 0, 5104, 5102, 1, 0, 0, 0, 5104, 5105, 1, 0, 0, 0, 5105, 891, 1, 0, 0, 0, 5106, 5108, 3, 894, 447, 0, 5107, 5106, 1, 0, 0, 0, 5108, 5109, 1, 0, 0, 0, 5109, 5107, 1, 0, 0, 0, 5109, 5110, 1, 0, 0, 0, 5110, 5115, 1, 0, 0, 0, 5111, 5112, 5, 502, 0, 0, 5112, 5116, 5, 49, 0, 0, 5113, 5114, 5, 148, 0, 0, 5114, 5116, 5, 49, 0, 0, 5115, 5111, 1, 0, 0, 0, 5115, 5113, 1, 0, 0, 0, 5116, 5117, 1, 0, 0, 0, 5117, 5118, 3, 898, 449, 0, 5118, 893, 1, 0, 0, 0, 5119, 5120, 3, 1074, 537, 0, 5120, 895, 1, 0, 0, 0, 5121, 5131, 5, 326, 0, 0, 5122, 5131, 5, 324, 0, 0, 5123, 5126, 5, 182, 0, 0, 5124, 5127, 3, 1074, 537, 0, 5125, 5127, 3, 1172, 586, 0, 5126, 5124, 1, 0, 0, 0, 5126, 5125, 1, 0, 0, 0, 5127, 5131, 1, 0, 0, 0, 5128, 5131, 3, 1074, 537, 0, 5129, 5131, 3, 1172, 586, 0, 5130, 5121, 1, 0, 0, 0, 5130, 5122, 1, 0, 0, 0, 5130, 5123, 1, 0, 0, 0, 5130, 5128, 1, 0, 0, 0, 5130, 5129, 1, 0, 0, 0, 5131, 897, 1, 0, 0, 0, 5132, 5135, 3, 1074, 537, 0, 5133, 5135, 3, 1172, 586, 0, 5134, 5132, 1, 0, 0, 0, 5134, 5133, 1, 0, 0, 0, 5135, 899, 1, 0, 0, 0, 5136, 5137, 5, 440, 0, 0, 5137, 5139, 3, 1134, 567, 0, 5138, 5140, 3, 902, 451, 0, 5139, 5138, 1, 0, 0, 0, 5140, 5141, 1, 0, 0, 0, 5141, 5139, 1, 0, 0, 0, 5141, 5142, 1, 0, 0, 0, 5142, 5144, 1, 0, 0, 0, 5143, 5145, 3, 904, 452, 0, 5144, 5143, 1, 0, 0, 0, 5144, 5145, 1, 0, 0, 0, 5145, 5147, 1, 0, 0, 0, 5146, 5148, 3, 906, 453, 0, 5147, 5146, 1, 0, 0, 0, 5147, 5148, 1, 0, 0, 0, 5148, 5150, 1, 0, 0, 0, 5149, 5151, 3, 912, 456, 0, 5150, 5149, 1, 0, 0, 0, 5150, 5151, 1, 0, 0, 0, 5151, 5155, 1, 0, 0, 0, 5152, 5154, 3, 916, 458, 0, 5153, 5152, 1, 0, 0, 0, 5154, 5157, 1, 0, 0, 0, 5155, 5153, 1, 0, 0, 0, 5155, 5156, 1, 0, 0, 0, 5156, 5159, 1, 0, 0, 0, 5157, 5155, 1, 0, 0, 0, 5158, 5160, 3, 918, 459, 0, 5159, 5158, 1, 0, 0, 0, 5159, 5160, 1, 0, 0, 0, 5160, 5164, 1, 0, 0, 0, 5161, 5163, 3, 922, 461, 0, 5162, 5161, 1, 0, 0, 0, 5163, 5166, 1, 0, 0, 0, 5164, 5162, 1, 0, 0, 0, 5164, 5165, 1, 0, 0, 0, 5165, 901, 1, 0, 0, 0, 5166, 5164, 1, 0, 0, 0, 5167, 5169, 5, 326, 0, 0, 5168, 5167, 1, 0, 0, 0, 5168, 5169, 1, 0, 0, 0, 5169, 5170, 1, 0, 0, 0, 5170, 5172, 7, 41, 0, 0, 5171, 5173, 5, 259, 0, 0, 5172, 5171, 1, 0, 0, 0, 5172, 5173, 1, 0, 0, 0, 5173, 5175, 1, 0, 0, 0, 5174, 5176, 3, 1090, 545, 0, 5175, 5174, 1, 0, 0, 0, 5176, 5177, 1, 0, 0, 0, 5177, 5175, 1, 0, 0, 0, 5177, 5178, 1, 0, 0, 0, 5178, 903, 1, 0, 0, 0, 5179, 5181, 5, 514, 0, 0, 5180, 5179, 1, 0, 0, 0, 5180, 5181, 1, 0, 0, 0, 5181, 5182, 1, 0, 0, 0, 5182, 5184, 5, 149, 0, 0, 5183, 5185, 5, 239, 0, 0, 5184, 5183, 1, 0, 0, 0, 5184, 5185, 1, 0, 0, 0, 5185, 5187, 1, 0, 0, 0, 5186, 5188, 5, 330, 0, 0, 5187, 5186, 1, 0, 0, 0, 5187, 5188, 1, 0, 0, 0, 5188, 905, 1, 0, 0, 0, 5189, 5191, 5, 72, 0, 0, 5190, 5189, 1, 0, 0, 0, 5190, 5191, 1, 0, 0, 0, 5191, 5192, 1, 0, 0, 0, 5192, 5194, 5, 428, 0, 0, 5193, 5195, 5, 254, 0, 0, 5194, 5193, 1, 0, 0, 0, 5194, 5195, 1, 0, 0, 0, 5195, 5197, 1, 0, 0, 0, 5196, 5198, 3, 1114, 557, 0, 5197, 5196, 1, 0, 0, 0, 5198, 5199, 1, 0, 0, 0, 5199, 5197, 1, 0, 0, 0, 5199, 5200, 1, 0, 0, 0, 5200, 5202, 1, 0, 0, 0, 5201, 5203, 3, 908, 454, 0, 5202, 5201, 1, 0, 0, 0, 5202, 5203, 1, 0, 0, 0, 5203, 5205, 1, 0, 0, 0, 5204, 5206, 3, 910, 455, 0, 5205, 5204, 1, 0, 0, 0, 5205, 5206, 1, 0, 0, 0, 5206, 907, 1, 0, 0, 0, 5207, 5209, 5, 212, 0, 0, 5208, 5207, 1, 0, 0, 0, 5208, 5209, 1, 0, 0, 0, 5209, 5210, 1, 0, 0, 0, 5210, 5211, 5, 14, 0, 0, 5211, 5212, 5, 254, 0, 0, 5212, 5213, 3, 1114, 557, 0, 5213, 909, 1, 0, 0, 0, 5214, 5216, 5, 212, 0, 0, 5215, 5214, 1, 0, 0, 0, 5215, 5216, 1, 0, 0, 0, 5216, 5217, 1, 0, 0, 0, 5217, 5219, 5, 304, 0, 0, 5218, 5220, 5, 254, 0, 0, 5219, 5218, 1, 0, 0, 0, 5219, 5220, 1, 0, 0, 0, 5220, 5221, 1, 0, 0, 0, 5221, 5222, 3, 1114, 557, 0, 5222, 911, 1, 0, 0, 0, 5223, 5224, 5, 246, 0, 0, 5224, 5226, 5, 356, 0, 0, 5225, 5227, 5, 254, 0, 0, 5226, 5225, 1, 0, 0, 0, 5226, 5227, 1, 0, 0, 0, 5227, 5228, 1, 0, 0, 0, 5228, 5230, 3, 1150, 575, 0, 5229, 5231, 3, 914, 457, 0, 5230, 5229, 1, 0, 0, 0, 5230, 5231, 1, 0, 0, 0, 5231, 913, 1, 0, 0, 0, 5232, 5233, 7, 4, 0, 0, 5233, 5234, 3, 1150, 575, 0, 5234, 915, 1, 0, 0, 0, 5235, 5237, 5, 506, 0, 0, 5236, 5238, 3, 1134, 567, 0, 5237, 5236, 1, 0, 0, 0, 5238, 5239, 1, 0, 0, 0, 5239, 5237, 1, 0, 0, 0, 5239, 5240, 1, 0, 0, 0, 5240, 917, 1, 0, 0, 0, 5241, 5242, 5, 334, 0, 0, 5242, 5244, 5, 356, 0, 0, 5243, 5245, 5, 254, 0, 0, 5244, 5243, 1, 0, 0, 0, 5244, 5245, 1, 0, 0, 0, 5245, 5246, 1, 0, 0, 0, 5246, 5248, 3, 1150, 575, 0, 5247, 5249, 3, 920, 460, 0, 5248, 5247, 1, 0, 0, 0, 5248, 5249, 1, 0, 0, 0, 5249, 919, 1, 0, 0, 0, 5250, 5251, 7, 4, 0, 0, 5251, 5252, 3, 1150, 575, 0, 5252, 921, 1, 0, 0, 0, 5253, 5255, 5, 222, 0, 0, 5254, 5256, 3, 924, 462, 0, 5255, 5254, 1, 0, 0, 0, 5256, 5257, 1, 0, 0, 0, 5257, 5255, 1, 0, 0, 0, 5257, 5258, 1, 0, 0, 0, 5258, 923, 1, 0, 0, 0, 5259, 5269, 3, 1134, 567, 0, 5260, 5270, 5, 286, 0, 0, 5261, 5270, 5, 415, 0, 0, 5262, 5263, 5, 310, 0, 0, 5263, 5270, 5, 407, 0, 0, 5264, 5270, 5, 106, 0, 0, 5265, 5270, 5, 387, 0, 0, 5266, 5267, 5, 514, 0, 0, 5267, 5268, 5, 391, 0, 0, 5268, 5270, 5, 106, 0, 0, 5269, 5260, 1, 0, 0, 0, 5269, 5261, 1, 0, 0, 0, 5269, 5262, 1, 0, 0, 0, 5269, 5264, 1, 0, 0, 0, 5269, 5265, 1, 0, 0, 0, 5269, 5266, 1, 0, 0, 0, 5269, 5270, 1, 0, 0, 0, 5270, 925, 1, 0, 0, 0, 5271, 5272, 5, 456, 0, 0, 5272, 5274, 3, 1134, 567, 0, 5273, 5275, 3, 928, 464, 0, 5274, 5273, 1, 0, 0, 0, 5274, 5275, 1, 0, 0, 0, 5275, 5277, 1, 0, 0, 0, 5276, 5278, 3, 1016, 508, 0, 5277, 5276, 1, 0, 0, 0, 5277, 5278, 1, 0, 0, 0, 5278, 5280, 1, 0, 0, 0, 5279, 5281, 3, 1018, 509, 0, 5280, 5279, 1, 0, 0, 0, 5280, 5281, 1, 0, 0, 0, 5281, 5283, 1, 0, 0, 0, 5282, 5284, 5, 175, 0, 0, 5283, 5282, 1, 0, 0, 0, 5283, 5284, 1, 0, 0, 0, 5284, 927, 1, 0, 0, 0, 5285, 5287, 5, 259, 0, 0, 5286, 5288, 5, 254, 0, 0, 5287, 5286, 1, 0, 0, 0, 5287, 5288, 1, 0, 0, 0, 5288, 5316, 1, 0, 0, 0, 5289, 5291, 5, 186, 0, 0, 5290, 5292, 5, 489, 0, 0, 5291, 5290, 1, 0, 0, 0, 5291, 5292, 1, 0, 0, 0, 5292, 5317, 1, 0, 0, 0, 5293, 5317, 5, 536, 0, 0, 5294, 5296, 5, 225, 0, 0, 5295, 5297, 5, 479, 0, 0, 5296, 5295, 1, 0, 0, 0, 5296, 5297, 1, 0, 0, 0, 5297, 5317, 1, 0, 0, 0, 5298, 5317, 5, 544, 0, 0, 5299, 5300, 5, 312, 0, 0, 5300, 5302, 5, 271, 0, 0, 5301, 5303, 5, 479, 0, 0, 5302, 5301, 1, 0, 0, 0, 5302, 5303, 1, 0, 0, 0, 5303, 5317, 1, 0, 0, 0, 5304, 5305, 5, 312, 0, 0, 5305, 5317, 5, 540, 0, 0, 5306, 5308, 5, 225, 0, 0, 5307, 5309, 5, 479, 0, 0, 5308, 5307, 1, 0, 0, 0, 5308, 5309, 1, 0, 0, 0, 5309, 5310, 1, 0, 0, 0, 5310, 5311, 5, 329, 0, 0, 5311, 5313, 5, 186, 0, 0, 5312, 5314, 5, 489, 0, 0, 5313, 5312, 1, 0, 0, 0, 5313, 5314, 1, 0, 0, 0, 5314, 5317, 1, 0, 0, 0, 5315, 5317, 5, 545, 0, 0, 5316, 5289, 1, 0, 0, 0, 5316, 5293, 1, 0, 0, 0, 5316, 5294, 1, 0, 0, 0, 5316, 5298, 1, 0, 0, 0, 5316, 5299, 1, 0, 0, 0, 5316, 5304, 1, 0, 0, 0, 5316, 5306, 1, 0, 0, 0, 5316, 5315, 1, 0, 0, 0, 5317, 5318, 1, 0, 0, 0, 5318, 5319, 3, 1090, 545, 0, 5319, 929, 1, 0, 0, 0, 5320, 5323, 5, 458, 0, 0, 5321, 5324, 5, 413, 0, 0, 5322, 5324, 3, 1172, 586, 0, 5323, 5321, 1, 0, 0, 0, 5323, 5322, 1, 0, 0, 0, 5324, 931, 1, 0, 0, 0, 5325, 5327, 5, 459, 0, 0, 5326, 5328, 3, 934, 467, 0, 5327, 5326, 1, 0, 0, 0, 5328, 5329, 1, 0, 0, 0, 5329, 5327, 1, 0, 0, 0, 5329, 5330, 1, 0, 0, 0, 5330, 5331, 1, 0, 0, 0, 5331, 5333, 3, 942, 471, 0, 5332, 5334, 3, 944, 472, 0, 5333, 5332, 1, 0, 0, 0, 5333, 5334, 1, 0, 0, 0, 5334, 5336, 1, 0, 0, 0, 5335, 5337, 3, 1020, 510, 0, 5336, 5335, 1, 0, 0, 0, 5336, 5337, 1, 0, 0, 0, 5337, 5339, 1, 0, 0, 0, 5338, 5340, 3, 1022, 511, 0, 5339, 5338, 1, 0, 0, 0, 5339, 5340, 1, 0, 0, 0, 5340, 5342, 1, 0, 0, 0, 5341, 5343, 5, 176, 0, 0, 5342, 5341, 1, 0, 0, 0, 5342, 5343, 1, 0, 0, 0, 5343, 933, 1, 0, 0, 0, 5344, 5346, 3, 936, 468, 0, 5345, 5344, 1, 0, 0, 0, 5346, 5347, 1, 0, 0, 0, 5347, 5345, 1, 0, 0, 0, 5347, 5348, 1, 0, 0, 0, 5348, 5351, 1, 0, 0, 0, 5349, 5352, 3, 938, 469, 0, 5350, 5352, 3, 940, 470, 0, 5351, 5349, 1, 0, 0, 0, 5351, 5350, 1, 0, 0, 0, 5352, 935, 1, 0, 0, 0, 5353, 5356, 3, 1074, 537, 0, 5354, 5356, 3, 1172, 586, 0, 5355, 5353, 1, 0, 0, 0, 5355, 5354, 1, 0, 0, 0, 5356, 937, 1, 0, 0, 0, 5357, 5359, 5, 132, 0, 0, 5358, 5360, 5, 49, 0, 0, 5359, 5358, 1, 0, 0, 0, 5359, 5360, 1, 0, 0, 0, 5360, 5364, 1, 0, 0, 0, 5361, 5365, 5, 439, 0, 0, 5362, 5365, 3, 1074, 537, 0, 5363, 5365, 3, 1172, 586, 0, 5364, 5361, 1, 0, 0, 0, 5364, 5362, 1, 0, 0, 0, 5364, 5363, 1, 0, 0, 0, 5365, 939, 1, 0, 0, 0, 5366, 5369, 5, 212, 0, 0, 5367, 5370, 3, 1074, 537, 0, 5368, 5370, 3, 1172, 586, 0, 5369, 5367, 1, 0, 0, 0, 5369, 5368, 1, 0, 0, 0, 5370, 941, 1, 0, 0, 0, 5371, 5372, 5, 251, 0, 0, 5372, 5373, 3, 1074, 537, 0, 5373, 943, 1, 0, 0, 0, 5374, 5376, 5, 514, 0, 0, 5375, 5374, 1, 0, 0, 0, 5375, 5376, 1, 0, 0, 0, 5376, 5377, 1, 0, 0, 0, 5377, 5378, 5, 349, 0, 0, 5378, 5379, 3, 1090, 545, 0, 5379, 945, 1, 0, 0, 0, 5380, 5384, 5, 463, 0, 0, 5381, 5385, 3, 948, 474, 0, 5382, 5385, 3, 950, 475, 0, 5383, 5385, 3, 952, 476, 0, 5384, 5381, 1, 0, 0, 0, 5384, 5382, 1, 0, 0, 0, 5384, 5383, 1, 0, 0, 0, 5385, 5387, 1, 0, 0, 0, 5386, 5388, 3, 1024, 512, 0, 5387, 5386, 1, 0, 0, 0, 5387, 5388, 1, 0, 0, 0, 5388, 5390, 1, 0, 0, 0, 5389, 5391, 3, 1026, 513, 0, 5390, 5389, 1, 0, 0, 0, 5390, 5391, 1, 0, 0, 0, 5391, 5393, 1, 0, 0, 0, 5392, 5394, 5, 177, 0, 0, 5393, 5392, 1, 0, 0, 0, 5393, 5394, 1, 0, 0, 0, 5394, 947, 1, 0, 0, 0, 5395, 5397, 3, 954, 477, 0, 5396, 5395, 1, 0, 0, 0, 5397, 5398, 1, 0, 0, 0, 5398, 5396, 1, 0, 0, 0, 5398, 5399, 1, 0, 0, 0, 5399, 5400, 1, 0, 0, 0, 5400, 5402, 5, 215, 0, 0, 5401, 5403, 3, 956, 478, 0, 5402, 5401, 1, 0, 0, 0, 5403, 5404, 1, 0, 0, 0, 5404, 5402, 1, 0, 0, 0, 5404, 5405, 1, 0, 0, 0, 5405, 949, 1, 0, 0, 0, 5406, 5408, 3, 954, 477, 0, 5407, 5406, 1, 0, 0, 0, 5408, 5409, 1, 0, 0, 0, 5409, 5407, 1, 0, 0, 0, 5409, 5410, 1, 0, 0, 0, 5410, 5411, 1, 0, 0, 0, 5411, 5412, 5, 215, 0, 0, 5412, 5413, 3, 958, 479, 0, 5413, 5415, 5, 222, 0, 0, 5414, 5416, 3, 960, 480, 0, 5415, 5414, 1, 0, 0, 0, 5416, 5417, 1, 0, 0, 0, 5417, 5415, 1, 0, 0, 0, 5417, 5418, 1, 0, 0, 0, 5418, 951, 1, 0, 0, 0, 5419, 5420, 7, 50, 0, 0, 5420, 5421, 3, 1090, 545, 0, 5421, 5422, 5, 215, 0, 0, 5422, 5423, 3, 962, 481, 0, 5423, 953, 1, 0, 0, 0, 5424, 5427, 3, 1074, 537, 0, 5425, 5427, 3, 1172, 586, 0, 5426, 5424, 1, 0, 0, 0, 5426, 5425, 1, 0, 0, 0, 5427, 955, 1, 0, 0, 0, 5428, 5430, 3, 1074, 537, 0, 5429, 5431, 5, 412, 0, 0, 5430, 5429, 1, 0, 0, 0, 5430, 5431, 1, 0, 0, 0, 5431, 957, 1, 0, 0, 0, 5432, 5435, 3, 1074, 537, 0, 5433, 5435, 3, 1172, 586, 0, 5434, 5432, 1, 0, 0, 0, 5434, 5433, 1, 0, 0, 0, 5435, 959, 1, 0, 0, 0, 5436, 5438, 3, 1074, 537, 0, 5437, 5439, 5, 412, 0, 0, 5438, 5437, 1, 0, 0, 0, 5438, 5439, 1, 0, 0, 0, 5439, 961, 1, 0, 0, 0, 5440, 5442, 3, 1090, 545, 0, 5441, 5443, 5, 412, 0, 0, 5442, 5441, 1, 0, 0, 0, 5442, 5443, 1, 0, 0, 0, 5443, 963, 1, 0, 0, 0, 5444, 5445, 5, 476, 0, 0, 5445, 5446, 3, 1156, 578, 0, 5446, 965, 1, 0, 0, 0, 5447, 5448, 5, 500, 0, 0, 5448, 5449, 3, 968, 484, 0, 5449, 5451, 3, 974, 487, 0, 5450, 5452, 3, 982, 491, 0, 5451, 5450, 1, 0, 0, 0, 5451, 5452, 1, 0, 0, 0, 5452, 5454, 1, 0, 0, 0, 5453, 5455, 3, 984, 492, 0, 5454, 5453, 1, 0, 0, 0, 5454, 5455, 1, 0, 0, 0, 5455, 5457, 1, 0, 0, 0, 5456, 5458, 3, 1020, 510, 0, 5457, 5456, 1, 0, 0, 0, 5457, 5458, 1, 0, 0, 0, 5458, 5460, 1, 0, 0, 0, 5459, 5461, 3, 1022, 511, 0, 5460, 5459, 1, 0, 0, 0, 5460, 5461, 1, 0, 0, 0, 5461, 5463, 1, 0, 0, 0, 5462, 5464, 5, 178, 0, 0, 5463, 5462, 1, 0, 0, 0, 5463, 5464, 1, 0, 0, 0, 5464, 967, 1, 0, 0, 0, 5465, 5473, 3, 1074, 537, 0, 5466, 5470, 3, 970, 485, 0, 5467, 5469, 3, 972, 486, 0, 5468, 5467, 1, 0, 0, 0, 5469, 5472, 1, 0, 0, 0, 5470, 5468, 1, 0, 0, 0, 5470, 5471, 1, 0, 0, 0, 5471, 5474, 1, 0, 0, 0, 5472, 5470, 1, 0, 0, 0, 5473, 5466, 1, 0, 0, 0, 5473, 5474, 1, 0, 0, 0, 5474, 969, 1, 0, 0, 0, 5475, 5477, 5, 132, 0, 0, 5476, 5478, 5, 49, 0, 0, 5477, 5476, 1, 0, 0, 0, 5477, 5478, 1, 0, 0, 0, 5478, 5480, 1, 0, 0, 0, 5479, 5481, 5, 9, 0, 0, 5480, 5479, 1, 0, 0, 0, 5480, 5481, 1, 0, 0, 0, 5481, 5484, 1, 0, 0, 0, 5482, 5485, 3, 1074, 537, 0, 5483, 5485, 3, 1172, 586, 0, 5484, 5482, 1, 0, 0, 0, 5484, 5483, 1, 0, 0, 0, 5485, 971, 1, 0, 0, 0, 5486, 5488, 5, 329, 0, 0, 5487, 5489, 5, 9, 0, 0, 5488, 5487, 1, 0, 0, 0, 5488, 5489, 1, 0, 0, 0, 5489, 5492, 1, 0, 0, 0, 5490, 5493, 3, 1074, 537, 0, 5491, 5493, 3, 1172, 586, 0, 5492, 5490, 1, 0, 0, 0, 5492, 5491, 1, 0, 0, 0, 5493, 973, 1, 0, 0, 0, 5494, 5496, 5, 251, 0, 0, 5495, 5497, 3, 976, 488, 0, 5496, 5495, 1, 0, 0, 0, 5497, 5498, 1, 0, 0, 0, 5498, 5496, 1, 0, 0, 0, 5498, 5499, 1, 0, 0, 0, 5499, 975, 1, 0, 0, 0, 5500, 5502, 3, 1074, 537, 0, 5501, 5503, 3, 978, 489, 0, 5502, 5501, 1, 0, 0, 0, 5502, 5503, 1, 0, 0, 0, 5503, 5505, 1, 0, 0, 0, 5504, 5506, 3, 980, 490, 0, 5505, 5504, 1, 0, 0, 0, 5505, 5506, 1, 0, 0, 0, 5506, 977, 1, 0, 0, 0, 5507, 5509, 5, 133, 0, 0, 5508, 5510, 5, 239, 0, 0, 5509, 5508, 1, 0, 0, 0, 5509, 5510, 1, 0, 0, 0, 5510, 5511, 1, 0, 0, 0, 5511, 5512, 3, 1074, 537, 0, 5512, 979, 1, 0, 0, 0, 5513, 5515, 5, 105, 0, 0, 5514, 5516, 5, 239, 0, 0, 5515, 5514, 1, 0, 0, 0, 5515, 5516, 1, 0, 0, 0, 5516, 5517, 1, 0, 0, 0, 5517, 5518, 3, 1074, 537, 0, 5518, 981, 1, 0, 0, 0, 5519, 5521, 5, 514, 0, 0, 5520, 5519, 1, 0, 0, 0, 5520, 5521, 1, 0, 0, 0, 5521, 5522, 1, 0, 0, 0, 5522, 5523, 5, 349, 0, 0, 5523, 5524, 3, 1090, 545, 0, 5524, 983, 1, 0, 0, 0, 5525, 5527, 5, 472, 0, 0, 5526, 5528, 5, 239, 0, 0, 5527, 5526, 1, 0, 0, 0, 5527, 5528, 1, 0, 0, 0, 5528, 5529, 1, 0, 0, 0, 5529, 5530, 3, 1090, 545, 0, 5530, 985, 1, 0, 0, 0, 5531, 5534, 5, 505, 0, 0, 5532, 5535, 3, 988, 494, 0, 5533, 5535, 3, 992, 496, 0, 5534, 5532, 1, 0, 0, 0, 5534, 5533, 1, 0, 0, 0, 5535, 987, 1, 0, 0, 0, 5536, 5538, 5, 223, 0, 0, 5537, 5536, 1, 0, 0, 0, 5537, 5538, 1, 0, 0, 0, 5538, 5539, 1, 0, 0, 0, 5539, 5541, 5, 7, 0, 0, 5540, 5542, 5, 453, 0, 0, 5541, 5540, 1, 0, 0, 0, 5541, 5542, 1, 0, 0, 0, 5542, 5543, 1, 0, 0, 0, 5543, 5544, 7, 60, 0, 0, 5544, 5546, 5, 356, 0, 0, 5545, 5547, 5, 326, 0, 0, 5546, 5545, 1, 0, 0, 0, 5546, 5547, 1, 0, 0, 0, 5547, 5548, 1, 0, 0, 0, 5548, 5549, 3, 990, 495, 0, 5549, 989, 1, 0, 0, 0, 5550, 5560, 5, 246, 0, 0, 5551, 5560, 5, 334, 0, 0, 5552, 5560, 5, 232, 0, 0, 5553, 5560, 5, 201, 0, 0, 5554, 5556, 3, 1134, 567, 0, 5555, 5554, 1, 0, 0, 0, 5556, 5557, 1, 0, 0, 0, 5557, 5555, 1, 0, 0, 0, 5557, 5558, 1, 0, 0, 0, 5558, 5560, 1, 0, 0, 0, 5559, 5550, 1, 0, 0, 0, 5559, 5551, 1, 0, 0, 0, 5559, 5552, 1, 0, 0, 0, 5559, 5553, 1, 0, 0, 0, 5559, 5555, 1, 0, 0, 0, 5560, 991, 1, 0, 0, 0, 5561, 5563, 5, 212, 0, 0, 5562, 5561, 1, 0, 0, 0, 5562, 5563, 1, 0, 0, 0, 5563, 5564, 1, 0, 0, 0, 5564, 5566, 5, 125, 0, 0, 5565, 5567, 5, 326, 0, 0, 5566, 5565, 1, 0, 0, 0, 5566, 5567, 1, 0, 0, 0, 5567, 5569, 1, 0, 0, 0, 5568, 5570, 3, 994, 497, 0, 5569, 5568, 1, 0, 0, 0, 5570, 5571, 1, 0, 0, 0, 5571, 5569, 1, 0, 0, 0, 5571, 5572, 1, 0, 0, 0, 5572, 993, 1, 0, 0, 0, 5573, 5574, 5, 9, 0, 0, 5574, 5586, 5, 358, 0, 0, 5575, 5577, 5, 9, 0, 0, 5576, 5578, 5, 385, 0, 0, 5577, 5576, 1, 0, 0, 0, 5577, 5578, 1, 0, 0, 0, 5578, 5580, 1, 0, 0, 0, 5579, 5581, 5, 323, 0, 0, 5580, 5579, 1, 0, 0, 0, 5580, 5581, 1, 0, 0, 0, 5581, 5582, 1, 0, 0, 0, 5582, 5586, 3, 1074, 537, 0, 5583, 5586, 3, 1150, 575, 0, 5584, 5586, 3, 1134, 567, 0, 5585, 5573, 1, 0, 0, 0, 5585, 5575, 1, 0, 0, 0, 5585, 5583, 1, 0, 0, 0, 5585, 5584, 1, 0, 0, 0, 5586, 995, 1, 0, 0, 0, 5587, 5588, 5, 517, 0, 0, 5588, 5590, 3, 1154, 577, 0, 5589, 5591, 3, 998, 499, 0, 5590, 5589, 1, 0, 0, 0, 5590, 5591, 1, 0, 0, 0, 5591, 5593, 1, 0, 0, 0, 5592, 5594, 3, 1000, 500, 0, 5593, 5592, 1, 0, 0, 0, 5593, 5594, 1, 0, 0, 0, 5594, 5596, 1, 0, 0, 0, 5595, 5597, 3, 1008, 504, 0, 5596, 5595, 1, 0, 0, 0, 5596, 5597, 1, 0, 0, 0, 5597, 5599, 1, 0, 0, 0, 5598, 5600, 3, 1010, 505, 0, 5599, 5598, 1, 0, 0, 0, 5599, 5600, 1, 0, 0, 0, 5600, 5602, 1, 0, 0, 0, 5601, 5603, 3, 1016, 508, 0, 5602, 5601, 1, 0, 0, 0, 5602, 5603, 1, 0, 0, 0, 5603, 5605, 1, 0, 0, 0, 5604, 5606, 3, 1018, 509, 0, 5605, 5604, 1, 0, 0, 0, 5605, 5606, 1, 0, 0, 0, 5606, 5608, 1, 0, 0, 0, 5607, 5609, 5, 179, 0, 0, 5608, 5607, 1, 0, 0, 0, 5608, 5609, 1, 0, 0, 0, 5609, 997, 1, 0, 0, 0, 5610, 5613, 5, 215, 0, 0, 5611, 5614, 3, 1074, 537, 0, 5612, 5614, 3, 1172, 586, 0, 5613, 5611, 1, 0, 0, 0, 5613, 5612, 1, 0, 0, 0, 5614, 999, 1, 0, 0, 0, 5615, 5617, 7, 56, 0, 0, 5616, 5618, 5, 6, 0, 0, 5617, 5616, 1, 0, 0, 0, 5617, 5618, 1, 0, 0, 0, 5618, 5622, 1, 0, 0, 0, 5619, 5623, 3, 1002, 501, 0, 5620, 5623, 3, 1004, 502, 0, 5621, 5623, 3, 1006, 503, 0, 5622, 5619, 1, 0, 0, 0, 5622, 5620, 1, 0, 0, 0, 5622, 5621, 1, 0, 0, 0, 5623, 1001, 1, 0, 0, 0, 5624, 5625, 5, 340, 0, 0, 5625, 1003, 1, 0, 0, 0, 5626, 5629, 3, 1074, 537, 0, 5627, 5629, 3, 1172, 586, 0, 5628, 5626, 1, 0, 0, 0, 5628, 5627, 1, 0, 0, 0, 5629, 5631, 1, 0, 0, 0, 5630, 5632, 7, 33, 0, 0, 5631, 5630, 1, 0, 0, 0, 5631, 5632, 1, 0, 0, 0, 5632, 1005, 1, 0, 0, 0, 5633, 5634, 3, 1146, 573, 0, 5634, 1007, 1, 0, 0, 0, 5635, 5637, 5, 30, 0, 0, 5636, 5635, 1, 0, 0, 0, 5636, 5637, 1, 0, 0, 0, 5637, 5638, 1, 0, 0, 0, 5638, 5642, 7, 61, 0, 0, 5639, 5641, 3, 536, 268, 0, 5640, 5639, 1, 0, 0, 0, 5641, 5644, 1, 0, 0, 0, 5642, 5640, 1, 0, 0, 0, 5642, 5643, 1, 0, 0, 0, 5643, 1009, 1, 0, 0, 0, 5644, 5642, 1, 0, 0, 0, 5645, 5647, 5, 312, 0, 0, 5646, 5648, 5, 30, 0, 0, 5647, 5646, 1, 0, 0, 0, 5647, 5648, 1, 0, 0, 0, 5648, 5649, 1, 0, 0, 0, 5649, 5653, 7, 61, 0, 0, 5650, 5652, 3, 536, 268, 0, 5651, 5650, 1, 0, 0, 0, 5652, 5655, 1, 0, 0, 0, 5653, 5651, 1, 0, 0, 0, 5653, 5654, 1, 0, 0, 0, 5654, 1011, 1, 0, 0, 0, 5655, 5653, 1, 0, 0, 0, 5656, 5658, 5, 30, 0, 0, 5657, 5656, 1, 0, 0, 0, 5657, 5658, 1, 0, 0, 0, 5658, 5659, 1, 0, 0, 0, 5659, 5663, 5, 158, 0, 0, 5660, 5662, 3, 536, 268, 0, 5661, 5660, 1, 0, 0, 0, 5662, 5665, 1, 0, 0, 0, 5663, 5661, 1, 0, 0, 0, 5663, 5664, 1, 0, 0, 0, 5664, 1013, 1, 0, 0, 0, 5665, 5663, 1, 0, 0, 0, 5666, 5668, 5, 312, 0, 0, 5667, 5669, 5, 30, 0, 0, 5668, 5667, 1, 0, 0, 0, 5668, 5669, 1, 0, 0, 0, 5669, 5670, 1, 0, 0, 0, 5670, 5674, 5, 158, 0, 0, 5671, 5673, 3, 536, 268, 0, 5672, 5671, 1, 0, 0, 0, 5673, 5676, 1, 0, 0, 0, 5674, 5672, 1, 0, 0, 0, 5674, 5675, 1, 0, 0, 0, 5675, 1015, 1, 0, 0, 0, 5676, 5674, 1, 0, 0, 0, 5677, 5679, 5, 252, 0, 0, 5678, 5680, 5, 259, 0, 0, 5679, 5678, 1, 0, 0, 0, 5679, 5680, 1, 0, 0, 0, 5680, 5684, 1, 0, 0, 0, 5681, 5683, 3, 536, 268, 0, 5682, 5681, 1, 0, 0, 0, 5683, 5686, 1, 0, 0, 0, 5684, 5682, 1, 0, 0, 0, 5684, 5685, 1, 0, 0, 0, 5685, 1017, 1, 0, 0, 0, 5686, 5684, 1, 0, 0, 0, 5687, 5688, 5, 312, 0, 0, 5688, 5690, 5, 252, 0, 0, 5689, 5691, 5, 259, 0, 0, 5690, 5689, 1, 0, 0, 0, 5690, 5691, 1, 0, 0, 0, 5691, 5695, 1, 0, 0, 0, 5692, 5694, 3, 536, 268, 0, 5693, 5692, 1, 0, 0, 0, 5694, 5697, 1, 0, 0, 0, 5695, 5693, 1, 0, 0, 0, 5695, 5696, 1, 0, 0, 0, 5696, 1019, 1, 0, 0, 0, 5697, 5695, 1, 0, 0, 0, 5698, 5700, 5, 326, 0, 0, 5699, 5698, 1, 0, 0, 0, 5699, 5700, 1, 0, 0, 0, 5700, 5701, 1, 0, 0, 0, 5701, 5705, 5, 335, 0, 0, 5702, 5704, 3, 536, 268, 0, 5703, 5702, 1, 0, 0, 0, 5704, 5707, 1, 0, 0, 0, 5705, 5703, 1, 0, 0, 0, 5705, 5706, 1, 0, 0, 0, 5706, 1021, 1, 0, 0, 0, 5707, 5705, 1, 0, 0, 0, 5708, 5710, 5, 312, 0, 0, 5709, 5711, 5, 326, 0, 0, 5710, 5709, 1, 0, 0, 0, 5710, 5711, 1, 0, 0, 0, 5711, 5712, 1, 0, 0, 0, 5712, 5716, 5, 335, 0, 0, 5713, 5715, 3, 536, 268, 0, 5714, 5713, 1, 0, 0, 0, 5715, 5718, 1, 0, 0, 0, 5716, 5714, 1, 0, 0, 0, 5716, 5717, 1, 0, 0, 0, 5717, 1023, 1, 0, 0, 0, 5718, 5716, 1, 0, 0, 0, 5719, 5721, 5, 326, 0, 0, 5720, 5719, 1, 0, 0, 0, 5720, 5721, 1, 0, 0, 0, 5721, 5722, 1, 0, 0, 0, 5722, 5723, 5, 439, 0, 0, 5723, 5727, 5, 188, 0, 0, 5724, 5726, 3, 536, 268, 0, 5725, 5724, 1, 0, 0, 0, 5726, 5729, 1, 0, 0, 0, 5727, 5725, 1, 0, 0, 0, 5727, 5728, 1, 0, 0, 0, 5728, 1025, 1, 0, 0, 0, 5729, 5727, 1, 0, 0, 0, 5730, 5732, 5, 312, 0, 0, 5731, 5733, 5, 326, 0, 0, 5732, 5731, 1, 0, 0, 0, 5732, 5733, 1, 0, 0, 0, 5733, 5734, 1, 0, 0, 0, 5734, 5735, 5, 439, 0, 0, 5735, 5739, 5, 188, 0, 0, 5736, 5738, 3, 536, 268, 0, 5737, 5736, 1, 0, 0, 0, 5738, 5741, 1, 0, 0, 0, 5739, 5737, 1, 0, 0, 0, 5739, 5740, 1, 0, 0, 0, 5740, 1027, 1, 0, 0, 0, 5741, 5739, 1, 0, 0, 0, 5742, 5744, 5, 326, 0, 0, 5743, 5742, 1, 0, 0, 0, 5743, 5744, 1, 0, 0, 0, 5744, 5745, 1, 0, 0, 0, 5745, 5749, 5, 196, 0, 0, 5746, 5748, 3, 536, 268, 0, 5747, 5746, 1, 0, 0, 0, 5748, 5751, 1, 0, 0, 0, 5749, 5747, 1, 0, 0, 0, 5749, 5750, 1, 0, 0, 0, 5750, 1029, 1, 0, 0, 0, 5751, 5749, 1, 0, 0, 0, 5752, 5754, 5, 312, 0, 0, 5753, 5755, 5, 326, 0, 0, 5754, 5753, 1, 0, 0, 0, 5754, 5755, 1, 0, 0, 0, 5755, 5756, 1, 0, 0, 0, 5756, 5760, 5, 196, 0, 0, 5757, 5759, 3, 536, 268, 0, 5758, 5757, 1, 0, 0, 0, 5759, 5762, 1, 0, 0, 0, 5760, 5758, 1, 0, 0, 0, 5760, 5761, 1, 0, 0, 0, 5761, 1031, 1, 0, 0, 0, 5762, 5760, 1, 0, 0, 0, 5763, 5767, 3, 1036, 518, 0, 5764, 5766, 3, 1034, 517, 0, 5765, 5764, 1, 0, 0, 0, 5766, 5769, 1, 0, 0, 0, 5767, 5765, 1, 0, 0, 0, 5767, 5768, 1, 0, 0, 0, 5768, 1033, 1, 0, 0, 0, 5769, 5767, 1, 0, 0, 0, 5770, 5771, 7, 62, 0, 0, 5771, 5772, 3, 1036, 518, 0, 5772, 1035, 1, 0, 0, 0, 5773, 5777, 3, 1040, 520, 0, 5774, 5776, 3, 1038, 519, 0, 5775, 5774, 1, 0, 0, 0, 5776, 5779, 1, 0, 0, 0, 5777, 5775, 1, 0, 0, 0, 5777, 5778, 1, 0, 0, 0, 5778, 1037, 1, 0, 0, 0, 5779, 5777, 1, 0, 0, 0, 5780, 5781, 7, 63, 0, 0, 5781, 5782, 3, 1040, 520, 0, 5782, 1039, 1, 0, 0, 0, 5783, 5785, 7, 62, 0, 0, 5784, 5783, 1, 0, 0, 0, 5784, 5785, 1, 0, 0, 0, 5785, 5786, 1, 0, 0, 0, 5786, 5790, 3, 1044, 522, 0, 5787, 5789, 3, 1042, 521, 0, 5788, 5787, 1, 0, 0, 0, 5789, 5792, 1, 0, 0, 0, 5790, 5788, 1, 0, 0, 0, 5790, 5791, 1, 0, 0, 0, 5791, 1041, 1, 0, 0, 0, 5792, 5790, 1, 0, 0, 0, 5793, 5794, 5, 527, 0, 0, 5794, 5795, 3, 1044, 522, 0, 5795, 1043, 1, 0, 0, 0, 5796, 5797, 5, 542, 0, 0, 5797, 5798, 3, 1032, 516, 0, 5798, 5799, 5, 549, 0, 0, 5799, 5803, 1, 0, 0, 0, 5800, 5803, 3, 1074, 537, 0, 5801, 5803, 3, 1172, 586, 0, 5802, 5796, 1, 0, 0, 0, 5802, 5800, 1, 0, 0, 0, 5802, 5801, 1, 0, 0, 0, 5803, 1045, 1, 0, 0, 0, 5804, 5808, 3, 1050, 525, 0, 5805, 5807, 3, 1048, 524, 0, 5806, 5805, 1, 0, 0, 0, 5807, 5810, 1, 0, 0, 0, 5808, 5806, 1, 0, 0, 0, 5808, 5809, 1, 0, 0, 0, 5809, 1047, 1, 0, 0, 0, 5810, 5808, 1, 0, 0, 0, 5811, 5818, 7, 64, 0, 0, 5812, 5819, 3, 1050, 525, 0, 5813, 5815, 3, 1072, 536, 0, 5814, 5813, 1, 0, 0, 0, 5815, 5816, 1, 0, 0, 0, 5816, 5814, 1, 0, 0, 0, 5816, 5817, 1, 0, 0, 0, 5817, 5819, 1, 0, 0, 0, 5818, 5812, 1, 0, 0, 0, 5818, 5814, 1, 0, 0, 0, 5819, 1049, 1, 0, 0, 0, 5820, 5822, 5, 312, 0, 0, 5821, 5820, 1, 0, 0, 0, 5821, 5822, 1, 0, 0, 0, 5822, 5823, 1, 0, 0, 0, 5823, 5824, 3, 1052, 526, 0, 5824, 1051, 1, 0, 0, 0, 5825, 5826, 5, 542, 0, 0, 5826, 5827, 3, 1046, 523, 0, 5827, 5828, 5, 549, 0, 0, 5828, 5833, 1, 0, 0, 0, 5829, 5833, 3, 1060, 530, 0, 5830, 5833, 3, 1054, 527, 0, 5831, 5833, 3, 1056, 528, 0, 5832, 5825, 1, 0, 0, 0, 5832, 5829, 1, 0, 0, 0, 5832, 5830, 1, 0, 0, 0, 5832, 5831, 1, 0, 0, 0, 5833, 1053, 1, 0, 0, 0, 5834, 5836, 3, 1074, 537, 0, 5835, 5837, 5, 254, 0, 0, 5836, 5835, 1, 0, 0, 0, 5836, 5837, 1, 0, 0, 0, 5837, 5839, 1, 0, 0, 0, 5838, 5840, 5, 312, 0, 0, 5839, 5838, 1, 0, 0, 0, 5839, 5840, 1, 0, 0, 0, 5840, 5848, 1, 0, 0, 0, 5841, 5849, 5, 316, 0, 0, 5842, 5849, 5, 11, 0, 0, 5843, 5849, 5, 12, 0, 0, 5844, 5849, 5, 13, 0, 0, 5845, 5849, 5, 116, 0, 0, 5846, 5849, 5, 257, 0, 0, 5847, 5849, 3, 1122, 561, 0, 5848, 5841, 1, 0, 0, 0, 5848, 5842, 1, 0, 0, 0, 5848, 5843, 1, 0, 0, 0, 5848, 5844, 1, 0, 0, 0, 5848, 5845, 1, 0, 0, 0, 5848, 5846, 1, 0, 0, 0, 5848, 5847, 1, 0, 0, 0, 5849, 1055, 1, 0, 0, 0, 5850, 5872, 3, 1126, 563, 0, 5851, 5853, 3, 1102, 551, 0, 5852, 5851, 1, 0, 0, 0, 5853, 5856, 1, 0, 0, 0, 5854, 5852, 1, 0, 0, 0, 5854, 5855, 1, 0, 0, 0, 5855, 5858, 1, 0, 0, 0, 5856, 5854, 1, 0, 0, 0, 5857, 5859, 3, 1104, 552, 0, 5858, 5857, 1, 0, 0, 0, 5858, 5859, 1, 0, 0, 0, 5859, 5863, 1, 0, 0, 0, 5860, 5862, 3, 1058, 529, 0, 5861, 5860, 1, 0, 0, 0, 5862, 5865, 1, 0, 0, 0, 5863, 5861, 1, 0, 0, 0, 5863, 5864, 1, 0, 0, 0, 5864, 5873, 1, 0, 0, 0, 5865, 5863, 1, 0, 0, 0, 5866, 5868, 3, 1106, 553, 0, 5867, 5866, 1, 0, 0, 0, 5868, 5871, 1, 0, 0, 0, 5869, 5867, 1, 0, 0, 0, 5869, 5870, 1, 0, 0, 0, 5870, 5873, 1, 0, 0, 0, 5871, 5869, 1, 0, 0, 0, 5872, 5854, 1, 0, 0, 0, 5872, 5869, 1, 0, 0, 0, 5873, 1057, 1, 0, 0, 0, 5874, 5875, 5, 542, 0, 0, 5875, 5882, 3, 1086, 543, 0, 5876, 5878, 5, 529, 0, 0, 5877, 5876, 1, 0, 0, 0, 5877, 5878, 1, 0, 0, 0, 5878, 5879, 1, 0, 0, 0, 5879, 5881, 3, 1086, 543, 0, 5880, 5877, 1, 0, 0, 0, 5881, 5884, 1, 0, 0, 0, 5882, 5880, 1, 0, 0, 0, 5882, 5883, 1, 0, 0, 0, 5883, 5885, 1, 0, 0, 0, 5884, 5882, 1, 0, 0, 0, 5885, 5886, 5, 549, 0, 0, 5886, 1059, 1, 0, 0, 0, 5887, 5891, 3, 1062, 531, 0, 5888, 5891, 3, 1064, 532, 0, 5889, 5891, 3, 1066, 533, 0, 5890, 5887, 1, 0, 0, 0, 5890, 5888, 1, 0, 0, 0, 5890, 5889, 1, 0, 0, 0, 5891, 1061, 1, 0, 0, 0, 5892, 5894, 3, 1032, 516, 0, 5893, 5895, 5, 254, 0, 0, 5894, 5893, 1, 0, 0, 0, 5894, 5895, 1, 0, 0, 0, 5895, 5897, 1, 0, 0, 0, 5896, 5898, 5, 312, 0, 0, 5897, 5896, 1, 0, 0, 0, 5897, 5898, 1, 0, 0, 0, 5898, 5899, 1, 0, 0, 0, 5899, 5900, 7, 65, 0, 0, 5900, 1063, 1, 0, 0, 0, 5901, 5902, 3, 1032, 516, 0, 5902, 5903, 3, 1070, 535, 0, 5903, 5904, 3, 1032, 516, 0, 5904, 1065, 1, 0, 0, 0, 5905, 5906, 3, 1032, 516, 0, 5906, 5907, 3, 1070, 535, 0, 5907, 5908, 5, 542, 0, 0, 5908, 5909, 3, 1068, 534, 0, 5909, 5910, 5, 549, 0, 0, 5910, 1067, 1, 0, 0, 0, 5911, 5914, 3, 1032, 516, 0, 5912, 5913, 7, 64, 0, 0, 5913, 5915, 3, 1032, 516, 0, 5914, 5912, 1, 0, 0, 0, 5915, 5916, 1, 0, 0, 0, 5916, 5914, 1, 0, 0, 0, 5916, 5917, 1, 0, 0, 0, 5917, 1069, 1, 0, 0, 0, 5918, 5920, 7, 8, 0, 0, 5919, 5918, 1, 0, 0, 0, 5919, 5920, 1, 0, 0, 0, 5920, 5962, 1, 0, 0, 0, 5921, 5923, 5, 312, 0, 0, 5922, 5921, 1, 0, 0, 0, 5922, 5923, 1, 0, 0, 0, 5923, 5939, 1, 0, 0, 0, 5924, 5926, 5, 225, 0, 0, 5925, 5927, 5, 479, 0, 0, 5926, 5925, 1, 0, 0, 0, 5926, 5927, 1, 0, 0, 0, 5927, 5940, 1, 0, 0, 0, 5928, 5940, 5, 544, 0, 0, 5929, 5931, 5, 271, 0, 0, 5930, 5932, 5, 479, 0, 0, 5931, 5930, 1, 0, 0, 0, 5931, 5932, 1, 0, 0, 0, 5932, 5940, 1, 0, 0, 0, 5933, 5940, 5, 540, 0, 0, 5934, 5936, 5, 186, 0, 0, 5935, 5937, 5, 489, 0, 0, 5936, 5935, 1, 0, 0, 0, 5936, 5937, 1, 0, 0, 0, 5937, 5940, 1, 0, 0, 0, 5938, 5940, 5, 536, 0, 0, 5939, 5924, 1, 0, 0, 0, 5939, 5928, 1, 0, 0, 0, 5939, 5929, 1, 0, 0, 0, 5939, 5933, 1, 0, 0, 0, 5939, 5934, 1, 0, 0, 0, 5939, 5938, 1, 0, 0, 0, 5940, 5963, 1, 0, 0, 0, 5941, 5963, 5, 546, 0, 0, 5942, 5944, 5, 225, 0, 0, 5943, 5945, 5, 479, 0, 0, 5944, 5943, 1, 0, 0, 0, 5944, 5945, 1, 0, 0, 0, 5945, 5946, 1, 0, 0, 0, 5946, 5947, 5, 329, 0, 0, 5947, 5949, 5, 186, 0, 0, 5948, 5950, 5, 489, 0, 0, 5949, 5948, 1, 0, 0, 0, 5949, 5950, 1, 0, 0, 0, 5950, 5963, 1, 0, 0, 0, 5951, 5963, 5, 545, 0, 0, 5952, 5954, 5, 271, 0, 0, 5953, 5955, 5, 479, 0, 0, 5954, 5953, 1, 0, 0, 0, 5954, 5955, 1, 0, 0, 0, 5955, 5956, 1, 0, 0, 0, 5956, 5957, 5, 329, 0, 0, 5957, 5959, 5, 186, 0, 0, 5958, 5960, 5, 489, 0, 0, 5959, 5958, 1, 0, 0, 0, 5959, 5960, 1, 0, 0, 0, 5960, 5963, 1, 0, 0, 0, 5961, 5963, 5, 541, 0, 0, 5962, 5922, 1, 0, 0, 0, 5962, 5941, 1, 0, 0, 0, 5962, 5942, 1, 0, 0, 0, 5962, 5951, 1, 0, 0, 0, 5962, 5952, 1, 0, 0, 0, 5962, 5961, 1, 0, 0, 0, 5963, 1071, 1, 0, 0, 0, 5964, 5966, 5, 312, 0, 0, 5965, 5964, 1, 0, 0, 0, 5965, 5966, 1, 0, 0, 0, 5966, 5968, 1, 0, 0, 0, 5967, 5969, 3, 1070, 535, 0, 5968, 5967, 1, 0, 0, 0, 5968, 5969, 1, 0, 0, 0, 5969, 5976, 1, 0, 0, 0, 5970, 5977, 3, 1032, 516, 0, 5971, 5972, 5, 542, 0, 0, 5972, 5973, 3, 1032, 516, 0, 5973, 5974, 3, 1072, 536, 0, 5974, 5975, 5, 549, 0, 0, 5975, 5977, 1, 0, 0, 0, 5976, 5970, 1, 0, 0, 0, 5976, 5971, 1, 0, 0, 0, 5977, 1073, 1, 0, 0, 0, 5978, 5983, 3, 1090, 545, 0, 5979, 5983, 3, 1076, 538, 0, 5980, 5983, 3, 1078, 539, 0, 5981, 5983, 3, 1186, 593, 0, 5982, 5978, 1, 0, 0, 0, 5982, 5979, 1, 0, 0, 0, 5982, 5980, 1, 0, 0, 0, 5982, 5981, 1, 0, 0, 0, 5983, 1075, 1, 0, 0, 0, 5984, 6000, 3, 1090, 545, 0, 5985, 5986, 5, 542, 0, 0, 5986, 5993, 3, 1086, 543, 0, 5987, 5989, 5, 529, 0, 0, 5988, 5987, 1, 0, 0, 0, 5988, 5989, 1, 0, 0, 0, 5989, 5990, 1, 0, 0, 0, 5990, 5992, 3, 1086, 543, 0, 5991, 5988, 1, 0, 0, 0, 5992, 5995, 1, 0, 0, 0, 5993, 5991, 1, 0, 0, 0, 5993, 5994, 1, 0, 0, 0, 5994, 5996, 1, 0, 0, 0, 5995, 5993, 1, 0, 0, 0, 5996, 5997, 5, 549, 0, 0, 5997, 5999, 1, 0, 0, 0, 5998, 5985, 1, 0, 0, 0, 5999, 6002, 1, 0, 0, 0, 6000, 5998, 1, 0, 0, 0, 6000, 6001, 1, 0, 0, 0, 6001, 6004, 1, 0, 0, 0, 6002, 6000, 1, 0, 0, 0, 6003, 6005, 3, 1080, 540, 0, 6004, 6003, 1, 0, 0, 0, 6004, 6005, 1, 0, 0, 0, 6005, 1077, 1, 0, 0, 0, 6006, 6007, 5, 217, 0, 0, 6007, 6023, 3, 1136, 568, 0, 6008, 6009, 5, 542, 0, 0, 6009, 6016, 3, 1088, 544, 0, 6010, 6012, 5, 529, 0, 0, 6011, 6010, 1, 0, 0, 0, 6011, 6012, 1, 0, 0, 0, 6012, 6013, 1, 0, 0, 0, 6013, 6015, 3, 1088, 544, 0, 6014, 6011, 1, 0, 0, 0, 6015, 6018, 1, 0, 0, 0, 6016, 6014, 1, 0, 0, 0, 6016, 6017, 1, 0, 0, 0, 6017, 6019, 1, 0, 0, 0, 6018, 6016, 1, 0, 0, 0, 6019, 6020, 5, 549, 0, 0, 6020, 6022, 1, 0, 0, 0, 6021, 6008, 1, 0, 0, 0, 6022, 6025, 1, 0, 0, 0, 6023, 6021, 1, 0, 0, 0, 6023, 6024, 1, 0, 0, 0, 6024, 6027, 1, 0, 0, 0, 6025, 6023, 1, 0, 0, 0, 6026, 6028, 3, 1080, 540, 0, 6027, 6026, 1, 0, 0, 0, 6027, 6028, 1, 0, 0, 0, 6028, 1079, 1, 0, 0, 0, 6029, 6030, 5, 542, 0, 0, 6030, 6031, 3, 1082, 541, 0, 6031, 6033, 5, 528, 0, 0, 6032, 6034, 3, 1084, 542, 0, 6033, 6032, 1, 0, 0, 0, 6033, 6034, 1, 0, 0, 0, 6034, 6035, 1, 0, 0, 0, 6035, 6036, 5, 549, 0, 0, 6036, 1081, 1, 0, 0, 0, 6037, 6038, 3, 1032, 516, 0, 6038, 1083, 1, 0, 0, 0, 6039, 6040, 3, 1032, 516, 0, 6040, 1085, 1, 0, 0, 0, 6041, 6053, 5, 9, 0, 0, 6042, 6053, 3, 1178, 589, 0, 6043, 6045, 3, 1090, 545, 0, 6044, 6046, 3, 1178, 589, 0, 6045, 6044, 1, 0, 0, 0, 6045, 6046, 1, 0, 0, 0, 6046, 6053, 1, 0, 0, 0, 6047, 6049, 3, 1138, 569, 0, 6048, 6050, 3, 1178, 589, 0, 6049, 6048, 1, 0, 0, 0, 6049, 6050, 1, 0, 0, 0, 6050, 6053, 1, 0, 0, 0, 6051, 6053, 3, 1032, 516, 0, 6052, 6041, 1, 0, 0, 0, 6052, 6042, 1, 0, 0, 0, 6052, 6043, 1, 0, 0, 0, 6052, 6047, 1, 0, 0, 0, 6052, 6051, 1, 0, 0, 0, 6053, 1087, 1, 0, 0, 0, 6054, 6066, 3, 1172, 586, 0, 6055, 6066, 3, 1074, 537, 0, 6056, 6058, 3, 1090, 545, 0, 6057, 6059, 3, 1178, 589, 0, 6058, 6057, 1, 0, 0, 0, 6058, 6059, 1, 0, 0, 0, 6059, 6066, 1, 0, 0, 0, 6060, 6062, 3, 1138, 569, 0, 6061, 6063, 3, 1178, 589, 0, 6062, 6061, 1, 0, 0, 0, 6062, 6063, 1, 0, 0, 0, 6063, 6066, 1, 0, 0, 0, 6064, 6066, 3, 1032, 516, 0, 6065, 6054, 1, 0, 0, 0, 6065, 6055, 1, 0, 0, 0, 6065, 6056, 1, 0, 0, 0, 6065, 6060, 1, 0, 0, 0, 6065, 6064, 1, 0, 0, 0, 6066, 1089, 1, 0, 0, 0, 6067, 6072, 3, 1092, 546, 0, 6068, 6072, 3, 1094, 547, 0, 6069, 6072, 3, 1096, 548, 0, 6070, 6072, 3, 1098, 549, 0, 6071, 6067, 1, 0, 0, 0, 6071, 6068, 1, 0, 0, 0, 6071, 6069, 1, 0, 0, 0, 6071, 6070, 1, 0, 0, 0, 6072, 1091, 1, 0, 0, 0, 6073, 6076, 3, 1128, 564, 0, 6074, 6076, 3, 1126, 563, 0, 6075, 6073, 1, 0, 0, 0, 6075, 6074, 1, 0, 0, 0, 6076, 6086, 1, 0, 0, 0, 6077, 6079, 3, 1100, 550, 0, 6078, 6077, 1, 0, 0, 0, 6079, 6080, 1, 0, 0, 0, 6080, 6078, 1, 0, 0, 0, 6080, 6081, 1, 0, 0, 0, 6081, 6083, 1, 0, 0, 0, 6082, 6084, 3, 1104, 552, 0, 6083, 6082, 1, 0, 0, 0, 6083, 6084, 1, 0, 0, 0, 6084, 6087, 1, 0, 0, 0, 6085, 6087, 3, 1104, 552, 0, 6086, 6078, 1, 0, 0, 0, 6086, 6085, 1, 0, 0, 0, 6086, 6087, 1, 0, 0, 0, 6087, 1093, 1, 0, 0, 0, 6088, 6089, 3, 1148, 574, 0, 6089, 6090, 3, 1108, 554, 0, 6090, 1095, 1, 0, 0, 0, 6091, 6092, 3, 1168, 584, 0, 6092, 6093, 3, 1110, 555, 0, 6093, 1097, 1, 0, 0, 0, 6094, 6095, 5, 278, 0, 0, 6095, 6096, 3, 1104, 552, 0, 6096, 1099, 1, 0, 0, 0, 6097, 6100, 3, 1102, 551, 0, 6098, 6100, 3, 1112, 556, 0, 6099, 6097, 1, 0, 0, 0, 6099, 6098, 1, 0, 0, 0, 6100, 1101, 1, 0, 0, 0, 6101, 6102, 7, 66, 0, 0, 6102, 6103, 3, 1128, 564, 0, 6103, 1103, 1, 0, 0, 0, 6104, 6105, 7, 66, 0, 0, 6105, 6106, 3, 1134, 567, 0, 6106, 1105, 1, 0, 0, 0, 6107, 6108, 7, 66, 0, 0, 6108, 6109, 3, 1146, 573, 0, 6109, 1107, 1, 0, 0, 0, 6110, 6111, 7, 66, 0, 0, 6111, 6112, 3, 1162, 581, 0, 6112, 1109, 1, 0, 0, 0, 6113, 6114, 7, 66, 0, 0, 6114, 6115, 3, 1142, 571, 0, 6115, 1111, 1, 0, 0, 0, 6116, 6117, 7, 66, 0, 0, 6117, 6118, 3, 1076, 538, 0, 6118, 1113, 1, 0, 0, 0, 6119, 6120, 3, 1170, 585, 0, 6120, 1115, 1, 0, 0, 0, 6121, 6122, 3, 1164, 582, 0, 6122, 1117, 1, 0, 0, 0, 6123, 6124, 3, 1152, 576, 0, 6124, 1119, 1, 0, 0, 0, 6125, 6126, 3, 1170, 585, 0, 6126, 1121, 1, 0, 0, 0, 6127, 6128, 3, 1170, 585, 0, 6128, 1123, 1, 0, 0, 0, 6129, 6130, 3, 1164, 582, 0, 6130, 1125, 1, 0, 0, 0, 6131, 6132, 3, 1170, 585, 0, 6132, 1127, 1, 0, 0, 0, 6133, 6134, 3, 1170, 585, 0, 6134, 1129, 1, 0, 0, 0, 6135, 6139, 5, 208, 0, 0, 6136, 6139, 5, 108, 0, 0, 6137, 6139, 3, 1128, 564, 0, 6138, 6135, 1, 0, 0, 0, 6138, 6136, 1, 0, 0, 0, 6138, 6137, 1, 0, 0, 0, 6139, 1131, 1, 0, 0, 0, 6140, 6141, 3, 1164, 582, 0, 6141, 1133, 1, 0, 0, 0, 6142, 6143, 3, 1170, 585, 0, 6143, 1135, 1, 0, 0, 0, 6144, 6151, 5, 250, 0, 0, 6145, 6151, 5, 269, 0, 0, 6146, 6151, 5, 369, 0, 0, 6147, 6151, 5, 464, 0, 0, 6148, 6151, 5, 513, 0, 0, 6149, 6151, 3, 1170, 585, 0, 6150, 6144, 1, 0, 0, 0, 6150, 6145, 1, 0, 0, 0, 6150, 6146, 1, 0, 0, 0, 6150, 6147, 1, 0, 0, 0, 6150, 6148, 1, 0, 0, 0, 6150, 6149, 1, 0, 0, 0, 6151, 1137, 1, 0, 0, 0, 6152, 6153, 3, 1170, 585, 0, 6153, 1139, 1, 0, 0, 0, 6154, 6155, 3, 1164, 582, 0, 6155, 1141, 1, 0, 0, 0, 6156, 6157, 3, 1170, 585, 0, 6157, 1143, 1, 0, 0, 0, 6158, 6159, 3, 1170, 585, 0, 6159, 1145, 1, 0, 0, 0, 6160, 6161, 3, 1170, 585, 0, 6161, 1147, 1, 0, 0, 0, 6162, 6165, 3, 1170, 585, 0, 6163, 6165, 3, 1178, 589, 0, 6164, 6162, 1, 0, 0, 0, 6164, 6163, 1, 0, 0, 0, 6165, 1149, 1, 0, 0, 0, 6166, 6168, 3, 1148, 574, 0, 6167, 6169, 3, 1108, 554, 0, 6168, 6167, 1, 0, 0, 0, 6168, 6169, 1, 0, 0, 0, 6169, 6172, 1, 0, 0, 0, 6170, 6172, 3, 1162, 581, 0, 6171, 6166, 1, 0, 0, 0, 6171, 6170, 1, 0, 0, 0, 6172, 1151, 1, 0, 0, 0, 6173, 6176, 5, 551, 0, 0, 6174, 6176, 3, 1170, 585, 0, 6175, 6173, 1, 0, 0, 0, 6175, 6174, 1, 0, 0, 0, 6176, 1153, 1, 0, 0, 0, 6177, 6178, 3, 1090, 545, 0, 6178, 1155, 1, 0, 0, 0, 6179, 6180, 3, 1090, 545, 0, 6180, 1157, 1, 0, 0, 0, 6181, 6182, 3, 1170, 585, 0, 6182, 1159, 1, 0, 0, 0, 6183, 6184, 3, 1170, 585, 0, 6184, 1161, 1, 0, 0, 0, 6185, 6188, 3, 1170, 585, 0, 6186, 6188, 3, 1178, 589, 0, 6187, 6185, 1, 0, 0, 0, 6187, 6186, 1, 0, 0, 0, 6188, 1163, 1, 0, 0, 0, 6189, 6190, 3, 1170, 585, 0, 6190, 1165, 1, 0, 0, 0, 6191, 6192, 3, 1170, 585, 0, 6192, 1167, 1, 0, 0, 0, 6193, 6194, 3, 1170, 585, 0, 6194, 1169, 1, 0, 0, 0, 6195, 6196, 7, 67, 0, 0, 6196, 1171, 1, 0, 0, 0, 6197, 6204, 5, 551, 0, 0, 6198, 6204, 3, 1184, 592, 0, 6199, 6204, 3, 1176, 588, 0, 6200, 6204, 3, 1174, 587, 0, 6201, 6204, 3, 1180, 590, 0, 6202, 6204, 3, 1182, 591, 0, 6203, 6197, 1, 0, 0, 0, 6203, 6198, 1, 0, 0, 0, 6203, 6199, 1, 0, 0, 0, 6203, 6200, 1, 0, 0, 0, 6203, 6201, 1, 0, 0, 0, 6203, 6202, 1, 0, 0, 0, 6204, 1173, 1, 0, 0, 0, 6205, 6206, 7, 68, 0, 0, 6206, 1175, 1, 0, 0, 0, 6207, 6211, 5, 556, 0, 0, 6208, 6211, 5, 521, 0, 0, 6209, 6211, 3, 1178, 589, 0, 6210, 6207, 1, 0, 0, 0, 6210, 6208, 1, 0, 0, 0, 6210, 6209, 1, 0, 0, 0, 6211, 1177, 1, 0, 0, 0, 6212, 6213, 7, 69, 0, 0, 6213, 1179, 1, 0, 0, 0, 6214, 6215, 5, 138, 0, 0, 6215, 6218, 5, 542, 0, 0, 6216, 6219, 3, 1170, 585, 0, 6217, 6219, 3, 1172, 586, 0, 6218, 6216, 1, 0, 0, 0, 6218, 6217, 1, 0, 0, 0, 6219, 6220, 1, 0, 0, 0, 6220, 6221, 5, 549, 0, 0, 6221, 1181, 1, 0, 0, 0, 6222, 6223, 5, 139, 0, 0, 6223, 6226, 5, 542, 0, 0, 6224, 6227, 3, 1170, 585, 0, 6225, 6227, 3, 1172, 586, 0, 6226, 6224, 1, 0, 0, 0, 6226, 6225, 1, 0, 0, 0, 6227, 6228, 1, 0, 0, 0, 6228, 6229, 5, 549, 0, 0, 6229, 1183, 1, 0, 0, 0, 6230, 6231, 5, 9, 0, 0, 6231, 6246, 3, 1172, 586, 0, 6232, 6246, 5, 230, 0, 0, 6233, 6246, 5, 231, 0, 0, 6234, 6246, 5, 291, 0, 0, 6235, 6246, 5, 292, 0, 0, 6236, 6246, 5, 313, 0, 0, 6237, 6246, 5, 314, 0, 0, 6238, 6246, 5, 367, 0, 0, 6239, 6246, 5, 368, 0, 0, 6240, 6246, 5, 450, 0, 0, 6241, 6246, 5, 451, 0, 0, 6242, 6246, 5, 521, 0, 0, 6243, 6246, 5, 523, 0, 0, 6244, 6246, 5, 524, 0, 0, 6245, 6230, 1, 0, 0, 0, 6245, 6232, 1, 0, 0, 0, 6245, 6233, 1, 0, 0, 0, 6245, 6234, 1, 0, 0, 0, 6245, 6235, 1, 0, 0, 0, 6245, 6236, 1, 0, 0, 0, 6245, 6237, 1, 0, 0, 0, 6245, 6238, 1, 0, 0, 0, 6245, 6239, 1, 0, 0, 0, 6245, 6240, 1, 0, 0, 0, 6245, 6241, 1, 0, 0, 0, 6245, 6242, 1, 0, 0, 0, 6245, 6243, 1, 0, 0, 0, 6245, 6244, 1, 0, 0, 0, 6246, 1185, 1, 0, 0, 0, 6247, 6248, 5, 5, 0, 0, 6248, 6249, 5, 323, 0, 0, 6249, 6281, 3, 1074, 537, 0, 6250, 6281, 5, 111, 0, 0, 6251, 6281, 5, 114, 0, 0, 6252, 6281, 5, 115, 0, 0, 6253, 6281, 5, 118, 0, 0, 6254, 6281, 5, 119, 0, 0, 6255, 6281, 5, 120, 0, 0, 6256, 6281, 5, 121, 0, 0, 6257, 6281, 5, 122, 0, 0, 6258, 6281, 5, 123, 0, 0, 6259, 6281, 5, 124, 0, 0, 6260, 6262, 5, 269, 0, 0, 6261, 6263, 5, 323, 0, 0, 6262, 6261, 1, 0, 0, 0, 6262, 6263, 1, 0, 0, 0, 6263, 6264, 1, 0, 0, 0, 6264, 6281, 3, 1074, 537, 0, 6265, 6281, 5, 278, 0, 0, 6266, 6281, 5, 281, 0, 0, 6267, 6281, 5, 341, 0, 0, 6268, 6281, 5, 404, 0, 0, 6269, 6281, 5, 435, 0, 0, 6270, 6281, 5, 436, 0, 0, 6271, 6281, 5, 441, 0, 0, 6272, 6281, 5, 442, 0, 0, 6273, 6281, 5, 443, 0, 0, 6274, 6281, 5, 445, 0, 0, 6275, 6281, 5, 446, 0, 0, 6276, 6281, 5, 447, 0, 0, 6277, 6281, 5, 471, 0, 0, 6278, 6281, 5, 485, 0, 0, 6279, 6281, 5, 513, 0, 0, 6280, 6247, 1, 0, 0, 0, 6280, 6250, 1, 0, 0, 0, 6280, 6251, 1, 0, 0, 0, 6280, 6252, 1, 0, 0, 0, 6280, 6253, 1, 0, 0, 0, 6280, 6254, 1, 0, 0, 0, 6280, 6255, 1, 0, 0, 0, 6280, 6256, 1, 0, 0, 0, 6280, 6257, 1, 0, 0, 0, 6280, 6258, 1, 0, 0, 0, 6280, 6259, 1, 0, 0, 0, 6280, 6260, 1, 0, 0, 0, 6280, 6265, 1, 0, 0, 0, 6280, 6266, 1, 0, 0, 0, 6280, 6267, 1, 0, 0, 0, 6280, 6268, 1, 0, 0, 0, 6280, 6269, 1, 0, 0, 0, 6280, 6270, 1, 0, 0, 0, 6280, 6271, 1, 0, 0, 0, 6280, 6272, 1, 0, 0, 0, 6280, 6273, 1, 0, 0, 0, 6280, 6274, 1, 0, 0, 0, 6280, 6275, 1, 0, 0, 0, 6280, 6276, 1, 0, 0, 0, 6280, 6277, 1, 0, 0, 0, 6280, 6278, 1, 0, 0, 0, 6280, 6279, 1, 0, 0, 0, 6281, 1187, 1, 0, 0, 0, 6282, 6284, 5, 562, 0, 0, 6283, 6282, 1, 0, 0, 0, 6284, 6285, 1, 0, 0, 0, 6285, 6283, 1, 0, 0, 0, 6285, 6286, 1, 0, 0, 0, 6286, 1189, 1, 0, 0, 0, 979, 1196, 1200, 1203, 1206, 1211, 1215, 1229, 1238, 1244, 1248, 1250, 1253, 1256, 1261, 1266, 1271, 1276, 1281, 1286, 1294, 1300, 1308, 1314, 1320, 1324, 1334, 1344, 1348, 1352, 1355, 1359, 1362, 1366, 1369, 1372, 1375, 1379, 1384, 1387, 1390, 1393, 1397, 1402, 1406, 1412, 1425, 1429, 1442, 1446, 1452, 1455, 1466, 1468, 1475, 1477, 1486, 1491, 1495, 1500, 1505, 1512, 1515, 1518, 1523, 1528, 1532, 1536, 1540, 1543, 1547, 1552, 1556, 1562, 1566, 1568, 1571, 1575, 1580, 1582, 1587, 1589, 1593, 1597, 1600, 1604, 1607, 1612, 1615, 1618, 1622, 1625, 1630, 1633, 1636, 1638, 1642, 1648, 1651, 1654, 1658, 1662, 1665, 1668, 1673, 1677, 1682, 1685, 1690, 1698, 1703, 1707, 1712, 1721, 1726, 1741, 1745, 1758, 1763, 1766, 1769, 1773, 1775, 1782, 1788, 1791, 1795, 1800, 1805, 1809, 1812, 1818, 1821, 1825, 1828, 1831, 1836, 1839, 1843, 1846, 1849, 1853, 1858, 1862, 1866, 1870, 1873, 1882, 1887, 1891, 1897, 1903, 1905, 1911, 1917, 1920, 1928, 1932, 1935, 1938, 1943, 1948, 1951, 1956, 1961, 1966, 1976, 1988, 1996, 2002, 2007, 2014, 2028, 2031, 2036, 2042, 2046, 2049, 2058, 2061, 2065, 2068, 2072, 2075, 2078, 2082, 2085, 2087, 2091, 2094, 2097, 2102, 2110, 2114, 2116, 2123, 2125, 2132, 2136, 2140, 2145, 2149, 2151, 2156, 2160, 2164, 2167, 2172, 2178, 2181, 2185, 2189, 2192, 2195, 2200, 2203, 2206, 2211, 2215, 2218, 2226, 2232, 2236, 2238, 2243, 2251, 2265, 2274, 2282, 2284, 2290, 2295, 2298, 2310, 2313, 2315, 2323, 2332, 2334, 2342, 2352, 2355, 2357, 2365, 2379, 2381, 2386, 2393, 2398, 2402, 2409, 2416, 2423, 2428, 2432, 2437, 2441, 2446, 2450, 2455, 2459, 2464, 2468, 2475, 2486, 2491, 2500, 2506, 2526, 2538, 2540, 2565, 2569, 2573, 2576, 2579, 2583, 2587, 2590, 2593, 2597, 2601, 2605, 2609, 2613, 2617, 2623, 2629, 2636, 2639, 2649, 2655, 2661, 2665, 2667, 2672, 2674, 2684, 2687, 2691, 2694, 2699, 2711, 2718, 2723, 2727, 2730, 2733, 2736, 2738, 2743, 2750, 2754, 2756, 2760, 2779, 2784, 2787, 2791, 2797, 2800, 2807, 2820, 2823, 2825, 2832, 2838, 2841, 2847, 2851, 2854, 2857, 2860, 2864, 2868, 2872, 2880, 2885, 2895, 2901, 2905, 2909, 2914, 2918, 2925, 2930, 2936, 2941, 2944, 2948, 2957, 2962, 2967, 2972, 2976, 2983, 2987, 2991, 2993, 3000, 3005, 3009, 3019, 3024, 3030, 3033, 3039, 3042, 3046, 3048, 3054, 3057, 3061, 3065, 3068, 3071, 3074, 3082, 3088, 3095, 3100, 3103, 3106, 3109, 3121, 3125, 3131, 3135, 3138, 3143, 3151, 3156, 3179, 3181, 3199, 3202, 3208, 3215, 3220, 3223, 3231, 3236, 3239, 3243, 3246, 3251, 3256, 3259, 3264, 3266, 3273, 3276, 3281, 3285, 3292, 3295, 3299, 3317, 3324, 3327, 3341, 3345, 3347, 3352, 3354, 3358, 3361, 3367, 3372, 3378, 3380, 3384, 3415, 3420, 3424, 3428, 3432, 3434, 3438, 3443, 3448, 3452, 3458, 3466, 3469, 3473, 3481, 3488, 3491, 3494, 3499, 3502, 3506, 3509, 3512, 3518, 3523, 3530, 3545, 3551, 3561, 3567, 3576, 3579, 3584, 3638, 3646, 3649, 3652, 3655, 3660, 3664, 3671, 3677, 3687, 3695, 3698, 3701, 3704, 3709, 3715, 3720, 3726, 3728, 3734, 3743, 3747, 3751, 3755, 3759, 3767, 3773, 3780, 3783, 3786, 3789, 3792, 3795, 3798, 3804, 3809, 3812, 3815, 3820, 3826, 3831, 3834, 3837, 3843, 3849, 3851, 3855, 3858, 3864, 3870, 3872, 3877, 3886, 3893, 3899, 3905, 3909, 3912, 3915, 3920, 3922, 3925, 3930, 3933, 3939, 3945, 3947, 3952, 3956, 3963, 3967, 3971, 3977, 3982, 3985, 3988, 3992, 3999, 4002, 4005, 4008, 4013, 4018, 4022, 4027, 4033, 4036, 4039, 4042, 4046, 4051, 4056, 4059, 4067, 4072, 4075, 4078, 4081, 4084, 4090, 4095, 4098, 4103, 4106, 4112, 4116, 4120, 4128, 4133, 4137, 4142, 4150, 4152, 4159, 4165, 4168, 4171, 4177, 4185, 4190, 4198, 4203, 4207, 4211, 4224, 4230, 4235, 4240, 4245, 4249, 4252, 4257, 4261, 4265, 4274, 4278, 4286, 4290, 4293, 4295, 4301, 4304, 4307, 4314, 4317, 4325, 4328, 4334, 4337, 4343, 4347, 4352, 4358, 4366, 4372, 4377, 4379, 4385, 4390, 4395, 4401, 4408, 4410, 4416, 4424, 4431, 4437, 4441, 4446, 4451, 4457, 4463, 4468, 4472, 4476, 4483, 4486, 4491, 4495, 4500, 4504, 4508, 4513, 4516, 4520, 4525, 4528, 4531, 4534, 4541, 4545, 4553, 4558, 4562, 4571, 4583, 4587, 4591, 4598, 4602, 4610, 4617, 4622, 4625, 4628, 4631, 4636, 4640, 4647, 4651, 4655, 4662, 4664, 4670, 4675, 4679, 4685, 4689, 4693, 4699, 4705, 4710, 4713, 4718, 4726, 4729, 4734, 4738, 4743, 4753, 4755, 4762, 4767, 4780, 4786, 4789, 4798, 4803, 4806, 4809, 4812, 4815, 4818, 4821, 4824, 4827, 4830, 4836, 4841, 4845, 4852, 4855, 4858, 4861, 4871, 4873, 4882, 4887, 4891, 4894, 4901, 4909, 4914, 4918, 4921, 4928, 4934, 4938, 4942, 4950, 4955, 4958, 4962, 4965, 4973, 4976, 4979, 4982, 4989, 4993, 4996, 5001, 5004, 5016, 5019, 5024, 5027, 5030, 5034, 5037, 5040, 5043, 5046, 5060, 5064, 5068, 5073, 5079, 5082, 5090, 5093, 5098, 5104, 5109, 5115, 5126, 5130, 5134, 5141, 5144, 5147, 5150, 5155, 5159, 5164, 5168, 5172, 5177, 5180, 5184, 5187, 5190, 5194, 5199, 5202, 5205, 5208, 5215, 5219, 5226, 5230, 5239, 5244, 5248, 5257, 5269, 5274, 5277, 5280, 5283, 5287, 5291, 5296, 5302, 5308, 5313, 5316, 5323, 5329, 5333, 5336, 5339, 5342, 5347, 5351, 5355, 5359, 5364, 5369, 5375, 5384, 5387, 5390, 5393, 5398, 5404, 5409, 5417, 5426, 5430, 5434, 5438, 5442, 5451, 5454, 5457, 5460, 5463, 5470, 5473, 5477, 5480, 5484, 5488, 5492, 5498, 5502, 5505, 5509, 5515, 5520, 5527, 5534, 5537, 5541, 5546, 5557, 5559, 5562, 5566, 5571, 5577, 5580, 5585, 5590, 5593, 5596, 5599, 5602, 5605, 5608, 5613, 5617, 5622, 5628, 5631, 5636, 5642, 5647, 5653, 5657, 5663, 5668, 5674, 5679, 5684, 5690, 5695, 5699, 5705, 5710, 5716, 5720, 5727, 5732, 5739, 5743, 5749, 5754, 5760, 5767, 5777, 5784, 5790, 5802, 5808, 5816, 5818, 5821, 5832, 5836, 5839, 5848, 5854, 5858, 5863, 5869, 5872, 5877, 5882, 5890, 5894, 5897, 5916, 5919, 5922, 5926, 5931, 5936, 5939, 5944, 5949, 5954, 5959, 5962, 5965, 5968, 5976, 5982, 5988, 5993, 6000, 6004, 6011, 6016, 6023, 6027, 6033, 6045, 6049, 6052, 6058, 6062, 6065, 6071, 6075, 6080, 6083, 6086, 6099, 6138, 6150, 6164, 6168, 6171, 6175, 6187, 6203, 6210, 6218, 6226, 6245, 6262, 6280, 6285] \ No newline at end of file diff --git a/src/Cobol85.tokens b/src/Cobol85.tokens new file mode 100644 index 0000000..e73851f --- /dev/null +++ b/src/Cobol85.tokens @@ -0,0 +1,594 @@ +ABORT=1 +ACCEPT=2 +ACCESS=3 +ADD=4 +ADDRESS=5 +ADVANCING=6 +AFTER=7 +ALIGNED=8 +ALL=9 +ALPHABET=10 +ALPHABETIC=11 +ALPHABETIC_LOWER=12 +ALPHABETIC_UPPER=13 +ALPHANUMERIC=14 +ALPHANUMERIC_EDITED=15 +ALSO=16 +ALTER=17 +ALTERNATE=18 +AND=19 +ANY=20 +ARE=21 +AREA=22 +AREAS=23 +AS=24 +ASCENDING=25 +ASCII=26 +ASSIGN=27 +ASSOCIATED_DATA=28 +ASSOCIATED_DATA_LENGTH=29 +AT=30 +ATTRIBUTE=31 +AUTHOR=32 +AUTO=33 +AUTO_SKIP=34 +BACKGROUND_COLOR=35 +BACKGROUND_COLOUR=36 +BASIS=37 +BEEP=38 +BEFORE=39 +BEGINNING=40 +BELL=41 +BINARY=42 +BIT=43 +BLANK=44 +BLINK=45 +BLOCK=46 +BOUNDS=47 +BOTTOM=48 +BY=49 +BYFUNCTION=50 +BYTITLE=51 +CALL=52 +CANCEL=53 +CAPABLE=54 +CCSVERSION=55 +CD=56 +CF=57 +CH=58 +CHAINING=59 +CHANGED=60 +CHANNEL=61 +CHARACTER=62 +CHARACTERS=63 +CLASS=64 +CLASS_ID=65 +CLOCK_UNITS=66 +CLOSE=67 +CLOSE_DISPOSITION=68 +COBOL=69 +CODE=70 +CODE_SET=71 +COLLATING=72 +COL=73 +COLUMN=74 +COM_REG=75 +COMMA=76 +COMMITMENT=77 +COMMON=78 +COMMUNICATION=79 +COMP=80 +COMP_1=81 +COMP_2=82 +COMP_3=83 +COMP_4=84 +COMP_5=85 +COMPUTATIONAL=86 +COMPUTATIONAL_1=87 +COMPUTATIONAL_2=88 +COMPUTATIONAL_3=89 +COMPUTATIONAL_4=90 +COMPUTATIONAL_5=91 +COMPUTE=92 +CONFIGURATION=93 +CONTAINS=94 +CONTENT=95 +CONTINUE=96 +CONTROL=97 +CONTROL_POINT=98 +CONTROLS=99 +CONVENTION=100 +CONVERTING=101 +COPY=102 +CORR=103 +CORRESPONDING=104 +COUNT=105 +CRUNCH=106 +CURRENCY=107 +CURSOR=108 +DATA=109 +DATA_BASE=110 +DATE=111 +DATE_COMPILED=112 +DATE_WRITTEN=113 +DAY=114 +DAY_OF_WEEK=115 +DBCS=116 +DE=117 +DEBUG_CONTENTS=118 +DEBUG_ITEM=119 +DEBUG_LINE=120 +DEBUG_NAME=121 +DEBUG_SUB_1=122 +DEBUG_SUB_2=123 +DEBUG_SUB_3=124 +DEBUGGING=125 +DECIMAL_POINT=126 +DECLARATIVES=127 +DEFAULT=128 +DEFAULT_DISPLAY=129 +DEFINITION=130 +DELETE=131 +DELIMITED=132 +DELIMITER=133 +DEPENDING=134 +DESCENDING=135 +DESTINATION=136 +DETAIL=137 +DFHRESP=138 +DFHVALUE=139 +DISABLE=140 +DISK=141 +DISPLAY=142 +DISPLAY_1=143 +DIVIDE=144 +DIVISION=145 +DONTCARE=146 +DOUBLE=147 +DOWN=148 +DUPLICATES=149 +DYNAMIC=150 +EBCDIC=151 +EGCS=152 +EGI=153 +ELSE=154 +EMI=155 +EMPTY_CHECK=156 +ENABLE=157 +END=158 +END_ACCEPT=159 +END_ADD=160 +END_CALL=161 +END_COMPUTE=162 +END_DELETE=163 +END_DIVIDE=164 +END_EVALUATE=165 +END_IF=166 +END_MULTIPLY=167 +END_OF_PAGE=168 +END_PERFORM=169 +END_READ=170 +END_RECEIVE=171 +END_RETURN=172 +END_REWRITE=173 +END_SEARCH=174 +END_START=175 +END_STRING=176 +END_SUBTRACT=177 +END_UNSTRING=178 +END_WRITE=179 +ENDING=180 +ENTER=181 +ENTRY=182 +ENTRY_PROCEDURE=183 +ENVIRONMENT=184 +EOP=185 +EQUAL=186 +ERASE=187 +ERROR=188 +EOL=189 +EOS=190 +ESCAPE=191 +ESI=192 +EVALUATE=193 +EVENT=194 +EVERY=195 +EXCEPTION=196 +EXCLUSIVE=197 +EXHIBIT=198 +EXIT=199 +EXPORT=200 +EXTEND=201 +EXTENDED=202 +EXTERNAL=203 +FALSE=204 +FD=205 +FILE=206 +FILE_CONTROL=207 +FILLER=208 +FINAL=209 +FIRST=210 +FOOTING=211 +FOR=212 +FOREGROUND_COLOR=213 +FOREGROUND_COLOUR=214 +FROM=215 +FULL=216 +FUNCTION=217 +FUNCTIONNAME=218 +FUNCTION_POINTER=219 +GENERATE=220 +GOBACK=221 +GIVING=222 +GLOBAL=223 +GO=224 +GREATER=225 +GRID=226 +GROUP=227 +HEADING=228 +HIGHLIGHT=229 +HIGH_VALUE=230 +HIGH_VALUES=231 +I_O=232 +I_O_CONTROL=233 +ID=234 +IDENTIFICATION=235 +IF=236 +IMPLICIT=237 +IMPORT=238 +IN=239 +INDEX=240 +INDEXED=241 +INDICATE=242 +INITIAL=243 +INITIALIZE=244 +INITIATE=245 +INPUT=246 +INPUT_OUTPUT=247 +INSPECT=248 +INSTALLATION=249 +INTEGER=250 +INTO=251 +INVALID=252 +INVOKE=253 +IS=254 +JUST=255 +JUSTIFIED=256 +KANJI=257 +KEPT=258 +KEY=259 +KEYBOARD=260 +LABEL=261 +LANGUAGE=262 +LAST=263 +LB=264 +LD=265 +LEADING=266 +LEFT=267 +LEFTLINE=268 +LENGTH=269 +LENGTH_CHECK=270 +LESS=271 +LIBACCESS=272 +LIBPARAMETER=273 +LIBRARY=274 +LIMIT=275 +LIMITS=276 +LINAGE=277 +LINAGE_COUNTER=278 +LINE=279 +LINES=280 +LINE_COUNTER=281 +LINKAGE=282 +LIST=283 +LOCAL=284 +LOCAL_STORAGE=285 +LOCK=286 +LONG_DATE=287 +LONG_TIME=288 +LOWER=289 +LOWLIGHT=290 +LOW_VALUE=291 +LOW_VALUES=292 +MEMORY=293 +MERGE=294 +MESSAGE=295 +MMDDYYYY=296 +MODE=297 +MODULES=298 +MORE_LABELS=299 +MOVE=300 +MULTIPLE=301 +MULTIPLY=302 +NAMED=303 +NATIONAL=304 +NATIONAL_EDITED=305 +NATIVE=306 +NEGATIVE=307 +NETWORK=308 +NEXT=309 +NO=310 +NO_ECHO=311 +NOT=312 +NULL_=313 +NULLS=314 +NUMBER=315 +NUMERIC=316 +NUMERIC_DATE=317 +NUMERIC_EDITED=318 +NUMERIC_TIME=319 +OBJECT_COMPUTER=320 +OCCURS=321 +ODT=322 +OF=323 +OFF=324 +OMITTED=325 +ON=326 +OPEN=327 +OPTIONAL=328 +OR=329 +ORDER=330 +ORDERLY=331 +ORGANIZATION=332 +OTHER=333 +OUTPUT=334 +OVERFLOW=335 +OVERLINE=336 +OWN=337 +PACKED_DECIMAL=338 +PADDING=339 +PAGE=340 +PAGE_COUNTER=341 +PASSWORD=342 +PERFORM=343 +PF=344 +PH=345 +PIC=346 +PICTURE=347 +PLUS=348 +POINTER=349 +POSITION=350 +POSITIVE=351 +PORT=352 +PRINTER=353 +PRINTING=354 +PRIVATE=355 +PROCEDURE=356 +PROCEDURE_POINTER=357 +PROCEDURES=358 +PROCEED=359 +PROCESS=360 +PROGRAM=361 +PROGRAM_ID=362 +PROGRAM_LIBRARY=363 +PROMPT=364 +PURGE=365 +QUEUE=366 +QUOTE=367 +QUOTES=368 +RANDOM=369 +READER=370 +REMOTE=371 +RD=372 +REAL=373 +READ=374 +RECEIVE=375 +RECEIVED=376 +RECORD=377 +RECORDING=378 +RECORDS=379 +RECURSIVE=380 +REDEFINES=381 +REEL=382 +REF=383 +REFERENCE=384 +REFERENCES=385 +RELATIVE=386 +RELEASE=387 +REMAINDER=388 +REMARKS=389 +REMOVAL=390 +REMOVE=391 +RENAMES=392 +REPLACE=393 +REPLACING=394 +REPORT=395 +REPORTING=396 +REPORTS=397 +REQUIRED=398 +RERUN=399 +RESERVE=400 +REVERSE_VIDEO=401 +RESET=402 +RETURN=403 +RETURN_CODE=404 +RETURNING=405 +REVERSED=406 +REWIND=407 +REWRITE=408 +RF=409 +RH=410 +RIGHT=411 +ROUNDED=412 +RUN=413 +SAME=414 +SAVE=415 +SCREEN=416 +SD=417 +SEARCH=418 +SECTION=419 +SECURE=420 +SECURITY=421 +SEGMENT=422 +SEGMENT_LIMIT=423 +SELECT=424 +SEND=425 +SENTENCE=426 +SEPARATE=427 +SEQUENCE=428 +SEQUENTIAL=429 +SET=430 +SHARED=431 +SHAREDBYALL=432 +SHAREDBYRUNUNIT=433 +SHARING=434 +SHIFT_IN=435 +SHIFT_OUT=436 +SHORT_DATE=437 +SIGN=438 +SIZE=439 +SORT=440 +SORT_CONTROL=441 +SORT_CORE_SIZE=442 +SORT_FILE_SIZE=443 +SORT_MERGE=444 +SORT_MESSAGE=445 +SORT_MODE_SIZE=446 +SORT_RETURN=447 +SOURCE=448 +SOURCE_COMPUTER=449 +SPACE=450 +SPACES=451 +SPECIAL_NAMES=452 +STANDARD=453 +STANDARD_1=454 +STANDARD_2=455 +START=456 +STATUS=457 +STOP=458 +STRING=459 +SUB_QUEUE_1=460 +SUB_QUEUE_2=461 +SUB_QUEUE_3=462 +SUBTRACT=463 +SUM=464 +SUPPRESS=465 +SYMBOL=466 +SYMBOLIC=467 +SYNC=468 +SYNCHRONIZED=469 +TABLE=470 +TALLY=471 +TALLYING=472 +TASK=473 +TAPE=474 +TERMINAL=475 +TERMINATE=476 +TEST=477 +TEXT=478 +THAN=479 +THEN=480 +THREAD=481 +THREAD_LOCAL=482 +THROUGH=483 +THRU=484 +TIME=485 +TIMER=486 +TIMES=487 +TITLE=488 +TO=489 +TODAYS_DATE=490 +TODAYS_NAME=491 +TOP=492 +TRAILING=493 +TRUE=494 +TRUNCATED=495 +TYPE=496 +TYPEDEF=497 +UNDERLINE=498 +UNIT=499 +UNSTRING=500 +UNTIL=501 +UP=502 +UPON=503 +USAGE=504 +USE=505 +USING=506 +VALUE=507 +VALUES=508 +VARYING=509 +VIRTUAL=510 +WAIT=511 +WHEN=512 +WHEN_COMPILED=513 +WITH=514 +WORDS=515 +WORKING_STORAGE=516 +WRITE=517 +YEAR=518 +YYYYMMDD=519 +YYYYDDD=520 +ZERO=521 +ZERO_FILL=522 +ZEROS=523 +ZEROES=524 +AMPCHAR=525 +ASTERISKCHAR=526 +DOUBLEASTERISKCHAR=527 +COLONCHAR=528 +COMMACHAR=529 +COMMENTENTRYTAG=530 +COMMENTTAG=531 +DOLLARCHAR=532 +DOUBLEQUOTE=533 +DOT_FS=534 +DOT=535 +EQUALCHAR=536 +EXECCICSTAG=537 +EXECSQLTAG=538 +EXECSQLIMSTAG=539 +LESSTHANCHAR=540 +LESSTHANOREQUAL=541 +LPARENCHAR=542 +MINUSCHAR=543 +MORETHANCHAR=544 +MORETHANOREQUAL=545 +NOTEQUALCHAR=546 +PLUSCHAR=547 +SINGLEQUOTE=548 +RPARENCHAR=549 +SLASHCHAR=550 +NONNUMERICLITERAL=551 +LEVEL_NUMBER_66=552 +LEVEL_NUMBER_77=553 +LEVEL_NUMBER_88=554 +INTEGERLITERAL=555 +NUMERICLITERAL=556 +IDENTIFIER=557 +NEWLINE=558 +EXECCICSLINE=559 +EXECSQLIMSLINE=560 +EXECSQLLINE=561 +COMMENTENTRYLINE=562 +COMMENTLINE=563 +WS=564 +SEPARATOR=565 +'&'=525 +'*'=526 +'**'=527 +':'=528 +','=529 +'*>CE'=530 +'*>'=531 +'$'=532 +'"'=533 +'.'=535 +'='=536 +'*>EXECCICS'=537 +'*>EXECSQL'=538 +'*>EXECSQLIMS'=539 +'<'=540 +'<='=541 +'('=542 +'-'=543 +'>'=544 +'>='=545 +'<>'=546 +'+'=547 +'\''=548 +')'=549 +'/'=550 +'66'=552 +'77'=553 +'88'=554 +', '=565 diff --git a/src/Cobol85Lexer.interp b/src/Cobol85Lexer.interp new file mode 100644 index 0000000..dc3943b --- /dev/null +++ b/src/Cobol85Lexer.interp @@ -0,0 +1,1742 @@ +token literal 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 +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +'&' +'*' +'**' +':' +',' +'*>CE' +'*>' +'$' +'"' +null +'.' +'=' +'*>EXECCICS' +'*>EXECSQL' +'*>EXECSQLIMS' +'<' +'<=' +'(' +'-' +'>' +'>=' +'<>' +'+' +'\'' +')' +'/' +null +'66' +'77' +'88' +null +null +null +null +null +null +null +null +null +null +', ' + +token symbolic names: +null +ABORT +ACCEPT +ACCESS +ADD +ADDRESS +ADVANCING +AFTER +ALIGNED +ALL +ALPHABET +ALPHABETIC +ALPHABETIC_LOWER +ALPHABETIC_UPPER +ALPHANUMERIC +ALPHANUMERIC_EDITED +ALSO +ALTER +ALTERNATE +AND +ANY +ARE +AREA +AREAS +AS +ASCENDING +ASCII +ASSIGN +ASSOCIATED_DATA +ASSOCIATED_DATA_LENGTH +AT +ATTRIBUTE +AUTHOR +AUTO +AUTO_SKIP +BACKGROUND_COLOR +BACKGROUND_COLOUR +BASIS +BEEP +BEFORE +BEGINNING +BELL +BINARY +BIT +BLANK +BLINK +BLOCK +BOUNDS +BOTTOM +BY +BYFUNCTION +BYTITLE +CALL +CANCEL +CAPABLE +CCSVERSION +CD +CF +CH +CHAINING +CHANGED +CHANNEL +CHARACTER +CHARACTERS +CLASS +CLASS_ID +CLOCK_UNITS +CLOSE +CLOSE_DISPOSITION +COBOL +CODE +CODE_SET +COLLATING +COL +COLUMN +COM_REG +COMMA +COMMITMENT +COMMON +COMMUNICATION +COMP +COMP_1 +COMP_2 +COMP_3 +COMP_4 +COMP_5 +COMPUTATIONAL +COMPUTATIONAL_1 +COMPUTATIONAL_2 +COMPUTATIONAL_3 +COMPUTATIONAL_4 +COMPUTATIONAL_5 +COMPUTE +CONFIGURATION +CONTAINS +CONTENT +CONTINUE +CONTROL +CONTROL_POINT +CONTROLS +CONVENTION +CONVERTING +COPY +CORR +CORRESPONDING +COUNT +CRUNCH +CURRENCY +CURSOR +DATA +DATA_BASE +DATE +DATE_COMPILED +DATE_WRITTEN +DAY +DAY_OF_WEEK +DBCS +DE +DEBUG_CONTENTS +DEBUG_ITEM +DEBUG_LINE +DEBUG_NAME +DEBUG_SUB_1 +DEBUG_SUB_2 +DEBUG_SUB_3 +DEBUGGING +DECIMAL_POINT +DECLARATIVES +DEFAULT +DEFAULT_DISPLAY +DEFINITION +DELETE +DELIMITED +DELIMITER +DEPENDING +DESCENDING +DESTINATION +DETAIL +DFHRESP +DFHVALUE +DISABLE +DISK +DISPLAY +DISPLAY_1 +DIVIDE +DIVISION +DONTCARE +DOUBLE +DOWN +DUPLICATES +DYNAMIC +EBCDIC +EGCS +EGI +ELSE +EMI +EMPTY_CHECK +ENABLE +END +END_ACCEPT +END_ADD +END_CALL +END_COMPUTE +END_DELETE +END_DIVIDE +END_EVALUATE +END_IF +END_MULTIPLY +END_OF_PAGE +END_PERFORM +END_READ +END_RECEIVE +END_RETURN +END_REWRITE +END_SEARCH +END_START +END_STRING +END_SUBTRACT +END_UNSTRING +END_WRITE +ENDING +ENTER +ENTRY +ENTRY_PROCEDURE +ENVIRONMENT +EOP +EQUAL +ERASE +ERROR +EOL +EOS +ESCAPE +ESI +EVALUATE +EVENT +EVERY +EXCEPTION +EXCLUSIVE +EXHIBIT +EXIT +EXPORT +EXTEND +EXTENDED +EXTERNAL +FALSE +FD +FILE +FILE_CONTROL +FILLER +FINAL +FIRST +FOOTING +FOR +FOREGROUND_COLOR +FOREGROUND_COLOUR +FROM +FULL +FUNCTION +FUNCTIONNAME +FUNCTION_POINTER +GENERATE +GOBACK +GIVING +GLOBAL +GO +GREATER +GRID +GROUP +HEADING +HIGHLIGHT +HIGH_VALUE +HIGH_VALUES +I_O +I_O_CONTROL +ID +IDENTIFICATION +IF +IMPLICIT +IMPORT +IN +INDEX +INDEXED +INDICATE +INITIAL +INITIALIZE +INITIATE +INPUT +INPUT_OUTPUT +INSPECT +INSTALLATION +INTEGER +INTO +INVALID +INVOKE +IS +JUST +JUSTIFIED +KANJI +KEPT +KEY +KEYBOARD +LABEL +LANGUAGE +LAST +LB +LD +LEADING +LEFT +LEFTLINE +LENGTH +LENGTH_CHECK +LESS +LIBACCESS +LIBPARAMETER +LIBRARY +LIMIT +LIMITS +LINAGE +LINAGE_COUNTER +LINE +LINES +LINE_COUNTER +LINKAGE +LIST +LOCAL +LOCAL_STORAGE +LOCK +LONG_DATE +LONG_TIME +LOWER +LOWLIGHT +LOW_VALUE +LOW_VALUES +MEMORY +MERGE +MESSAGE +MMDDYYYY +MODE +MODULES +MORE_LABELS +MOVE +MULTIPLE +MULTIPLY +NAMED +NATIONAL +NATIONAL_EDITED +NATIVE +NEGATIVE +NETWORK +NEXT +NO +NO_ECHO +NOT +NULL_ +NULLS +NUMBER +NUMERIC +NUMERIC_DATE +NUMERIC_EDITED +NUMERIC_TIME +OBJECT_COMPUTER +OCCURS +ODT +OF +OFF +OMITTED +ON +OPEN +OPTIONAL +OR +ORDER +ORDERLY +ORGANIZATION +OTHER +OUTPUT +OVERFLOW +OVERLINE +OWN +PACKED_DECIMAL +PADDING +PAGE +PAGE_COUNTER +PASSWORD +PERFORM +PF +PH +PIC +PICTURE +PLUS +POINTER +POSITION +POSITIVE +PORT +PRINTER +PRINTING +PRIVATE +PROCEDURE +PROCEDURE_POINTER +PROCEDURES +PROCEED +PROCESS +PROGRAM +PROGRAM_ID +PROGRAM_LIBRARY +PROMPT +PURGE +QUEUE +QUOTE +QUOTES +RANDOM +READER +REMOTE +RD +REAL +READ +RECEIVE +RECEIVED +RECORD +RECORDING +RECORDS +RECURSIVE +REDEFINES +REEL +REF +REFERENCE +REFERENCES +RELATIVE +RELEASE +REMAINDER +REMARKS +REMOVAL +REMOVE +RENAMES +REPLACE +REPLACING +REPORT +REPORTING +REPORTS +REQUIRED +RERUN +RESERVE +REVERSE_VIDEO +RESET +RETURN +RETURN_CODE +RETURNING +REVERSED +REWIND +REWRITE +RF +RH +RIGHT +ROUNDED +RUN +SAME +SAVE +SCREEN +SD +SEARCH +SECTION +SECURE +SECURITY +SEGMENT +SEGMENT_LIMIT +SELECT +SEND +SENTENCE +SEPARATE +SEQUENCE +SEQUENTIAL +SET +SHARED +SHAREDBYALL +SHAREDBYRUNUNIT +SHARING +SHIFT_IN +SHIFT_OUT +SHORT_DATE +SIGN +SIZE +SORT +SORT_CONTROL +SORT_CORE_SIZE +SORT_FILE_SIZE +SORT_MERGE +SORT_MESSAGE +SORT_MODE_SIZE +SORT_RETURN +SOURCE +SOURCE_COMPUTER +SPACE +SPACES +SPECIAL_NAMES +STANDARD +STANDARD_1 +STANDARD_2 +START +STATUS +STOP +STRING +SUB_QUEUE_1 +SUB_QUEUE_2 +SUB_QUEUE_3 +SUBTRACT +SUM +SUPPRESS +SYMBOL +SYMBOLIC +SYNC +SYNCHRONIZED +TABLE +TALLY +TALLYING +TASK +TAPE +TERMINAL +TERMINATE +TEST +TEXT +THAN +THEN +THREAD +THREAD_LOCAL +THROUGH +THRU +TIME +TIMER +TIMES +TITLE +TO +TODAYS_DATE +TODAYS_NAME +TOP +TRAILING +TRUE +TRUNCATED +TYPE +TYPEDEF +UNDERLINE +UNIT +UNSTRING +UNTIL +UP +UPON +USAGE +USE +USING +VALUE +VALUES +VARYING +VIRTUAL +WAIT +WHEN +WHEN_COMPILED +WITH +WORDS +WORKING_STORAGE +WRITE +YEAR +YYYYMMDD +YYYYDDD +ZERO +ZERO_FILL +ZEROS +ZEROES +AMPCHAR +ASTERISKCHAR +DOUBLEASTERISKCHAR +COLONCHAR +COMMACHAR +COMMENTENTRYTAG +COMMENTTAG +DOLLARCHAR +DOUBLEQUOTE +DOT_FS +DOT +EQUALCHAR +EXECCICSTAG +EXECSQLTAG +EXECSQLIMSTAG +LESSTHANCHAR +LESSTHANOREQUAL +LPARENCHAR +MINUSCHAR +MORETHANCHAR +MORETHANOREQUAL +NOTEQUALCHAR +PLUSCHAR +SINGLEQUOTE +RPARENCHAR +SLASHCHAR +NONNUMERICLITERAL +LEVEL_NUMBER_66 +LEVEL_NUMBER_77 +LEVEL_NUMBER_88 +INTEGERLITERAL +NUMERICLITERAL +IDENTIFIER +NEWLINE +EXECCICSLINE +EXECSQLIMSLINE +EXECSQLLINE +COMMENTENTRYLINE +COMMENTLINE +WS +SEPARATOR + +rule names: +ABORT +ACCEPT +ACCESS +ADD +ADDRESS +ADVANCING +AFTER +ALIGNED +ALL +ALPHABET +ALPHABETIC +ALPHABETIC_LOWER +ALPHABETIC_UPPER +ALPHANUMERIC +ALPHANUMERIC_EDITED +ALSO +ALTER +ALTERNATE +AND +ANY +ARE +AREA +AREAS +AS +ASCENDING +ASCII +ASSIGN +ASSOCIATED_DATA +ASSOCIATED_DATA_LENGTH +AT +ATTRIBUTE +AUTHOR +AUTO +AUTO_SKIP +BACKGROUND_COLOR +BACKGROUND_COLOUR +BASIS +BEEP +BEFORE +BEGINNING +BELL +BINARY +BIT +BLANK +BLINK +BLOCK +BOUNDS +BOTTOM +BY +BYFUNCTION +BYTITLE +CALL +CANCEL +CAPABLE +CCSVERSION +CD +CF +CH +CHAINING +CHANGED +CHANNEL +CHARACTER +CHARACTERS +CLASS +CLASS_ID +CLOCK_UNITS +CLOSE +CLOSE_DISPOSITION +COBOL +CODE +CODE_SET +COLLATING +COL +COLUMN +COM_REG +COMMA +COMMITMENT +COMMON +COMMUNICATION +COMP +COMP_1 +COMP_2 +COMP_3 +COMP_4 +COMP_5 +COMPUTATIONAL +COMPUTATIONAL_1 +COMPUTATIONAL_2 +COMPUTATIONAL_3 +COMPUTATIONAL_4 +COMPUTATIONAL_5 +COMPUTE +CONFIGURATION +CONTAINS +CONTENT +CONTINUE +CONTROL +CONTROL_POINT +CONTROLS +CONVENTION +CONVERTING +COPY +CORR +CORRESPONDING +COUNT +CRUNCH +CURRENCY +CURSOR +DATA +DATA_BASE +DATE +DATE_COMPILED +DATE_WRITTEN +DAY +DAY_OF_WEEK +DBCS +DE +DEBUG_CONTENTS +DEBUG_ITEM +DEBUG_LINE +DEBUG_NAME +DEBUG_SUB_1 +DEBUG_SUB_2 +DEBUG_SUB_3 +DEBUGGING +DECIMAL_POINT +DECLARATIVES +DEFAULT +DEFAULT_DISPLAY +DEFINITION +DELETE +DELIMITED +DELIMITER +DEPENDING +DESCENDING +DESTINATION +DETAIL +DFHRESP +DFHVALUE +DISABLE +DISK +DISPLAY +DISPLAY_1 +DIVIDE +DIVISION +DONTCARE +DOUBLE +DOWN +DUPLICATES +DYNAMIC +EBCDIC +EGCS +EGI +ELSE +EMI +EMPTY_CHECK +ENABLE +END +END_ACCEPT +END_ADD +END_CALL +END_COMPUTE +END_DELETE +END_DIVIDE +END_EVALUATE +END_IF +END_MULTIPLY +END_OF_PAGE +END_PERFORM +END_READ +END_RECEIVE +END_RETURN +END_REWRITE +END_SEARCH +END_START +END_STRING +END_SUBTRACT +END_UNSTRING +END_WRITE +ENDING +ENTER +ENTRY +ENTRY_PROCEDURE +ENVIRONMENT +EOP +EQUAL +ERASE +ERROR +EOL +EOS +ESCAPE +ESI +EVALUATE +EVENT +EVERY +EXCEPTION +EXCLUSIVE +EXHIBIT +EXIT +EXPORT +EXTEND +EXTENDED +EXTERNAL +FALSE +FD +FILE +FILE_CONTROL +FILLER +FINAL +FIRST +FOOTING +FOR +FOREGROUND_COLOR +FOREGROUND_COLOUR +FROM +FULL +FUNCTION +FUNCTIONNAME +FUNCTION_POINTER +GENERATE +GOBACK +GIVING +GLOBAL +GO +GREATER +GRID +GROUP +HEADING +HIGHLIGHT +HIGH_VALUE +HIGH_VALUES +I_O +I_O_CONTROL +ID +IDENTIFICATION +IF +IMPLICIT +IMPORT +IN +INDEX +INDEXED +INDICATE +INITIAL +INITIALIZE +INITIATE +INPUT +INPUT_OUTPUT +INSPECT +INSTALLATION +INTEGER +INTO +INVALID +INVOKE +IS +JUST +JUSTIFIED +KANJI +KEPT +KEY +KEYBOARD +LABEL +LANGUAGE +LAST +LB +LD +LEADING +LEFT +LEFTLINE +LENGTH +LENGTH_CHECK +LESS +LIBACCESS +LIBPARAMETER +LIBRARY +LIMIT +LIMITS +LINAGE +LINAGE_COUNTER +LINE +LINES +LINE_COUNTER +LINKAGE +LIST +LOCAL +LOCAL_STORAGE +LOCK +LONG_DATE +LONG_TIME +LOWER +LOWLIGHT +LOW_VALUE +LOW_VALUES +MEMORY +MERGE +MESSAGE +MMDDYYYY +MODE +MODULES +MORE_LABELS +MOVE +MULTIPLE +MULTIPLY +NAMED +NATIONAL +NATIONAL_EDITED +NATIVE +NEGATIVE +NETWORK +NEXT +NO +NO_ECHO +NOT +NULL_ +NULLS +NUMBER +NUMERIC +NUMERIC_DATE +NUMERIC_EDITED +NUMERIC_TIME +OBJECT_COMPUTER +OCCURS +ODT +OF +OFF +OMITTED +ON +OPEN +OPTIONAL +OR +ORDER +ORDERLY +ORGANIZATION +OTHER +OUTPUT +OVERFLOW +OVERLINE +OWN +PACKED_DECIMAL +PADDING +PAGE +PAGE_COUNTER +PASSWORD +PERFORM +PF +PH +PIC +PICTURE +PLUS +POINTER +POSITION +POSITIVE +PORT +PRINTER +PRINTING +PRIVATE +PROCEDURE +PROCEDURE_POINTER +PROCEDURES +PROCEED +PROCESS +PROGRAM +PROGRAM_ID +PROGRAM_LIBRARY +PROMPT +PURGE +QUEUE +QUOTE +QUOTES +RANDOM +READER +REMOTE +RD +REAL +READ +RECEIVE +RECEIVED +RECORD +RECORDING +RECORDS +RECURSIVE +REDEFINES +REEL +REF +REFERENCE +REFERENCES +RELATIVE +RELEASE +REMAINDER +REMARKS +REMOVAL +REMOVE +RENAMES +REPLACE +REPLACING +REPORT +REPORTING +REPORTS +REQUIRED +RERUN +RESERVE +REVERSE_VIDEO +RESET +RETURN +RETURN_CODE +RETURNING +REVERSED +REWIND +REWRITE +RF +RH +RIGHT +ROUNDED +RUN +SAME +SAVE +SCREEN +SD +SEARCH +SECTION +SECURE +SECURITY +SEGMENT +SEGMENT_LIMIT +SELECT +SEND +SENTENCE +SEPARATE +SEQUENCE +SEQUENTIAL +SET +SHARED +SHAREDBYALL +SHAREDBYRUNUNIT +SHARING +SHIFT_IN +SHIFT_OUT +SHORT_DATE +SIGN +SIZE +SORT +SORT_CONTROL +SORT_CORE_SIZE +SORT_FILE_SIZE +SORT_MERGE +SORT_MESSAGE +SORT_MODE_SIZE +SORT_RETURN +SOURCE +SOURCE_COMPUTER +SPACE +SPACES +SPECIAL_NAMES +STANDARD +STANDARD_1 +STANDARD_2 +START +STATUS +STOP +STRING +SUB_QUEUE_1 +SUB_QUEUE_2 +SUB_QUEUE_3 +SUBTRACT +SUM +SUPPRESS +SYMBOL +SYMBOLIC +SYNC +SYNCHRONIZED +TABLE +TALLY +TALLYING +TASK +TAPE +TERMINAL +TERMINATE +TEST +TEXT +THAN +THEN +THREAD +THREAD_LOCAL +THROUGH +THRU +TIME +TIMER +TIMES +TITLE +TO +TODAYS_DATE +TODAYS_NAME +TOP +TRAILING +TRUE +TRUNCATED +TYPE +TYPEDEF +UNDERLINE +UNIT +UNSTRING +UNTIL +UP +UPON +USAGE +USE +USING +VALUE +VALUES +VARYING +VIRTUAL +WAIT +WHEN +WHEN_COMPILED +WITH +WORDS +WORKING_STORAGE +WRITE +YEAR +YYYYMMDD +YYYYDDD +ZERO +ZERO_FILL +ZEROS +ZEROES +AMPCHAR +ASTERISKCHAR +DOUBLEASTERISKCHAR +COLONCHAR +COMMACHAR +COMMENTENTRYTAG +COMMENTTAG +DOLLARCHAR +DOUBLEQUOTE +DOT_FS +DOT +EQUALCHAR +EXECCICSTAG +EXECSQLTAG +EXECSQLIMSTAG +LESSTHANCHAR +LESSTHANOREQUAL +LPARENCHAR +MINUSCHAR +MORETHANCHAR +MORETHANOREQUAL +NOTEQUALCHAR +PLUSCHAR +SINGLEQUOTE +RPARENCHAR +SLASHCHAR +NONNUMERICLITERAL +HEXNUMBER +NULLTERMINATED +STRINGLITERAL +DBCSLITERAL +LEVEL_NUMBER_66 +LEVEL_NUMBER_77 +LEVEL_NUMBER_88 +INTEGERLITERAL +NUMERICLITERAL +IDENTIFIER +NEWLINE +EXECCICSLINE +EXECSQLIMSLINE +EXECSQLLINE +COMMENTENTRYLINE +COMMENTLINE +WS +SEPARATOR +A +B +C +D +E +F +G +H +I +J +K +L +M +N +O +P +Q +R +S +T +U +V +W +X +Y +Z + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 565, 5916, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, 243, 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, 247, 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, 252, 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, 256, 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, 261, 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, 265, 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, 270, 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, 274, 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, 279, 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, 283, 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, 288, 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, 292, 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, 297, 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, 301, 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, 306, 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, 310, 2, 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, 315, 7, 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, 319, 2, 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, 324, 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, 328, 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, 333, 7, 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, 337, 2, 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, 342, 7, 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, 346, 2, 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, 351, 7, 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, 355, 2, 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, 360, 7, 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, 364, 2, 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, 369, 7, 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, 373, 2, 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, 378, 7, 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, 382, 2, 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, 387, 7, 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, 391, 2, 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, 396, 7, 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, 400, 2, 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, 405, 7, 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, 409, 2, 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, 414, 7, 414, 2, 415, 7, 415, 2, 416, 7, 416, 2, 417, 7, 417, 2, 418, 7, 418, 2, 419, 7, 419, 2, 420, 7, 420, 2, 421, 7, 421, 2, 422, 7, 422, 2, 423, 7, 423, 2, 424, 7, 424, 2, 425, 7, 425, 2, 426, 7, 426, 2, 427, 7, 427, 2, 428, 7, 428, 2, 429, 7, 429, 2, 430, 7, 430, 2, 431, 7, 431, 2, 432, 7, 432, 2, 433, 7, 433, 2, 434, 7, 434, 2, 435, 7, 435, 2, 436, 7, 436, 2, 437, 7, 437, 2, 438, 7, 438, 2, 439, 7, 439, 2, 440, 7, 440, 2, 441, 7, 441, 2, 442, 7, 442, 2, 443, 7, 443, 2, 444, 7, 444, 2, 445, 7, 445, 2, 446, 7, 446, 2, 447, 7, 447, 2, 448, 7, 448, 2, 449, 7, 449, 2, 450, 7, 450, 2, 451, 7, 451, 2, 452, 7, 452, 2, 453, 7, 453, 2, 454, 7, 454, 2, 455, 7, 455, 2, 456, 7, 456, 2, 457, 7, 457, 2, 458, 7, 458, 2, 459, 7, 459, 2, 460, 7, 460, 2, 461, 7, 461, 2, 462, 7, 462, 2, 463, 7, 463, 2, 464, 7, 464, 2, 465, 7, 465, 2, 466, 7, 466, 2, 467, 7, 467, 2, 468, 7, 468, 2, 469, 7, 469, 2, 470, 7, 470, 2, 471, 7, 471, 2, 472, 7, 472, 2, 473, 7, 473, 2, 474, 7, 474, 2, 475, 7, 475, 2, 476, 7, 476, 2, 477, 7, 477, 2, 478, 7, 478, 2, 479, 7, 479, 2, 480, 7, 480, 2, 481, 7, 481, 2, 482, 7, 482, 2, 483, 7, 483, 2, 484, 7, 484, 2, 485, 7, 485, 2, 486, 7, 486, 2, 487, 7, 487, 2, 488, 7, 488, 2, 489, 7, 489, 2, 490, 7, 490, 2, 491, 7, 491, 2, 492, 7, 492, 2, 493, 7, 493, 2, 494, 7, 494, 2, 495, 7, 495, 2, 496, 7, 496, 2, 497, 7, 497, 2, 498, 7, 498, 2, 499, 7, 499, 2, 500, 7, 500, 2, 501, 7, 501, 2, 502, 7, 502, 2, 503, 7, 503, 2, 504, 7, 504, 2, 505, 7, 505, 2, 506, 7, 506, 2, 507, 7, 507, 2, 508, 7, 508, 2, 509, 7, 509, 2, 510, 7, 510, 2, 511, 7, 511, 2, 512, 7, 512, 2, 513, 7, 513, 2, 514, 7, 514, 2, 515, 7, 515, 2, 516, 7, 516, 2, 517, 7, 517, 2, 518, 7, 518, 2, 519, 7, 519, 2, 520, 7, 520, 2, 521, 7, 521, 2, 522, 7, 522, 2, 523, 7, 523, 2, 524, 7, 524, 2, 525, 7, 525, 2, 526, 7, 526, 2, 527, 7, 527, 2, 528, 7, 528, 2, 529, 7, 529, 2, 530, 7, 530, 2, 531, 7, 531, 2, 532, 7, 532, 2, 533, 7, 533, 2, 534, 7, 534, 2, 535, 7, 535, 2, 536, 7, 536, 2, 537, 7, 537, 2, 538, 7, 538, 2, 539, 7, 539, 2, 540, 7, 540, 2, 541, 7, 541, 2, 542, 7, 542, 2, 543, 7, 543, 2, 544, 7, 544, 2, 545, 7, 545, 2, 546, 7, 546, 2, 547, 7, 547, 2, 548, 7, 548, 2, 549, 7, 549, 2, 550, 7, 550, 2, 551, 7, 551, 2, 552, 7, 552, 2, 553, 7, 553, 2, 554, 7, 554, 2, 555, 7, 555, 2, 556, 7, 556, 2, 557, 7, 557, 2, 558, 7, 558, 2, 559, 7, 559, 2, 560, 7, 560, 2, 561, 7, 561, 2, 562, 7, 562, 2, 563, 7, 563, 2, 564, 7, 564, 2, 565, 7, 565, 2, 566, 7, 566, 2, 567, 7, 567, 2, 568, 7, 568, 2, 569, 7, 569, 2, 570, 7, 570, 2, 571, 7, 571, 2, 572, 7, 572, 2, 573, 7, 573, 2, 574, 7, 574, 2, 575, 7, 575, 2, 576, 7, 576, 2, 577, 7, 577, 2, 578, 7, 578, 2, 579, 7, 579, 2, 580, 7, 580, 2, 581, 7, 581, 2, 582, 7, 582, 2, 583, 7, 583, 2, 584, 7, 584, 2, 585, 7, 585, 2, 586, 7, 586, 2, 587, 7, 587, 2, 588, 7, 588, 2, 589, 7, 589, 2, 590, 7, 590, 2, 591, 7, 591, 2, 592, 7, 592, 2, 593, 7, 593, 2, 594, 7, 594, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 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, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 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, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 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, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 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, 39, 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, 40, 1, 40, 1, 41, 1, 41, 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, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 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, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 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, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 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, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 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, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 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, 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, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 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, 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, 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, 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, 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, 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, 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, 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, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 233, 1, 233, 1, 233, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 253, 1, 253, 1, 253, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 322, 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 325, 1, 325, 1, 325, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 328, 1, 328, 1, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 336, 1, 336, 1, 336, 1, 336, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 339, 1, 339, 1, 339, 1, 339, 1, 339, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, 1, 343, 1, 343, 1, 343, 1, 344, 1, 344, 1, 344, 1, 345, 1, 345, 1, 345, 1, 345, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 371, 1, 371, 1, 371, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 382, 1, 382, 1, 382, 1, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 408, 1, 408, 1, 408, 1, 409, 1, 409, 1, 409, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 412, 1, 412, 1, 412, 1, 412, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 416, 1, 416, 1, 416, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 429, 1, 429, 1, 429, 1, 429, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 431, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 446, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 463, 1, 463, 1, 463, 1, 463, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, 470, 1, 470, 1, 470, 1, 470, 1, 470, 1, 470, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 488, 1, 488, 1, 488, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 491, 1, 491, 1, 491, 1, 491, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 501, 1, 501, 1, 501, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 504, 1, 504, 1, 504, 1, 504, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 516, 1, 516, 1, 516, 1, 516, 1, 516, 1, 516, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 521, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 524, 1, 524, 1, 525, 1, 525, 1, 526, 1, 526, 1, 526, 1, 527, 1, 527, 1, 528, 1, 528, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 530, 1, 530, 1, 530, 1, 531, 1, 531, 1, 532, 1, 532, 1, 533, 1, 533, 4, 533, 5554, 8, 533, 11, 533, 12, 533, 5555, 1, 533, 1, 533, 3, 533, 5560, 8, 533, 1, 534, 1, 534, 1, 535, 1, 535, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 539, 1, 539, 1, 540, 1, 540, 1, 540, 1, 541, 1, 541, 1, 542, 1, 542, 1, 543, 1, 543, 1, 544, 1, 544, 1, 544, 1, 545, 1, 545, 1, 545, 1, 546, 1, 546, 1, 547, 1, 547, 1, 548, 1, 548, 1, 549, 1, 549, 1, 550, 1, 550, 1, 550, 1, 550, 3, 550, 5629, 8, 550, 1, 551, 1, 551, 1, 551, 4, 551, 5634, 8, 551, 11, 551, 12, 551, 5635, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 4, 551, 5643, 8, 551, 11, 551, 12, 551, 5644, 1, 551, 1, 551, 3, 551, 5649, 8, 551, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 5, 552, 5657, 8, 552, 10, 552, 12, 552, 5660, 9, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 5, 552, 5670, 8, 552, 10, 552, 12, 552, 5673, 9, 552, 1, 552, 1, 552, 3, 552, 5677, 8, 552, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 5, 553, 5684, 8, 553, 10, 553, 12, 553, 5687, 9, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 5, 553, 5695, 8, 553, 10, 553, 12, 553, 5698, 9, 553, 1, 553, 3, 553, 5701, 8, 553, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 5, 554, 5709, 8, 554, 10, 554, 12, 554, 5712, 9, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 5, 554, 5721, 8, 554, 10, 554, 12, 554, 5724, 9, 554, 1, 554, 3, 554, 5727, 8, 554, 1, 555, 1, 555, 1, 555, 1, 556, 1, 556, 1, 556, 1, 557, 1, 557, 1, 557, 1, 558, 1, 558, 3, 558, 5740, 8, 558, 1, 558, 4, 558, 5743, 8, 558, 11, 558, 12, 558, 5744, 1, 559, 1, 559, 3, 559, 5749, 8, 559, 1, 559, 5, 559, 5752, 8, 559, 10, 559, 12, 559, 5755, 9, 559, 1, 559, 1, 559, 3, 559, 5759, 8, 559, 1, 559, 4, 559, 5762, 8, 559, 11, 559, 12, 559, 5763, 1, 559, 1, 559, 1, 559, 3, 559, 5769, 8, 559, 1, 559, 4, 559, 5772, 8, 559, 11, 559, 12, 559, 5773, 3, 559, 5776, 8, 559, 1, 560, 4, 560, 5779, 8, 560, 11, 560, 12, 560, 5780, 1, 560, 4, 560, 5784, 8, 560, 11, 560, 12, 560, 5785, 1, 560, 4, 560, 5789, 8, 560, 11, 560, 12, 560, 5790, 5, 560, 5793, 8, 560, 10, 560, 12, 560, 5796, 9, 560, 1, 561, 3, 561, 5799, 8, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 562, 1, 562, 1, 562, 5, 562, 5808, 8, 562, 10, 562, 12, 562, 5811, 9, 562, 1, 562, 1, 562, 1, 563, 1, 563, 1, 563, 5, 563, 5818, 8, 563, 10, 563, 12, 563, 5821, 9, 563, 1, 563, 1, 563, 1, 564, 1, 564, 1, 564, 5, 564, 5828, 8, 564, 10, 564, 12, 564, 5831, 9, 564, 1, 564, 1, 564, 1, 565, 1, 565, 1, 565, 5, 565, 5838, 8, 565, 10, 565, 12, 565, 5841, 9, 565, 1, 566, 1, 566, 1, 566, 5, 566, 5846, 8, 566, 10, 566, 12, 566, 5849, 9, 566, 1, 566, 1, 566, 1, 567, 4, 567, 5854, 8, 567, 11, 567, 12, 567, 5855, 1, 567, 1, 567, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 569, 1, 569, 1, 570, 1, 570, 1, 571, 1, 571, 1, 572, 1, 572, 1, 573, 1, 573, 1, 574, 1, 574, 1, 575, 1, 575, 1, 576, 1, 576, 1, 577, 1, 577, 1, 578, 1, 578, 1, 579, 1, 579, 1, 580, 1, 580, 1, 581, 1, 581, 1, 582, 1, 582, 1, 583, 1, 583, 1, 584, 1, 584, 1, 585, 1, 585, 1, 586, 1, 586, 1, 587, 1, 587, 1, 588, 1, 588, 1, 589, 1, 589, 1, 590, 1, 590, 1, 591, 1, 591, 1, 592, 1, 592, 1, 593, 1, 593, 1, 594, 1, 594, 0, 0, 595, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, 57, 115, 58, 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, 65, 131, 66, 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72, 145, 73, 147, 74, 149, 75, 151, 76, 153, 77, 155, 78, 157, 79, 159, 80, 161, 81, 163, 82, 165, 83, 167, 84, 169, 85, 171, 86, 173, 87, 175, 88, 177, 89, 179, 90, 181, 91, 183, 92, 185, 93, 187, 94, 189, 95, 191, 96, 193, 97, 195, 98, 197, 99, 199, 100, 201, 101, 203, 102, 205, 103, 207, 104, 209, 105, 211, 106, 213, 107, 215, 108, 217, 109, 219, 110, 221, 111, 223, 112, 225, 113, 227, 114, 229, 115, 231, 116, 233, 117, 235, 118, 237, 119, 239, 120, 241, 121, 243, 122, 245, 123, 247, 124, 249, 125, 251, 126, 253, 127, 255, 128, 257, 129, 259, 130, 261, 131, 263, 132, 265, 133, 267, 134, 269, 135, 271, 136, 273, 137, 275, 138, 277, 139, 279, 140, 281, 141, 283, 142, 285, 143, 287, 144, 289, 145, 291, 146, 293, 147, 295, 148, 297, 149, 299, 150, 301, 151, 303, 152, 305, 153, 307, 154, 309, 155, 311, 156, 313, 157, 315, 158, 317, 159, 319, 160, 321, 161, 323, 162, 325, 163, 327, 164, 329, 165, 331, 166, 333, 167, 335, 168, 337, 169, 339, 170, 341, 171, 343, 172, 345, 173, 347, 174, 349, 175, 351, 176, 353, 177, 355, 178, 357, 179, 359, 180, 361, 181, 363, 182, 365, 183, 367, 184, 369, 185, 371, 186, 373, 187, 375, 188, 377, 189, 379, 190, 381, 191, 383, 192, 385, 193, 387, 194, 389, 195, 391, 196, 393, 197, 395, 198, 397, 199, 399, 200, 401, 201, 403, 202, 405, 203, 407, 204, 409, 205, 411, 206, 413, 207, 415, 208, 417, 209, 419, 210, 421, 211, 423, 212, 425, 213, 427, 214, 429, 215, 431, 216, 433, 217, 435, 218, 437, 219, 439, 220, 441, 221, 443, 222, 445, 223, 447, 224, 449, 225, 451, 226, 453, 227, 455, 228, 457, 229, 459, 230, 461, 231, 463, 232, 465, 233, 467, 234, 469, 235, 471, 236, 473, 237, 475, 238, 477, 239, 479, 240, 481, 241, 483, 242, 485, 243, 487, 244, 489, 245, 491, 246, 493, 247, 495, 248, 497, 249, 499, 250, 501, 251, 503, 252, 505, 253, 507, 254, 509, 255, 511, 256, 513, 257, 515, 258, 517, 259, 519, 260, 521, 261, 523, 262, 525, 263, 527, 264, 529, 265, 531, 266, 533, 267, 535, 268, 537, 269, 539, 270, 541, 271, 543, 272, 545, 273, 547, 274, 549, 275, 551, 276, 553, 277, 555, 278, 557, 279, 559, 280, 561, 281, 563, 282, 565, 283, 567, 284, 569, 285, 571, 286, 573, 287, 575, 288, 577, 289, 579, 290, 581, 291, 583, 292, 585, 293, 587, 294, 589, 295, 591, 296, 593, 297, 595, 298, 597, 299, 599, 300, 601, 301, 603, 302, 605, 303, 607, 304, 609, 305, 611, 306, 613, 307, 615, 308, 617, 309, 619, 310, 621, 311, 623, 312, 625, 313, 627, 314, 629, 315, 631, 316, 633, 317, 635, 318, 637, 319, 639, 320, 641, 321, 643, 322, 645, 323, 647, 324, 649, 325, 651, 326, 653, 327, 655, 328, 657, 329, 659, 330, 661, 331, 663, 332, 665, 333, 667, 334, 669, 335, 671, 336, 673, 337, 675, 338, 677, 339, 679, 340, 681, 341, 683, 342, 685, 343, 687, 344, 689, 345, 691, 346, 693, 347, 695, 348, 697, 349, 699, 350, 701, 351, 703, 352, 705, 353, 707, 354, 709, 355, 711, 356, 713, 357, 715, 358, 717, 359, 719, 360, 721, 361, 723, 362, 725, 363, 727, 364, 729, 365, 731, 366, 733, 367, 735, 368, 737, 369, 739, 370, 741, 371, 743, 372, 745, 373, 747, 374, 749, 375, 751, 376, 753, 377, 755, 378, 757, 379, 759, 380, 761, 381, 763, 382, 765, 383, 767, 384, 769, 385, 771, 386, 773, 387, 775, 388, 777, 389, 779, 390, 781, 391, 783, 392, 785, 393, 787, 394, 789, 395, 791, 396, 793, 397, 795, 398, 797, 399, 799, 400, 801, 401, 803, 402, 805, 403, 807, 404, 809, 405, 811, 406, 813, 407, 815, 408, 817, 409, 819, 410, 821, 411, 823, 412, 825, 413, 827, 414, 829, 415, 831, 416, 833, 417, 835, 418, 837, 419, 839, 420, 841, 421, 843, 422, 845, 423, 847, 424, 849, 425, 851, 426, 853, 427, 855, 428, 857, 429, 859, 430, 861, 431, 863, 432, 865, 433, 867, 434, 869, 435, 871, 436, 873, 437, 875, 438, 877, 439, 879, 440, 881, 441, 883, 442, 885, 443, 887, 444, 889, 445, 891, 446, 893, 447, 895, 448, 897, 449, 899, 450, 901, 451, 903, 452, 905, 453, 907, 454, 909, 455, 911, 456, 913, 457, 915, 458, 917, 459, 919, 460, 921, 461, 923, 462, 925, 463, 927, 464, 929, 465, 931, 466, 933, 467, 935, 468, 937, 469, 939, 470, 941, 471, 943, 472, 945, 473, 947, 474, 949, 475, 951, 476, 953, 477, 955, 478, 957, 479, 959, 480, 961, 481, 963, 482, 965, 483, 967, 484, 969, 485, 971, 486, 973, 487, 975, 488, 977, 489, 979, 490, 981, 491, 983, 492, 985, 493, 987, 494, 989, 495, 991, 496, 993, 497, 995, 498, 997, 499, 999, 500, 1001, 501, 1003, 502, 1005, 503, 1007, 504, 1009, 505, 1011, 506, 1013, 507, 1015, 508, 1017, 509, 1019, 510, 1021, 511, 1023, 512, 1025, 513, 1027, 514, 1029, 515, 1031, 516, 1033, 517, 1035, 518, 1037, 519, 1039, 520, 1041, 521, 1043, 522, 1045, 523, 1047, 524, 1049, 525, 1051, 526, 1053, 527, 1055, 528, 1057, 529, 1059, 530, 1061, 531, 1063, 532, 1065, 533, 1067, 534, 1069, 535, 1071, 536, 1073, 537, 1075, 538, 1077, 539, 1079, 540, 1081, 541, 1083, 542, 1085, 543, 1087, 544, 1089, 545, 1091, 546, 1093, 547, 1095, 548, 1097, 549, 1099, 550, 1101, 551, 1103, 0, 1105, 0, 1107, 0, 1109, 0, 1111, 552, 1113, 553, 1115, 554, 1117, 555, 1119, 556, 1121, 557, 1123, 558, 1125, 559, 1127, 560, 1129, 561, 1131, 562, 1133, 563, 1135, 564, 1137, 565, 1139, 0, 1141, 0, 1143, 0, 1145, 0, 1147, 0, 1149, 0, 1151, 0, 1153, 0, 1155, 0, 1157, 0, 1159, 0, 1161, 0, 1163, 0, 1165, 0, 1167, 0, 1169, 0, 1171, 0, 1173, 0, 1175, 0, 1177, 0, 1179, 0, 1181, 0, 1183, 0, 1185, 0, 1187, 0, 1189, 0, 1, 0, 37, 3, 0, 9, 10, 12, 13, 32, 32, 2, 0, 48, 57, 65, 70, 3, 0, 10, 10, 13, 13, 34, 34, 3, 0, 10, 10, 13, 13, 39, 39, 2, 0, 71, 71, 78, 78, 1, 0, 48, 57, 2, 0, 69, 69, 101, 101, 3, 0, 48, 57, 65, 90, 97, 122, 2, 0, 45, 45, 95, 95, 3, 0, 10, 10, 13, 13, 125, 125, 2, 0, 10, 10, 13, 13, 4, 0, 9, 9, 12, 12, 32, 32, 59, 59, 2, 0, 65, 65, 97, 97, 2, 0, 66, 66, 98, 98, 2, 0, 67, 67, 99, 99, 2, 0, 68, 68, 100, 100, 2, 0, 70, 70, 102, 102, 2, 0, 71, 71, 103, 103, 2, 0, 72, 72, 104, 104, 2, 0, 73, 73, 105, 105, 2, 0, 74, 74, 106, 106, 2, 0, 75, 75, 107, 107, 2, 0, 76, 76, 108, 108, 2, 0, 77, 77, 109, 109, 2, 0, 78, 78, 110, 110, 2, 0, 79, 79, 111, 111, 2, 0, 80, 80, 112, 112, 2, 0, 81, 81, 113, 113, 2, 0, 82, 82, 114, 114, 2, 0, 83, 83, 115, 115, 2, 0, 84, 84, 116, 116, 2, 0, 85, 85, 117, 117, 2, 0, 86, 86, 118, 118, 2, 0, 87, 87, 119, 119, 2, 0, 88, 88, 120, 120, 2, 0, 89, 89, 121, 121, 2, 0, 90, 90, 122, 122, 5937, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, 0, 0, 0, 0, 253, 1, 0, 0, 0, 0, 255, 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, 0, 259, 1, 0, 0, 0, 0, 261, 1, 0, 0, 0, 0, 263, 1, 0, 0, 0, 0, 265, 1, 0, 0, 0, 0, 267, 1, 0, 0, 0, 0, 269, 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 273, 1, 0, 0, 0, 0, 275, 1, 0, 0, 0, 0, 277, 1, 0, 0, 0, 0, 279, 1, 0, 0, 0, 0, 281, 1, 0, 0, 0, 0, 283, 1, 0, 0, 0, 0, 285, 1, 0, 0, 0, 0, 287, 1, 0, 0, 0, 0, 289, 1, 0, 0, 0, 0, 291, 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, 0, 295, 1, 0, 0, 0, 0, 297, 1, 0, 0, 0, 0, 299, 1, 0, 0, 0, 0, 301, 1, 0, 0, 0, 0, 303, 1, 0, 0, 0, 0, 305, 1, 0, 0, 0, 0, 307, 1, 0, 0, 0, 0, 309, 1, 0, 0, 0, 0, 311, 1, 0, 0, 0, 0, 313, 1, 0, 0, 0, 0, 315, 1, 0, 0, 0, 0, 317, 1, 0, 0, 0, 0, 319, 1, 0, 0, 0, 0, 321, 1, 0, 0, 0, 0, 323, 1, 0, 0, 0, 0, 325, 1, 0, 0, 0, 0, 327, 1, 0, 0, 0, 0, 329, 1, 0, 0, 0, 0, 331, 1, 0, 0, 0, 0, 333, 1, 0, 0, 0, 0, 335, 1, 0, 0, 0, 0, 337, 1, 0, 0, 0, 0, 339, 1, 0, 0, 0, 0, 341, 1, 0, 0, 0, 0, 343, 1, 0, 0, 0, 0, 345, 1, 0, 0, 0, 0, 347, 1, 0, 0, 0, 0, 349, 1, 0, 0, 0, 0, 351, 1, 0, 0, 0, 0, 353, 1, 0, 0, 0, 0, 355, 1, 0, 0, 0, 0, 357, 1, 0, 0, 0, 0, 359, 1, 0, 0, 0, 0, 361, 1, 0, 0, 0, 0, 363, 1, 0, 0, 0, 0, 365, 1, 0, 0, 0, 0, 367, 1, 0, 0, 0, 0, 369, 1, 0, 0, 0, 0, 371, 1, 0, 0, 0, 0, 373, 1, 0, 0, 0, 0, 375, 1, 0, 0, 0, 0, 377, 1, 0, 0, 0, 0, 379, 1, 0, 0, 0, 0, 381, 1, 0, 0, 0, 0, 383, 1, 0, 0, 0, 0, 385, 1, 0, 0, 0, 0, 387, 1, 0, 0, 0, 0, 389, 1, 0, 0, 0, 0, 391, 1, 0, 0, 0, 0, 393, 1, 0, 0, 0, 0, 395, 1, 0, 0, 0, 0, 397, 1, 0, 0, 0, 0, 399, 1, 0, 0, 0, 0, 401, 1, 0, 0, 0, 0, 403, 1, 0, 0, 0, 0, 405, 1, 0, 0, 0, 0, 407, 1, 0, 0, 0, 0, 409, 1, 0, 0, 0, 0, 411, 1, 0, 0, 0, 0, 413, 1, 0, 0, 0, 0, 415, 1, 0, 0, 0, 0, 417, 1, 0, 0, 0, 0, 419, 1, 0, 0, 0, 0, 421, 1, 0, 0, 0, 0, 423, 1, 0, 0, 0, 0, 425, 1, 0, 0, 0, 0, 427, 1, 0, 0, 0, 0, 429, 1, 0, 0, 0, 0, 431, 1, 0, 0, 0, 0, 433, 1, 0, 0, 0, 0, 435, 1, 0, 0, 0, 0, 437, 1, 0, 0, 0, 0, 439, 1, 0, 0, 0, 0, 441, 1, 0, 0, 0, 0, 443, 1, 0, 0, 0, 0, 445, 1, 0, 0, 0, 0, 447, 1, 0, 0, 0, 0, 449, 1, 0, 0, 0, 0, 451, 1, 0, 0, 0, 0, 453, 1, 0, 0, 0, 0, 455, 1, 0, 0, 0, 0, 457, 1, 0, 0, 0, 0, 459, 1, 0, 0, 0, 0, 461, 1, 0, 0, 0, 0, 463, 1, 0, 0, 0, 0, 465, 1, 0, 0, 0, 0, 467, 1, 0, 0, 0, 0, 469, 1, 0, 0, 0, 0, 471, 1, 0, 0, 0, 0, 473, 1, 0, 0, 0, 0, 475, 1, 0, 0, 0, 0, 477, 1, 0, 0, 0, 0, 479, 1, 0, 0, 0, 0, 481, 1, 0, 0, 0, 0, 483, 1, 0, 0, 0, 0, 485, 1, 0, 0, 0, 0, 487, 1, 0, 0, 0, 0, 489, 1, 0, 0, 0, 0, 491, 1, 0, 0, 0, 0, 493, 1, 0, 0, 0, 0, 495, 1, 0, 0, 0, 0, 497, 1, 0, 0, 0, 0, 499, 1, 0, 0, 0, 0, 501, 1, 0, 0, 0, 0, 503, 1, 0, 0, 0, 0, 505, 1, 0, 0, 0, 0, 507, 1, 0, 0, 0, 0, 509, 1, 0, 0, 0, 0, 511, 1, 0, 0, 0, 0, 513, 1, 0, 0, 0, 0, 515, 1, 0, 0, 0, 0, 517, 1, 0, 0, 0, 0, 519, 1, 0, 0, 0, 0, 521, 1, 0, 0, 0, 0, 523, 1, 0, 0, 0, 0, 525, 1, 0, 0, 0, 0, 527, 1, 0, 0, 0, 0, 529, 1, 0, 0, 0, 0, 531, 1, 0, 0, 0, 0, 533, 1, 0, 0, 0, 0, 535, 1, 0, 0, 0, 0, 537, 1, 0, 0, 0, 0, 539, 1, 0, 0, 0, 0, 541, 1, 0, 0, 0, 0, 543, 1, 0, 0, 0, 0, 545, 1, 0, 0, 0, 0, 547, 1, 0, 0, 0, 0, 549, 1, 0, 0, 0, 0, 551, 1, 0, 0, 0, 0, 553, 1, 0, 0, 0, 0, 555, 1, 0, 0, 0, 0, 557, 1, 0, 0, 0, 0, 559, 1, 0, 0, 0, 0, 561, 1, 0, 0, 0, 0, 563, 1, 0, 0, 0, 0, 565, 1, 0, 0, 0, 0, 567, 1, 0, 0, 0, 0, 569, 1, 0, 0, 0, 0, 571, 1, 0, 0, 0, 0, 573, 1, 0, 0, 0, 0, 575, 1, 0, 0, 0, 0, 577, 1, 0, 0, 0, 0, 579, 1, 0, 0, 0, 0, 581, 1, 0, 0, 0, 0, 583, 1, 0, 0, 0, 0, 585, 1, 0, 0, 0, 0, 587, 1, 0, 0, 0, 0, 589, 1, 0, 0, 0, 0, 591, 1, 0, 0, 0, 0, 593, 1, 0, 0, 0, 0, 595, 1, 0, 0, 0, 0, 597, 1, 0, 0, 0, 0, 599, 1, 0, 0, 0, 0, 601, 1, 0, 0, 0, 0, 603, 1, 0, 0, 0, 0, 605, 1, 0, 0, 0, 0, 607, 1, 0, 0, 0, 0, 609, 1, 0, 0, 0, 0, 611, 1, 0, 0, 0, 0, 613, 1, 0, 0, 0, 0, 615, 1, 0, 0, 0, 0, 617, 1, 0, 0, 0, 0, 619, 1, 0, 0, 0, 0, 621, 1, 0, 0, 0, 0, 623, 1, 0, 0, 0, 0, 625, 1, 0, 0, 0, 0, 627, 1, 0, 0, 0, 0, 629, 1, 0, 0, 0, 0, 631, 1, 0, 0, 0, 0, 633, 1, 0, 0, 0, 0, 635, 1, 0, 0, 0, 0, 637, 1, 0, 0, 0, 0, 639, 1, 0, 0, 0, 0, 641, 1, 0, 0, 0, 0, 643, 1, 0, 0, 0, 0, 645, 1, 0, 0, 0, 0, 647, 1, 0, 0, 0, 0, 649, 1, 0, 0, 0, 0, 651, 1, 0, 0, 0, 0, 653, 1, 0, 0, 0, 0, 655, 1, 0, 0, 0, 0, 657, 1, 0, 0, 0, 0, 659, 1, 0, 0, 0, 0, 661, 1, 0, 0, 0, 0, 663, 1, 0, 0, 0, 0, 665, 1, 0, 0, 0, 0, 667, 1, 0, 0, 0, 0, 669, 1, 0, 0, 0, 0, 671, 1, 0, 0, 0, 0, 673, 1, 0, 0, 0, 0, 675, 1, 0, 0, 0, 0, 677, 1, 0, 0, 0, 0, 679, 1, 0, 0, 0, 0, 681, 1, 0, 0, 0, 0, 683, 1, 0, 0, 0, 0, 685, 1, 0, 0, 0, 0, 687, 1, 0, 0, 0, 0, 689, 1, 0, 0, 0, 0, 691, 1, 0, 0, 0, 0, 693, 1, 0, 0, 0, 0, 695, 1, 0, 0, 0, 0, 697, 1, 0, 0, 0, 0, 699, 1, 0, 0, 0, 0, 701, 1, 0, 0, 0, 0, 703, 1, 0, 0, 0, 0, 705, 1, 0, 0, 0, 0, 707, 1, 0, 0, 0, 0, 709, 1, 0, 0, 0, 0, 711, 1, 0, 0, 0, 0, 713, 1, 0, 0, 0, 0, 715, 1, 0, 0, 0, 0, 717, 1, 0, 0, 0, 0, 719, 1, 0, 0, 0, 0, 721, 1, 0, 0, 0, 0, 723, 1, 0, 0, 0, 0, 725, 1, 0, 0, 0, 0, 727, 1, 0, 0, 0, 0, 729, 1, 0, 0, 0, 0, 731, 1, 0, 0, 0, 0, 733, 1, 0, 0, 0, 0, 735, 1, 0, 0, 0, 0, 737, 1, 0, 0, 0, 0, 739, 1, 0, 0, 0, 0, 741, 1, 0, 0, 0, 0, 743, 1, 0, 0, 0, 0, 745, 1, 0, 0, 0, 0, 747, 1, 0, 0, 0, 0, 749, 1, 0, 0, 0, 0, 751, 1, 0, 0, 0, 0, 753, 1, 0, 0, 0, 0, 755, 1, 0, 0, 0, 0, 757, 1, 0, 0, 0, 0, 759, 1, 0, 0, 0, 0, 761, 1, 0, 0, 0, 0, 763, 1, 0, 0, 0, 0, 765, 1, 0, 0, 0, 0, 767, 1, 0, 0, 0, 0, 769, 1, 0, 0, 0, 0, 771, 1, 0, 0, 0, 0, 773, 1, 0, 0, 0, 0, 775, 1, 0, 0, 0, 0, 777, 1, 0, 0, 0, 0, 779, 1, 0, 0, 0, 0, 781, 1, 0, 0, 0, 0, 783, 1, 0, 0, 0, 0, 785, 1, 0, 0, 0, 0, 787, 1, 0, 0, 0, 0, 789, 1, 0, 0, 0, 0, 791, 1, 0, 0, 0, 0, 793, 1, 0, 0, 0, 0, 795, 1, 0, 0, 0, 0, 797, 1, 0, 0, 0, 0, 799, 1, 0, 0, 0, 0, 801, 1, 0, 0, 0, 0, 803, 1, 0, 0, 0, 0, 805, 1, 0, 0, 0, 0, 807, 1, 0, 0, 0, 0, 809, 1, 0, 0, 0, 0, 811, 1, 0, 0, 0, 0, 813, 1, 0, 0, 0, 0, 815, 1, 0, 0, 0, 0, 817, 1, 0, 0, 0, 0, 819, 1, 0, 0, 0, 0, 821, 1, 0, 0, 0, 0, 823, 1, 0, 0, 0, 0, 825, 1, 0, 0, 0, 0, 827, 1, 0, 0, 0, 0, 829, 1, 0, 0, 0, 0, 831, 1, 0, 0, 0, 0, 833, 1, 0, 0, 0, 0, 835, 1, 0, 0, 0, 0, 837, 1, 0, 0, 0, 0, 839, 1, 0, 0, 0, 0, 841, 1, 0, 0, 0, 0, 843, 1, 0, 0, 0, 0, 845, 1, 0, 0, 0, 0, 847, 1, 0, 0, 0, 0, 849, 1, 0, 0, 0, 0, 851, 1, 0, 0, 0, 0, 853, 1, 0, 0, 0, 0, 855, 1, 0, 0, 0, 0, 857, 1, 0, 0, 0, 0, 859, 1, 0, 0, 0, 0, 861, 1, 0, 0, 0, 0, 863, 1, 0, 0, 0, 0, 865, 1, 0, 0, 0, 0, 867, 1, 0, 0, 0, 0, 869, 1, 0, 0, 0, 0, 871, 1, 0, 0, 0, 0, 873, 1, 0, 0, 0, 0, 875, 1, 0, 0, 0, 0, 877, 1, 0, 0, 0, 0, 879, 1, 0, 0, 0, 0, 881, 1, 0, 0, 0, 0, 883, 1, 0, 0, 0, 0, 885, 1, 0, 0, 0, 0, 887, 1, 0, 0, 0, 0, 889, 1, 0, 0, 0, 0, 891, 1, 0, 0, 0, 0, 893, 1, 0, 0, 0, 0, 895, 1, 0, 0, 0, 0, 897, 1, 0, 0, 0, 0, 899, 1, 0, 0, 0, 0, 901, 1, 0, 0, 0, 0, 903, 1, 0, 0, 0, 0, 905, 1, 0, 0, 0, 0, 907, 1, 0, 0, 0, 0, 909, 1, 0, 0, 0, 0, 911, 1, 0, 0, 0, 0, 913, 1, 0, 0, 0, 0, 915, 1, 0, 0, 0, 0, 917, 1, 0, 0, 0, 0, 919, 1, 0, 0, 0, 0, 921, 1, 0, 0, 0, 0, 923, 1, 0, 0, 0, 0, 925, 1, 0, 0, 0, 0, 927, 1, 0, 0, 0, 0, 929, 1, 0, 0, 0, 0, 931, 1, 0, 0, 0, 0, 933, 1, 0, 0, 0, 0, 935, 1, 0, 0, 0, 0, 937, 1, 0, 0, 0, 0, 939, 1, 0, 0, 0, 0, 941, 1, 0, 0, 0, 0, 943, 1, 0, 0, 0, 0, 945, 1, 0, 0, 0, 0, 947, 1, 0, 0, 0, 0, 949, 1, 0, 0, 0, 0, 951, 1, 0, 0, 0, 0, 953, 1, 0, 0, 0, 0, 955, 1, 0, 0, 0, 0, 957, 1, 0, 0, 0, 0, 959, 1, 0, 0, 0, 0, 961, 1, 0, 0, 0, 0, 963, 1, 0, 0, 0, 0, 965, 1, 0, 0, 0, 0, 967, 1, 0, 0, 0, 0, 969, 1, 0, 0, 0, 0, 971, 1, 0, 0, 0, 0, 973, 1, 0, 0, 0, 0, 975, 1, 0, 0, 0, 0, 977, 1, 0, 0, 0, 0, 979, 1, 0, 0, 0, 0, 981, 1, 0, 0, 0, 0, 983, 1, 0, 0, 0, 0, 985, 1, 0, 0, 0, 0, 987, 1, 0, 0, 0, 0, 989, 1, 0, 0, 0, 0, 991, 1, 0, 0, 0, 0, 993, 1, 0, 0, 0, 0, 995, 1, 0, 0, 0, 0, 997, 1, 0, 0, 0, 0, 999, 1, 0, 0, 0, 0, 1001, 1, 0, 0, 0, 0, 1003, 1, 0, 0, 0, 0, 1005, 1, 0, 0, 0, 0, 1007, 1, 0, 0, 0, 0, 1009, 1, 0, 0, 0, 0, 1011, 1, 0, 0, 0, 0, 1013, 1, 0, 0, 0, 0, 1015, 1, 0, 0, 0, 0, 1017, 1, 0, 0, 0, 0, 1019, 1, 0, 0, 0, 0, 1021, 1, 0, 0, 0, 0, 1023, 1, 0, 0, 0, 0, 1025, 1, 0, 0, 0, 0, 1027, 1, 0, 0, 0, 0, 1029, 1, 0, 0, 0, 0, 1031, 1, 0, 0, 0, 0, 1033, 1, 0, 0, 0, 0, 1035, 1, 0, 0, 0, 0, 1037, 1, 0, 0, 0, 0, 1039, 1, 0, 0, 0, 0, 1041, 1, 0, 0, 0, 0, 1043, 1, 0, 0, 0, 0, 1045, 1, 0, 0, 0, 0, 1047, 1, 0, 0, 0, 0, 1049, 1, 0, 0, 0, 0, 1051, 1, 0, 0, 0, 0, 1053, 1, 0, 0, 0, 0, 1055, 1, 0, 0, 0, 0, 1057, 1, 0, 0, 0, 0, 1059, 1, 0, 0, 0, 0, 1061, 1, 0, 0, 0, 0, 1063, 1, 0, 0, 0, 0, 1065, 1, 0, 0, 0, 0, 1067, 1, 0, 0, 0, 0, 1069, 1, 0, 0, 0, 0, 1071, 1, 0, 0, 0, 0, 1073, 1, 0, 0, 0, 0, 1075, 1, 0, 0, 0, 0, 1077, 1, 0, 0, 0, 0, 1079, 1, 0, 0, 0, 0, 1081, 1, 0, 0, 0, 0, 1083, 1, 0, 0, 0, 0, 1085, 1, 0, 0, 0, 0, 1087, 1, 0, 0, 0, 0, 1089, 1, 0, 0, 0, 0, 1091, 1, 0, 0, 0, 0, 1093, 1, 0, 0, 0, 0, 1095, 1, 0, 0, 0, 0, 1097, 1, 0, 0, 0, 0, 1099, 1, 0, 0, 0, 0, 1101, 1, 0, 0, 0, 0, 1111, 1, 0, 0, 0, 0, 1113, 1, 0, 0, 0, 0, 1115, 1, 0, 0, 0, 0, 1117, 1, 0, 0, 0, 0, 1119, 1, 0, 0, 0, 0, 1121, 1, 0, 0, 0, 0, 1123, 1, 0, 0, 0, 0, 1125, 1, 0, 0, 0, 0, 1127, 1, 0, 0, 0, 0, 1129, 1, 0, 0, 0, 0, 1131, 1, 0, 0, 0, 0, 1133, 1, 0, 0, 0, 0, 1135, 1, 0, 0, 0, 0, 1137, 1, 0, 0, 0, 1, 1191, 1, 0, 0, 0, 3, 1197, 1, 0, 0, 0, 5, 1204, 1, 0, 0, 0, 7, 1211, 1, 0, 0, 0, 9, 1215, 1, 0, 0, 0, 11, 1223, 1, 0, 0, 0, 13, 1233, 1, 0, 0, 0, 15, 1239, 1, 0, 0, 0, 17, 1247, 1, 0, 0, 0, 19, 1251, 1, 0, 0, 0, 21, 1260, 1, 0, 0, 0, 23, 1271, 1, 0, 0, 0, 25, 1288, 1, 0, 0, 0, 27, 1305, 1, 0, 0, 0, 29, 1318, 1, 0, 0, 0, 31, 1338, 1, 0, 0, 0, 33, 1343, 1, 0, 0, 0, 35, 1349, 1, 0, 0, 0, 37, 1359, 1, 0, 0, 0, 39, 1363, 1, 0, 0, 0, 41, 1367, 1, 0, 0, 0, 43, 1371, 1, 0, 0, 0, 45, 1376, 1, 0, 0, 0, 47, 1382, 1, 0, 0, 0, 49, 1385, 1, 0, 0, 0, 51, 1395, 1, 0, 0, 0, 53, 1401, 1, 0, 0, 0, 55, 1408, 1, 0, 0, 0, 57, 1424, 1, 0, 0, 0, 59, 1447, 1, 0, 0, 0, 61, 1450, 1, 0, 0, 0, 63, 1460, 1, 0, 0, 0, 65, 1467, 1, 0, 0, 0, 67, 1472, 1, 0, 0, 0, 69, 1482, 1, 0, 0, 0, 71, 1499, 1, 0, 0, 0, 73, 1517, 1, 0, 0, 0, 75, 1523, 1, 0, 0, 0, 77, 1528, 1, 0, 0, 0, 79, 1535, 1, 0, 0, 0, 81, 1545, 1, 0, 0, 0, 83, 1550, 1, 0, 0, 0, 85, 1557, 1, 0, 0, 0, 87, 1561, 1, 0, 0, 0, 89, 1567, 1, 0, 0, 0, 91, 1573, 1, 0, 0, 0, 93, 1579, 1, 0, 0, 0, 95, 1586, 1, 0, 0, 0, 97, 1593, 1, 0, 0, 0, 99, 1596, 1, 0, 0, 0, 101, 1607, 1, 0, 0, 0, 103, 1615, 1, 0, 0, 0, 105, 1620, 1, 0, 0, 0, 107, 1627, 1, 0, 0, 0, 109, 1635, 1, 0, 0, 0, 111, 1646, 1, 0, 0, 0, 113, 1649, 1, 0, 0, 0, 115, 1652, 1, 0, 0, 0, 117, 1655, 1, 0, 0, 0, 119, 1664, 1, 0, 0, 0, 121, 1672, 1, 0, 0, 0, 123, 1680, 1, 0, 0, 0, 125, 1690, 1, 0, 0, 0, 127, 1701, 1, 0, 0, 0, 129, 1707, 1, 0, 0, 0, 131, 1716, 1, 0, 0, 0, 133, 1728, 1, 0, 0, 0, 135, 1734, 1, 0, 0, 0, 137, 1752, 1, 0, 0, 0, 139, 1758, 1, 0, 0, 0, 141, 1763, 1, 0, 0, 0, 143, 1772, 1, 0, 0, 0, 145, 1782, 1, 0, 0, 0, 147, 1786, 1, 0, 0, 0, 149, 1793, 1, 0, 0, 0, 151, 1801, 1, 0, 0, 0, 153, 1807, 1, 0, 0, 0, 155, 1818, 1, 0, 0, 0, 157, 1825, 1, 0, 0, 0, 159, 1839, 1, 0, 0, 0, 161, 1844, 1, 0, 0, 0, 163, 1851, 1, 0, 0, 0, 165, 1858, 1, 0, 0, 0, 167, 1865, 1, 0, 0, 0, 169, 1872, 1, 0, 0, 0, 171, 1879, 1, 0, 0, 0, 173, 1893, 1, 0, 0, 0, 175, 1909, 1, 0, 0, 0, 177, 1925, 1, 0, 0, 0, 179, 1941, 1, 0, 0, 0, 181, 1957, 1, 0, 0, 0, 183, 1973, 1, 0, 0, 0, 185, 1981, 1, 0, 0, 0, 187, 1995, 1, 0, 0, 0, 189, 2004, 1, 0, 0, 0, 191, 2012, 1, 0, 0, 0, 193, 2021, 1, 0, 0, 0, 195, 2029, 1, 0, 0, 0, 197, 2043, 1, 0, 0, 0, 199, 2052, 1, 0, 0, 0, 201, 2063, 1, 0, 0, 0, 203, 2074, 1, 0, 0, 0, 205, 2079, 1, 0, 0, 0, 207, 2084, 1, 0, 0, 0, 209, 2098, 1, 0, 0, 0, 211, 2104, 1, 0, 0, 0, 213, 2111, 1, 0, 0, 0, 215, 2120, 1, 0, 0, 0, 217, 2127, 1, 0, 0, 0, 219, 2132, 1, 0, 0, 0, 221, 2142, 1, 0, 0, 0, 223, 2147, 1, 0, 0, 0, 225, 2161, 1, 0, 0, 0, 227, 2174, 1, 0, 0, 0, 229, 2178, 1, 0, 0, 0, 231, 2190, 1, 0, 0, 0, 233, 2195, 1, 0, 0, 0, 235, 2198, 1, 0, 0, 0, 237, 2213, 1, 0, 0, 0, 239, 2224, 1, 0, 0, 0, 241, 2235, 1, 0, 0, 0, 243, 2246, 1, 0, 0, 0, 245, 2258, 1, 0, 0, 0, 247, 2270, 1, 0, 0, 0, 249, 2282, 1, 0, 0, 0, 251, 2292, 1, 0, 0, 0, 253, 2306, 1, 0, 0, 0, 255, 2319, 1, 0, 0, 0, 257, 2327, 1, 0, 0, 0, 259, 2343, 1, 0, 0, 0, 261, 2354, 1, 0, 0, 0, 263, 2361, 1, 0, 0, 0, 265, 2371, 1, 0, 0, 0, 267, 2381, 1, 0, 0, 0, 269, 2391, 1, 0, 0, 0, 271, 2402, 1, 0, 0, 0, 273, 2414, 1, 0, 0, 0, 275, 2421, 1, 0, 0, 0, 277, 2429, 1, 0, 0, 0, 279, 2438, 1, 0, 0, 0, 281, 2446, 1, 0, 0, 0, 283, 2451, 1, 0, 0, 0, 285, 2459, 1, 0, 0, 0, 287, 2469, 1, 0, 0, 0, 289, 2476, 1, 0, 0, 0, 291, 2485, 1, 0, 0, 0, 293, 2494, 1, 0, 0, 0, 295, 2501, 1, 0, 0, 0, 297, 2506, 1, 0, 0, 0, 299, 2517, 1, 0, 0, 0, 301, 2525, 1, 0, 0, 0, 303, 2532, 1, 0, 0, 0, 305, 2537, 1, 0, 0, 0, 307, 2541, 1, 0, 0, 0, 309, 2546, 1, 0, 0, 0, 311, 2550, 1, 0, 0, 0, 313, 2562, 1, 0, 0, 0, 315, 2569, 1, 0, 0, 0, 317, 2573, 1, 0, 0, 0, 319, 2584, 1, 0, 0, 0, 321, 2592, 1, 0, 0, 0, 323, 2601, 1, 0, 0, 0, 325, 2613, 1, 0, 0, 0, 327, 2624, 1, 0, 0, 0, 329, 2635, 1, 0, 0, 0, 331, 2648, 1, 0, 0, 0, 333, 2655, 1, 0, 0, 0, 335, 2668, 1, 0, 0, 0, 337, 2680, 1, 0, 0, 0, 339, 2692, 1, 0, 0, 0, 341, 2701, 1, 0, 0, 0, 343, 2713, 1, 0, 0, 0, 345, 2724, 1, 0, 0, 0, 347, 2736, 1, 0, 0, 0, 349, 2747, 1, 0, 0, 0, 351, 2757, 1, 0, 0, 0, 353, 2768, 1, 0, 0, 0, 355, 2781, 1, 0, 0, 0, 357, 2794, 1, 0, 0, 0, 359, 2804, 1, 0, 0, 0, 361, 2811, 1, 0, 0, 0, 363, 2817, 1, 0, 0, 0, 365, 2823, 1, 0, 0, 0, 367, 2839, 1, 0, 0, 0, 369, 2851, 1, 0, 0, 0, 371, 2855, 1, 0, 0, 0, 373, 2861, 1, 0, 0, 0, 375, 2867, 1, 0, 0, 0, 377, 2873, 1, 0, 0, 0, 379, 2877, 1, 0, 0, 0, 381, 2881, 1, 0, 0, 0, 383, 2888, 1, 0, 0, 0, 385, 2892, 1, 0, 0, 0, 387, 2901, 1, 0, 0, 0, 389, 2907, 1, 0, 0, 0, 391, 2913, 1, 0, 0, 0, 393, 2923, 1, 0, 0, 0, 395, 2933, 1, 0, 0, 0, 397, 2941, 1, 0, 0, 0, 399, 2946, 1, 0, 0, 0, 401, 2953, 1, 0, 0, 0, 403, 2960, 1, 0, 0, 0, 405, 2969, 1, 0, 0, 0, 407, 2978, 1, 0, 0, 0, 409, 2984, 1, 0, 0, 0, 411, 2987, 1, 0, 0, 0, 413, 2992, 1, 0, 0, 0, 415, 3005, 1, 0, 0, 0, 417, 3012, 1, 0, 0, 0, 419, 3018, 1, 0, 0, 0, 421, 3024, 1, 0, 0, 0, 423, 3032, 1, 0, 0, 0, 425, 3036, 1, 0, 0, 0, 427, 3053, 1, 0, 0, 0, 429, 3071, 1, 0, 0, 0, 431, 3076, 1, 0, 0, 0, 433, 3081, 1, 0, 0, 0, 435, 3090, 1, 0, 0, 0, 437, 3103, 1, 0, 0, 0, 439, 3120, 1, 0, 0, 0, 441, 3129, 1, 0, 0, 0, 443, 3136, 1, 0, 0, 0, 445, 3143, 1, 0, 0, 0, 447, 3150, 1, 0, 0, 0, 449, 3153, 1, 0, 0, 0, 451, 3161, 1, 0, 0, 0, 453, 3166, 1, 0, 0, 0, 455, 3172, 1, 0, 0, 0, 457, 3180, 1, 0, 0, 0, 459, 3190, 1, 0, 0, 0, 461, 3201, 1, 0, 0, 0, 463, 3213, 1, 0, 0, 0, 465, 3217, 1, 0, 0, 0, 467, 3229, 1, 0, 0, 0, 469, 3232, 1, 0, 0, 0, 471, 3247, 1, 0, 0, 0, 473, 3250, 1, 0, 0, 0, 475, 3259, 1, 0, 0, 0, 477, 3266, 1, 0, 0, 0, 479, 3269, 1, 0, 0, 0, 481, 3275, 1, 0, 0, 0, 483, 3283, 1, 0, 0, 0, 485, 3292, 1, 0, 0, 0, 487, 3300, 1, 0, 0, 0, 489, 3311, 1, 0, 0, 0, 491, 3320, 1, 0, 0, 0, 493, 3326, 1, 0, 0, 0, 495, 3339, 1, 0, 0, 0, 497, 3347, 1, 0, 0, 0, 499, 3360, 1, 0, 0, 0, 501, 3368, 1, 0, 0, 0, 503, 3373, 1, 0, 0, 0, 505, 3381, 1, 0, 0, 0, 507, 3388, 1, 0, 0, 0, 509, 3391, 1, 0, 0, 0, 511, 3396, 1, 0, 0, 0, 513, 3406, 1, 0, 0, 0, 515, 3412, 1, 0, 0, 0, 517, 3417, 1, 0, 0, 0, 519, 3421, 1, 0, 0, 0, 521, 3430, 1, 0, 0, 0, 523, 3436, 1, 0, 0, 0, 525, 3445, 1, 0, 0, 0, 527, 3450, 1, 0, 0, 0, 529, 3453, 1, 0, 0, 0, 531, 3456, 1, 0, 0, 0, 533, 3464, 1, 0, 0, 0, 535, 3469, 1, 0, 0, 0, 537, 3478, 1, 0, 0, 0, 539, 3485, 1, 0, 0, 0, 541, 3498, 1, 0, 0, 0, 543, 3503, 1, 0, 0, 0, 545, 3513, 1, 0, 0, 0, 547, 3526, 1, 0, 0, 0, 549, 3534, 1, 0, 0, 0, 551, 3540, 1, 0, 0, 0, 553, 3547, 1, 0, 0, 0, 555, 3554, 1, 0, 0, 0, 557, 3569, 1, 0, 0, 0, 559, 3574, 1, 0, 0, 0, 561, 3580, 1, 0, 0, 0, 563, 3593, 1, 0, 0, 0, 565, 3601, 1, 0, 0, 0, 567, 3606, 1, 0, 0, 0, 569, 3612, 1, 0, 0, 0, 571, 3626, 1, 0, 0, 0, 573, 3631, 1, 0, 0, 0, 575, 3641, 1, 0, 0, 0, 577, 3651, 1, 0, 0, 0, 579, 3657, 1, 0, 0, 0, 581, 3666, 1, 0, 0, 0, 583, 3676, 1, 0, 0, 0, 585, 3687, 1, 0, 0, 0, 587, 3694, 1, 0, 0, 0, 589, 3700, 1, 0, 0, 0, 591, 3708, 1, 0, 0, 0, 593, 3717, 1, 0, 0, 0, 595, 3722, 1, 0, 0, 0, 597, 3730, 1, 0, 0, 0, 599, 3742, 1, 0, 0, 0, 601, 3747, 1, 0, 0, 0, 603, 3756, 1, 0, 0, 0, 605, 3765, 1, 0, 0, 0, 607, 3771, 1, 0, 0, 0, 609, 3780, 1, 0, 0, 0, 611, 3796, 1, 0, 0, 0, 613, 3803, 1, 0, 0, 0, 615, 3812, 1, 0, 0, 0, 617, 3820, 1, 0, 0, 0, 619, 3825, 1, 0, 0, 0, 621, 3828, 1, 0, 0, 0, 623, 3836, 1, 0, 0, 0, 625, 3840, 1, 0, 0, 0, 627, 3845, 1, 0, 0, 0, 629, 3851, 1, 0, 0, 0, 631, 3858, 1, 0, 0, 0, 633, 3866, 1, 0, 0, 0, 635, 3879, 1, 0, 0, 0, 637, 3894, 1, 0, 0, 0, 639, 3907, 1, 0, 0, 0, 641, 3923, 1, 0, 0, 0, 643, 3930, 1, 0, 0, 0, 645, 3934, 1, 0, 0, 0, 647, 3937, 1, 0, 0, 0, 649, 3941, 1, 0, 0, 0, 651, 3949, 1, 0, 0, 0, 653, 3952, 1, 0, 0, 0, 655, 3957, 1, 0, 0, 0, 657, 3966, 1, 0, 0, 0, 659, 3969, 1, 0, 0, 0, 661, 3975, 1, 0, 0, 0, 663, 3983, 1, 0, 0, 0, 665, 3996, 1, 0, 0, 0, 667, 4002, 1, 0, 0, 0, 669, 4009, 1, 0, 0, 0, 671, 4018, 1, 0, 0, 0, 673, 4027, 1, 0, 0, 0, 675, 4031, 1, 0, 0, 0, 677, 4046, 1, 0, 0, 0, 679, 4054, 1, 0, 0, 0, 681, 4059, 1, 0, 0, 0, 683, 4072, 1, 0, 0, 0, 685, 4081, 1, 0, 0, 0, 687, 4089, 1, 0, 0, 0, 689, 4092, 1, 0, 0, 0, 691, 4095, 1, 0, 0, 0, 693, 4099, 1, 0, 0, 0, 695, 4107, 1, 0, 0, 0, 697, 4112, 1, 0, 0, 0, 699, 4120, 1, 0, 0, 0, 701, 4129, 1, 0, 0, 0, 703, 4138, 1, 0, 0, 0, 705, 4143, 1, 0, 0, 0, 707, 4151, 1, 0, 0, 0, 709, 4160, 1, 0, 0, 0, 711, 4168, 1, 0, 0, 0, 713, 4178, 1, 0, 0, 0, 715, 4196, 1, 0, 0, 0, 717, 4207, 1, 0, 0, 0, 719, 4215, 1, 0, 0, 0, 721, 4223, 1, 0, 0, 0, 723, 4231, 1, 0, 0, 0, 725, 4242, 1, 0, 0, 0, 727, 4258, 1, 0, 0, 0, 729, 4265, 1, 0, 0, 0, 731, 4271, 1, 0, 0, 0, 733, 4277, 1, 0, 0, 0, 735, 4283, 1, 0, 0, 0, 737, 4290, 1, 0, 0, 0, 739, 4297, 1, 0, 0, 0, 741, 4304, 1, 0, 0, 0, 743, 4311, 1, 0, 0, 0, 745, 4314, 1, 0, 0, 0, 747, 4319, 1, 0, 0, 0, 749, 4324, 1, 0, 0, 0, 751, 4332, 1, 0, 0, 0, 753, 4341, 1, 0, 0, 0, 755, 4348, 1, 0, 0, 0, 757, 4358, 1, 0, 0, 0, 759, 4366, 1, 0, 0, 0, 761, 4376, 1, 0, 0, 0, 763, 4386, 1, 0, 0, 0, 765, 4391, 1, 0, 0, 0, 767, 4395, 1, 0, 0, 0, 769, 4405, 1, 0, 0, 0, 771, 4416, 1, 0, 0, 0, 773, 4425, 1, 0, 0, 0, 775, 4433, 1, 0, 0, 0, 777, 4443, 1, 0, 0, 0, 779, 4451, 1, 0, 0, 0, 781, 4459, 1, 0, 0, 0, 783, 4466, 1, 0, 0, 0, 785, 4474, 1, 0, 0, 0, 787, 4482, 1, 0, 0, 0, 789, 4492, 1, 0, 0, 0, 791, 4499, 1, 0, 0, 0, 793, 4509, 1, 0, 0, 0, 795, 4517, 1, 0, 0, 0, 797, 4526, 1, 0, 0, 0, 799, 4532, 1, 0, 0, 0, 801, 4540, 1, 0, 0, 0, 803, 4554, 1, 0, 0, 0, 805, 4560, 1, 0, 0, 0, 807, 4567, 1, 0, 0, 0, 809, 4579, 1, 0, 0, 0, 811, 4589, 1, 0, 0, 0, 813, 4598, 1, 0, 0, 0, 815, 4605, 1, 0, 0, 0, 817, 4613, 1, 0, 0, 0, 819, 4616, 1, 0, 0, 0, 821, 4619, 1, 0, 0, 0, 823, 4625, 1, 0, 0, 0, 825, 4633, 1, 0, 0, 0, 827, 4637, 1, 0, 0, 0, 829, 4642, 1, 0, 0, 0, 831, 4647, 1, 0, 0, 0, 833, 4654, 1, 0, 0, 0, 835, 4657, 1, 0, 0, 0, 837, 4664, 1, 0, 0, 0, 839, 4672, 1, 0, 0, 0, 841, 4679, 1, 0, 0, 0, 843, 4688, 1, 0, 0, 0, 845, 4696, 1, 0, 0, 0, 847, 4710, 1, 0, 0, 0, 849, 4717, 1, 0, 0, 0, 851, 4722, 1, 0, 0, 0, 853, 4731, 1, 0, 0, 0, 855, 4740, 1, 0, 0, 0, 857, 4749, 1, 0, 0, 0, 859, 4760, 1, 0, 0, 0, 861, 4764, 1, 0, 0, 0, 863, 4771, 1, 0, 0, 0, 865, 4783, 1, 0, 0, 0, 867, 4799, 1, 0, 0, 0, 869, 4807, 1, 0, 0, 0, 871, 4816, 1, 0, 0, 0, 873, 4826, 1, 0, 0, 0, 875, 4837, 1, 0, 0, 0, 877, 4842, 1, 0, 0, 0, 879, 4847, 1, 0, 0, 0, 881, 4852, 1, 0, 0, 0, 883, 4865, 1, 0, 0, 0, 885, 4880, 1, 0, 0, 0, 887, 4895, 1, 0, 0, 0, 889, 4906, 1, 0, 0, 0, 891, 4919, 1, 0, 0, 0, 893, 4934, 1, 0, 0, 0, 895, 4946, 1, 0, 0, 0, 897, 4953, 1, 0, 0, 0, 899, 4969, 1, 0, 0, 0, 901, 4975, 1, 0, 0, 0, 903, 4982, 1, 0, 0, 0, 905, 4996, 1, 0, 0, 0, 907, 5005, 1, 0, 0, 0, 909, 5016, 1, 0, 0, 0, 911, 5027, 1, 0, 0, 0, 913, 5033, 1, 0, 0, 0, 915, 5040, 1, 0, 0, 0, 917, 5045, 1, 0, 0, 0, 919, 5052, 1, 0, 0, 0, 921, 5064, 1, 0, 0, 0, 923, 5076, 1, 0, 0, 0, 925, 5088, 1, 0, 0, 0, 927, 5097, 1, 0, 0, 0, 929, 5101, 1, 0, 0, 0, 931, 5110, 1, 0, 0, 0, 933, 5117, 1, 0, 0, 0, 935, 5126, 1, 0, 0, 0, 937, 5131, 1, 0, 0, 0, 939, 5144, 1, 0, 0, 0, 941, 5150, 1, 0, 0, 0, 943, 5156, 1, 0, 0, 0, 945, 5165, 1, 0, 0, 0, 947, 5170, 1, 0, 0, 0, 949, 5175, 1, 0, 0, 0, 951, 5184, 1, 0, 0, 0, 953, 5194, 1, 0, 0, 0, 955, 5199, 1, 0, 0, 0, 957, 5204, 1, 0, 0, 0, 959, 5209, 1, 0, 0, 0, 961, 5214, 1, 0, 0, 0, 963, 5221, 1, 0, 0, 0, 965, 5234, 1, 0, 0, 0, 967, 5242, 1, 0, 0, 0, 969, 5247, 1, 0, 0, 0, 971, 5252, 1, 0, 0, 0, 973, 5258, 1, 0, 0, 0, 975, 5264, 1, 0, 0, 0, 977, 5270, 1, 0, 0, 0, 979, 5273, 1, 0, 0, 0, 981, 5285, 1, 0, 0, 0, 983, 5297, 1, 0, 0, 0, 985, 5301, 1, 0, 0, 0, 987, 5310, 1, 0, 0, 0, 989, 5315, 1, 0, 0, 0, 991, 5325, 1, 0, 0, 0, 993, 5330, 1, 0, 0, 0, 995, 5338, 1, 0, 0, 0, 997, 5348, 1, 0, 0, 0, 999, 5353, 1, 0, 0, 0, 1001, 5362, 1, 0, 0, 0, 1003, 5368, 1, 0, 0, 0, 1005, 5371, 1, 0, 0, 0, 1007, 5376, 1, 0, 0, 0, 1009, 5382, 1, 0, 0, 0, 1011, 5386, 1, 0, 0, 0, 1013, 5392, 1, 0, 0, 0, 1015, 5398, 1, 0, 0, 0, 1017, 5405, 1, 0, 0, 0, 1019, 5413, 1, 0, 0, 0, 1021, 5421, 1, 0, 0, 0, 1023, 5426, 1, 0, 0, 0, 1025, 5431, 1, 0, 0, 0, 1027, 5445, 1, 0, 0, 0, 1029, 5450, 1, 0, 0, 0, 1031, 5456, 1, 0, 0, 0, 1033, 5472, 1, 0, 0, 0, 1035, 5478, 1, 0, 0, 0, 1037, 5483, 1, 0, 0, 0, 1039, 5492, 1, 0, 0, 0, 1041, 5500, 1, 0, 0, 0, 1043, 5505, 1, 0, 0, 0, 1045, 5515, 1, 0, 0, 0, 1047, 5521, 1, 0, 0, 0, 1049, 5528, 1, 0, 0, 0, 1051, 5530, 1, 0, 0, 0, 1053, 5532, 1, 0, 0, 0, 1055, 5535, 1, 0, 0, 0, 1057, 5537, 1, 0, 0, 0, 1059, 5539, 1, 0, 0, 0, 1061, 5544, 1, 0, 0, 0, 1063, 5547, 1, 0, 0, 0, 1065, 5549, 1, 0, 0, 0, 1067, 5559, 1, 0, 0, 0, 1069, 5561, 1, 0, 0, 0, 1071, 5563, 1, 0, 0, 0, 1073, 5565, 1, 0, 0, 0, 1075, 5576, 1, 0, 0, 0, 1077, 5586, 1, 0, 0, 0, 1079, 5599, 1, 0, 0, 0, 1081, 5601, 1, 0, 0, 0, 1083, 5604, 1, 0, 0, 0, 1085, 5606, 1, 0, 0, 0, 1087, 5608, 1, 0, 0, 0, 1089, 5610, 1, 0, 0, 0, 1091, 5613, 1, 0, 0, 0, 1093, 5616, 1, 0, 0, 0, 1095, 5618, 1, 0, 0, 0, 1097, 5620, 1, 0, 0, 0, 1099, 5622, 1, 0, 0, 0, 1101, 5628, 1, 0, 0, 0, 1103, 5648, 1, 0, 0, 0, 1105, 5676, 1, 0, 0, 0, 1107, 5700, 1, 0, 0, 0, 1109, 5726, 1, 0, 0, 0, 1111, 5728, 1, 0, 0, 0, 1113, 5731, 1, 0, 0, 0, 1115, 5734, 1, 0, 0, 0, 1117, 5739, 1, 0, 0, 0, 1119, 5748, 1, 0, 0, 0, 1121, 5778, 1, 0, 0, 0, 1123, 5798, 1, 0, 0, 0, 1125, 5804, 1, 0, 0, 0, 1127, 5814, 1, 0, 0, 0, 1129, 5824, 1, 0, 0, 0, 1131, 5834, 1, 0, 0, 0, 1133, 5842, 1, 0, 0, 0, 1135, 5853, 1, 0, 0, 0, 1137, 5859, 1, 0, 0, 0, 1139, 5864, 1, 0, 0, 0, 1141, 5866, 1, 0, 0, 0, 1143, 5868, 1, 0, 0, 0, 1145, 5870, 1, 0, 0, 0, 1147, 5872, 1, 0, 0, 0, 1149, 5874, 1, 0, 0, 0, 1151, 5876, 1, 0, 0, 0, 1153, 5878, 1, 0, 0, 0, 1155, 5880, 1, 0, 0, 0, 1157, 5882, 1, 0, 0, 0, 1159, 5884, 1, 0, 0, 0, 1161, 5886, 1, 0, 0, 0, 1163, 5888, 1, 0, 0, 0, 1165, 5890, 1, 0, 0, 0, 1167, 5892, 1, 0, 0, 0, 1169, 5894, 1, 0, 0, 0, 1171, 5896, 1, 0, 0, 0, 1173, 5898, 1, 0, 0, 0, 1175, 5900, 1, 0, 0, 0, 1177, 5902, 1, 0, 0, 0, 1179, 5904, 1, 0, 0, 0, 1181, 5906, 1, 0, 0, 0, 1183, 5908, 1, 0, 0, 0, 1185, 5910, 1, 0, 0, 0, 1187, 5912, 1, 0, 0, 0, 1189, 5914, 1, 0, 0, 0, 1191, 1192, 3, 1139, 569, 0, 1192, 1193, 3, 1141, 570, 0, 1193, 1194, 3, 1167, 583, 0, 1194, 1195, 3, 1173, 586, 0, 1195, 1196, 3, 1177, 588, 0, 1196, 2, 1, 0, 0, 0, 1197, 1198, 3, 1139, 569, 0, 1198, 1199, 3, 1143, 571, 0, 1199, 1200, 3, 1143, 571, 0, 1200, 1201, 3, 1147, 573, 0, 1201, 1202, 3, 1169, 584, 0, 1202, 1203, 3, 1177, 588, 0, 1203, 4, 1, 0, 0, 0, 1204, 1205, 3, 1139, 569, 0, 1205, 1206, 3, 1143, 571, 0, 1206, 1207, 3, 1143, 571, 0, 1207, 1208, 3, 1147, 573, 0, 1208, 1209, 3, 1175, 587, 0, 1209, 1210, 3, 1175, 587, 0, 1210, 6, 1, 0, 0, 0, 1211, 1212, 3, 1139, 569, 0, 1212, 1213, 3, 1145, 572, 0, 1213, 1214, 3, 1145, 572, 0, 1214, 8, 1, 0, 0, 0, 1215, 1216, 3, 1139, 569, 0, 1216, 1217, 3, 1145, 572, 0, 1217, 1218, 3, 1145, 572, 0, 1218, 1219, 3, 1173, 586, 0, 1219, 1220, 3, 1147, 573, 0, 1220, 1221, 3, 1175, 587, 0, 1221, 1222, 3, 1175, 587, 0, 1222, 10, 1, 0, 0, 0, 1223, 1224, 3, 1139, 569, 0, 1224, 1225, 3, 1145, 572, 0, 1225, 1226, 3, 1181, 590, 0, 1226, 1227, 3, 1139, 569, 0, 1227, 1228, 3, 1165, 582, 0, 1228, 1229, 3, 1143, 571, 0, 1229, 1230, 3, 1155, 577, 0, 1230, 1231, 3, 1165, 582, 0, 1231, 1232, 3, 1151, 575, 0, 1232, 12, 1, 0, 0, 0, 1233, 1234, 3, 1139, 569, 0, 1234, 1235, 3, 1149, 574, 0, 1235, 1236, 3, 1177, 588, 0, 1236, 1237, 3, 1147, 573, 0, 1237, 1238, 3, 1173, 586, 0, 1238, 14, 1, 0, 0, 0, 1239, 1240, 3, 1139, 569, 0, 1240, 1241, 3, 1161, 580, 0, 1241, 1242, 3, 1155, 577, 0, 1242, 1243, 3, 1151, 575, 0, 1243, 1244, 3, 1165, 582, 0, 1244, 1245, 3, 1147, 573, 0, 1245, 1246, 3, 1145, 572, 0, 1246, 16, 1, 0, 0, 0, 1247, 1248, 3, 1139, 569, 0, 1248, 1249, 3, 1161, 580, 0, 1249, 1250, 3, 1161, 580, 0, 1250, 18, 1, 0, 0, 0, 1251, 1252, 3, 1139, 569, 0, 1252, 1253, 3, 1161, 580, 0, 1253, 1254, 3, 1169, 584, 0, 1254, 1255, 3, 1153, 576, 0, 1255, 1256, 3, 1139, 569, 0, 1256, 1257, 3, 1141, 570, 0, 1257, 1258, 3, 1147, 573, 0, 1258, 1259, 3, 1177, 588, 0, 1259, 20, 1, 0, 0, 0, 1260, 1261, 3, 1139, 569, 0, 1261, 1262, 3, 1161, 580, 0, 1262, 1263, 3, 1169, 584, 0, 1263, 1264, 3, 1153, 576, 0, 1264, 1265, 3, 1139, 569, 0, 1265, 1266, 3, 1141, 570, 0, 1266, 1267, 3, 1147, 573, 0, 1267, 1268, 3, 1177, 588, 0, 1268, 1269, 3, 1155, 577, 0, 1269, 1270, 3, 1143, 571, 0, 1270, 22, 1, 0, 0, 0, 1271, 1272, 3, 1139, 569, 0, 1272, 1273, 3, 1161, 580, 0, 1273, 1274, 3, 1169, 584, 0, 1274, 1275, 3, 1153, 576, 0, 1275, 1276, 3, 1139, 569, 0, 1276, 1277, 3, 1141, 570, 0, 1277, 1278, 3, 1147, 573, 0, 1278, 1279, 3, 1177, 588, 0, 1279, 1280, 3, 1155, 577, 0, 1280, 1281, 3, 1143, 571, 0, 1281, 1282, 3, 1085, 542, 0, 1282, 1283, 3, 1161, 580, 0, 1283, 1284, 3, 1167, 583, 0, 1284, 1285, 3, 1183, 591, 0, 1285, 1286, 3, 1147, 573, 0, 1286, 1287, 3, 1173, 586, 0, 1287, 24, 1, 0, 0, 0, 1288, 1289, 3, 1139, 569, 0, 1289, 1290, 3, 1161, 580, 0, 1290, 1291, 3, 1169, 584, 0, 1291, 1292, 3, 1153, 576, 0, 1292, 1293, 3, 1139, 569, 0, 1293, 1294, 3, 1141, 570, 0, 1294, 1295, 3, 1147, 573, 0, 1295, 1296, 3, 1177, 588, 0, 1296, 1297, 3, 1155, 577, 0, 1297, 1298, 3, 1143, 571, 0, 1298, 1299, 3, 1085, 542, 0, 1299, 1300, 3, 1179, 589, 0, 1300, 1301, 3, 1169, 584, 0, 1301, 1302, 3, 1169, 584, 0, 1302, 1303, 3, 1147, 573, 0, 1303, 1304, 3, 1173, 586, 0, 1304, 26, 1, 0, 0, 0, 1305, 1306, 3, 1139, 569, 0, 1306, 1307, 3, 1161, 580, 0, 1307, 1308, 3, 1169, 584, 0, 1308, 1309, 3, 1153, 576, 0, 1309, 1310, 3, 1139, 569, 0, 1310, 1311, 3, 1165, 582, 0, 1311, 1312, 3, 1179, 589, 0, 1312, 1313, 3, 1163, 581, 0, 1313, 1314, 3, 1147, 573, 0, 1314, 1315, 3, 1173, 586, 0, 1315, 1316, 3, 1155, 577, 0, 1316, 1317, 3, 1143, 571, 0, 1317, 28, 1, 0, 0, 0, 1318, 1319, 3, 1139, 569, 0, 1319, 1320, 3, 1161, 580, 0, 1320, 1321, 3, 1169, 584, 0, 1321, 1322, 3, 1153, 576, 0, 1322, 1323, 3, 1139, 569, 0, 1323, 1324, 3, 1165, 582, 0, 1324, 1325, 3, 1179, 589, 0, 1325, 1326, 3, 1163, 581, 0, 1326, 1327, 3, 1147, 573, 0, 1327, 1328, 3, 1173, 586, 0, 1328, 1329, 3, 1155, 577, 0, 1329, 1330, 3, 1143, 571, 0, 1330, 1331, 3, 1085, 542, 0, 1331, 1332, 3, 1147, 573, 0, 1332, 1333, 3, 1145, 572, 0, 1333, 1334, 3, 1155, 577, 0, 1334, 1335, 3, 1177, 588, 0, 1335, 1336, 3, 1147, 573, 0, 1336, 1337, 3, 1145, 572, 0, 1337, 30, 1, 0, 0, 0, 1338, 1339, 3, 1139, 569, 0, 1339, 1340, 3, 1161, 580, 0, 1340, 1341, 3, 1175, 587, 0, 1341, 1342, 3, 1167, 583, 0, 1342, 32, 1, 0, 0, 0, 1343, 1344, 3, 1139, 569, 0, 1344, 1345, 3, 1161, 580, 0, 1345, 1346, 3, 1177, 588, 0, 1346, 1347, 3, 1147, 573, 0, 1347, 1348, 3, 1173, 586, 0, 1348, 34, 1, 0, 0, 0, 1349, 1350, 3, 1139, 569, 0, 1350, 1351, 3, 1161, 580, 0, 1351, 1352, 3, 1177, 588, 0, 1352, 1353, 3, 1147, 573, 0, 1353, 1354, 3, 1173, 586, 0, 1354, 1355, 3, 1165, 582, 0, 1355, 1356, 3, 1139, 569, 0, 1356, 1357, 3, 1177, 588, 0, 1357, 1358, 3, 1147, 573, 0, 1358, 36, 1, 0, 0, 0, 1359, 1360, 3, 1139, 569, 0, 1360, 1361, 3, 1165, 582, 0, 1361, 1362, 3, 1145, 572, 0, 1362, 38, 1, 0, 0, 0, 1363, 1364, 3, 1139, 569, 0, 1364, 1365, 3, 1165, 582, 0, 1365, 1366, 3, 1187, 593, 0, 1366, 40, 1, 0, 0, 0, 1367, 1368, 3, 1139, 569, 0, 1368, 1369, 3, 1173, 586, 0, 1369, 1370, 3, 1147, 573, 0, 1370, 42, 1, 0, 0, 0, 1371, 1372, 3, 1139, 569, 0, 1372, 1373, 3, 1173, 586, 0, 1373, 1374, 3, 1147, 573, 0, 1374, 1375, 3, 1139, 569, 0, 1375, 44, 1, 0, 0, 0, 1376, 1377, 3, 1139, 569, 0, 1377, 1378, 3, 1173, 586, 0, 1378, 1379, 3, 1147, 573, 0, 1379, 1380, 3, 1139, 569, 0, 1380, 1381, 3, 1175, 587, 0, 1381, 46, 1, 0, 0, 0, 1382, 1383, 3, 1139, 569, 0, 1383, 1384, 3, 1175, 587, 0, 1384, 48, 1, 0, 0, 0, 1385, 1386, 3, 1139, 569, 0, 1386, 1387, 3, 1175, 587, 0, 1387, 1388, 3, 1143, 571, 0, 1388, 1389, 3, 1147, 573, 0, 1389, 1390, 3, 1165, 582, 0, 1390, 1391, 3, 1145, 572, 0, 1391, 1392, 3, 1155, 577, 0, 1392, 1393, 3, 1165, 582, 0, 1393, 1394, 3, 1151, 575, 0, 1394, 50, 1, 0, 0, 0, 1395, 1396, 3, 1139, 569, 0, 1396, 1397, 3, 1175, 587, 0, 1397, 1398, 3, 1143, 571, 0, 1398, 1399, 3, 1155, 577, 0, 1399, 1400, 3, 1155, 577, 0, 1400, 52, 1, 0, 0, 0, 1401, 1402, 3, 1139, 569, 0, 1402, 1403, 3, 1175, 587, 0, 1403, 1404, 3, 1175, 587, 0, 1404, 1405, 3, 1155, 577, 0, 1405, 1406, 3, 1151, 575, 0, 1406, 1407, 3, 1165, 582, 0, 1407, 54, 1, 0, 0, 0, 1408, 1409, 3, 1139, 569, 0, 1409, 1410, 3, 1175, 587, 0, 1410, 1411, 3, 1175, 587, 0, 1411, 1412, 3, 1167, 583, 0, 1412, 1413, 3, 1143, 571, 0, 1413, 1414, 3, 1155, 577, 0, 1414, 1415, 3, 1139, 569, 0, 1415, 1416, 3, 1177, 588, 0, 1416, 1417, 3, 1147, 573, 0, 1417, 1418, 3, 1145, 572, 0, 1418, 1419, 3, 1085, 542, 0, 1419, 1420, 3, 1145, 572, 0, 1420, 1421, 3, 1139, 569, 0, 1421, 1422, 3, 1177, 588, 0, 1422, 1423, 3, 1139, 569, 0, 1423, 56, 1, 0, 0, 0, 1424, 1425, 3, 1139, 569, 0, 1425, 1426, 3, 1175, 587, 0, 1426, 1427, 3, 1175, 587, 0, 1427, 1428, 3, 1167, 583, 0, 1428, 1429, 3, 1143, 571, 0, 1429, 1430, 3, 1155, 577, 0, 1430, 1431, 3, 1139, 569, 0, 1431, 1432, 3, 1177, 588, 0, 1432, 1433, 3, 1147, 573, 0, 1433, 1434, 3, 1145, 572, 0, 1434, 1435, 3, 1085, 542, 0, 1435, 1436, 3, 1145, 572, 0, 1436, 1437, 3, 1139, 569, 0, 1437, 1438, 3, 1177, 588, 0, 1438, 1439, 3, 1139, 569, 0, 1439, 1440, 3, 1085, 542, 0, 1440, 1441, 3, 1161, 580, 0, 1441, 1442, 3, 1147, 573, 0, 1442, 1443, 3, 1165, 582, 0, 1443, 1444, 3, 1151, 575, 0, 1444, 1445, 3, 1177, 588, 0, 1445, 1446, 3, 1153, 576, 0, 1446, 58, 1, 0, 0, 0, 1447, 1448, 3, 1139, 569, 0, 1448, 1449, 3, 1177, 588, 0, 1449, 60, 1, 0, 0, 0, 1450, 1451, 3, 1139, 569, 0, 1451, 1452, 3, 1177, 588, 0, 1452, 1453, 3, 1177, 588, 0, 1453, 1454, 3, 1173, 586, 0, 1454, 1455, 3, 1155, 577, 0, 1455, 1456, 3, 1141, 570, 0, 1456, 1457, 3, 1179, 589, 0, 1457, 1458, 3, 1177, 588, 0, 1458, 1459, 3, 1147, 573, 0, 1459, 62, 1, 0, 0, 0, 1460, 1461, 3, 1139, 569, 0, 1461, 1462, 3, 1179, 589, 0, 1462, 1463, 3, 1177, 588, 0, 1463, 1464, 3, 1153, 576, 0, 1464, 1465, 3, 1167, 583, 0, 1465, 1466, 3, 1173, 586, 0, 1466, 64, 1, 0, 0, 0, 1467, 1468, 3, 1139, 569, 0, 1468, 1469, 3, 1179, 589, 0, 1469, 1470, 3, 1177, 588, 0, 1470, 1471, 3, 1167, 583, 0, 1471, 66, 1, 0, 0, 0, 1472, 1473, 3, 1139, 569, 0, 1473, 1474, 3, 1179, 589, 0, 1474, 1475, 3, 1177, 588, 0, 1475, 1476, 3, 1167, 583, 0, 1476, 1477, 3, 1085, 542, 0, 1477, 1478, 3, 1175, 587, 0, 1478, 1479, 3, 1159, 579, 0, 1479, 1480, 3, 1155, 577, 0, 1480, 1481, 3, 1169, 584, 0, 1481, 68, 1, 0, 0, 0, 1482, 1483, 3, 1141, 570, 0, 1483, 1484, 3, 1139, 569, 0, 1484, 1485, 3, 1143, 571, 0, 1485, 1486, 3, 1159, 579, 0, 1486, 1487, 3, 1151, 575, 0, 1487, 1488, 3, 1173, 586, 0, 1488, 1489, 3, 1167, 583, 0, 1489, 1490, 3, 1179, 589, 0, 1490, 1491, 3, 1165, 582, 0, 1491, 1492, 3, 1145, 572, 0, 1492, 1493, 3, 1085, 542, 0, 1493, 1494, 3, 1143, 571, 0, 1494, 1495, 3, 1167, 583, 0, 1495, 1496, 3, 1161, 580, 0, 1496, 1497, 3, 1167, 583, 0, 1497, 1498, 3, 1173, 586, 0, 1498, 70, 1, 0, 0, 0, 1499, 1500, 3, 1141, 570, 0, 1500, 1501, 3, 1139, 569, 0, 1501, 1502, 3, 1143, 571, 0, 1502, 1503, 3, 1159, 579, 0, 1503, 1504, 3, 1151, 575, 0, 1504, 1505, 3, 1173, 586, 0, 1505, 1506, 3, 1167, 583, 0, 1506, 1507, 3, 1179, 589, 0, 1507, 1508, 3, 1165, 582, 0, 1508, 1509, 3, 1145, 572, 0, 1509, 1510, 3, 1085, 542, 0, 1510, 1511, 3, 1143, 571, 0, 1511, 1512, 3, 1167, 583, 0, 1512, 1513, 3, 1161, 580, 0, 1513, 1514, 3, 1167, 583, 0, 1514, 1515, 3, 1179, 589, 0, 1515, 1516, 3, 1173, 586, 0, 1516, 72, 1, 0, 0, 0, 1517, 1518, 3, 1141, 570, 0, 1518, 1519, 3, 1139, 569, 0, 1519, 1520, 3, 1175, 587, 0, 1520, 1521, 3, 1155, 577, 0, 1521, 1522, 3, 1175, 587, 0, 1522, 74, 1, 0, 0, 0, 1523, 1524, 3, 1141, 570, 0, 1524, 1525, 3, 1147, 573, 0, 1525, 1526, 3, 1147, 573, 0, 1526, 1527, 3, 1169, 584, 0, 1527, 76, 1, 0, 0, 0, 1528, 1529, 3, 1141, 570, 0, 1529, 1530, 3, 1147, 573, 0, 1530, 1531, 3, 1149, 574, 0, 1531, 1532, 3, 1167, 583, 0, 1532, 1533, 3, 1173, 586, 0, 1533, 1534, 3, 1147, 573, 0, 1534, 78, 1, 0, 0, 0, 1535, 1536, 3, 1141, 570, 0, 1536, 1537, 3, 1147, 573, 0, 1537, 1538, 3, 1151, 575, 0, 1538, 1539, 3, 1155, 577, 0, 1539, 1540, 3, 1165, 582, 0, 1540, 1541, 3, 1165, 582, 0, 1541, 1542, 3, 1155, 577, 0, 1542, 1543, 3, 1165, 582, 0, 1543, 1544, 3, 1151, 575, 0, 1544, 80, 1, 0, 0, 0, 1545, 1546, 3, 1141, 570, 0, 1546, 1547, 3, 1147, 573, 0, 1547, 1548, 3, 1161, 580, 0, 1548, 1549, 3, 1161, 580, 0, 1549, 82, 1, 0, 0, 0, 1550, 1551, 3, 1141, 570, 0, 1551, 1552, 3, 1155, 577, 0, 1552, 1553, 3, 1165, 582, 0, 1553, 1554, 3, 1139, 569, 0, 1554, 1555, 3, 1173, 586, 0, 1555, 1556, 3, 1187, 593, 0, 1556, 84, 1, 0, 0, 0, 1557, 1558, 3, 1141, 570, 0, 1558, 1559, 3, 1155, 577, 0, 1559, 1560, 3, 1177, 588, 0, 1560, 86, 1, 0, 0, 0, 1561, 1562, 3, 1141, 570, 0, 1562, 1563, 3, 1161, 580, 0, 1563, 1564, 3, 1139, 569, 0, 1564, 1565, 3, 1165, 582, 0, 1565, 1566, 3, 1159, 579, 0, 1566, 88, 1, 0, 0, 0, 1567, 1568, 3, 1141, 570, 0, 1568, 1569, 3, 1161, 580, 0, 1569, 1570, 3, 1155, 577, 0, 1570, 1571, 3, 1165, 582, 0, 1571, 1572, 3, 1159, 579, 0, 1572, 90, 1, 0, 0, 0, 1573, 1574, 3, 1141, 570, 0, 1574, 1575, 3, 1161, 580, 0, 1575, 1576, 3, 1167, 583, 0, 1576, 1577, 3, 1143, 571, 0, 1577, 1578, 3, 1159, 579, 0, 1578, 92, 1, 0, 0, 0, 1579, 1580, 3, 1141, 570, 0, 1580, 1581, 3, 1167, 583, 0, 1581, 1582, 3, 1179, 589, 0, 1582, 1583, 3, 1165, 582, 0, 1583, 1584, 3, 1145, 572, 0, 1584, 1585, 3, 1175, 587, 0, 1585, 94, 1, 0, 0, 0, 1586, 1587, 3, 1141, 570, 0, 1587, 1588, 3, 1167, 583, 0, 1588, 1589, 3, 1177, 588, 0, 1589, 1590, 3, 1177, 588, 0, 1590, 1591, 3, 1167, 583, 0, 1591, 1592, 3, 1163, 581, 0, 1592, 96, 1, 0, 0, 0, 1593, 1594, 3, 1141, 570, 0, 1594, 1595, 3, 1187, 593, 0, 1595, 98, 1, 0, 0, 0, 1596, 1597, 3, 1141, 570, 0, 1597, 1598, 3, 1187, 593, 0, 1598, 1599, 3, 1149, 574, 0, 1599, 1600, 3, 1179, 589, 0, 1600, 1601, 3, 1165, 582, 0, 1601, 1602, 3, 1143, 571, 0, 1602, 1603, 3, 1177, 588, 0, 1603, 1604, 3, 1155, 577, 0, 1604, 1605, 3, 1167, 583, 0, 1605, 1606, 3, 1165, 582, 0, 1606, 100, 1, 0, 0, 0, 1607, 1608, 3, 1141, 570, 0, 1608, 1609, 3, 1187, 593, 0, 1609, 1610, 3, 1177, 588, 0, 1610, 1611, 3, 1155, 577, 0, 1611, 1612, 3, 1177, 588, 0, 1612, 1613, 3, 1161, 580, 0, 1613, 1614, 3, 1147, 573, 0, 1614, 102, 1, 0, 0, 0, 1615, 1616, 3, 1143, 571, 0, 1616, 1617, 3, 1139, 569, 0, 1617, 1618, 3, 1161, 580, 0, 1618, 1619, 3, 1161, 580, 0, 1619, 104, 1, 0, 0, 0, 1620, 1621, 3, 1143, 571, 0, 1621, 1622, 3, 1139, 569, 0, 1622, 1623, 3, 1165, 582, 0, 1623, 1624, 3, 1143, 571, 0, 1624, 1625, 3, 1147, 573, 0, 1625, 1626, 3, 1161, 580, 0, 1626, 106, 1, 0, 0, 0, 1627, 1628, 3, 1143, 571, 0, 1628, 1629, 3, 1139, 569, 0, 1629, 1630, 3, 1169, 584, 0, 1630, 1631, 3, 1139, 569, 0, 1631, 1632, 3, 1141, 570, 0, 1632, 1633, 3, 1161, 580, 0, 1633, 1634, 3, 1147, 573, 0, 1634, 108, 1, 0, 0, 0, 1635, 1636, 3, 1143, 571, 0, 1636, 1637, 3, 1143, 571, 0, 1637, 1638, 3, 1175, 587, 0, 1638, 1639, 3, 1181, 590, 0, 1639, 1640, 3, 1147, 573, 0, 1640, 1641, 3, 1173, 586, 0, 1641, 1642, 3, 1175, 587, 0, 1642, 1643, 3, 1155, 577, 0, 1643, 1644, 3, 1167, 583, 0, 1644, 1645, 3, 1165, 582, 0, 1645, 110, 1, 0, 0, 0, 1646, 1647, 3, 1143, 571, 0, 1647, 1648, 3, 1145, 572, 0, 1648, 112, 1, 0, 0, 0, 1649, 1650, 3, 1143, 571, 0, 1650, 1651, 3, 1149, 574, 0, 1651, 114, 1, 0, 0, 0, 1652, 1653, 3, 1143, 571, 0, 1653, 1654, 3, 1153, 576, 0, 1654, 116, 1, 0, 0, 0, 1655, 1656, 3, 1143, 571, 0, 1656, 1657, 3, 1153, 576, 0, 1657, 1658, 3, 1139, 569, 0, 1658, 1659, 3, 1155, 577, 0, 1659, 1660, 3, 1165, 582, 0, 1660, 1661, 3, 1155, 577, 0, 1661, 1662, 3, 1165, 582, 0, 1662, 1663, 3, 1151, 575, 0, 1663, 118, 1, 0, 0, 0, 1664, 1665, 3, 1143, 571, 0, 1665, 1666, 3, 1153, 576, 0, 1666, 1667, 3, 1139, 569, 0, 1667, 1668, 3, 1165, 582, 0, 1668, 1669, 3, 1151, 575, 0, 1669, 1670, 3, 1147, 573, 0, 1670, 1671, 3, 1145, 572, 0, 1671, 120, 1, 0, 0, 0, 1672, 1673, 3, 1143, 571, 0, 1673, 1674, 3, 1153, 576, 0, 1674, 1675, 3, 1139, 569, 0, 1675, 1676, 3, 1165, 582, 0, 1676, 1677, 3, 1165, 582, 0, 1677, 1678, 3, 1147, 573, 0, 1678, 1679, 3, 1161, 580, 0, 1679, 122, 1, 0, 0, 0, 1680, 1681, 3, 1143, 571, 0, 1681, 1682, 3, 1153, 576, 0, 1682, 1683, 3, 1139, 569, 0, 1683, 1684, 3, 1173, 586, 0, 1684, 1685, 3, 1139, 569, 0, 1685, 1686, 3, 1143, 571, 0, 1686, 1687, 3, 1177, 588, 0, 1687, 1688, 3, 1147, 573, 0, 1688, 1689, 3, 1173, 586, 0, 1689, 124, 1, 0, 0, 0, 1690, 1691, 3, 1143, 571, 0, 1691, 1692, 3, 1153, 576, 0, 1692, 1693, 3, 1139, 569, 0, 1693, 1694, 3, 1173, 586, 0, 1694, 1695, 3, 1139, 569, 0, 1695, 1696, 3, 1143, 571, 0, 1696, 1697, 3, 1177, 588, 0, 1697, 1698, 3, 1147, 573, 0, 1698, 1699, 3, 1173, 586, 0, 1699, 1700, 3, 1175, 587, 0, 1700, 126, 1, 0, 0, 0, 1701, 1702, 3, 1143, 571, 0, 1702, 1703, 3, 1161, 580, 0, 1703, 1704, 3, 1139, 569, 0, 1704, 1705, 3, 1175, 587, 0, 1705, 1706, 3, 1175, 587, 0, 1706, 128, 1, 0, 0, 0, 1707, 1708, 3, 1143, 571, 0, 1708, 1709, 3, 1161, 580, 0, 1709, 1710, 3, 1139, 569, 0, 1710, 1711, 3, 1175, 587, 0, 1711, 1712, 3, 1175, 587, 0, 1712, 1713, 3, 1085, 542, 0, 1713, 1714, 3, 1155, 577, 0, 1714, 1715, 3, 1145, 572, 0, 1715, 130, 1, 0, 0, 0, 1716, 1717, 3, 1143, 571, 0, 1717, 1718, 3, 1161, 580, 0, 1718, 1719, 3, 1167, 583, 0, 1719, 1720, 3, 1143, 571, 0, 1720, 1721, 3, 1159, 579, 0, 1721, 1722, 3, 1085, 542, 0, 1722, 1723, 3, 1179, 589, 0, 1723, 1724, 3, 1165, 582, 0, 1724, 1725, 3, 1155, 577, 0, 1725, 1726, 3, 1177, 588, 0, 1726, 1727, 3, 1175, 587, 0, 1727, 132, 1, 0, 0, 0, 1728, 1729, 3, 1143, 571, 0, 1729, 1730, 3, 1161, 580, 0, 1730, 1731, 3, 1167, 583, 0, 1731, 1732, 3, 1175, 587, 0, 1732, 1733, 3, 1147, 573, 0, 1733, 134, 1, 0, 0, 0, 1734, 1735, 3, 1143, 571, 0, 1735, 1736, 3, 1161, 580, 0, 1736, 1737, 3, 1167, 583, 0, 1737, 1738, 3, 1175, 587, 0, 1738, 1739, 3, 1147, 573, 0, 1739, 1740, 3, 1085, 542, 0, 1740, 1741, 3, 1145, 572, 0, 1741, 1742, 3, 1155, 577, 0, 1742, 1743, 3, 1175, 587, 0, 1743, 1744, 3, 1169, 584, 0, 1744, 1745, 3, 1167, 583, 0, 1745, 1746, 3, 1175, 587, 0, 1746, 1747, 3, 1155, 577, 0, 1747, 1748, 3, 1177, 588, 0, 1748, 1749, 3, 1155, 577, 0, 1749, 1750, 3, 1167, 583, 0, 1750, 1751, 3, 1165, 582, 0, 1751, 136, 1, 0, 0, 0, 1752, 1753, 3, 1143, 571, 0, 1753, 1754, 3, 1167, 583, 0, 1754, 1755, 3, 1141, 570, 0, 1755, 1756, 3, 1167, 583, 0, 1756, 1757, 3, 1161, 580, 0, 1757, 138, 1, 0, 0, 0, 1758, 1759, 3, 1143, 571, 0, 1759, 1760, 3, 1167, 583, 0, 1760, 1761, 3, 1145, 572, 0, 1761, 1762, 3, 1147, 573, 0, 1762, 140, 1, 0, 0, 0, 1763, 1764, 3, 1143, 571, 0, 1764, 1765, 3, 1167, 583, 0, 1765, 1766, 3, 1145, 572, 0, 1766, 1767, 3, 1147, 573, 0, 1767, 1768, 3, 1085, 542, 0, 1768, 1769, 3, 1175, 587, 0, 1769, 1770, 3, 1147, 573, 0, 1770, 1771, 3, 1177, 588, 0, 1771, 142, 1, 0, 0, 0, 1772, 1773, 3, 1143, 571, 0, 1773, 1774, 3, 1167, 583, 0, 1774, 1775, 3, 1161, 580, 0, 1775, 1776, 3, 1161, 580, 0, 1776, 1777, 3, 1139, 569, 0, 1777, 1778, 3, 1177, 588, 0, 1778, 1779, 3, 1155, 577, 0, 1779, 1780, 3, 1165, 582, 0, 1780, 1781, 3, 1151, 575, 0, 1781, 144, 1, 0, 0, 0, 1782, 1783, 3, 1143, 571, 0, 1783, 1784, 3, 1167, 583, 0, 1784, 1785, 3, 1161, 580, 0, 1785, 146, 1, 0, 0, 0, 1786, 1787, 3, 1143, 571, 0, 1787, 1788, 3, 1167, 583, 0, 1788, 1789, 3, 1161, 580, 0, 1789, 1790, 3, 1179, 589, 0, 1790, 1791, 3, 1163, 581, 0, 1791, 1792, 3, 1165, 582, 0, 1792, 148, 1, 0, 0, 0, 1793, 1794, 3, 1143, 571, 0, 1794, 1795, 3, 1167, 583, 0, 1795, 1796, 3, 1163, 581, 0, 1796, 1797, 3, 1085, 542, 0, 1797, 1798, 3, 1173, 586, 0, 1798, 1799, 3, 1147, 573, 0, 1799, 1800, 3, 1151, 575, 0, 1800, 150, 1, 0, 0, 0, 1801, 1802, 3, 1143, 571, 0, 1802, 1803, 3, 1167, 583, 0, 1803, 1804, 3, 1163, 581, 0, 1804, 1805, 3, 1163, 581, 0, 1805, 1806, 3, 1139, 569, 0, 1806, 152, 1, 0, 0, 0, 1807, 1808, 3, 1143, 571, 0, 1808, 1809, 3, 1167, 583, 0, 1809, 1810, 3, 1163, 581, 0, 1810, 1811, 3, 1163, 581, 0, 1811, 1812, 3, 1155, 577, 0, 1812, 1813, 3, 1177, 588, 0, 1813, 1814, 3, 1163, 581, 0, 1814, 1815, 3, 1147, 573, 0, 1815, 1816, 3, 1165, 582, 0, 1816, 1817, 3, 1177, 588, 0, 1817, 154, 1, 0, 0, 0, 1818, 1819, 3, 1143, 571, 0, 1819, 1820, 3, 1167, 583, 0, 1820, 1821, 3, 1163, 581, 0, 1821, 1822, 3, 1163, 581, 0, 1822, 1823, 3, 1167, 583, 0, 1823, 1824, 3, 1165, 582, 0, 1824, 156, 1, 0, 0, 0, 1825, 1826, 3, 1143, 571, 0, 1826, 1827, 3, 1167, 583, 0, 1827, 1828, 3, 1163, 581, 0, 1828, 1829, 3, 1163, 581, 0, 1829, 1830, 3, 1179, 589, 0, 1830, 1831, 3, 1165, 582, 0, 1831, 1832, 3, 1155, 577, 0, 1832, 1833, 3, 1143, 571, 0, 1833, 1834, 3, 1139, 569, 0, 1834, 1835, 3, 1177, 588, 0, 1835, 1836, 3, 1155, 577, 0, 1836, 1837, 3, 1167, 583, 0, 1837, 1838, 3, 1165, 582, 0, 1838, 158, 1, 0, 0, 0, 1839, 1840, 3, 1143, 571, 0, 1840, 1841, 3, 1167, 583, 0, 1841, 1842, 3, 1163, 581, 0, 1842, 1843, 3, 1169, 584, 0, 1843, 160, 1, 0, 0, 0, 1844, 1845, 3, 1143, 571, 0, 1845, 1846, 3, 1167, 583, 0, 1846, 1847, 3, 1163, 581, 0, 1847, 1848, 3, 1169, 584, 0, 1848, 1849, 3, 1085, 542, 0, 1849, 1850, 5, 49, 0, 0, 1850, 162, 1, 0, 0, 0, 1851, 1852, 3, 1143, 571, 0, 1852, 1853, 3, 1167, 583, 0, 1853, 1854, 3, 1163, 581, 0, 1854, 1855, 3, 1169, 584, 0, 1855, 1856, 3, 1085, 542, 0, 1856, 1857, 5, 50, 0, 0, 1857, 164, 1, 0, 0, 0, 1858, 1859, 3, 1143, 571, 0, 1859, 1860, 3, 1167, 583, 0, 1860, 1861, 3, 1163, 581, 0, 1861, 1862, 3, 1169, 584, 0, 1862, 1863, 3, 1085, 542, 0, 1863, 1864, 5, 51, 0, 0, 1864, 166, 1, 0, 0, 0, 1865, 1866, 3, 1143, 571, 0, 1866, 1867, 3, 1167, 583, 0, 1867, 1868, 3, 1163, 581, 0, 1868, 1869, 3, 1169, 584, 0, 1869, 1870, 3, 1085, 542, 0, 1870, 1871, 5, 52, 0, 0, 1871, 168, 1, 0, 0, 0, 1872, 1873, 3, 1143, 571, 0, 1873, 1874, 3, 1167, 583, 0, 1874, 1875, 3, 1163, 581, 0, 1875, 1876, 3, 1169, 584, 0, 1876, 1877, 3, 1085, 542, 0, 1877, 1878, 5, 53, 0, 0, 1878, 170, 1, 0, 0, 0, 1879, 1880, 3, 1143, 571, 0, 1880, 1881, 3, 1167, 583, 0, 1881, 1882, 3, 1163, 581, 0, 1882, 1883, 3, 1169, 584, 0, 1883, 1884, 3, 1179, 589, 0, 1884, 1885, 3, 1177, 588, 0, 1885, 1886, 3, 1139, 569, 0, 1886, 1887, 3, 1177, 588, 0, 1887, 1888, 3, 1155, 577, 0, 1888, 1889, 3, 1167, 583, 0, 1889, 1890, 3, 1165, 582, 0, 1890, 1891, 3, 1139, 569, 0, 1891, 1892, 3, 1161, 580, 0, 1892, 172, 1, 0, 0, 0, 1893, 1894, 3, 1143, 571, 0, 1894, 1895, 3, 1167, 583, 0, 1895, 1896, 3, 1163, 581, 0, 1896, 1897, 3, 1169, 584, 0, 1897, 1898, 3, 1179, 589, 0, 1898, 1899, 3, 1177, 588, 0, 1899, 1900, 3, 1139, 569, 0, 1900, 1901, 3, 1177, 588, 0, 1901, 1902, 3, 1155, 577, 0, 1902, 1903, 3, 1167, 583, 0, 1903, 1904, 3, 1165, 582, 0, 1904, 1905, 3, 1139, 569, 0, 1905, 1906, 3, 1161, 580, 0, 1906, 1907, 3, 1085, 542, 0, 1907, 1908, 5, 49, 0, 0, 1908, 174, 1, 0, 0, 0, 1909, 1910, 3, 1143, 571, 0, 1910, 1911, 3, 1167, 583, 0, 1911, 1912, 3, 1163, 581, 0, 1912, 1913, 3, 1169, 584, 0, 1913, 1914, 3, 1179, 589, 0, 1914, 1915, 3, 1177, 588, 0, 1915, 1916, 3, 1139, 569, 0, 1916, 1917, 3, 1177, 588, 0, 1917, 1918, 3, 1155, 577, 0, 1918, 1919, 3, 1167, 583, 0, 1919, 1920, 3, 1165, 582, 0, 1920, 1921, 3, 1139, 569, 0, 1921, 1922, 3, 1161, 580, 0, 1922, 1923, 3, 1085, 542, 0, 1923, 1924, 5, 50, 0, 0, 1924, 176, 1, 0, 0, 0, 1925, 1926, 3, 1143, 571, 0, 1926, 1927, 3, 1167, 583, 0, 1927, 1928, 3, 1163, 581, 0, 1928, 1929, 3, 1169, 584, 0, 1929, 1930, 3, 1179, 589, 0, 1930, 1931, 3, 1177, 588, 0, 1931, 1932, 3, 1139, 569, 0, 1932, 1933, 3, 1177, 588, 0, 1933, 1934, 3, 1155, 577, 0, 1934, 1935, 3, 1167, 583, 0, 1935, 1936, 3, 1165, 582, 0, 1936, 1937, 3, 1139, 569, 0, 1937, 1938, 3, 1161, 580, 0, 1938, 1939, 3, 1085, 542, 0, 1939, 1940, 5, 51, 0, 0, 1940, 178, 1, 0, 0, 0, 1941, 1942, 3, 1143, 571, 0, 1942, 1943, 3, 1167, 583, 0, 1943, 1944, 3, 1163, 581, 0, 1944, 1945, 3, 1169, 584, 0, 1945, 1946, 3, 1179, 589, 0, 1946, 1947, 3, 1177, 588, 0, 1947, 1948, 3, 1139, 569, 0, 1948, 1949, 3, 1177, 588, 0, 1949, 1950, 3, 1155, 577, 0, 1950, 1951, 3, 1167, 583, 0, 1951, 1952, 3, 1165, 582, 0, 1952, 1953, 3, 1139, 569, 0, 1953, 1954, 3, 1161, 580, 0, 1954, 1955, 3, 1085, 542, 0, 1955, 1956, 5, 52, 0, 0, 1956, 180, 1, 0, 0, 0, 1957, 1958, 3, 1143, 571, 0, 1958, 1959, 3, 1167, 583, 0, 1959, 1960, 3, 1163, 581, 0, 1960, 1961, 3, 1169, 584, 0, 1961, 1962, 3, 1179, 589, 0, 1962, 1963, 3, 1177, 588, 0, 1963, 1964, 3, 1139, 569, 0, 1964, 1965, 3, 1177, 588, 0, 1965, 1966, 3, 1155, 577, 0, 1966, 1967, 3, 1167, 583, 0, 1967, 1968, 3, 1165, 582, 0, 1968, 1969, 3, 1139, 569, 0, 1969, 1970, 3, 1161, 580, 0, 1970, 1971, 3, 1085, 542, 0, 1971, 1972, 5, 53, 0, 0, 1972, 182, 1, 0, 0, 0, 1973, 1974, 3, 1143, 571, 0, 1974, 1975, 3, 1167, 583, 0, 1975, 1976, 3, 1163, 581, 0, 1976, 1977, 3, 1169, 584, 0, 1977, 1978, 3, 1179, 589, 0, 1978, 1979, 3, 1177, 588, 0, 1979, 1980, 3, 1147, 573, 0, 1980, 184, 1, 0, 0, 0, 1981, 1982, 3, 1143, 571, 0, 1982, 1983, 3, 1167, 583, 0, 1983, 1984, 3, 1165, 582, 0, 1984, 1985, 3, 1149, 574, 0, 1985, 1986, 3, 1155, 577, 0, 1986, 1987, 3, 1151, 575, 0, 1987, 1988, 3, 1179, 589, 0, 1988, 1989, 3, 1173, 586, 0, 1989, 1990, 3, 1139, 569, 0, 1990, 1991, 3, 1177, 588, 0, 1991, 1992, 3, 1155, 577, 0, 1992, 1993, 3, 1167, 583, 0, 1993, 1994, 3, 1165, 582, 0, 1994, 186, 1, 0, 0, 0, 1995, 1996, 3, 1143, 571, 0, 1996, 1997, 3, 1167, 583, 0, 1997, 1998, 3, 1165, 582, 0, 1998, 1999, 3, 1177, 588, 0, 1999, 2000, 3, 1139, 569, 0, 2000, 2001, 3, 1155, 577, 0, 2001, 2002, 3, 1165, 582, 0, 2002, 2003, 3, 1175, 587, 0, 2003, 188, 1, 0, 0, 0, 2004, 2005, 3, 1143, 571, 0, 2005, 2006, 3, 1167, 583, 0, 2006, 2007, 3, 1165, 582, 0, 2007, 2008, 3, 1177, 588, 0, 2008, 2009, 3, 1147, 573, 0, 2009, 2010, 3, 1165, 582, 0, 2010, 2011, 3, 1177, 588, 0, 2011, 190, 1, 0, 0, 0, 2012, 2013, 3, 1143, 571, 0, 2013, 2014, 3, 1167, 583, 0, 2014, 2015, 3, 1165, 582, 0, 2015, 2016, 3, 1177, 588, 0, 2016, 2017, 3, 1155, 577, 0, 2017, 2018, 3, 1165, 582, 0, 2018, 2019, 3, 1179, 589, 0, 2019, 2020, 3, 1147, 573, 0, 2020, 192, 1, 0, 0, 0, 2021, 2022, 3, 1143, 571, 0, 2022, 2023, 3, 1167, 583, 0, 2023, 2024, 3, 1165, 582, 0, 2024, 2025, 3, 1177, 588, 0, 2025, 2026, 3, 1173, 586, 0, 2026, 2027, 3, 1167, 583, 0, 2027, 2028, 3, 1161, 580, 0, 2028, 194, 1, 0, 0, 0, 2029, 2030, 3, 1143, 571, 0, 2030, 2031, 3, 1167, 583, 0, 2031, 2032, 3, 1165, 582, 0, 2032, 2033, 3, 1177, 588, 0, 2033, 2034, 3, 1173, 586, 0, 2034, 2035, 3, 1167, 583, 0, 2035, 2036, 3, 1161, 580, 0, 2036, 2037, 3, 1085, 542, 0, 2037, 2038, 3, 1169, 584, 0, 2038, 2039, 3, 1167, 583, 0, 2039, 2040, 3, 1155, 577, 0, 2040, 2041, 3, 1165, 582, 0, 2041, 2042, 3, 1177, 588, 0, 2042, 196, 1, 0, 0, 0, 2043, 2044, 3, 1143, 571, 0, 2044, 2045, 3, 1167, 583, 0, 2045, 2046, 3, 1165, 582, 0, 2046, 2047, 3, 1177, 588, 0, 2047, 2048, 3, 1173, 586, 0, 2048, 2049, 3, 1167, 583, 0, 2049, 2050, 3, 1161, 580, 0, 2050, 2051, 3, 1175, 587, 0, 2051, 198, 1, 0, 0, 0, 2052, 2053, 3, 1143, 571, 0, 2053, 2054, 3, 1167, 583, 0, 2054, 2055, 3, 1165, 582, 0, 2055, 2056, 3, 1181, 590, 0, 2056, 2057, 3, 1147, 573, 0, 2057, 2058, 3, 1165, 582, 0, 2058, 2059, 3, 1177, 588, 0, 2059, 2060, 3, 1155, 577, 0, 2060, 2061, 3, 1167, 583, 0, 2061, 2062, 3, 1165, 582, 0, 2062, 200, 1, 0, 0, 0, 2063, 2064, 3, 1143, 571, 0, 2064, 2065, 3, 1167, 583, 0, 2065, 2066, 3, 1165, 582, 0, 2066, 2067, 3, 1181, 590, 0, 2067, 2068, 3, 1147, 573, 0, 2068, 2069, 3, 1173, 586, 0, 2069, 2070, 3, 1177, 588, 0, 2070, 2071, 3, 1155, 577, 0, 2071, 2072, 3, 1165, 582, 0, 2072, 2073, 3, 1151, 575, 0, 2073, 202, 1, 0, 0, 0, 2074, 2075, 3, 1143, 571, 0, 2075, 2076, 3, 1167, 583, 0, 2076, 2077, 3, 1169, 584, 0, 2077, 2078, 3, 1187, 593, 0, 2078, 204, 1, 0, 0, 0, 2079, 2080, 3, 1143, 571, 0, 2080, 2081, 3, 1167, 583, 0, 2081, 2082, 3, 1173, 586, 0, 2082, 2083, 3, 1173, 586, 0, 2083, 206, 1, 0, 0, 0, 2084, 2085, 3, 1143, 571, 0, 2085, 2086, 3, 1167, 583, 0, 2086, 2087, 3, 1173, 586, 0, 2087, 2088, 3, 1173, 586, 0, 2088, 2089, 3, 1147, 573, 0, 2089, 2090, 3, 1175, 587, 0, 2090, 2091, 3, 1169, 584, 0, 2091, 2092, 3, 1167, 583, 0, 2092, 2093, 3, 1165, 582, 0, 2093, 2094, 3, 1145, 572, 0, 2094, 2095, 3, 1155, 577, 0, 2095, 2096, 3, 1165, 582, 0, 2096, 2097, 3, 1151, 575, 0, 2097, 208, 1, 0, 0, 0, 2098, 2099, 3, 1143, 571, 0, 2099, 2100, 3, 1167, 583, 0, 2100, 2101, 3, 1179, 589, 0, 2101, 2102, 3, 1165, 582, 0, 2102, 2103, 3, 1177, 588, 0, 2103, 210, 1, 0, 0, 0, 2104, 2105, 3, 1143, 571, 0, 2105, 2106, 3, 1173, 586, 0, 2106, 2107, 3, 1179, 589, 0, 2107, 2108, 3, 1165, 582, 0, 2108, 2109, 3, 1143, 571, 0, 2109, 2110, 3, 1153, 576, 0, 2110, 212, 1, 0, 0, 0, 2111, 2112, 3, 1143, 571, 0, 2112, 2113, 3, 1179, 589, 0, 2113, 2114, 3, 1173, 586, 0, 2114, 2115, 3, 1173, 586, 0, 2115, 2116, 3, 1147, 573, 0, 2116, 2117, 3, 1165, 582, 0, 2117, 2118, 3, 1143, 571, 0, 2118, 2119, 3, 1187, 593, 0, 2119, 214, 1, 0, 0, 0, 2120, 2121, 3, 1143, 571, 0, 2121, 2122, 3, 1179, 589, 0, 2122, 2123, 3, 1173, 586, 0, 2123, 2124, 3, 1175, 587, 0, 2124, 2125, 3, 1167, 583, 0, 2125, 2126, 3, 1173, 586, 0, 2126, 216, 1, 0, 0, 0, 2127, 2128, 3, 1145, 572, 0, 2128, 2129, 3, 1139, 569, 0, 2129, 2130, 3, 1177, 588, 0, 2130, 2131, 3, 1139, 569, 0, 2131, 218, 1, 0, 0, 0, 2132, 2133, 3, 1145, 572, 0, 2133, 2134, 3, 1139, 569, 0, 2134, 2135, 3, 1177, 588, 0, 2135, 2136, 3, 1139, 569, 0, 2136, 2137, 3, 1085, 542, 0, 2137, 2138, 3, 1141, 570, 0, 2138, 2139, 3, 1139, 569, 0, 2139, 2140, 3, 1175, 587, 0, 2140, 2141, 3, 1147, 573, 0, 2141, 220, 1, 0, 0, 0, 2142, 2143, 3, 1145, 572, 0, 2143, 2144, 3, 1139, 569, 0, 2144, 2145, 3, 1177, 588, 0, 2145, 2146, 3, 1147, 573, 0, 2146, 222, 1, 0, 0, 0, 2147, 2148, 3, 1145, 572, 0, 2148, 2149, 3, 1139, 569, 0, 2149, 2150, 3, 1177, 588, 0, 2150, 2151, 3, 1147, 573, 0, 2151, 2152, 3, 1085, 542, 0, 2152, 2153, 3, 1143, 571, 0, 2153, 2154, 3, 1167, 583, 0, 2154, 2155, 3, 1163, 581, 0, 2155, 2156, 3, 1169, 584, 0, 2156, 2157, 3, 1155, 577, 0, 2157, 2158, 3, 1161, 580, 0, 2158, 2159, 3, 1147, 573, 0, 2159, 2160, 3, 1145, 572, 0, 2160, 224, 1, 0, 0, 0, 2161, 2162, 3, 1145, 572, 0, 2162, 2163, 3, 1139, 569, 0, 2163, 2164, 3, 1177, 588, 0, 2164, 2165, 3, 1147, 573, 0, 2165, 2166, 3, 1085, 542, 0, 2166, 2167, 3, 1183, 591, 0, 2167, 2168, 3, 1173, 586, 0, 2168, 2169, 3, 1155, 577, 0, 2169, 2170, 3, 1177, 588, 0, 2170, 2171, 3, 1177, 588, 0, 2171, 2172, 3, 1147, 573, 0, 2172, 2173, 3, 1165, 582, 0, 2173, 226, 1, 0, 0, 0, 2174, 2175, 3, 1145, 572, 0, 2175, 2176, 3, 1139, 569, 0, 2176, 2177, 3, 1187, 593, 0, 2177, 228, 1, 0, 0, 0, 2178, 2179, 3, 1145, 572, 0, 2179, 2180, 3, 1139, 569, 0, 2180, 2181, 3, 1187, 593, 0, 2181, 2182, 3, 1085, 542, 0, 2182, 2183, 3, 1167, 583, 0, 2183, 2184, 3, 1149, 574, 0, 2184, 2185, 3, 1085, 542, 0, 2185, 2186, 3, 1183, 591, 0, 2186, 2187, 3, 1147, 573, 0, 2187, 2188, 3, 1147, 573, 0, 2188, 2189, 3, 1159, 579, 0, 2189, 230, 1, 0, 0, 0, 2190, 2191, 3, 1145, 572, 0, 2191, 2192, 3, 1141, 570, 0, 2192, 2193, 3, 1143, 571, 0, 2193, 2194, 3, 1175, 587, 0, 2194, 232, 1, 0, 0, 0, 2195, 2196, 3, 1145, 572, 0, 2196, 2197, 3, 1147, 573, 0, 2197, 234, 1, 0, 0, 0, 2198, 2199, 3, 1145, 572, 0, 2199, 2200, 3, 1147, 573, 0, 2200, 2201, 3, 1141, 570, 0, 2201, 2202, 3, 1179, 589, 0, 2202, 2203, 3, 1151, 575, 0, 2203, 2204, 3, 1085, 542, 0, 2204, 2205, 3, 1143, 571, 0, 2205, 2206, 3, 1167, 583, 0, 2206, 2207, 3, 1165, 582, 0, 2207, 2208, 3, 1177, 588, 0, 2208, 2209, 3, 1147, 573, 0, 2209, 2210, 3, 1165, 582, 0, 2210, 2211, 3, 1177, 588, 0, 2211, 2212, 3, 1175, 587, 0, 2212, 236, 1, 0, 0, 0, 2213, 2214, 3, 1145, 572, 0, 2214, 2215, 3, 1147, 573, 0, 2215, 2216, 3, 1141, 570, 0, 2216, 2217, 3, 1179, 589, 0, 2217, 2218, 3, 1151, 575, 0, 2218, 2219, 3, 1085, 542, 0, 2219, 2220, 3, 1155, 577, 0, 2220, 2221, 3, 1177, 588, 0, 2221, 2222, 3, 1147, 573, 0, 2222, 2223, 3, 1163, 581, 0, 2223, 238, 1, 0, 0, 0, 2224, 2225, 3, 1145, 572, 0, 2225, 2226, 3, 1147, 573, 0, 2226, 2227, 3, 1141, 570, 0, 2227, 2228, 3, 1179, 589, 0, 2228, 2229, 3, 1151, 575, 0, 2229, 2230, 3, 1085, 542, 0, 2230, 2231, 3, 1161, 580, 0, 2231, 2232, 3, 1155, 577, 0, 2232, 2233, 3, 1165, 582, 0, 2233, 2234, 3, 1147, 573, 0, 2234, 240, 1, 0, 0, 0, 2235, 2236, 3, 1145, 572, 0, 2236, 2237, 3, 1147, 573, 0, 2237, 2238, 3, 1141, 570, 0, 2238, 2239, 3, 1179, 589, 0, 2239, 2240, 3, 1151, 575, 0, 2240, 2241, 3, 1085, 542, 0, 2241, 2242, 3, 1165, 582, 0, 2242, 2243, 3, 1139, 569, 0, 2243, 2244, 3, 1163, 581, 0, 2244, 2245, 3, 1147, 573, 0, 2245, 242, 1, 0, 0, 0, 2246, 2247, 3, 1145, 572, 0, 2247, 2248, 3, 1147, 573, 0, 2248, 2249, 3, 1141, 570, 0, 2249, 2250, 3, 1179, 589, 0, 2250, 2251, 3, 1151, 575, 0, 2251, 2252, 3, 1085, 542, 0, 2252, 2253, 3, 1175, 587, 0, 2253, 2254, 3, 1179, 589, 0, 2254, 2255, 3, 1141, 570, 0, 2255, 2256, 3, 1085, 542, 0, 2256, 2257, 5, 49, 0, 0, 2257, 244, 1, 0, 0, 0, 2258, 2259, 3, 1145, 572, 0, 2259, 2260, 3, 1147, 573, 0, 2260, 2261, 3, 1141, 570, 0, 2261, 2262, 3, 1179, 589, 0, 2262, 2263, 3, 1151, 575, 0, 2263, 2264, 3, 1085, 542, 0, 2264, 2265, 3, 1175, 587, 0, 2265, 2266, 3, 1179, 589, 0, 2266, 2267, 3, 1141, 570, 0, 2267, 2268, 3, 1085, 542, 0, 2268, 2269, 5, 50, 0, 0, 2269, 246, 1, 0, 0, 0, 2270, 2271, 3, 1145, 572, 0, 2271, 2272, 3, 1147, 573, 0, 2272, 2273, 3, 1141, 570, 0, 2273, 2274, 3, 1179, 589, 0, 2274, 2275, 3, 1151, 575, 0, 2275, 2276, 3, 1085, 542, 0, 2276, 2277, 3, 1175, 587, 0, 2277, 2278, 3, 1179, 589, 0, 2278, 2279, 3, 1141, 570, 0, 2279, 2280, 3, 1085, 542, 0, 2280, 2281, 5, 51, 0, 0, 2281, 248, 1, 0, 0, 0, 2282, 2283, 3, 1145, 572, 0, 2283, 2284, 3, 1147, 573, 0, 2284, 2285, 3, 1141, 570, 0, 2285, 2286, 3, 1179, 589, 0, 2286, 2287, 3, 1151, 575, 0, 2287, 2288, 3, 1151, 575, 0, 2288, 2289, 3, 1155, 577, 0, 2289, 2290, 3, 1165, 582, 0, 2290, 2291, 3, 1151, 575, 0, 2291, 250, 1, 0, 0, 0, 2292, 2293, 3, 1145, 572, 0, 2293, 2294, 3, 1147, 573, 0, 2294, 2295, 3, 1143, 571, 0, 2295, 2296, 3, 1155, 577, 0, 2296, 2297, 3, 1163, 581, 0, 2297, 2298, 3, 1139, 569, 0, 2298, 2299, 3, 1161, 580, 0, 2299, 2300, 3, 1085, 542, 0, 2300, 2301, 3, 1169, 584, 0, 2301, 2302, 3, 1167, 583, 0, 2302, 2303, 3, 1155, 577, 0, 2303, 2304, 3, 1165, 582, 0, 2304, 2305, 3, 1177, 588, 0, 2305, 252, 1, 0, 0, 0, 2306, 2307, 3, 1145, 572, 0, 2307, 2308, 3, 1147, 573, 0, 2308, 2309, 3, 1143, 571, 0, 2309, 2310, 3, 1161, 580, 0, 2310, 2311, 3, 1139, 569, 0, 2311, 2312, 3, 1173, 586, 0, 2312, 2313, 3, 1139, 569, 0, 2313, 2314, 3, 1177, 588, 0, 2314, 2315, 3, 1155, 577, 0, 2315, 2316, 3, 1181, 590, 0, 2316, 2317, 3, 1147, 573, 0, 2317, 2318, 3, 1175, 587, 0, 2318, 254, 1, 0, 0, 0, 2319, 2320, 3, 1145, 572, 0, 2320, 2321, 3, 1147, 573, 0, 2321, 2322, 3, 1149, 574, 0, 2322, 2323, 3, 1139, 569, 0, 2323, 2324, 3, 1179, 589, 0, 2324, 2325, 3, 1161, 580, 0, 2325, 2326, 3, 1177, 588, 0, 2326, 256, 1, 0, 0, 0, 2327, 2328, 3, 1145, 572, 0, 2328, 2329, 3, 1147, 573, 0, 2329, 2330, 3, 1149, 574, 0, 2330, 2331, 3, 1139, 569, 0, 2331, 2332, 3, 1179, 589, 0, 2332, 2333, 3, 1161, 580, 0, 2333, 2334, 3, 1177, 588, 0, 2334, 2335, 3, 1085, 542, 0, 2335, 2336, 3, 1145, 572, 0, 2336, 2337, 3, 1155, 577, 0, 2337, 2338, 3, 1175, 587, 0, 2338, 2339, 3, 1169, 584, 0, 2339, 2340, 3, 1161, 580, 0, 2340, 2341, 3, 1139, 569, 0, 2341, 2342, 3, 1187, 593, 0, 2342, 258, 1, 0, 0, 0, 2343, 2344, 3, 1145, 572, 0, 2344, 2345, 3, 1147, 573, 0, 2345, 2346, 3, 1149, 574, 0, 2346, 2347, 3, 1155, 577, 0, 2347, 2348, 3, 1165, 582, 0, 2348, 2349, 3, 1155, 577, 0, 2349, 2350, 3, 1177, 588, 0, 2350, 2351, 3, 1155, 577, 0, 2351, 2352, 3, 1167, 583, 0, 2352, 2353, 3, 1165, 582, 0, 2353, 260, 1, 0, 0, 0, 2354, 2355, 3, 1145, 572, 0, 2355, 2356, 3, 1147, 573, 0, 2356, 2357, 3, 1161, 580, 0, 2357, 2358, 3, 1147, 573, 0, 2358, 2359, 3, 1177, 588, 0, 2359, 2360, 3, 1147, 573, 0, 2360, 262, 1, 0, 0, 0, 2361, 2362, 3, 1145, 572, 0, 2362, 2363, 3, 1147, 573, 0, 2363, 2364, 3, 1161, 580, 0, 2364, 2365, 3, 1155, 577, 0, 2365, 2366, 3, 1163, 581, 0, 2366, 2367, 3, 1155, 577, 0, 2367, 2368, 3, 1177, 588, 0, 2368, 2369, 3, 1147, 573, 0, 2369, 2370, 3, 1145, 572, 0, 2370, 264, 1, 0, 0, 0, 2371, 2372, 3, 1145, 572, 0, 2372, 2373, 3, 1147, 573, 0, 2373, 2374, 3, 1161, 580, 0, 2374, 2375, 3, 1155, 577, 0, 2375, 2376, 3, 1163, 581, 0, 2376, 2377, 3, 1155, 577, 0, 2377, 2378, 3, 1177, 588, 0, 2378, 2379, 3, 1147, 573, 0, 2379, 2380, 3, 1173, 586, 0, 2380, 266, 1, 0, 0, 0, 2381, 2382, 3, 1145, 572, 0, 2382, 2383, 3, 1147, 573, 0, 2383, 2384, 3, 1169, 584, 0, 2384, 2385, 3, 1147, 573, 0, 2385, 2386, 3, 1165, 582, 0, 2386, 2387, 3, 1145, 572, 0, 2387, 2388, 3, 1155, 577, 0, 2388, 2389, 3, 1165, 582, 0, 2389, 2390, 3, 1151, 575, 0, 2390, 268, 1, 0, 0, 0, 2391, 2392, 3, 1145, 572, 0, 2392, 2393, 3, 1147, 573, 0, 2393, 2394, 3, 1175, 587, 0, 2394, 2395, 3, 1143, 571, 0, 2395, 2396, 3, 1147, 573, 0, 2396, 2397, 3, 1165, 582, 0, 2397, 2398, 3, 1145, 572, 0, 2398, 2399, 3, 1155, 577, 0, 2399, 2400, 3, 1165, 582, 0, 2400, 2401, 3, 1151, 575, 0, 2401, 270, 1, 0, 0, 0, 2402, 2403, 3, 1145, 572, 0, 2403, 2404, 3, 1147, 573, 0, 2404, 2405, 3, 1175, 587, 0, 2405, 2406, 3, 1177, 588, 0, 2406, 2407, 3, 1155, 577, 0, 2407, 2408, 3, 1165, 582, 0, 2408, 2409, 3, 1139, 569, 0, 2409, 2410, 3, 1177, 588, 0, 2410, 2411, 3, 1155, 577, 0, 2411, 2412, 3, 1167, 583, 0, 2412, 2413, 3, 1165, 582, 0, 2413, 272, 1, 0, 0, 0, 2414, 2415, 3, 1145, 572, 0, 2415, 2416, 3, 1147, 573, 0, 2416, 2417, 3, 1177, 588, 0, 2417, 2418, 3, 1139, 569, 0, 2418, 2419, 3, 1155, 577, 0, 2419, 2420, 3, 1161, 580, 0, 2420, 274, 1, 0, 0, 0, 2421, 2422, 3, 1145, 572, 0, 2422, 2423, 3, 1149, 574, 0, 2423, 2424, 3, 1153, 576, 0, 2424, 2425, 3, 1173, 586, 0, 2425, 2426, 3, 1147, 573, 0, 2426, 2427, 3, 1175, 587, 0, 2427, 2428, 3, 1169, 584, 0, 2428, 276, 1, 0, 0, 0, 2429, 2430, 3, 1145, 572, 0, 2430, 2431, 3, 1149, 574, 0, 2431, 2432, 3, 1153, 576, 0, 2432, 2433, 3, 1181, 590, 0, 2433, 2434, 3, 1139, 569, 0, 2434, 2435, 3, 1161, 580, 0, 2435, 2436, 3, 1179, 589, 0, 2436, 2437, 3, 1147, 573, 0, 2437, 278, 1, 0, 0, 0, 2438, 2439, 3, 1145, 572, 0, 2439, 2440, 3, 1155, 577, 0, 2440, 2441, 3, 1175, 587, 0, 2441, 2442, 3, 1139, 569, 0, 2442, 2443, 3, 1141, 570, 0, 2443, 2444, 3, 1161, 580, 0, 2444, 2445, 3, 1147, 573, 0, 2445, 280, 1, 0, 0, 0, 2446, 2447, 3, 1145, 572, 0, 2447, 2448, 3, 1155, 577, 0, 2448, 2449, 3, 1175, 587, 0, 2449, 2450, 3, 1159, 579, 0, 2450, 282, 1, 0, 0, 0, 2451, 2452, 3, 1145, 572, 0, 2452, 2453, 3, 1155, 577, 0, 2453, 2454, 3, 1175, 587, 0, 2454, 2455, 3, 1169, 584, 0, 2455, 2456, 3, 1161, 580, 0, 2456, 2457, 3, 1139, 569, 0, 2457, 2458, 3, 1187, 593, 0, 2458, 284, 1, 0, 0, 0, 2459, 2460, 3, 1145, 572, 0, 2460, 2461, 3, 1155, 577, 0, 2461, 2462, 3, 1175, 587, 0, 2462, 2463, 3, 1169, 584, 0, 2463, 2464, 3, 1161, 580, 0, 2464, 2465, 3, 1139, 569, 0, 2465, 2466, 3, 1187, 593, 0, 2466, 2467, 3, 1085, 542, 0, 2467, 2468, 5, 49, 0, 0, 2468, 286, 1, 0, 0, 0, 2469, 2470, 3, 1145, 572, 0, 2470, 2471, 3, 1155, 577, 0, 2471, 2472, 3, 1181, 590, 0, 2472, 2473, 3, 1155, 577, 0, 2473, 2474, 3, 1145, 572, 0, 2474, 2475, 3, 1147, 573, 0, 2475, 288, 1, 0, 0, 0, 2476, 2477, 3, 1145, 572, 0, 2477, 2478, 3, 1155, 577, 0, 2478, 2479, 3, 1181, 590, 0, 2479, 2480, 3, 1155, 577, 0, 2480, 2481, 3, 1175, 587, 0, 2481, 2482, 3, 1155, 577, 0, 2482, 2483, 3, 1167, 583, 0, 2483, 2484, 3, 1165, 582, 0, 2484, 290, 1, 0, 0, 0, 2485, 2486, 3, 1145, 572, 0, 2486, 2487, 3, 1167, 583, 0, 2487, 2488, 3, 1165, 582, 0, 2488, 2489, 3, 1177, 588, 0, 2489, 2490, 3, 1143, 571, 0, 2490, 2491, 3, 1139, 569, 0, 2491, 2492, 3, 1173, 586, 0, 2492, 2493, 3, 1147, 573, 0, 2493, 292, 1, 0, 0, 0, 2494, 2495, 3, 1145, 572, 0, 2495, 2496, 3, 1167, 583, 0, 2496, 2497, 3, 1179, 589, 0, 2497, 2498, 3, 1141, 570, 0, 2498, 2499, 3, 1161, 580, 0, 2499, 2500, 3, 1147, 573, 0, 2500, 294, 1, 0, 0, 0, 2501, 2502, 3, 1145, 572, 0, 2502, 2503, 3, 1167, 583, 0, 2503, 2504, 3, 1183, 591, 0, 2504, 2505, 3, 1165, 582, 0, 2505, 296, 1, 0, 0, 0, 2506, 2507, 3, 1145, 572, 0, 2507, 2508, 3, 1179, 589, 0, 2508, 2509, 3, 1169, 584, 0, 2509, 2510, 3, 1161, 580, 0, 2510, 2511, 3, 1155, 577, 0, 2511, 2512, 3, 1143, 571, 0, 2512, 2513, 3, 1139, 569, 0, 2513, 2514, 3, 1177, 588, 0, 2514, 2515, 3, 1147, 573, 0, 2515, 2516, 3, 1175, 587, 0, 2516, 298, 1, 0, 0, 0, 2517, 2518, 3, 1145, 572, 0, 2518, 2519, 3, 1187, 593, 0, 2519, 2520, 3, 1165, 582, 0, 2520, 2521, 3, 1139, 569, 0, 2521, 2522, 3, 1163, 581, 0, 2522, 2523, 3, 1155, 577, 0, 2523, 2524, 3, 1143, 571, 0, 2524, 300, 1, 0, 0, 0, 2525, 2526, 3, 1147, 573, 0, 2526, 2527, 3, 1141, 570, 0, 2527, 2528, 3, 1143, 571, 0, 2528, 2529, 3, 1145, 572, 0, 2529, 2530, 3, 1155, 577, 0, 2530, 2531, 3, 1143, 571, 0, 2531, 302, 1, 0, 0, 0, 2532, 2533, 3, 1147, 573, 0, 2533, 2534, 3, 1151, 575, 0, 2534, 2535, 3, 1143, 571, 0, 2535, 2536, 3, 1175, 587, 0, 2536, 304, 1, 0, 0, 0, 2537, 2538, 3, 1147, 573, 0, 2538, 2539, 3, 1151, 575, 0, 2539, 2540, 3, 1155, 577, 0, 2540, 306, 1, 0, 0, 0, 2541, 2542, 3, 1147, 573, 0, 2542, 2543, 3, 1161, 580, 0, 2543, 2544, 3, 1175, 587, 0, 2544, 2545, 3, 1147, 573, 0, 2545, 308, 1, 0, 0, 0, 2546, 2547, 3, 1147, 573, 0, 2547, 2548, 3, 1163, 581, 0, 2548, 2549, 3, 1155, 577, 0, 2549, 310, 1, 0, 0, 0, 2550, 2551, 3, 1147, 573, 0, 2551, 2552, 3, 1163, 581, 0, 2552, 2553, 3, 1169, 584, 0, 2553, 2554, 3, 1177, 588, 0, 2554, 2555, 3, 1187, 593, 0, 2555, 2556, 3, 1085, 542, 0, 2556, 2557, 3, 1143, 571, 0, 2557, 2558, 3, 1153, 576, 0, 2558, 2559, 3, 1147, 573, 0, 2559, 2560, 3, 1143, 571, 0, 2560, 2561, 3, 1159, 579, 0, 2561, 312, 1, 0, 0, 0, 2562, 2563, 3, 1147, 573, 0, 2563, 2564, 3, 1165, 582, 0, 2564, 2565, 3, 1139, 569, 0, 2565, 2566, 3, 1141, 570, 0, 2566, 2567, 3, 1161, 580, 0, 2567, 2568, 3, 1147, 573, 0, 2568, 314, 1, 0, 0, 0, 2569, 2570, 3, 1147, 573, 0, 2570, 2571, 3, 1165, 582, 0, 2571, 2572, 3, 1145, 572, 0, 2572, 316, 1, 0, 0, 0, 2573, 2574, 3, 1147, 573, 0, 2574, 2575, 3, 1165, 582, 0, 2575, 2576, 3, 1145, 572, 0, 2576, 2577, 3, 1085, 542, 0, 2577, 2578, 3, 1139, 569, 0, 2578, 2579, 3, 1143, 571, 0, 2579, 2580, 3, 1143, 571, 0, 2580, 2581, 3, 1147, 573, 0, 2581, 2582, 3, 1169, 584, 0, 2582, 2583, 3, 1177, 588, 0, 2583, 318, 1, 0, 0, 0, 2584, 2585, 3, 1147, 573, 0, 2585, 2586, 3, 1165, 582, 0, 2586, 2587, 3, 1145, 572, 0, 2587, 2588, 3, 1085, 542, 0, 2588, 2589, 3, 1139, 569, 0, 2589, 2590, 3, 1145, 572, 0, 2590, 2591, 3, 1145, 572, 0, 2591, 320, 1, 0, 0, 0, 2592, 2593, 3, 1147, 573, 0, 2593, 2594, 3, 1165, 582, 0, 2594, 2595, 3, 1145, 572, 0, 2595, 2596, 3, 1085, 542, 0, 2596, 2597, 3, 1143, 571, 0, 2597, 2598, 3, 1139, 569, 0, 2598, 2599, 3, 1161, 580, 0, 2599, 2600, 3, 1161, 580, 0, 2600, 322, 1, 0, 0, 0, 2601, 2602, 3, 1147, 573, 0, 2602, 2603, 3, 1165, 582, 0, 2603, 2604, 3, 1145, 572, 0, 2604, 2605, 3, 1085, 542, 0, 2605, 2606, 3, 1143, 571, 0, 2606, 2607, 3, 1167, 583, 0, 2607, 2608, 3, 1163, 581, 0, 2608, 2609, 3, 1169, 584, 0, 2609, 2610, 3, 1179, 589, 0, 2610, 2611, 3, 1177, 588, 0, 2611, 2612, 3, 1147, 573, 0, 2612, 324, 1, 0, 0, 0, 2613, 2614, 3, 1147, 573, 0, 2614, 2615, 3, 1165, 582, 0, 2615, 2616, 3, 1145, 572, 0, 2616, 2617, 3, 1085, 542, 0, 2617, 2618, 3, 1145, 572, 0, 2618, 2619, 3, 1147, 573, 0, 2619, 2620, 3, 1161, 580, 0, 2620, 2621, 3, 1147, 573, 0, 2621, 2622, 3, 1177, 588, 0, 2622, 2623, 3, 1147, 573, 0, 2623, 326, 1, 0, 0, 0, 2624, 2625, 3, 1147, 573, 0, 2625, 2626, 3, 1165, 582, 0, 2626, 2627, 3, 1145, 572, 0, 2627, 2628, 3, 1085, 542, 0, 2628, 2629, 3, 1145, 572, 0, 2629, 2630, 3, 1155, 577, 0, 2630, 2631, 3, 1181, 590, 0, 2631, 2632, 3, 1155, 577, 0, 2632, 2633, 3, 1145, 572, 0, 2633, 2634, 3, 1147, 573, 0, 2634, 328, 1, 0, 0, 0, 2635, 2636, 3, 1147, 573, 0, 2636, 2637, 3, 1165, 582, 0, 2637, 2638, 3, 1145, 572, 0, 2638, 2639, 3, 1085, 542, 0, 2639, 2640, 3, 1147, 573, 0, 2640, 2641, 3, 1181, 590, 0, 2641, 2642, 3, 1139, 569, 0, 2642, 2643, 3, 1161, 580, 0, 2643, 2644, 3, 1179, 589, 0, 2644, 2645, 3, 1139, 569, 0, 2645, 2646, 3, 1177, 588, 0, 2646, 2647, 3, 1147, 573, 0, 2647, 330, 1, 0, 0, 0, 2648, 2649, 3, 1147, 573, 0, 2649, 2650, 3, 1165, 582, 0, 2650, 2651, 3, 1145, 572, 0, 2651, 2652, 3, 1085, 542, 0, 2652, 2653, 3, 1155, 577, 0, 2653, 2654, 3, 1149, 574, 0, 2654, 332, 1, 0, 0, 0, 2655, 2656, 3, 1147, 573, 0, 2656, 2657, 3, 1165, 582, 0, 2657, 2658, 3, 1145, 572, 0, 2658, 2659, 3, 1085, 542, 0, 2659, 2660, 3, 1163, 581, 0, 2660, 2661, 3, 1179, 589, 0, 2661, 2662, 3, 1161, 580, 0, 2662, 2663, 3, 1177, 588, 0, 2663, 2664, 3, 1155, 577, 0, 2664, 2665, 3, 1169, 584, 0, 2665, 2666, 3, 1161, 580, 0, 2666, 2667, 3, 1187, 593, 0, 2667, 334, 1, 0, 0, 0, 2668, 2669, 3, 1147, 573, 0, 2669, 2670, 3, 1165, 582, 0, 2670, 2671, 3, 1145, 572, 0, 2671, 2672, 3, 1085, 542, 0, 2672, 2673, 3, 1167, 583, 0, 2673, 2674, 3, 1149, 574, 0, 2674, 2675, 3, 1085, 542, 0, 2675, 2676, 3, 1169, 584, 0, 2676, 2677, 3, 1139, 569, 0, 2677, 2678, 3, 1151, 575, 0, 2678, 2679, 3, 1147, 573, 0, 2679, 336, 1, 0, 0, 0, 2680, 2681, 3, 1147, 573, 0, 2681, 2682, 3, 1165, 582, 0, 2682, 2683, 3, 1145, 572, 0, 2683, 2684, 3, 1085, 542, 0, 2684, 2685, 3, 1169, 584, 0, 2685, 2686, 3, 1147, 573, 0, 2686, 2687, 3, 1173, 586, 0, 2687, 2688, 3, 1149, 574, 0, 2688, 2689, 3, 1167, 583, 0, 2689, 2690, 3, 1173, 586, 0, 2690, 2691, 3, 1163, 581, 0, 2691, 338, 1, 0, 0, 0, 2692, 2693, 3, 1147, 573, 0, 2693, 2694, 3, 1165, 582, 0, 2694, 2695, 3, 1145, 572, 0, 2695, 2696, 3, 1085, 542, 0, 2696, 2697, 3, 1173, 586, 0, 2697, 2698, 3, 1147, 573, 0, 2698, 2699, 3, 1139, 569, 0, 2699, 2700, 3, 1145, 572, 0, 2700, 340, 1, 0, 0, 0, 2701, 2702, 3, 1147, 573, 0, 2702, 2703, 3, 1165, 582, 0, 2703, 2704, 3, 1145, 572, 0, 2704, 2705, 3, 1085, 542, 0, 2705, 2706, 3, 1173, 586, 0, 2706, 2707, 3, 1147, 573, 0, 2707, 2708, 3, 1143, 571, 0, 2708, 2709, 3, 1147, 573, 0, 2709, 2710, 3, 1155, 577, 0, 2710, 2711, 3, 1181, 590, 0, 2711, 2712, 3, 1147, 573, 0, 2712, 342, 1, 0, 0, 0, 2713, 2714, 3, 1147, 573, 0, 2714, 2715, 3, 1165, 582, 0, 2715, 2716, 3, 1145, 572, 0, 2716, 2717, 3, 1085, 542, 0, 2717, 2718, 3, 1173, 586, 0, 2718, 2719, 3, 1147, 573, 0, 2719, 2720, 3, 1177, 588, 0, 2720, 2721, 3, 1179, 589, 0, 2721, 2722, 3, 1173, 586, 0, 2722, 2723, 3, 1165, 582, 0, 2723, 344, 1, 0, 0, 0, 2724, 2725, 3, 1147, 573, 0, 2725, 2726, 3, 1165, 582, 0, 2726, 2727, 3, 1145, 572, 0, 2727, 2728, 3, 1085, 542, 0, 2728, 2729, 3, 1173, 586, 0, 2729, 2730, 3, 1147, 573, 0, 2730, 2731, 3, 1183, 591, 0, 2731, 2732, 3, 1173, 586, 0, 2732, 2733, 3, 1155, 577, 0, 2733, 2734, 3, 1177, 588, 0, 2734, 2735, 3, 1147, 573, 0, 2735, 346, 1, 0, 0, 0, 2736, 2737, 3, 1147, 573, 0, 2737, 2738, 3, 1165, 582, 0, 2738, 2739, 3, 1145, 572, 0, 2739, 2740, 3, 1085, 542, 0, 2740, 2741, 3, 1175, 587, 0, 2741, 2742, 3, 1147, 573, 0, 2742, 2743, 3, 1139, 569, 0, 2743, 2744, 3, 1173, 586, 0, 2744, 2745, 3, 1143, 571, 0, 2745, 2746, 3, 1153, 576, 0, 2746, 348, 1, 0, 0, 0, 2747, 2748, 3, 1147, 573, 0, 2748, 2749, 3, 1165, 582, 0, 2749, 2750, 3, 1145, 572, 0, 2750, 2751, 3, 1085, 542, 0, 2751, 2752, 3, 1175, 587, 0, 2752, 2753, 3, 1177, 588, 0, 2753, 2754, 3, 1139, 569, 0, 2754, 2755, 3, 1173, 586, 0, 2755, 2756, 3, 1177, 588, 0, 2756, 350, 1, 0, 0, 0, 2757, 2758, 3, 1147, 573, 0, 2758, 2759, 3, 1165, 582, 0, 2759, 2760, 3, 1145, 572, 0, 2760, 2761, 3, 1085, 542, 0, 2761, 2762, 3, 1175, 587, 0, 2762, 2763, 3, 1177, 588, 0, 2763, 2764, 3, 1173, 586, 0, 2764, 2765, 3, 1155, 577, 0, 2765, 2766, 3, 1165, 582, 0, 2766, 2767, 3, 1151, 575, 0, 2767, 352, 1, 0, 0, 0, 2768, 2769, 3, 1147, 573, 0, 2769, 2770, 3, 1165, 582, 0, 2770, 2771, 3, 1145, 572, 0, 2771, 2772, 3, 1085, 542, 0, 2772, 2773, 3, 1175, 587, 0, 2773, 2774, 3, 1179, 589, 0, 2774, 2775, 3, 1141, 570, 0, 2775, 2776, 3, 1177, 588, 0, 2776, 2777, 3, 1173, 586, 0, 2777, 2778, 3, 1139, 569, 0, 2778, 2779, 3, 1143, 571, 0, 2779, 2780, 3, 1177, 588, 0, 2780, 354, 1, 0, 0, 0, 2781, 2782, 3, 1147, 573, 0, 2782, 2783, 3, 1165, 582, 0, 2783, 2784, 3, 1145, 572, 0, 2784, 2785, 3, 1085, 542, 0, 2785, 2786, 3, 1179, 589, 0, 2786, 2787, 3, 1165, 582, 0, 2787, 2788, 3, 1175, 587, 0, 2788, 2789, 3, 1177, 588, 0, 2789, 2790, 3, 1173, 586, 0, 2790, 2791, 3, 1155, 577, 0, 2791, 2792, 3, 1165, 582, 0, 2792, 2793, 3, 1151, 575, 0, 2793, 356, 1, 0, 0, 0, 2794, 2795, 3, 1147, 573, 0, 2795, 2796, 3, 1165, 582, 0, 2796, 2797, 3, 1145, 572, 0, 2797, 2798, 3, 1085, 542, 0, 2798, 2799, 3, 1183, 591, 0, 2799, 2800, 3, 1173, 586, 0, 2800, 2801, 3, 1155, 577, 0, 2801, 2802, 3, 1177, 588, 0, 2802, 2803, 3, 1147, 573, 0, 2803, 358, 1, 0, 0, 0, 2804, 2805, 3, 1147, 573, 0, 2805, 2806, 3, 1165, 582, 0, 2806, 2807, 3, 1145, 572, 0, 2807, 2808, 3, 1155, 577, 0, 2808, 2809, 3, 1165, 582, 0, 2809, 2810, 3, 1149, 574, 0, 2810, 360, 1, 0, 0, 0, 2811, 2812, 3, 1147, 573, 0, 2812, 2813, 3, 1165, 582, 0, 2813, 2814, 3, 1177, 588, 0, 2814, 2815, 3, 1147, 573, 0, 2815, 2816, 3, 1173, 586, 0, 2816, 362, 1, 0, 0, 0, 2817, 2818, 3, 1147, 573, 0, 2818, 2819, 3, 1165, 582, 0, 2819, 2820, 3, 1177, 588, 0, 2820, 2821, 3, 1173, 586, 0, 2821, 2822, 3, 1187, 593, 0, 2822, 364, 1, 0, 0, 0, 2823, 2824, 3, 1147, 573, 0, 2824, 2825, 3, 1165, 582, 0, 2825, 2826, 3, 1177, 588, 0, 2826, 2827, 3, 1173, 586, 0, 2827, 2828, 3, 1187, 593, 0, 2828, 2829, 3, 1085, 542, 0, 2829, 2830, 3, 1169, 584, 0, 2830, 2831, 3, 1173, 586, 0, 2831, 2832, 3, 1167, 583, 0, 2832, 2833, 3, 1143, 571, 0, 2833, 2834, 3, 1147, 573, 0, 2834, 2835, 3, 1145, 572, 0, 2835, 2836, 3, 1179, 589, 0, 2836, 2837, 3, 1173, 586, 0, 2837, 2838, 3, 1147, 573, 0, 2838, 366, 1, 0, 0, 0, 2839, 2840, 3, 1147, 573, 0, 2840, 2841, 3, 1165, 582, 0, 2841, 2842, 3, 1181, 590, 0, 2842, 2843, 3, 1155, 577, 0, 2843, 2844, 3, 1173, 586, 0, 2844, 2845, 3, 1167, 583, 0, 2845, 2846, 3, 1165, 582, 0, 2846, 2847, 3, 1163, 581, 0, 2847, 2848, 3, 1147, 573, 0, 2848, 2849, 3, 1165, 582, 0, 2849, 2850, 3, 1177, 588, 0, 2850, 368, 1, 0, 0, 0, 2851, 2852, 3, 1147, 573, 0, 2852, 2853, 3, 1167, 583, 0, 2853, 2854, 3, 1169, 584, 0, 2854, 370, 1, 0, 0, 0, 2855, 2856, 3, 1147, 573, 0, 2856, 2857, 3, 1171, 585, 0, 2857, 2858, 3, 1179, 589, 0, 2858, 2859, 3, 1139, 569, 0, 2859, 2860, 3, 1161, 580, 0, 2860, 372, 1, 0, 0, 0, 2861, 2862, 3, 1147, 573, 0, 2862, 2863, 3, 1173, 586, 0, 2863, 2864, 3, 1139, 569, 0, 2864, 2865, 3, 1175, 587, 0, 2865, 2866, 3, 1147, 573, 0, 2866, 374, 1, 0, 0, 0, 2867, 2868, 3, 1147, 573, 0, 2868, 2869, 3, 1173, 586, 0, 2869, 2870, 3, 1173, 586, 0, 2870, 2871, 3, 1167, 583, 0, 2871, 2872, 3, 1173, 586, 0, 2872, 376, 1, 0, 0, 0, 2873, 2874, 3, 1147, 573, 0, 2874, 2875, 3, 1167, 583, 0, 2875, 2876, 3, 1161, 580, 0, 2876, 378, 1, 0, 0, 0, 2877, 2878, 3, 1147, 573, 0, 2878, 2879, 3, 1167, 583, 0, 2879, 2880, 3, 1175, 587, 0, 2880, 380, 1, 0, 0, 0, 2881, 2882, 3, 1147, 573, 0, 2882, 2883, 3, 1175, 587, 0, 2883, 2884, 3, 1143, 571, 0, 2884, 2885, 3, 1139, 569, 0, 2885, 2886, 3, 1169, 584, 0, 2886, 2887, 3, 1147, 573, 0, 2887, 382, 1, 0, 0, 0, 2888, 2889, 3, 1147, 573, 0, 2889, 2890, 3, 1175, 587, 0, 2890, 2891, 3, 1155, 577, 0, 2891, 384, 1, 0, 0, 0, 2892, 2893, 3, 1147, 573, 0, 2893, 2894, 3, 1181, 590, 0, 2894, 2895, 3, 1139, 569, 0, 2895, 2896, 3, 1161, 580, 0, 2896, 2897, 3, 1179, 589, 0, 2897, 2898, 3, 1139, 569, 0, 2898, 2899, 3, 1177, 588, 0, 2899, 2900, 3, 1147, 573, 0, 2900, 386, 1, 0, 0, 0, 2901, 2902, 3, 1147, 573, 0, 2902, 2903, 3, 1181, 590, 0, 2903, 2904, 3, 1147, 573, 0, 2904, 2905, 3, 1165, 582, 0, 2905, 2906, 3, 1177, 588, 0, 2906, 388, 1, 0, 0, 0, 2907, 2908, 3, 1147, 573, 0, 2908, 2909, 3, 1181, 590, 0, 2909, 2910, 3, 1147, 573, 0, 2910, 2911, 3, 1173, 586, 0, 2911, 2912, 3, 1187, 593, 0, 2912, 390, 1, 0, 0, 0, 2913, 2914, 3, 1147, 573, 0, 2914, 2915, 3, 1185, 592, 0, 2915, 2916, 3, 1143, 571, 0, 2916, 2917, 3, 1147, 573, 0, 2917, 2918, 3, 1169, 584, 0, 2918, 2919, 3, 1177, 588, 0, 2919, 2920, 3, 1155, 577, 0, 2920, 2921, 3, 1167, 583, 0, 2921, 2922, 3, 1165, 582, 0, 2922, 392, 1, 0, 0, 0, 2923, 2924, 3, 1147, 573, 0, 2924, 2925, 3, 1185, 592, 0, 2925, 2926, 3, 1143, 571, 0, 2926, 2927, 3, 1161, 580, 0, 2927, 2928, 3, 1179, 589, 0, 2928, 2929, 3, 1175, 587, 0, 2929, 2930, 3, 1155, 577, 0, 2930, 2931, 3, 1181, 590, 0, 2931, 2932, 3, 1147, 573, 0, 2932, 394, 1, 0, 0, 0, 2933, 2934, 3, 1147, 573, 0, 2934, 2935, 3, 1185, 592, 0, 2935, 2936, 3, 1153, 576, 0, 2936, 2937, 3, 1155, 577, 0, 2937, 2938, 3, 1141, 570, 0, 2938, 2939, 3, 1155, 577, 0, 2939, 2940, 3, 1177, 588, 0, 2940, 396, 1, 0, 0, 0, 2941, 2942, 3, 1147, 573, 0, 2942, 2943, 3, 1185, 592, 0, 2943, 2944, 3, 1155, 577, 0, 2944, 2945, 3, 1177, 588, 0, 2945, 398, 1, 0, 0, 0, 2946, 2947, 3, 1147, 573, 0, 2947, 2948, 3, 1185, 592, 0, 2948, 2949, 3, 1169, 584, 0, 2949, 2950, 3, 1167, 583, 0, 2950, 2951, 3, 1173, 586, 0, 2951, 2952, 3, 1177, 588, 0, 2952, 400, 1, 0, 0, 0, 2953, 2954, 3, 1147, 573, 0, 2954, 2955, 3, 1185, 592, 0, 2955, 2956, 3, 1177, 588, 0, 2956, 2957, 3, 1147, 573, 0, 2957, 2958, 3, 1165, 582, 0, 2958, 2959, 3, 1145, 572, 0, 2959, 402, 1, 0, 0, 0, 2960, 2961, 3, 1147, 573, 0, 2961, 2962, 3, 1185, 592, 0, 2962, 2963, 3, 1177, 588, 0, 2963, 2964, 3, 1147, 573, 0, 2964, 2965, 3, 1165, 582, 0, 2965, 2966, 3, 1145, 572, 0, 2966, 2967, 3, 1147, 573, 0, 2967, 2968, 3, 1145, 572, 0, 2968, 404, 1, 0, 0, 0, 2969, 2970, 3, 1147, 573, 0, 2970, 2971, 3, 1185, 592, 0, 2971, 2972, 3, 1177, 588, 0, 2972, 2973, 3, 1147, 573, 0, 2973, 2974, 3, 1173, 586, 0, 2974, 2975, 3, 1165, 582, 0, 2975, 2976, 3, 1139, 569, 0, 2976, 2977, 3, 1161, 580, 0, 2977, 406, 1, 0, 0, 0, 2978, 2979, 3, 1149, 574, 0, 2979, 2980, 3, 1139, 569, 0, 2980, 2981, 3, 1161, 580, 0, 2981, 2982, 3, 1175, 587, 0, 2982, 2983, 3, 1147, 573, 0, 2983, 408, 1, 0, 0, 0, 2984, 2985, 3, 1149, 574, 0, 2985, 2986, 3, 1145, 572, 0, 2986, 410, 1, 0, 0, 0, 2987, 2988, 3, 1149, 574, 0, 2988, 2989, 3, 1155, 577, 0, 2989, 2990, 3, 1161, 580, 0, 2990, 2991, 3, 1147, 573, 0, 2991, 412, 1, 0, 0, 0, 2992, 2993, 3, 1149, 574, 0, 2993, 2994, 3, 1155, 577, 0, 2994, 2995, 3, 1161, 580, 0, 2995, 2996, 3, 1147, 573, 0, 2996, 2997, 3, 1085, 542, 0, 2997, 2998, 3, 1143, 571, 0, 2998, 2999, 3, 1167, 583, 0, 2999, 3000, 3, 1165, 582, 0, 3000, 3001, 3, 1177, 588, 0, 3001, 3002, 3, 1173, 586, 0, 3002, 3003, 3, 1167, 583, 0, 3003, 3004, 3, 1161, 580, 0, 3004, 414, 1, 0, 0, 0, 3005, 3006, 3, 1149, 574, 0, 3006, 3007, 3, 1155, 577, 0, 3007, 3008, 3, 1161, 580, 0, 3008, 3009, 3, 1161, 580, 0, 3009, 3010, 3, 1147, 573, 0, 3010, 3011, 3, 1173, 586, 0, 3011, 416, 1, 0, 0, 0, 3012, 3013, 3, 1149, 574, 0, 3013, 3014, 3, 1155, 577, 0, 3014, 3015, 3, 1165, 582, 0, 3015, 3016, 3, 1139, 569, 0, 3016, 3017, 3, 1161, 580, 0, 3017, 418, 1, 0, 0, 0, 3018, 3019, 3, 1149, 574, 0, 3019, 3020, 3, 1155, 577, 0, 3020, 3021, 3, 1173, 586, 0, 3021, 3022, 3, 1175, 587, 0, 3022, 3023, 3, 1177, 588, 0, 3023, 420, 1, 0, 0, 0, 3024, 3025, 3, 1149, 574, 0, 3025, 3026, 3, 1167, 583, 0, 3026, 3027, 3, 1167, 583, 0, 3027, 3028, 3, 1177, 588, 0, 3028, 3029, 3, 1155, 577, 0, 3029, 3030, 3, 1165, 582, 0, 3030, 3031, 3, 1151, 575, 0, 3031, 422, 1, 0, 0, 0, 3032, 3033, 3, 1149, 574, 0, 3033, 3034, 3, 1167, 583, 0, 3034, 3035, 3, 1173, 586, 0, 3035, 424, 1, 0, 0, 0, 3036, 3037, 3, 1149, 574, 0, 3037, 3038, 3, 1167, 583, 0, 3038, 3039, 3, 1173, 586, 0, 3039, 3040, 3, 1147, 573, 0, 3040, 3041, 3, 1151, 575, 0, 3041, 3042, 3, 1173, 586, 0, 3042, 3043, 3, 1167, 583, 0, 3043, 3044, 3, 1179, 589, 0, 3044, 3045, 3, 1165, 582, 0, 3045, 3046, 3, 1145, 572, 0, 3046, 3047, 3, 1085, 542, 0, 3047, 3048, 3, 1143, 571, 0, 3048, 3049, 3, 1167, 583, 0, 3049, 3050, 3, 1161, 580, 0, 3050, 3051, 3, 1167, 583, 0, 3051, 3052, 3, 1173, 586, 0, 3052, 426, 1, 0, 0, 0, 3053, 3054, 3, 1149, 574, 0, 3054, 3055, 3, 1167, 583, 0, 3055, 3056, 3, 1173, 586, 0, 3056, 3057, 3, 1147, 573, 0, 3057, 3058, 3, 1151, 575, 0, 3058, 3059, 3, 1173, 586, 0, 3059, 3060, 3, 1167, 583, 0, 3060, 3061, 3, 1179, 589, 0, 3061, 3062, 3, 1165, 582, 0, 3062, 3063, 3, 1145, 572, 0, 3063, 3064, 3, 1085, 542, 0, 3064, 3065, 3, 1143, 571, 0, 3065, 3066, 3, 1167, 583, 0, 3066, 3067, 3, 1161, 580, 0, 3067, 3068, 3, 1167, 583, 0, 3068, 3069, 3, 1179, 589, 0, 3069, 3070, 3, 1173, 586, 0, 3070, 428, 1, 0, 0, 0, 3071, 3072, 3, 1149, 574, 0, 3072, 3073, 3, 1173, 586, 0, 3073, 3074, 3, 1167, 583, 0, 3074, 3075, 3, 1163, 581, 0, 3075, 430, 1, 0, 0, 0, 3076, 3077, 3, 1149, 574, 0, 3077, 3078, 3, 1179, 589, 0, 3078, 3079, 3, 1161, 580, 0, 3079, 3080, 3, 1161, 580, 0, 3080, 432, 1, 0, 0, 0, 3081, 3082, 3, 1149, 574, 0, 3082, 3083, 3, 1179, 589, 0, 3083, 3084, 3, 1165, 582, 0, 3084, 3085, 3, 1143, 571, 0, 3085, 3086, 3, 1177, 588, 0, 3086, 3087, 3, 1155, 577, 0, 3087, 3088, 3, 1167, 583, 0, 3088, 3089, 3, 1165, 582, 0, 3089, 434, 1, 0, 0, 0, 3090, 3091, 3, 1149, 574, 0, 3091, 3092, 3, 1179, 589, 0, 3092, 3093, 3, 1165, 582, 0, 3093, 3094, 3, 1143, 571, 0, 3094, 3095, 3, 1177, 588, 0, 3095, 3096, 3, 1155, 577, 0, 3096, 3097, 3, 1167, 583, 0, 3097, 3098, 3, 1165, 582, 0, 3098, 3099, 3, 1165, 582, 0, 3099, 3100, 3, 1139, 569, 0, 3100, 3101, 3, 1163, 581, 0, 3101, 3102, 3, 1147, 573, 0, 3102, 436, 1, 0, 0, 0, 3103, 3104, 3, 1149, 574, 0, 3104, 3105, 3, 1179, 589, 0, 3105, 3106, 3, 1165, 582, 0, 3106, 3107, 3, 1143, 571, 0, 3107, 3108, 3, 1177, 588, 0, 3108, 3109, 3, 1155, 577, 0, 3109, 3110, 3, 1167, 583, 0, 3110, 3111, 3, 1165, 582, 0, 3111, 3112, 3, 1085, 542, 0, 3112, 3113, 3, 1169, 584, 0, 3113, 3114, 3, 1167, 583, 0, 3114, 3115, 3, 1155, 577, 0, 3115, 3116, 3, 1165, 582, 0, 3116, 3117, 3, 1177, 588, 0, 3117, 3118, 3, 1147, 573, 0, 3118, 3119, 3, 1173, 586, 0, 3119, 438, 1, 0, 0, 0, 3120, 3121, 3, 1151, 575, 0, 3121, 3122, 3, 1147, 573, 0, 3122, 3123, 3, 1165, 582, 0, 3123, 3124, 3, 1147, 573, 0, 3124, 3125, 3, 1173, 586, 0, 3125, 3126, 3, 1139, 569, 0, 3126, 3127, 3, 1177, 588, 0, 3127, 3128, 3, 1147, 573, 0, 3128, 440, 1, 0, 0, 0, 3129, 3130, 3, 1151, 575, 0, 3130, 3131, 3, 1167, 583, 0, 3131, 3132, 3, 1141, 570, 0, 3132, 3133, 3, 1139, 569, 0, 3133, 3134, 3, 1143, 571, 0, 3134, 3135, 3, 1159, 579, 0, 3135, 442, 1, 0, 0, 0, 3136, 3137, 3, 1151, 575, 0, 3137, 3138, 3, 1155, 577, 0, 3138, 3139, 3, 1181, 590, 0, 3139, 3140, 3, 1155, 577, 0, 3140, 3141, 3, 1165, 582, 0, 3141, 3142, 3, 1151, 575, 0, 3142, 444, 1, 0, 0, 0, 3143, 3144, 3, 1151, 575, 0, 3144, 3145, 3, 1161, 580, 0, 3145, 3146, 3, 1167, 583, 0, 3146, 3147, 3, 1141, 570, 0, 3147, 3148, 3, 1139, 569, 0, 3148, 3149, 3, 1161, 580, 0, 3149, 446, 1, 0, 0, 0, 3150, 3151, 3, 1151, 575, 0, 3151, 3152, 3, 1167, 583, 0, 3152, 448, 1, 0, 0, 0, 3153, 3154, 3, 1151, 575, 0, 3154, 3155, 3, 1173, 586, 0, 3155, 3156, 3, 1147, 573, 0, 3156, 3157, 3, 1139, 569, 0, 3157, 3158, 3, 1177, 588, 0, 3158, 3159, 3, 1147, 573, 0, 3159, 3160, 3, 1173, 586, 0, 3160, 450, 1, 0, 0, 0, 3161, 3162, 3, 1151, 575, 0, 3162, 3163, 3, 1173, 586, 0, 3163, 3164, 3, 1155, 577, 0, 3164, 3165, 3, 1145, 572, 0, 3165, 452, 1, 0, 0, 0, 3166, 3167, 3, 1151, 575, 0, 3167, 3168, 3, 1173, 586, 0, 3168, 3169, 3, 1167, 583, 0, 3169, 3170, 3, 1179, 589, 0, 3170, 3171, 3, 1169, 584, 0, 3171, 454, 1, 0, 0, 0, 3172, 3173, 3, 1153, 576, 0, 3173, 3174, 3, 1147, 573, 0, 3174, 3175, 3, 1139, 569, 0, 3175, 3176, 3, 1145, 572, 0, 3176, 3177, 3, 1155, 577, 0, 3177, 3178, 3, 1165, 582, 0, 3178, 3179, 3, 1151, 575, 0, 3179, 456, 1, 0, 0, 0, 3180, 3181, 3, 1153, 576, 0, 3181, 3182, 3, 1155, 577, 0, 3182, 3183, 3, 1151, 575, 0, 3183, 3184, 3, 1153, 576, 0, 3184, 3185, 3, 1161, 580, 0, 3185, 3186, 3, 1155, 577, 0, 3186, 3187, 3, 1151, 575, 0, 3187, 3188, 3, 1153, 576, 0, 3188, 3189, 3, 1177, 588, 0, 3189, 458, 1, 0, 0, 0, 3190, 3191, 3, 1153, 576, 0, 3191, 3192, 3, 1155, 577, 0, 3192, 3193, 3, 1151, 575, 0, 3193, 3194, 3, 1153, 576, 0, 3194, 3195, 3, 1085, 542, 0, 3195, 3196, 3, 1181, 590, 0, 3196, 3197, 3, 1139, 569, 0, 3197, 3198, 3, 1161, 580, 0, 3198, 3199, 3, 1179, 589, 0, 3199, 3200, 3, 1147, 573, 0, 3200, 460, 1, 0, 0, 0, 3201, 3202, 3, 1153, 576, 0, 3202, 3203, 3, 1155, 577, 0, 3203, 3204, 3, 1151, 575, 0, 3204, 3205, 3, 1153, 576, 0, 3205, 3206, 3, 1085, 542, 0, 3206, 3207, 3, 1181, 590, 0, 3207, 3208, 3, 1139, 569, 0, 3208, 3209, 3, 1161, 580, 0, 3209, 3210, 3, 1179, 589, 0, 3210, 3211, 3, 1147, 573, 0, 3211, 3212, 3, 1175, 587, 0, 3212, 462, 1, 0, 0, 0, 3213, 3214, 3, 1155, 577, 0, 3214, 3215, 3, 1085, 542, 0, 3215, 3216, 3, 1167, 583, 0, 3216, 464, 1, 0, 0, 0, 3217, 3218, 3, 1155, 577, 0, 3218, 3219, 3, 1085, 542, 0, 3219, 3220, 3, 1167, 583, 0, 3220, 3221, 3, 1085, 542, 0, 3221, 3222, 3, 1143, 571, 0, 3222, 3223, 3, 1167, 583, 0, 3223, 3224, 3, 1165, 582, 0, 3224, 3225, 3, 1177, 588, 0, 3225, 3226, 3, 1173, 586, 0, 3226, 3227, 3, 1167, 583, 0, 3227, 3228, 3, 1161, 580, 0, 3228, 466, 1, 0, 0, 0, 3229, 3230, 3, 1155, 577, 0, 3230, 3231, 3, 1145, 572, 0, 3231, 468, 1, 0, 0, 0, 3232, 3233, 3, 1155, 577, 0, 3233, 3234, 3, 1145, 572, 0, 3234, 3235, 3, 1147, 573, 0, 3235, 3236, 3, 1165, 582, 0, 3236, 3237, 3, 1177, 588, 0, 3237, 3238, 3, 1155, 577, 0, 3238, 3239, 3, 1149, 574, 0, 3239, 3240, 3, 1155, 577, 0, 3240, 3241, 3, 1143, 571, 0, 3241, 3242, 3, 1139, 569, 0, 3242, 3243, 3, 1177, 588, 0, 3243, 3244, 3, 1155, 577, 0, 3244, 3245, 3, 1167, 583, 0, 3245, 3246, 3, 1165, 582, 0, 3246, 470, 1, 0, 0, 0, 3247, 3248, 3, 1155, 577, 0, 3248, 3249, 3, 1149, 574, 0, 3249, 472, 1, 0, 0, 0, 3250, 3251, 3, 1155, 577, 0, 3251, 3252, 3, 1163, 581, 0, 3252, 3253, 3, 1169, 584, 0, 3253, 3254, 3, 1161, 580, 0, 3254, 3255, 3, 1155, 577, 0, 3255, 3256, 3, 1143, 571, 0, 3256, 3257, 3, 1155, 577, 0, 3257, 3258, 3, 1177, 588, 0, 3258, 474, 1, 0, 0, 0, 3259, 3260, 3, 1155, 577, 0, 3260, 3261, 3, 1163, 581, 0, 3261, 3262, 3, 1169, 584, 0, 3262, 3263, 3, 1167, 583, 0, 3263, 3264, 3, 1173, 586, 0, 3264, 3265, 3, 1177, 588, 0, 3265, 476, 1, 0, 0, 0, 3266, 3267, 3, 1155, 577, 0, 3267, 3268, 3, 1165, 582, 0, 3268, 478, 1, 0, 0, 0, 3269, 3270, 3, 1155, 577, 0, 3270, 3271, 3, 1165, 582, 0, 3271, 3272, 3, 1145, 572, 0, 3272, 3273, 3, 1147, 573, 0, 3273, 3274, 3, 1185, 592, 0, 3274, 480, 1, 0, 0, 0, 3275, 3276, 3, 1155, 577, 0, 3276, 3277, 3, 1165, 582, 0, 3277, 3278, 3, 1145, 572, 0, 3278, 3279, 3, 1147, 573, 0, 3279, 3280, 3, 1185, 592, 0, 3280, 3281, 3, 1147, 573, 0, 3281, 3282, 3, 1145, 572, 0, 3282, 482, 1, 0, 0, 0, 3283, 3284, 3, 1155, 577, 0, 3284, 3285, 3, 1165, 582, 0, 3285, 3286, 3, 1145, 572, 0, 3286, 3287, 3, 1155, 577, 0, 3287, 3288, 3, 1143, 571, 0, 3288, 3289, 3, 1139, 569, 0, 3289, 3290, 3, 1177, 588, 0, 3290, 3291, 3, 1147, 573, 0, 3291, 484, 1, 0, 0, 0, 3292, 3293, 3, 1155, 577, 0, 3293, 3294, 3, 1165, 582, 0, 3294, 3295, 3, 1155, 577, 0, 3295, 3296, 3, 1177, 588, 0, 3296, 3297, 3, 1155, 577, 0, 3297, 3298, 3, 1139, 569, 0, 3298, 3299, 3, 1161, 580, 0, 3299, 486, 1, 0, 0, 0, 3300, 3301, 3, 1155, 577, 0, 3301, 3302, 3, 1165, 582, 0, 3302, 3303, 3, 1155, 577, 0, 3303, 3304, 3, 1177, 588, 0, 3304, 3305, 3, 1155, 577, 0, 3305, 3306, 3, 1139, 569, 0, 3306, 3307, 3, 1161, 580, 0, 3307, 3308, 3, 1155, 577, 0, 3308, 3309, 3, 1189, 594, 0, 3309, 3310, 3, 1147, 573, 0, 3310, 488, 1, 0, 0, 0, 3311, 3312, 3, 1155, 577, 0, 3312, 3313, 3, 1165, 582, 0, 3313, 3314, 3, 1155, 577, 0, 3314, 3315, 3, 1177, 588, 0, 3315, 3316, 3, 1155, 577, 0, 3316, 3317, 3, 1139, 569, 0, 3317, 3318, 3, 1177, 588, 0, 3318, 3319, 3, 1147, 573, 0, 3319, 490, 1, 0, 0, 0, 3320, 3321, 3, 1155, 577, 0, 3321, 3322, 3, 1165, 582, 0, 3322, 3323, 3, 1169, 584, 0, 3323, 3324, 3, 1179, 589, 0, 3324, 3325, 3, 1177, 588, 0, 3325, 492, 1, 0, 0, 0, 3326, 3327, 3, 1155, 577, 0, 3327, 3328, 3, 1165, 582, 0, 3328, 3329, 3, 1169, 584, 0, 3329, 3330, 3, 1179, 589, 0, 3330, 3331, 3, 1177, 588, 0, 3331, 3332, 3, 1085, 542, 0, 3332, 3333, 3, 1167, 583, 0, 3333, 3334, 3, 1179, 589, 0, 3334, 3335, 3, 1177, 588, 0, 3335, 3336, 3, 1169, 584, 0, 3336, 3337, 3, 1179, 589, 0, 3337, 3338, 3, 1177, 588, 0, 3338, 494, 1, 0, 0, 0, 3339, 3340, 3, 1155, 577, 0, 3340, 3341, 3, 1165, 582, 0, 3341, 3342, 3, 1175, 587, 0, 3342, 3343, 3, 1169, 584, 0, 3343, 3344, 3, 1147, 573, 0, 3344, 3345, 3, 1143, 571, 0, 3345, 3346, 3, 1177, 588, 0, 3346, 496, 1, 0, 0, 0, 3347, 3348, 3, 1155, 577, 0, 3348, 3349, 3, 1165, 582, 0, 3349, 3350, 3, 1175, 587, 0, 3350, 3351, 3, 1177, 588, 0, 3351, 3352, 3, 1139, 569, 0, 3352, 3353, 3, 1161, 580, 0, 3353, 3354, 3, 1161, 580, 0, 3354, 3355, 3, 1139, 569, 0, 3355, 3356, 3, 1177, 588, 0, 3356, 3357, 3, 1155, 577, 0, 3357, 3358, 3, 1167, 583, 0, 3358, 3359, 3, 1165, 582, 0, 3359, 498, 1, 0, 0, 0, 3360, 3361, 3, 1155, 577, 0, 3361, 3362, 3, 1165, 582, 0, 3362, 3363, 3, 1177, 588, 0, 3363, 3364, 3, 1147, 573, 0, 3364, 3365, 3, 1151, 575, 0, 3365, 3366, 3, 1147, 573, 0, 3366, 3367, 3, 1173, 586, 0, 3367, 500, 1, 0, 0, 0, 3368, 3369, 3, 1155, 577, 0, 3369, 3370, 3, 1165, 582, 0, 3370, 3371, 3, 1177, 588, 0, 3371, 3372, 3, 1167, 583, 0, 3372, 502, 1, 0, 0, 0, 3373, 3374, 3, 1155, 577, 0, 3374, 3375, 3, 1165, 582, 0, 3375, 3376, 3, 1181, 590, 0, 3376, 3377, 3, 1139, 569, 0, 3377, 3378, 3, 1161, 580, 0, 3378, 3379, 3, 1155, 577, 0, 3379, 3380, 3, 1145, 572, 0, 3380, 504, 1, 0, 0, 0, 3381, 3382, 3, 1155, 577, 0, 3382, 3383, 3, 1165, 582, 0, 3383, 3384, 3, 1181, 590, 0, 3384, 3385, 3, 1167, 583, 0, 3385, 3386, 3, 1159, 579, 0, 3386, 3387, 3, 1147, 573, 0, 3387, 506, 1, 0, 0, 0, 3388, 3389, 3, 1155, 577, 0, 3389, 3390, 3, 1175, 587, 0, 3390, 508, 1, 0, 0, 0, 3391, 3392, 3, 1157, 578, 0, 3392, 3393, 3, 1179, 589, 0, 3393, 3394, 3, 1175, 587, 0, 3394, 3395, 3, 1177, 588, 0, 3395, 510, 1, 0, 0, 0, 3396, 3397, 3, 1157, 578, 0, 3397, 3398, 3, 1179, 589, 0, 3398, 3399, 3, 1175, 587, 0, 3399, 3400, 3, 1177, 588, 0, 3400, 3401, 3, 1155, 577, 0, 3401, 3402, 3, 1149, 574, 0, 3402, 3403, 3, 1155, 577, 0, 3403, 3404, 3, 1147, 573, 0, 3404, 3405, 3, 1145, 572, 0, 3405, 512, 1, 0, 0, 0, 3406, 3407, 3, 1159, 579, 0, 3407, 3408, 3, 1139, 569, 0, 3408, 3409, 3, 1165, 582, 0, 3409, 3410, 3, 1157, 578, 0, 3410, 3411, 3, 1155, 577, 0, 3411, 514, 1, 0, 0, 0, 3412, 3413, 3, 1159, 579, 0, 3413, 3414, 3, 1147, 573, 0, 3414, 3415, 3, 1169, 584, 0, 3415, 3416, 3, 1177, 588, 0, 3416, 516, 1, 0, 0, 0, 3417, 3418, 3, 1159, 579, 0, 3418, 3419, 3, 1147, 573, 0, 3419, 3420, 3, 1187, 593, 0, 3420, 518, 1, 0, 0, 0, 3421, 3422, 3, 1159, 579, 0, 3422, 3423, 3, 1147, 573, 0, 3423, 3424, 3, 1187, 593, 0, 3424, 3425, 3, 1141, 570, 0, 3425, 3426, 3, 1167, 583, 0, 3426, 3427, 3, 1139, 569, 0, 3427, 3428, 3, 1173, 586, 0, 3428, 3429, 3, 1145, 572, 0, 3429, 520, 1, 0, 0, 0, 3430, 3431, 3, 1161, 580, 0, 3431, 3432, 3, 1139, 569, 0, 3432, 3433, 3, 1141, 570, 0, 3433, 3434, 3, 1147, 573, 0, 3434, 3435, 3, 1161, 580, 0, 3435, 522, 1, 0, 0, 0, 3436, 3437, 3, 1161, 580, 0, 3437, 3438, 3, 1139, 569, 0, 3438, 3439, 3, 1165, 582, 0, 3439, 3440, 3, 1151, 575, 0, 3440, 3441, 3, 1179, 589, 0, 3441, 3442, 3, 1139, 569, 0, 3442, 3443, 3, 1151, 575, 0, 3443, 3444, 3, 1147, 573, 0, 3444, 524, 1, 0, 0, 0, 3445, 3446, 3, 1161, 580, 0, 3446, 3447, 3, 1139, 569, 0, 3447, 3448, 3, 1175, 587, 0, 3448, 3449, 3, 1177, 588, 0, 3449, 526, 1, 0, 0, 0, 3450, 3451, 3, 1161, 580, 0, 3451, 3452, 3, 1141, 570, 0, 3452, 528, 1, 0, 0, 0, 3453, 3454, 3, 1161, 580, 0, 3454, 3455, 3, 1145, 572, 0, 3455, 530, 1, 0, 0, 0, 3456, 3457, 3, 1161, 580, 0, 3457, 3458, 3, 1147, 573, 0, 3458, 3459, 3, 1139, 569, 0, 3459, 3460, 3, 1145, 572, 0, 3460, 3461, 3, 1155, 577, 0, 3461, 3462, 3, 1165, 582, 0, 3462, 3463, 3, 1151, 575, 0, 3463, 532, 1, 0, 0, 0, 3464, 3465, 3, 1161, 580, 0, 3465, 3466, 3, 1147, 573, 0, 3466, 3467, 3, 1149, 574, 0, 3467, 3468, 3, 1177, 588, 0, 3468, 534, 1, 0, 0, 0, 3469, 3470, 3, 1161, 580, 0, 3470, 3471, 3, 1147, 573, 0, 3471, 3472, 3, 1149, 574, 0, 3472, 3473, 3, 1177, 588, 0, 3473, 3474, 3, 1161, 580, 0, 3474, 3475, 3, 1155, 577, 0, 3475, 3476, 3, 1165, 582, 0, 3476, 3477, 3, 1147, 573, 0, 3477, 536, 1, 0, 0, 0, 3478, 3479, 3, 1161, 580, 0, 3479, 3480, 3, 1147, 573, 0, 3480, 3481, 3, 1165, 582, 0, 3481, 3482, 3, 1151, 575, 0, 3482, 3483, 3, 1177, 588, 0, 3483, 3484, 3, 1153, 576, 0, 3484, 538, 1, 0, 0, 0, 3485, 3486, 3, 1161, 580, 0, 3486, 3487, 3, 1147, 573, 0, 3487, 3488, 3, 1165, 582, 0, 3488, 3489, 3, 1151, 575, 0, 3489, 3490, 3, 1177, 588, 0, 3490, 3491, 3, 1153, 576, 0, 3491, 3492, 3, 1085, 542, 0, 3492, 3493, 3, 1143, 571, 0, 3493, 3494, 3, 1153, 576, 0, 3494, 3495, 3, 1147, 573, 0, 3495, 3496, 3, 1143, 571, 0, 3496, 3497, 3, 1159, 579, 0, 3497, 540, 1, 0, 0, 0, 3498, 3499, 3, 1161, 580, 0, 3499, 3500, 3, 1147, 573, 0, 3500, 3501, 3, 1175, 587, 0, 3501, 3502, 3, 1175, 587, 0, 3502, 542, 1, 0, 0, 0, 3503, 3504, 3, 1161, 580, 0, 3504, 3505, 3, 1155, 577, 0, 3505, 3506, 3, 1141, 570, 0, 3506, 3507, 3, 1139, 569, 0, 3507, 3508, 3, 1143, 571, 0, 3508, 3509, 3, 1143, 571, 0, 3509, 3510, 3, 1147, 573, 0, 3510, 3511, 3, 1175, 587, 0, 3511, 3512, 3, 1175, 587, 0, 3512, 544, 1, 0, 0, 0, 3513, 3514, 3, 1161, 580, 0, 3514, 3515, 3, 1155, 577, 0, 3515, 3516, 3, 1141, 570, 0, 3516, 3517, 3, 1169, 584, 0, 3517, 3518, 3, 1139, 569, 0, 3518, 3519, 3, 1173, 586, 0, 3519, 3520, 3, 1139, 569, 0, 3520, 3521, 3, 1163, 581, 0, 3521, 3522, 3, 1147, 573, 0, 3522, 3523, 3, 1177, 588, 0, 3523, 3524, 3, 1147, 573, 0, 3524, 3525, 3, 1173, 586, 0, 3525, 546, 1, 0, 0, 0, 3526, 3527, 3, 1161, 580, 0, 3527, 3528, 3, 1155, 577, 0, 3528, 3529, 3, 1141, 570, 0, 3529, 3530, 3, 1173, 586, 0, 3530, 3531, 3, 1139, 569, 0, 3531, 3532, 3, 1173, 586, 0, 3532, 3533, 3, 1187, 593, 0, 3533, 548, 1, 0, 0, 0, 3534, 3535, 3, 1161, 580, 0, 3535, 3536, 3, 1155, 577, 0, 3536, 3537, 3, 1163, 581, 0, 3537, 3538, 3, 1155, 577, 0, 3538, 3539, 3, 1177, 588, 0, 3539, 550, 1, 0, 0, 0, 3540, 3541, 3, 1161, 580, 0, 3541, 3542, 3, 1155, 577, 0, 3542, 3543, 3, 1163, 581, 0, 3543, 3544, 3, 1155, 577, 0, 3544, 3545, 3, 1177, 588, 0, 3545, 3546, 3, 1175, 587, 0, 3546, 552, 1, 0, 0, 0, 3547, 3548, 3, 1161, 580, 0, 3548, 3549, 3, 1155, 577, 0, 3549, 3550, 3, 1165, 582, 0, 3550, 3551, 3, 1139, 569, 0, 3551, 3552, 3, 1151, 575, 0, 3552, 3553, 3, 1147, 573, 0, 3553, 554, 1, 0, 0, 0, 3554, 3555, 3, 1161, 580, 0, 3555, 3556, 3, 1155, 577, 0, 3556, 3557, 3, 1165, 582, 0, 3557, 3558, 3, 1139, 569, 0, 3558, 3559, 3, 1151, 575, 0, 3559, 3560, 3, 1147, 573, 0, 3560, 3561, 3, 1085, 542, 0, 3561, 3562, 3, 1143, 571, 0, 3562, 3563, 3, 1167, 583, 0, 3563, 3564, 3, 1179, 589, 0, 3564, 3565, 3, 1165, 582, 0, 3565, 3566, 3, 1177, 588, 0, 3566, 3567, 3, 1147, 573, 0, 3567, 3568, 3, 1173, 586, 0, 3568, 556, 1, 0, 0, 0, 3569, 3570, 3, 1161, 580, 0, 3570, 3571, 3, 1155, 577, 0, 3571, 3572, 3, 1165, 582, 0, 3572, 3573, 3, 1147, 573, 0, 3573, 558, 1, 0, 0, 0, 3574, 3575, 3, 1161, 580, 0, 3575, 3576, 3, 1155, 577, 0, 3576, 3577, 3, 1165, 582, 0, 3577, 3578, 3, 1147, 573, 0, 3578, 3579, 3, 1175, 587, 0, 3579, 560, 1, 0, 0, 0, 3580, 3581, 3, 1161, 580, 0, 3581, 3582, 3, 1155, 577, 0, 3582, 3583, 3, 1165, 582, 0, 3583, 3584, 3, 1147, 573, 0, 3584, 3585, 3, 1085, 542, 0, 3585, 3586, 3, 1143, 571, 0, 3586, 3587, 3, 1167, 583, 0, 3587, 3588, 3, 1179, 589, 0, 3588, 3589, 3, 1165, 582, 0, 3589, 3590, 3, 1177, 588, 0, 3590, 3591, 3, 1147, 573, 0, 3591, 3592, 3, 1173, 586, 0, 3592, 562, 1, 0, 0, 0, 3593, 3594, 3, 1161, 580, 0, 3594, 3595, 3, 1155, 577, 0, 3595, 3596, 3, 1165, 582, 0, 3596, 3597, 3, 1159, 579, 0, 3597, 3598, 3, 1139, 569, 0, 3598, 3599, 3, 1151, 575, 0, 3599, 3600, 3, 1147, 573, 0, 3600, 564, 1, 0, 0, 0, 3601, 3602, 3, 1161, 580, 0, 3602, 3603, 3, 1155, 577, 0, 3603, 3604, 3, 1175, 587, 0, 3604, 3605, 3, 1177, 588, 0, 3605, 566, 1, 0, 0, 0, 3606, 3607, 3, 1161, 580, 0, 3607, 3608, 3, 1167, 583, 0, 3608, 3609, 3, 1143, 571, 0, 3609, 3610, 3, 1139, 569, 0, 3610, 3611, 3, 1161, 580, 0, 3611, 568, 1, 0, 0, 0, 3612, 3613, 3, 1161, 580, 0, 3613, 3614, 3, 1167, 583, 0, 3614, 3615, 3, 1143, 571, 0, 3615, 3616, 3, 1139, 569, 0, 3616, 3617, 3, 1161, 580, 0, 3617, 3618, 3, 1085, 542, 0, 3618, 3619, 3, 1175, 587, 0, 3619, 3620, 3, 1177, 588, 0, 3620, 3621, 3, 1167, 583, 0, 3621, 3622, 3, 1173, 586, 0, 3622, 3623, 3, 1139, 569, 0, 3623, 3624, 3, 1151, 575, 0, 3624, 3625, 3, 1147, 573, 0, 3625, 570, 1, 0, 0, 0, 3626, 3627, 3, 1161, 580, 0, 3627, 3628, 3, 1167, 583, 0, 3628, 3629, 3, 1143, 571, 0, 3629, 3630, 3, 1159, 579, 0, 3630, 572, 1, 0, 0, 0, 3631, 3632, 3, 1161, 580, 0, 3632, 3633, 3, 1167, 583, 0, 3633, 3634, 3, 1165, 582, 0, 3634, 3635, 3, 1151, 575, 0, 3635, 3636, 3, 1085, 542, 0, 3636, 3637, 3, 1145, 572, 0, 3637, 3638, 3, 1139, 569, 0, 3638, 3639, 3, 1177, 588, 0, 3639, 3640, 3, 1147, 573, 0, 3640, 574, 1, 0, 0, 0, 3641, 3642, 3, 1161, 580, 0, 3642, 3643, 3, 1167, 583, 0, 3643, 3644, 3, 1165, 582, 0, 3644, 3645, 3, 1151, 575, 0, 3645, 3646, 3, 1085, 542, 0, 3646, 3647, 3, 1177, 588, 0, 3647, 3648, 3, 1155, 577, 0, 3648, 3649, 3, 1163, 581, 0, 3649, 3650, 3, 1147, 573, 0, 3650, 576, 1, 0, 0, 0, 3651, 3652, 3, 1161, 580, 0, 3652, 3653, 3, 1167, 583, 0, 3653, 3654, 3, 1183, 591, 0, 3654, 3655, 3, 1147, 573, 0, 3655, 3656, 3, 1173, 586, 0, 3656, 578, 1, 0, 0, 0, 3657, 3658, 3, 1161, 580, 0, 3658, 3659, 3, 1167, 583, 0, 3659, 3660, 3, 1183, 591, 0, 3660, 3661, 3, 1161, 580, 0, 3661, 3662, 3, 1155, 577, 0, 3662, 3663, 3, 1151, 575, 0, 3663, 3664, 3, 1153, 576, 0, 3664, 3665, 3, 1177, 588, 0, 3665, 580, 1, 0, 0, 0, 3666, 3667, 3, 1161, 580, 0, 3667, 3668, 3, 1167, 583, 0, 3668, 3669, 3, 1183, 591, 0, 3669, 3670, 3, 1085, 542, 0, 3670, 3671, 3, 1181, 590, 0, 3671, 3672, 3, 1139, 569, 0, 3672, 3673, 3, 1161, 580, 0, 3673, 3674, 3, 1179, 589, 0, 3674, 3675, 3, 1147, 573, 0, 3675, 582, 1, 0, 0, 0, 3676, 3677, 3, 1161, 580, 0, 3677, 3678, 3, 1167, 583, 0, 3678, 3679, 3, 1183, 591, 0, 3679, 3680, 3, 1085, 542, 0, 3680, 3681, 3, 1181, 590, 0, 3681, 3682, 3, 1139, 569, 0, 3682, 3683, 3, 1161, 580, 0, 3683, 3684, 3, 1179, 589, 0, 3684, 3685, 3, 1147, 573, 0, 3685, 3686, 3, 1175, 587, 0, 3686, 584, 1, 0, 0, 0, 3687, 3688, 3, 1163, 581, 0, 3688, 3689, 3, 1147, 573, 0, 3689, 3690, 3, 1163, 581, 0, 3690, 3691, 3, 1167, 583, 0, 3691, 3692, 3, 1173, 586, 0, 3692, 3693, 3, 1187, 593, 0, 3693, 586, 1, 0, 0, 0, 3694, 3695, 3, 1163, 581, 0, 3695, 3696, 3, 1147, 573, 0, 3696, 3697, 3, 1173, 586, 0, 3697, 3698, 3, 1151, 575, 0, 3698, 3699, 3, 1147, 573, 0, 3699, 588, 1, 0, 0, 0, 3700, 3701, 3, 1163, 581, 0, 3701, 3702, 3, 1147, 573, 0, 3702, 3703, 3, 1175, 587, 0, 3703, 3704, 3, 1175, 587, 0, 3704, 3705, 3, 1139, 569, 0, 3705, 3706, 3, 1151, 575, 0, 3706, 3707, 3, 1147, 573, 0, 3707, 590, 1, 0, 0, 0, 3708, 3709, 3, 1163, 581, 0, 3709, 3710, 3, 1163, 581, 0, 3710, 3711, 3, 1145, 572, 0, 3711, 3712, 3, 1145, 572, 0, 3712, 3713, 3, 1187, 593, 0, 3713, 3714, 3, 1187, 593, 0, 3714, 3715, 3, 1187, 593, 0, 3715, 3716, 3, 1187, 593, 0, 3716, 592, 1, 0, 0, 0, 3717, 3718, 3, 1163, 581, 0, 3718, 3719, 3, 1167, 583, 0, 3719, 3720, 3, 1145, 572, 0, 3720, 3721, 3, 1147, 573, 0, 3721, 594, 1, 0, 0, 0, 3722, 3723, 3, 1163, 581, 0, 3723, 3724, 3, 1167, 583, 0, 3724, 3725, 3, 1145, 572, 0, 3725, 3726, 3, 1179, 589, 0, 3726, 3727, 3, 1161, 580, 0, 3727, 3728, 3, 1147, 573, 0, 3728, 3729, 3, 1175, 587, 0, 3729, 596, 1, 0, 0, 0, 3730, 3731, 3, 1163, 581, 0, 3731, 3732, 3, 1167, 583, 0, 3732, 3733, 3, 1173, 586, 0, 3733, 3734, 3, 1147, 573, 0, 3734, 3735, 3, 1085, 542, 0, 3735, 3736, 3, 1161, 580, 0, 3736, 3737, 3, 1139, 569, 0, 3737, 3738, 3, 1141, 570, 0, 3738, 3739, 3, 1147, 573, 0, 3739, 3740, 3, 1161, 580, 0, 3740, 3741, 3, 1175, 587, 0, 3741, 598, 1, 0, 0, 0, 3742, 3743, 3, 1163, 581, 0, 3743, 3744, 3, 1167, 583, 0, 3744, 3745, 3, 1181, 590, 0, 3745, 3746, 3, 1147, 573, 0, 3746, 600, 1, 0, 0, 0, 3747, 3748, 3, 1163, 581, 0, 3748, 3749, 3, 1179, 589, 0, 3749, 3750, 3, 1161, 580, 0, 3750, 3751, 3, 1177, 588, 0, 3751, 3752, 3, 1155, 577, 0, 3752, 3753, 3, 1169, 584, 0, 3753, 3754, 3, 1161, 580, 0, 3754, 3755, 3, 1147, 573, 0, 3755, 602, 1, 0, 0, 0, 3756, 3757, 3, 1163, 581, 0, 3757, 3758, 3, 1179, 589, 0, 3758, 3759, 3, 1161, 580, 0, 3759, 3760, 3, 1177, 588, 0, 3760, 3761, 3, 1155, 577, 0, 3761, 3762, 3, 1169, 584, 0, 3762, 3763, 3, 1161, 580, 0, 3763, 3764, 3, 1187, 593, 0, 3764, 604, 1, 0, 0, 0, 3765, 3766, 3, 1165, 582, 0, 3766, 3767, 3, 1139, 569, 0, 3767, 3768, 3, 1163, 581, 0, 3768, 3769, 3, 1147, 573, 0, 3769, 3770, 3, 1145, 572, 0, 3770, 606, 1, 0, 0, 0, 3771, 3772, 3, 1165, 582, 0, 3772, 3773, 3, 1139, 569, 0, 3773, 3774, 3, 1177, 588, 0, 3774, 3775, 3, 1155, 577, 0, 3775, 3776, 3, 1167, 583, 0, 3776, 3777, 3, 1165, 582, 0, 3777, 3778, 3, 1139, 569, 0, 3778, 3779, 3, 1161, 580, 0, 3779, 608, 1, 0, 0, 0, 3780, 3781, 3, 1165, 582, 0, 3781, 3782, 3, 1139, 569, 0, 3782, 3783, 3, 1177, 588, 0, 3783, 3784, 3, 1155, 577, 0, 3784, 3785, 3, 1167, 583, 0, 3785, 3786, 3, 1165, 582, 0, 3786, 3787, 3, 1139, 569, 0, 3787, 3788, 3, 1161, 580, 0, 3788, 3789, 3, 1085, 542, 0, 3789, 3790, 3, 1147, 573, 0, 3790, 3791, 3, 1145, 572, 0, 3791, 3792, 3, 1155, 577, 0, 3792, 3793, 3, 1177, 588, 0, 3793, 3794, 3, 1147, 573, 0, 3794, 3795, 3, 1145, 572, 0, 3795, 610, 1, 0, 0, 0, 3796, 3797, 3, 1165, 582, 0, 3797, 3798, 3, 1139, 569, 0, 3798, 3799, 3, 1177, 588, 0, 3799, 3800, 3, 1155, 577, 0, 3800, 3801, 3, 1181, 590, 0, 3801, 3802, 3, 1147, 573, 0, 3802, 612, 1, 0, 0, 0, 3803, 3804, 3, 1165, 582, 0, 3804, 3805, 3, 1147, 573, 0, 3805, 3806, 3, 1151, 575, 0, 3806, 3807, 3, 1139, 569, 0, 3807, 3808, 3, 1177, 588, 0, 3808, 3809, 3, 1155, 577, 0, 3809, 3810, 3, 1181, 590, 0, 3810, 3811, 3, 1147, 573, 0, 3811, 614, 1, 0, 0, 0, 3812, 3813, 3, 1165, 582, 0, 3813, 3814, 3, 1147, 573, 0, 3814, 3815, 3, 1177, 588, 0, 3815, 3816, 3, 1183, 591, 0, 3816, 3817, 3, 1167, 583, 0, 3817, 3818, 3, 1173, 586, 0, 3818, 3819, 3, 1159, 579, 0, 3819, 616, 1, 0, 0, 0, 3820, 3821, 3, 1165, 582, 0, 3821, 3822, 3, 1147, 573, 0, 3822, 3823, 3, 1185, 592, 0, 3823, 3824, 3, 1177, 588, 0, 3824, 618, 1, 0, 0, 0, 3825, 3826, 3, 1165, 582, 0, 3826, 3827, 3, 1167, 583, 0, 3827, 620, 1, 0, 0, 0, 3828, 3829, 3, 1165, 582, 0, 3829, 3830, 3, 1167, 583, 0, 3830, 3831, 3, 1085, 542, 0, 3831, 3832, 3, 1147, 573, 0, 3832, 3833, 3, 1143, 571, 0, 3833, 3834, 3, 1153, 576, 0, 3834, 3835, 3, 1167, 583, 0, 3835, 622, 1, 0, 0, 0, 3836, 3837, 3, 1165, 582, 0, 3837, 3838, 3, 1167, 583, 0, 3838, 3839, 3, 1177, 588, 0, 3839, 624, 1, 0, 0, 0, 3840, 3841, 3, 1165, 582, 0, 3841, 3842, 3, 1179, 589, 0, 3842, 3843, 3, 1161, 580, 0, 3843, 3844, 3, 1161, 580, 0, 3844, 626, 1, 0, 0, 0, 3845, 3846, 3, 1165, 582, 0, 3846, 3847, 3, 1179, 589, 0, 3847, 3848, 3, 1161, 580, 0, 3848, 3849, 3, 1161, 580, 0, 3849, 3850, 3, 1175, 587, 0, 3850, 628, 1, 0, 0, 0, 3851, 3852, 3, 1165, 582, 0, 3852, 3853, 3, 1179, 589, 0, 3853, 3854, 3, 1163, 581, 0, 3854, 3855, 3, 1141, 570, 0, 3855, 3856, 3, 1147, 573, 0, 3856, 3857, 3, 1173, 586, 0, 3857, 630, 1, 0, 0, 0, 3858, 3859, 3, 1165, 582, 0, 3859, 3860, 3, 1179, 589, 0, 3860, 3861, 3, 1163, 581, 0, 3861, 3862, 3, 1147, 573, 0, 3862, 3863, 3, 1173, 586, 0, 3863, 3864, 3, 1155, 577, 0, 3864, 3865, 3, 1143, 571, 0, 3865, 632, 1, 0, 0, 0, 3866, 3867, 3, 1165, 582, 0, 3867, 3868, 3, 1179, 589, 0, 3868, 3869, 3, 1163, 581, 0, 3869, 3870, 3, 1147, 573, 0, 3870, 3871, 3, 1173, 586, 0, 3871, 3872, 3, 1155, 577, 0, 3872, 3873, 3, 1143, 571, 0, 3873, 3874, 3, 1085, 542, 0, 3874, 3875, 3, 1145, 572, 0, 3875, 3876, 3, 1139, 569, 0, 3876, 3877, 3, 1177, 588, 0, 3877, 3878, 3, 1147, 573, 0, 3878, 634, 1, 0, 0, 0, 3879, 3880, 3, 1165, 582, 0, 3880, 3881, 3, 1179, 589, 0, 3881, 3882, 3, 1163, 581, 0, 3882, 3883, 3, 1147, 573, 0, 3883, 3884, 3, 1173, 586, 0, 3884, 3885, 3, 1155, 577, 0, 3885, 3886, 3, 1143, 571, 0, 3886, 3887, 3, 1085, 542, 0, 3887, 3888, 3, 1147, 573, 0, 3888, 3889, 3, 1145, 572, 0, 3889, 3890, 3, 1155, 577, 0, 3890, 3891, 3, 1177, 588, 0, 3891, 3892, 3, 1147, 573, 0, 3892, 3893, 3, 1145, 572, 0, 3893, 636, 1, 0, 0, 0, 3894, 3895, 3, 1165, 582, 0, 3895, 3896, 3, 1179, 589, 0, 3896, 3897, 3, 1163, 581, 0, 3897, 3898, 3, 1147, 573, 0, 3898, 3899, 3, 1173, 586, 0, 3899, 3900, 3, 1155, 577, 0, 3900, 3901, 3, 1143, 571, 0, 3901, 3902, 3, 1085, 542, 0, 3902, 3903, 3, 1177, 588, 0, 3903, 3904, 3, 1155, 577, 0, 3904, 3905, 3, 1163, 581, 0, 3905, 3906, 3, 1147, 573, 0, 3906, 638, 1, 0, 0, 0, 3907, 3908, 3, 1167, 583, 0, 3908, 3909, 3, 1141, 570, 0, 3909, 3910, 3, 1157, 578, 0, 3910, 3911, 3, 1147, 573, 0, 3911, 3912, 3, 1143, 571, 0, 3912, 3913, 3, 1177, 588, 0, 3913, 3914, 3, 1085, 542, 0, 3914, 3915, 3, 1143, 571, 0, 3915, 3916, 3, 1167, 583, 0, 3916, 3917, 3, 1163, 581, 0, 3917, 3918, 3, 1169, 584, 0, 3918, 3919, 3, 1179, 589, 0, 3919, 3920, 3, 1177, 588, 0, 3920, 3921, 3, 1147, 573, 0, 3921, 3922, 3, 1173, 586, 0, 3922, 640, 1, 0, 0, 0, 3923, 3924, 3, 1167, 583, 0, 3924, 3925, 3, 1143, 571, 0, 3925, 3926, 3, 1143, 571, 0, 3926, 3927, 3, 1179, 589, 0, 3927, 3928, 3, 1173, 586, 0, 3928, 3929, 3, 1175, 587, 0, 3929, 642, 1, 0, 0, 0, 3930, 3931, 3, 1167, 583, 0, 3931, 3932, 3, 1145, 572, 0, 3932, 3933, 3, 1177, 588, 0, 3933, 644, 1, 0, 0, 0, 3934, 3935, 3, 1167, 583, 0, 3935, 3936, 3, 1149, 574, 0, 3936, 646, 1, 0, 0, 0, 3937, 3938, 3, 1167, 583, 0, 3938, 3939, 3, 1149, 574, 0, 3939, 3940, 3, 1149, 574, 0, 3940, 648, 1, 0, 0, 0, 3941, 3942, 3, 1167, 583, 0, 3942, 3943, 3, 1163, 581, 0, 3943, 3944, 3, 1155, 577, 0, 3944, 3945, 3, 1177, 588, 0, 3945, 3946, 3, 1177, 588, 0, 3946, 3947, 3, 1147, 573, 0, 3947, 3948, 3, 1145, 572, 0, 3948, 650, 1, 0, 0, 0, 3949, 3950, 3, 1167, 583, 0, 3950, 3951, 3, 1165, 582, 0, 3951, 652, 1, 0, 0, 0, 3952, 3953, 3, 1167, 583, 0, 3953, 3954, 3, 1169, 584, 0, 3954, 3955, 3, 1147, 573, 0, 3955, 3956, 3, 1165, 582, 0, 3956, 654, 1, 0, 0, 0, 3957, 3958, 3, 1167, 583, 0, 3958, 3959, 3, 1169, 584, 0, 3959, 3960, 3, 1177, 588, 0, 3960, 3961, 3, 1155, 577, 0, 3961, 3962, 3, 1167, 583, 0, 3962, 3963, 3, 1165, 582, 0, 3963, 3964, 3, 1139, 569, 0, 3964, 3965, 3, 1161, 580, 0, 3965, 656, 1, 0, 0, 0, 3966, 3967, 3, 1167, 583, 0, 3967, 3968, 3, 1173, 586, 0, 3968, 658, 1, 0, 0, 0, 3969, 3970, 3, 1167, 583, 0, 3970, 3971, 3, 1173, 586, 0, 3971, 3972, 3, 1145, 572, 0, 3972, 3973, 3, 1147, 573, 0, 3973, 3974, 3, 1173, 586, 0, 3974, 660, 1, 0, 0, 0, 3975, 3976, 3, 1167, 583, 0, 3976, 3977, 3, 1173, 586, 0, 3977, 3978, 3, 1145, 572, 0, 3978, 3979, 3, 1147, 573, 0, 3979, 3980, 3, 1173, 586, 0, 3980, 3981, 3, 1161, 580, 0, 3981, 3982, 3, 1187, 593, 0, 3982, 662, 1, 0, 0, 0, 3983, 3984, 3, 1167, 583, 0, 3984, 3985, 3, 1173, 586, 0, 3985, 3986, 3, 1151, 575, 0, 3986, 3987, 3, 1139, 569, 0, 3987, 3988, 3, 1165, 582, 0, 3988, 3989, 3, 1155, 577, 0, 3989, 3990, 3, 1189, 594, 0, 3990, 3991, 3, 1139, 569, 0, 3991, 3992, 3, 1177, 588, 0, 3992, 3993, 3, 1155, 577, 0, 3993, 3994, 3, 1167, 583, 0, 3994, 3995, 3, 1165, 582, 0, 3995, 664, 1, 0, 0, 0, 3996, 3997, 3, 1167, 583, 0, 3997, 3998, 3, 1177, 588, 0, 3998, 3999, 3, 1153, 576, 0, 3999, 4000, 3, 1147, 573, 0, 4000, 4001, 3, 1173, 586, 0, 4001, 666, 1, 0, 0, 0, 4002, 4003, 3, 1167, 583, 0, 4003, 4004, 3, 1179, 589, 0, 4004, 4005, 3, 1177, 588, 0, 4005, 4006, 3, 1169, 584, 0, 4006, 4007, 3, 1179, 589, 0, 4007, 4008, 3, 1177, 588, 0, 4008, 668, 1, 0, 0, 0, 4009, 4010, 3, 1167, 583, 0, 4010, 4011, 3, 1181, 590, 0, 4011, 4012, 3, 1147, 573, 0, 4012, 4013, 3, 1173, 586, 0, 4013, 4014, 3, 1149, 574, 0, 4014, 4015, 3, 1161, 580, 0, 4015, 4016, 3, 1167, 583, 0, 4016, 4017, 3, 1183, 591, 0, 4017, 670, 1, 0, 0, 0, 4018, 4019, 3, 1167, 583, 0, 4019, 4020, 3, 1181, 590, 0, 4020, 4021, 3, 1147, 573, 0, 4021, 4022, 3, 1173, 586, 0, 4022, 4023, 3, 1161, 580, 0, 4023, 4024, 3, 1155, 577, 0, 4024, 4025, 3, 1165, 582, 0, 4025, 4026, 3, 1147, 573, 0, 4026, 672, 1, 0, 0, 0, 4027, 4028, 3, 1167, 583, 0, 4028, 4029, 3, 1183, 591, 0, 4029, 4030, 3, 1165, 582, 0, 4030, 674, 1, 0, 0, 0, 4031, 4032, 3, 1169, 584, 0, 4032, 4033, 3, 1139, 569, 0, 4033, 4034, 3, 1143, 571, 0, 4034, 4035, 3, 1159, 579, 0, 4035, 4036, 3, 1147, 573, 0, 4036, 4037, 3, 1145, 572, 0, 4037, 4038, 3, 1085, 542, 0, 4038, 4039, 3, 1145, 572, 0, 4039, 4040, 3, 1147, 573, 0, 4040, 4041, 3, 1143, 571, 0, 4041, 4042, 3, 1155, 577, 0, 4042, 4043, 3, 1163, 581, 0, 4043, 4044, 3, 1139, 569, 0, 4044, 4045, 3, 1161, 580, 0, 4045, 676, 1, 0, 0, 0, 4046, 4047, 3, 1169, 584, 0, 4047, 4048, 3, 1139, 569, 0, 4048, 4049, 3, 1145, 572, 0, 4049, 4050, 3, 1145, 572, 0, 4050, 4051, 3, 1155, 577, 0, 4051, 4052, 3, 1165, 582, 0, 4052, 4053, 3, 1151, 575, 0, 4053, 678, 1, 0, 0, 0, 4054, 4055, 3, 1169, 584, 0, 4055, 4056, 3, 1139, 569, 0, 4056, 4057, 3, 1151, 575, 0, 4057, 4058, 3, 1147, 573, 0, 4058, 680, 1, 0, 0, 0, 4059, 4060, 3, 1169, 584, 0, 4060, 4061, 3, 1139, 569, 0, 4061, 4062, 3, 1151, 575, 0, 4062, 4063, 3, 1147, 573, 0, 4063, 4064, 3, 1085, 542, 0, 4064, 4065, 3, 1143, 571, 0, 4065, 4066, 3, 1167, 583, 0, 4066, 4067, 3, 1179, 589, 0, 4067, 4068, 3, 1165, 582, 0, 4068, 4069, 3, 1177, 588, 0, 4069, 4070, 3, 1147, 573, 0, 4070, 4071, 3, 1173, 586, 0, 4071, 682, 1, 0, 0, 0, 4072, 4073, 3, 1169, 584, 0, 4073, 4074, 3, 1139, 569, 0, 4074, 4075, 3, 1175, 587, 0, 4075, 4076, 3, 1175, 587, 0, 4076, 4077, 3, 1183, 591, 0, 4077, 4078, 3, 1167, 583, 0, 4078, 4079, 3, 1173, 586, 0, 4079, 4080, 3, 1145, 572, 0, 4080, 684, 1, 0, 0, 0, 4081, 4082, 3, 1169, 584, 0, 4082, 4083, 3, 1147, 573, 0, 4083, 4084, 3, 1173, 586, 0, 4084, 4085, 3, 1149, 574, 0, 4085, 4086, 3, 1167, 583, 0, 4086, 4087, 3, 1173, 586, 0, 4087, 4088, 3, 1163, 581, 0, 4088, 686, 1, 0, 0, 0, 4089, 4090, 3, 1169, 584, 0, 4090, 4091, 3, 1149, 574, 0, 4091, 688, 1, 0, 0, 0, 4092, 4093, 3, 1169, 584, 0, 4093, 4094, 3, 1153, 576, 0, 4094, 690, 1, 0, 0, 0, 4095, 4096, 3, 1169, 584, 0, 4096, 4097, 3, 1155, 577, 0, 4097, 4098, 3, 1143, 571, 0, 4098, 692, 1, 0, 0, 0, 4099, 4100, 3, 1169, 584, 0, 4100, 4101, 3, 1155, 577, 0, 4101, 4102, 3, 1143, 571, 0, 4102, 4103, 3, 1177, 588, 0, 4103, 4104, 3, 1179, 589, 0, 4104, 4105, 3, 1173, 586, 0, 4105, 4106, 3, 1147, 573, 0, 4106, 694, 1, 0, 0, 0, 4107, 4108, 3, 1169, 584, 0, 4108, 4109, 3, 1161, 580, 0, 4109, 4110, 3, 1179, 589, 0, 4110, 4111, 3, 1175, 587, 0, 4111, 696, 1, 0, 0, 0, 4112, 4113, 3, 1169, 584, 0, 4113, 4114, 3, 1167, 583, 0, 4114, 4115, 3, 1155, 577, 0, 4115, 4116, 3, 1165, 582, 0, 4116, 4117, 3, 1177, 588, 0, 4117, 4118, 3, 1147, 573, 0, 4118, 4119, 3, 1173, 586, 0, 4119, 698, 1, 0, 0, 0, 4120, 4121, 3, 1169, 584, 0, 4121, 4122, 3, 1167, 583, 0, 4122, 4123, 3, 1175, 587, 0, 4123, 4124, 3, 1155, 577, 0, 4124, 4125, 3, 1177, 588, 0, 4125, 4126, 3, 1155, 577, 0, 4126, 4127, 3, 1167, 583, 0, 4127, 4128, 3, 1165, 582, 0, 4128, 700, 1, 0, 0, 0, 4129, 4130, 3, 1169, 584, 0, 4130, 4131, 3, 1167, 583, 0, 4131, 4132, 3, 1175, 587, 0, 4132, 4133, 3, 1155, 577, 0, 4133, 4134, 3, 1177, 588, 0, 4134, 4135, 3, 1155, 577, 0, 4135, 4136, 3, 1181, 590, 0, 4136, 4137, 3, 1147, 573, 0, 4137, 702, 1, 0, 0, 0, 4138, 4139, 3, 1169, 584, 0, 4139, 4140, 3, 1167, 583, 0, 4140, 4141, 3, 1173, 586, 0, 4141, 4142, 3, 1177, 588, 0, 4142, 704, 1, 0, 0, 0, 4143, 4144, 3, 1169, 584, 0, 4144, 4145, 3, 1173, 586, 0, 4145, 4146, 3, 1155, 577, 0, 4146, 4147, 3, 1165, 582, 0, 4147, 4148, 3, 1177, 588, 0, 4148, 4149, 3, 1147, 573, 0, 4149, 4150, 3, 1173, 586, 0, 4150, 706, 1, 0, 0, 0, 4151, 4152, 3, 1169, 584, 0, 4152, 4153, 3, 1173, 586, 0, 4153, 4154, 3, 1155, 577, 0, 4154, 4155, 3, 1165, 582, 0, 4155, 4156, 3, 1177, 588, 0, 4156, 4157, 3, 1155, 577, 0, 4157, 4158, 3, 1165, 582, 0, 4158, 4159, 3, 1151, 575, 0, 4159, 708, 1, 0, 0, 0, 4160, 4161, 3, 1169, 584, 0, 4161, 4162, 3, 1173, 586, 0, 4162, 4163, 3, 1155, 577, 0, 4163, 4164, 3, 1181, 590, 0, 4164, 4165, 3, 1139, 569, 0, 4165, 4166, 3, 1177, 588, 0, 4166, 4167, 3, 1147, 573, 0, 4167, 710, 1, 0, 0, 0, 4168, 4169, 3, 1169, 584, 0, 4169, 4170, 3, 1173, 586, 0, 4170, 4171, 3, 1167, 583, 0, 4171, 4172, 3, 1143, 571, 0, 4172, 4173, 3, 1147, 573, 0, 4173, 4174, 3, 1145, 572, 0, 4174, 4175, 3, 1179, 589, 0, 4175, 4176, 3, 1173, 586, 0, 4176, 4177, 3, 1147, 573, 0, 4177, 712, 1, 0, 0, 0, 4178, 4179, 3, 1169, 584, 0, 4179, 4180, 3, 1173, 586, 0, 4180, 4181, 3, 1167, 583, 0, 4181, 4182, 3, 1143, 571, 0, 4182, 4183, 3, 1147, 573, 0, 4183, 4184, 3, 1145, 572, 0, 4184, 4185, 3, 1179, 589, 0, 4185, 4186, 3, 1173, 586, 0, 4186, 4187, 3, 1147, 573, 0, 4187, 4188, 3, 1085, 542, 0, 4188, 4189, 3, 1169, 584, 0, 4189, 4190, 3, 1167, 583, 0, 4190, 4191, 3, 1155, 577, 0, 4191, 4192, 3, 1165, 582, 0, 4192, 4193, 3, 1177, 588, 0, 4193, 4194, 3, 1147, 573, 0, 4194, 4195, 3, 1173, 586, 0, 4195, 714, 1, 0, 0, 0, 4196, 4197, 3, 1169, 584, 0, 4197, 4198, 3, 1173, 586, 0, 4198, 4199, 3, 1167, 583, 0, 4199, 4200, 3, 1143, 571, 0, 4200, 4201, 3, 1147, 573, 0, 4201, 4202, 3, 1145, 572, 0, 4202, 4203, 3, 1179, 589, 0, 4203, 4204, 3, 1173, 586, 0, 4204, 4205, 3, 1147, 573, 0, 4205, 4206, 3, 1175, 587, 0, 4206, 716, 1, 0, 0, 0, 4207, 4208, 3, 1169, 584, 0, 4208, 4209, 3, 1173, 586, 0, 4209, 4210, 3, 1167, 583, 0, 4210, 4211, 3, 1143, 571, 0, 4211, 4212, 3, 1147, 573, 0, 4212, 4213, 3, 1147, 573, 0, 4213, 4214, 3, 1145, 572, 0, 4214, 718, 1, 0, 0, 0, 4215, 4216, 3, 1169, 584, 0, 4216, 4217, 3, 1173, 586, 0, 4217, 4218, 3, 1167, 583, 0, 4218, 4219, 3, 1143, 571, 0, 4219, 4220, 3, 1147, 573, 0, 4220, 4221, 3, 1175, 587, 0, 4221, 4222, 3, 1175, 587, 0, 4222, 720, 1, 0, 0, 0, 4223, 4224, 3, 1169, 584, 0, 4224, 4225, 3, 1173, 586, 0, 4225, 4226, 3, 1167, 583, 0, 4226, 4227, 3, 1151, 575, 0, 4227, 4228, 3, 1173, 586, 0, 4228, 4229, 3, 1139, 569, 0, 4229, 4230, 3, 1163, 581, 0, 4230, 722, 1, 0, 0, 0, 4231, 4232, 3, 1169, 584, 0, 4232, 4233, 3, 1173, 586, 0, 4233, 4234, 3, 1167, 583, 0, 4234, 4235, 3, 1151, 575, 0, 4235, 4236, 3, 1173, 586, 0, 4236, 4237, 3, 1139, 569, 0, 4237, 4238, 3, 1163, 581, 0, 4238, 4239, 3, 1085, 542, 0, 4239, 4240, 3, 1155, 577, 0, 4240, 4241, 3, 1145, 572, 0, 4241, 724, 1, 0, 0, 0, 4242, 4243, 3, 1169, 584, 0, 4243, 4244, 3, 1173, 586, 0, 4244, 4245, 3, 1167, 583, 0, 4245, 4246, 3, 1151, 575, 0, 4246, 4247, 3, 1173, 586, 0, 4247, 4248, 3, 1139, 569, 0, 4248, 4249, 3, 1163, 581, 0, 4249, 4250, 3, 1085, 542, 0, 4250, 4251, 3, 1161, 580, 0, 4251, 4252, 3, 1155, 577, 0, 4252, 4253, 3, 1141, 570, 0, 4253, 4254, 3, 1173, 586, 0, 4254, 4255, 3, 1139, 569, 0, 4255, 4256, 3, 1173, 586, 0, 4256, 4257, 3, 1187, 593, 0, 4257, 726, 1, 0, 0, 0, 4258, 4259, 3, 1169, 584, 0, 4259, 4260, 3, 1173, 586, 0, 4260, 4261, 3, 1167, 583, 0, 4261, 4262, 3, 1163, 581, 0, 4262, 4263, 3, 1169, 584, 0, 4263, 4264, 3, 1177, 588, 0, 4264, 728, 1, 0, 0, 0, 4265, 4266, 3, 1169, 584, 0, 4266, 4267, 3, 1179, 589, 0, 4267, 4268, 3, 1173, 586, 0, 4268, 4269, 3, 1151, 575, 0, 4269, 4270, 3, 1147, 573, 0, 4270, 730, 1, 0, 0, 0, 4271, 4272, 3, 1171, 585, 0, 4272, 4273, 3, 1179, 589, 0, 4273, 4274, 3, 1147, 573, 0, 4274, 4275, 3, 1179, 589, 0, 4275, 4276, 3, 1147, 573, 0, 4276, 732, 1, 0, 0, 0, 4277, 4278, 3, 1171, 585, 0, 4278, 4279, 3, 1179, 589, 0, 4279, 4280, 3, 1167, 583, 0, 4280, 4281, 3, 1177, 588, 0, 4281, 4282, 3, 1147, 573, 0, 4282, 734, 1, 0, 0, 0, 4283, 4284, 3, 1171, 585, 0, 4284, 4285, 3, 1179, 589, 0, 4285, 4286, 3, 1167, 583, 0, 4286, 4287, 3, 1177, 588, 0, 4287, 4288, 3, 1147, 573, 0, 4288, 4289, 3, 1175, 587, 0, 4289, 736, 1, 0, 0, 0, 4290, 4291, 3, 1173, 586, 0, 4291, 4292, 3, 1139, 569, 0, 4292, 4293, 3, 1165, 582, 0, 4293, 4294, 3, 1145, 572, 0, 4294, 4295, 3, 1167, 583, 0, 4295, 4296, 3, 1163, 581, 0, 4296, 738, 1, 0, 0, 0, 4297, 4298, 3, 1173, 586, 0, 4298, 4299, 3, 1147, 573, 0, 4299, 4300, 3, 1139, 569, 0, 4300, 4301, 3, 1145, 572, 0, 4301, 4302, 3, 1147, 573, 0, 4302, 4303, 3, 1173, 586, 0, 4303, 740, 1, 0, 0, 0, 4304, 4305, 3, 1173, 586, 0, 4305, 4306, 3, 1147, 573, 0, 4306, 4307, 3, 1163, 581, 0, 4307, 4308, 3, 1167, 583, 0, 4308, 4309, 3, 1177, 588, 0, 4309, 4310, 3, 1147, 573, 0, 4310, 742, 1, 0, 0, 0, 4311, 4312, 3, 1173, 586, 0, 4312, 4313, 3, 1145, 572, 0, 4313, 744, 1, 0, 0, 0, 4314, 4315, 3, 1173, 586, 0, 4315, 4316, 3, 1147, 573, 0, 4316, 4317, 3, 1139, 569, 0, 4317, 4318, 3, 1161, 580, 0, 4318, 746, 1, 0, 0, 0, 4319, 4320, 3, 1173, 586, 0, 4320, 4321, 3, 1147, 573, 0, 4321, 4322, 3, 1139, 569, 0, 4322, 4323, 3, 1145, 572, 0, 4323, 748, 1, 0, 0, 0, 4324, 4325, 3, 1173, 586, 0, 4325, 4326, 3, 1147, 573, 0, 4326, 4327, 3, 1143, 571, 0, 4327, 4328, 3, 1147, 573, 0, 4328, 4329, 3, 1155, 577, 0, 4329, 4330, 3, 1181, 590, 0, 4330, 4331, 3, 1147, 573, 0, 4331, 750, 1, 0, 0, 0, 4332, 4333, 3, 1173, 586, 0, 4333, 4334, 3, 1147, 573, 0, 4334, 4335, 3, 1143, 571, 0, 4335, 4336, 3, 1147, 573, 0, 4336, 4337, 3, 1155, 577, 0, 4337, 4338, 3, 1181, 590, 0, 4338, 4339, 3, 1147, 573, 0, 4339, 4340, 3, 1145, 572, 0, 4340, 752, 1, 0, 0, 0, 4341, 4342, 3, 1173, 586, 0, 4342, 4343, 3, 1147, 573, 0, 4343, 4344, 3, 1143, 571, 0, 4344, 4345, 3, 1167, 583, 0, 4345, 4346, 3, 1173, 586, 0, 4346, 4347, 3, 1145, 572, 0, 4347, 754, 1, 0, 0, 0, 4348, 4349, 3, 1173, 586, 0, 4349, 4350, 3, 1147, 573, 0, 4350, 4351, 3, 1143, 571, 0, 4351, 4352, 3, 1167, 583, 0, 4352, 4353, 3, 1173, 586, 0, 4353, 4354, 3, 1145, 572, 0, 4354, 4355, 3, 1155, 577, 0, 4355, 4356, 3, 1165, 582, 0, 4356, 4357, 3, 1151, 575, 0, 4357, 756, 1, 0, 0, 0, 4358, 4359, 3, 1173, 586, 0, 4359, 4360, 3, 1147, 573, 0, 4360, 4361, 3, 1143, 571, 0, 4361, 4362, 3, 1167, 583, 0, 4362, 4363, 3, 1173, 586, 0, 4363, 4364, 3, 1145, 572, 0, 4364, 4365, 3, 1175, 587, 0, 4365, 758, 1, 0, 0, 0, 4366, 4367, 3, 1173, 586, 0, 4367, 4368, 3, 1147, 573, 0, 4368, 4369, 3, 1143, 571, 0, 4369, 4370, 3, 1179, 589, 0, 4370, 4371, 3, 1173, 586, 0, 4371, 4372, 3, 1175, 587, 0, 4372, 4373, 3, 1155, 577, 0, 4373, 4374, 3, 1181, 590, 0, 4374, 4375, 3, 1147, 573, 0, 4375, 760, 1, 0, 0, 0, 4376, 4377, 3, 1173, 586, 0, 4377, 4378, 3, 1147, 573, 0, 4378, 4379, 3, 1145, 572, 0, 4379, 4380, 3, 1147, 573, 0, 4380, 4381, 3, 1149, 574, 0, 4381, 4382, 3, 1155, 577, 0, 4382, 4383, 3, 1165, 582, 0, 4383, 4384, 3, 1147, 573, 0, 4384, 4385, 3, 1175, 587, 0, 4385, 762, 1, 0, 0, 0, 4386, 4387, 3, 1173, 586, 0, 4387, 4388, 3, 1147, 573, 0, 4388, 4389, 3, 1147, 573, 0, 4389, 4390, 3, 1161, 580, 0, 4390, 764, 1, 0, 0, 0, 4391, 4392, 3, 1173, 586, 0, 4392, 4393, 3, 1147, 573, 0, 4393, 4394, 3, 1149, 574, 0, 4394, 766, 1, 0, 0, 0, 4395, 4396, 3, 1173, 586, 0, 4396, 4397, 3, 1147, 573, 0, 4397, 4398, 3, 1149, 574, 0, 4398, 4399, 3, 1147, 573, 0, 4399, 4400, 3, 1173, 586, 0, 4400, 4401, 3, 1147, 573, 0, 4401, 4402, 3, 1165, 582, 0, 4402, 4403, 3, 1143, 571, 0, 4403, 4404, 3, 1147, 573, 0, 4404, 768, 1, 0, 0, 0, 4405, 4406, 3, 1173, 586, 0, 4406, 4407, 3, 1147, 573, 0, 4407, 4408, 3, 1149, 574, 0, 4408, 4409, 3, 1147, 573, 0, 4409, 4410, 3, 1173, 586, 0, 4410, 4411, 3, 1147, 573, 0, 4411, 4412, 3, 1165, 582, 0, 4412, 4413, 3, 1143, 571, 0, 4413, 4414, 3, 1147, 573, 0, 4414, 4415, 3, 1175, 587, 0, 4415, 770, 1, 0, 0, 0, 4416, 4417, 3, 1173, 586, 0, 4417, 4418, 3, 1147, 573, 0, 4418, 4419, 3, 1161, 580, 0, 4419, 4420, 3, 1139, 569, 0, 4420, 4421, 3, 1177, 588, 0, 4421, 4422, 3, 1155, 577, 0, 4422, 4423, 3, 1181, 590, 0, 4423, 4424, 3, 1147, 573, 0, 4424, 772, 1, 0, 0, 0, 4425, 4426, 3, 1173, 586, 0, 4426, 4427, 3, 1147, 573, 0, 4427, 4428, 3, 1161, 580, 0, 4428, 4429, 3, 1147, 573, 0, 4429, 4430, 3, 1139, 569, 0, 4430, 4431, 3, 1175, 587, 0, 4431, 4432, 3, 1147, 573, 0, 4432, 774, 1, 0, 0, 0, 4433, 4434, 3, 1173, 586, 0, 4434, 4435, 3, 1147, 573, 0, 4435, 4436, 3, 1163, 581, 0, 4436, 4437, 3, 1139, 569, 0, 4437, 4438, 3, 1155, 577, 0, 4438, 4439, 3, 1165, 582, 0, 4439, 4440, 3, 1145, 572, 0, 4440, 4441, 3, 1147, 573, 0, 4441, 4442, 3, 1173, 586, 0, 4442, 776, 1, 0, 0, 0, 4443, 4444, 3, 1173, 586, 0, 4444, 4445, 3, 1147, 573, 0, 4445, 4446, 3, 1163, 581, 0, 4446, 4447, 3, 1139, 569, 0, 4447, 4448, 3, 1173, 586, 0, 4448, 4449, 3, 1159, 579, 0, 4449, 4450, 3, 1175, 587, 0, 4450, 778, 1, 0, 0, 0, 4451, 4452, 3, 1173, 586, 0, 4452, 4453, 3, 1147, 573, 0, 4453, 4454, 3, 1163, 581, 0, 4454, 4455, 3, 1167, 583, 0, 4455, 4456, 3, 1181, 590, 0, 4456, 4457, 3, 1139, 569, 0, 4457, 4458, 3, 1161, 580, 0, 4458, 780, 1, 0, 0, 0, 4459, 4460, 3, 1173, 586, 0, 4460, 4461, 3, 1147, 573, 0, 4461, 4462, 3, 1163, 581, 0, 4462, 4463, 3, 1167, 583, 0, 4463, 4464, 3, 1181, 590, 0, 4464, 4465, 3, 1147, 573, 0, 4465, 782, 1, 0, 0, 0, 4466, 4467, 3, 1173, 586, 0, 4467, 4468, 3, 1147, 573, 0, 4468, 4469, 3, 1165, 582, 0, 4469, 4470, 3, 1139, 569, 0, 4470, 4471, 3, 1163, 581, 0, 4471, 4472, 3, 1147, 573, 0, 4472, 4473, 3, 1175, 587, 0, 4473, 784, 1, 0, 0, 0, 4474, 4475, 3, 1173, 586, 0, 4475, 4476, 3, 1147, 573, 0, 4476, 4477, 3, 1169, 584, 0, 4477, 4478, 3, 1161, 580, 0, 4478, 4479, 3, 1139, 569, 0, 4479, 4480, 3, 1143, 571, 0, 4480, 4481, 3, 1147, 573, 0, 4481, 786, 1, 0, 0, 0, 4482, 4483, 3, 1173, 586, 0, 4483, 4484, 3, 1147, 573, 0, 4484, 4485, 3, 1169, 584, 0, 4485, 4486, 3, 1161, 580, 0, 4486, 4487, 3, 1139, 569, 0, 4487, 4488, 3, 1143, 571, 0, 4488, 4489, 3, 1155, 577, 0, 4489, 4490, 3, 1165, 582, 0, 4490, 4491, 3, 1151, 575, 0, 4491, 788, 1, 0, 0, 0, 4492, 4493, 3, 1173, 586, 0, 4493, 4494, 3, 1147, 573, 0, 4494, 4495, 3, 1169, 584, 0, 4495, 4496, 3, 1167, 583, 0, 4496, 4497, 3, 1173, 586, 0, 4497, 4498, 3, 1177, 588, 0, 4498, 790, 1, 0, 0, 0, 4499, 4500, 3, 1173, 586, 0, 4500, 4501, 3, 1147, 573, 0, 4501, 4502, 3, 1169, 584, 0, 4502, 4503, 3, 1167, 583, 0, 4503, 4504, 3, 1173, 586, 0, 4504, 4505, 3, 1177, 588, 0, 4505, 4506, 3, 1155, 577, 0, 4506, 4507, 3, 1165, 582, 0, 4507, 4508, 3, 1151, 575, 0, 4508, 792, 1, 0, 0, 0, 4509, 4510, 3, 1173, 586, 0, 4510, 4511, 3, 1147, 573, 0, 4511, 4512, 3, 1169, 584, 0, 4512, 4513, 3, 1167, 583, 0, 4513, 4514, 3, 1173, 586, 0, 4514, 4515, 3, 1177, 588, 0, 4515, 4516, 3, 1175, 587, 0, 4516, 794, 1, 0, 0, 0, 4517, 4518, 3, 1173, 586, 0, 4518, 4519, 3, 1147, 573, 0, 4519, 4520, 3, 1171, 585, 0, 4520, 4521, 3, 1179, 589, 0, 4521, 4522, 3, 1155, 577, 0, 4522, 4523, 3, 1173, 586, 0, 4523, 4524, 3, 1147, 573, 0, 4524, 4525, 3, 1145, 572, 0, 4525, 796, 1, 0, 0, 0, 4526, 4527, 3, 1173, 586, 0, 4527, 4528, 3, 1147, 573, 0, 4528, 4529, 3, 1173, 586, 0, 4529, 4530, 3, 1179, 589, 0, 4530, 4531, 3, 1165, 582, 0, 4531, 798, 1, 0, 0, 0, 4532, 4533, 3, 1173, 586, 0, 4533, 4534, 3, 1147, 573, 0, 4534, 4535, 3, 1175, 587, 0, 4535, 4536, 3, 1147, 573, 0, 4536, 4537, 3, 1173, 586, 0, 4537, 4538, 3, 1181, 590, 0, 4538, 4539, 3, 1147, 573, 0, 4539, 800, 1, 0, 0, 0, 4540, 4541, 3, 1173, 586, 0, 4541, 4542, 3, 1147, 573, 0, 4542, 4543, 3, 1175, 587, 0, 4543, 4544, 3, 1147, 573, 0, 4544, 4545, 3, 1173, 586, 0, 4545, 4546, 3, 1181, 590, 0, 4546, 4547, 3, 1147, 573, 0, 4547, 4548, 3, 1085, 542, 0, 4548, 4549, 3, 1181, 590, 0, 4549, 4550, 3, 1155, 577, 0, 4550, 4551, 3, 1145, 572, 0, 4551, 4552, 3, 1147, 573, 0, 4552, 4553, 3, 1167, 583, 0, 4553, 802, 1, 0, 0, 0, 4554, 4555, 3, 1173, 586, 0, 4555, 4556, 3, 1147, 573, 0, 4556, 4557, 3, 1175, 587, 0, 4557, 4558, 3, 1147, 573, 0, 4558, 4559, 3, 1177, 588, 0, 4559, 804, 1, 0, 0, 0, 4560, 4561, 3, 1173, 586, 0, 4561, 4562, 3, 1147, 573, 0, 4562, 4563, 3, 1177, 588, 0, 4563, 4564, 3, 1179, 589, 0, 4564, 4565, 3, 1173, 586, 0, 4565, 4566, 3, 1165, 582, 0, 4566, 806, 1, 0, 0, 0, 4567, 4568, 3, 1173, 586, 0, 4568, 4569, 3, 1147, 573, 0, 4569, 4570, 3, 1177, 588, 0, 4570, 4571, 3, 1179, 589, 0, 4571, 4572, 3, 1173, 586, 0, 4572, 4573, 3, 1165, 582, 0, 4573, 4574, 3, 1085, 542, 0, 4574, 4575, 3, 1143, 571, 0, 4575, 4576, 3, 1167, 583, 0, 4576, 4577, 3, 1145, 572, 0, 4577, 4578, 3, 1147, 573, 0, 4578, 808, 1, 0, 0, 0, 4579, 4580, 3, 1173, 586, 0, 4580, 4581, 3, 1147, 573, 0, 4581, 4582, 3, 1177, 588, 0, 4582, 4583, 3, 1179, 589, 0, 4583, 4584, 3, 1173, 586, 0, 4584, 4585, 3, 1165, 582, 0, 4585, 4586, 3, 1155, 577, 0, 4586, 4587, 3, 1165, 582, 0, 4587, 4588, 3, 1151, 575, 0, 4588, 810, 1, 0, 0, 0, 4589, 4590, 3, 1173, 586, 0, 4590, 4591, 3, 1147, 573, 0, 4591, 4592, 3, 1181, 590, 0, 4592, 4593, 3, 1147, 573, 0, 4593, 4594, 3, 1173, 586, 0, 4594, 4595, 3, 1175, 587, 0, 4595, 4596, 3, 1147, 573, 0, 4596, 4597, 3, 1145, 572, 0, 4597, 812, 1, 0, 0, 0, 4598, 4599, 3, 1173, 586, 0, 4599, 4600, 3, 1147, 573, 0, 4600, 4601, 3, 1183, 591, 0, 4601, 4602, 3, 1155, 577, 0, 4602, 4603, 3, 1165, 582, 0, 4603, 4604, 3, 1145, 572, 0, 4604, 814, 1, 0, 0, 0, 4605, 4606, 3, 1173, 586, 0, 4606, 4607, 3, 1147, 573, 0, 4607, 4608, 3, 1183, 591, 0, 4608, 4609, 3, 1173, 586, 0, 4609, 4610, 3, 1155, 577, 0, 4610, 4611, 3, 1177, 588, 0, 4611, 4612, 3, 1147, 573, 0, 4612, 816, 1, 0, 0, 0, 4613, 4614, 3, 1173, 586, 0, 4614, 4615, 3, 1149, 574, 0, 4615, 818, 1, 0, 0, 0, 4616, 4617, 3, 1173, 586, 0, 4617, 4618, 3, 1153, 576, 0, 4618, 820, 1, 0, 0, 0, 4619, 4620, 3, 1173, 586, 0, 4620, 4621, 3, 1155, 577, 0, 4621, 4622, 3, 1151, 575, 0, 4622, 4623, 3, 1153, 576, 0, 4623, 4624, 3, 1177, 588, 0, 4624, 822, 1, 0, 0, 0, 4625, 4626, 3, 1173, 586, 0, 4626, 4627, 3, 1167, 583, 0, 4627, 4628, 3, 1179, 589, 0, 4628, 4629, 3, 1165, 582, 0, 4629, 4630, 3, 1145, 572, 0, 4630, 4631, 3, 1147, 573, 0, 4631, 4632, 3, 1145, 572, 0, 4632, 824, 1, 0, 0, 0, 4633, 4634, 3, 1173, 586, 0, 4634, 4635, 3, 1179, 589, 0, 4635, 4636, 3, 1165, 582, 0, 4636, 826, 1, 0, 0, 0, 4637, 4638, 3, 1175, 587, 0, 4638, 4639, 3, 1139, 569, 0, 4639, 4640, 3, 1163, 581, 0, 4640, 4641, 3, 1147, 573, 0, 4641, 828, 1, 0, 0, 0, 4642, 4643, 3, 1175, 587, 0, 4643, 4644, 3, 1139, 569, 0, 4644, 4645, 3, 1181, 590, 0, 4645, 4646, 3, 1147, 573, 0, 4646, 830, 1, 0, 0, 0, 4647, 4648, 3, 1175, 587, 0, 4648, 4649, 3, 1143, 571, 0, 4649, 4650, 3, 1173, 586, 0, 4650, 4651, 3, 1147, 573, 0, 4651, 4652, 3, 1147, 573, 0, 4652, 4653, 3, 1165, 582, 0, 4653, 832, 1, 0, 0, 0, 4654, 4655, 3, 1175, 587, 0, 4655, 4656, 3, 1145, 572, 0, 4656, 834, 1, 0, 0, 0, 4657, 4658, 3, 1175, 587, 0, 4658, 4659, 3, 1147, 573, 0, 4659, 4660, 3, 1139, 569, 0, 4660, 4661, 3, 1173, 586, 0, 4661, 4662, 3, 1143, 571, 0, 4662, 4663, 3, 1153, 576, 0, 4663, 836, 1, 0, 0, 0, 4664, 4665, 3, 1175, 587, 0, 4665, 4666, 3, 1147, 573, 0, 4666, 4667, 3, 1143, 571, 0, 4667, 4668, 3, 1177, 588, 0, 4668, 4669, 3, 1155, 577, 0, 4669, 4670, 3, 1167, 583, 0, 4670, 4671, 3, 1165, 582, 0, 4671, 838, 1, 0, 0, 0, 4672, 4673, 3, 1175, 587, 0, 4673, 4674, 3, 1147, 573, 0, 4674, 4675, 3, 1143, 571, 0, 4675, 4676, 3, 1179, 589, 0, 4676, 4677, 3, 1173, 586, 0, 4677, 4678, 3, 1147, 573, 0, 4678, 840, 1, 0, 0, 0, 4679, 4680, 3, 1175, 587, 0, 4680, 4681, 3, 1147, 573, 0, 4681, 4682, 3, 1143, 571, 0, 4682, 4683, 3, 1179, 589, 0, 4683, 4684, 3, 1173, 586, 0, 4684, 4685, 3, 1155, 577, 0, 4685, 4686, 3, 1177, 588, 0, 4686, 4687, 3, 1187, 593, 0, 4687, 842, 1, 0, 0, 0, 4688, 4689, 3, 1175, 587, 0, 4689, 4690, 3, 1147, 573, 0, 4690, 4691, 3, 1151, 575, 0, 4691, 4692, 3, 1163, 581, 0, 4692, 4693, 3, 1147, 573, 0, 4693, 4694, 3, 1165, 582, 0, 4694, 4695, 3, 1177, 588, 0, 4695, 844, 1, 0, 0, 0, 4696, 4697, 3, 1175, 587, 0, 4697, 4698, 3, 1147, 573, 0, 4698, 4699, 3, 1151, 575, 0, 4699, 4700, 3, 1163, 581, 0, 4700, 4701, 3, 1147, 573, 0, 4701, 4702, 3, 1165, 582, 0, 4702, 4703, 3, 1177, 588, 0, 4703, 4704, 3, 1085, 542, 0, 4704, 4705, 3, 1161, 580, 0, 4705, 4706, 3, 1155, 577, 0, 4706, 4707, 3, 1163, 581, 0, 4707, 4708, 3, 1155, 577, 0, 4708, 4709, 3, 1177, 588, 0, 4709, 846, 1, 0, 0, 0, 4710, 4711, 3, 1175, 587, 0, 4711, 4712, 3, 1147, 573, 0, 4712, 4713, 3, 1161, 580, 0, 4713, 4714, 3, 1147, 573, 0, 4714, 4715, 3, 1143, 571, 0, 4715, 4716, 3, 1177, 588, 0, 4716, 848, 1, 0, 0, 0, 4717, 4718, 3, 1175, 587, 0, 4718, 4719, 3, 1147, 573, 0, 4719, 4720, 3, 1165, 582, 0, 4720, 4721, 3, 1145, 572, 0, 4721, 850, 1, 0, 0, 0, 4722, 4723, 3, 1175, 587, 0, 4723, 4724, 3, 1147, 573, 0, 4724, 4725, 3, 1165, 582, 0, 4725, 4726, 3, 1177, 588, 0, 4726, 4727, 3, 1147, 573, 0, 4727, 4728, 3, 1165, 582, 0, 4728, 4729, 3, 1143, 571, 0, 4729, 4730, 3, 1147, 573, 0, 4730, 852, 1, 0, 0, 0, 4731, 4732, 3, 1175, 587, 0, 4732, 4733, 3, 1147, 573, 0, 4733, 4734, 3, 1169, 584, 0, 4734, 4735, 3, 1139, 569, 0, 4735, 4736, 3, 1173, 586, 0, 4736, 4737, 3, 1139, 569, 0, 4737, 4738, 3, 1177, 588, 0, 4738, 4739, 3, 1147, 573, 0, 4739, 854, 1, 0, 0, 0, 4740, 4741, 3, 1175, 587, 0, 4741, 4742, 3, 1147, 573, 0, 4742, 4743, 3, 1171, 585, 0, 4743, 4744, 3, 1179, 589, 0, 4744, 4745, 3, 1147, 573, 0, 4745, 4746, 3, 1165, 582, 0, 4746, 4747, 3, 1143, 571, 0, 4747, 4748, 3, 1147, 573, 0, 4748, 856, 1, 0, 0, 0, 4749, 4750, 3, 1175, 587, 0, 4750, 4751, 3, 1147, 573, 0, 4751, 4752, 3, 1171, 585, 0, 4752, 4753, 3, 1179, 589, 0, 4753, 4754, 3, 1147, 573, 0, 4754, 4755, 3, 1165, 582, 0, 4755, 4756, 3, 1177, 588, 0, 4756, 4757, 3, 1155, 577, 0, 4757, 4758, 3, 1139, 569, 0, 4758, 4759, 3, 1161, 580, 0, 4759, 858, 1, 0, 0, 0, 4760, 4761, 3, 1175, 587, 0, 4761, 4762, 3, 1147, 573, 0, 4762, 4763, 3, 1177, 588, 0, 4763, 860, 1, 0, 0, 0, 4764, 4765, 3, 1175, 587, 0, 4765, 4766, 3, 1153, 576, 0, 4766, 4767, 3, 1139, 569, 0, 4767, 4768, 3, 1173, 586, 0, 4768, 4769, 3, 1147, 573, 0, 4769, 4770, 3, 1145, 572, 0, 4770, 862, 1, 0, 0, 0, 4771, 4772, 3, 1175, 587, 0, 4772, 4773, 3, 1153, 576, 0, 4773, 4774, 3, 1139, 569, 0, 4774, 4775, 3, 1173, 586, 0, 4775, 4776, 3, 1147, 573, 0, 4776, 4777, 3, 1145, 572, 0, 4777, 4778, 3, 1141, 570, 0, 4778, 4779, 3, 1187, 593, 0, 4779, 4780, 3, 1139, 569, 0, 4780, 4781, 3, 1161, 580, 0, 4781, 4782, 3, 1161, 580, 0, 4782, 864, 1, 0, 0, 0, 4783, 4784, 3, 1175, 587, 0, 4784, 4785, 3, 1153, 576, 0, 4785, 4786, 3, 1139, 569, 0, 4786, 4787, 3, 1173, 586, 0, 4787, 4788, 3, 1147, 573, 0, 4788, 4789, 3, 1145, 572, 0, 4789, 4790, 3, 1141, 570, 0, 4790, 4791, 3, 1187, 593, 0, 4791, 4792, 3, 1173, 586, 0, 4792, 4793, 3, 1179, 589, 0, 4793, 4794, 3, 1165, 582, 0, 4794, 4795, 3, 1179, 589, 0, 4795, 4796, 3, 1165, 582, 0, 4796, 4797, 3, 1155, 577, 0, 4797, 4798, 3, 1177, 588, 0, 4798, 866, 1, 0, 0, 0, 4799, 4800, 3, 1175, 587, 0, 4800, 4801, 3, 1153, 576, 0, 4801, 4802, 3, 1139, 569, 0, 4802, 4803, 3, 1173, 586, 0, 4803, 4804, 3, 1155, 577, 0, 4804, 4805, 3, 1165, 582, 0, 4805, 4806, 3, 1151, 575, 0, 4806, 868, 1, 0, 0, 0, 4807, 4808, 3, 1175, 587, 0, 4808, 4809, 3, 1153, 576, 0, 4809, 4810, 3, 1155, 577, 0, 4810, 4811, 3, 1149, 574, 0, 4811, 4812, 3, 1177, 588, 0, 4812, 4813, 3, 1085, 542, 0, 4813, 4814, 3, 1155, 577, 0, 4814, 4815, 3, 1165, 582, 0, 4815, 870, 1, 0, 0, 0, 4816, 4817, 3, 1175, 587, 0, 4817, 4818, 3, 1153, 576, 0, 4818, 4819, 3, 1155, 577, 0, 4819, 4820, 3, 1149, 574, 0, 4820, 4821, 3, 1177, 588, 0, 4821, 4822, 3, 1085, 542, 0, 4822, 4823, 3, 1167, 583, 0, 4823, 4824, 3, 1179, 589, 0, 4824, 4825, 3, 1177, 588, 0, 4825, 872, 1, 0, 0, 0, 4826, 4827, 3, 1175, 587, 0, 4827, 4828, 3, 1153, 576, 0, 4828, 4829, 3, 1167, 583, 0, 4829, 4830, 3, 1173, 586, 0, 4830, 4831, 3, 1177, 588, 0, 4831, 4832, 3, 1085, 542, 0, 4832, 4833, 3, 1145, 572, 0, 4833, 4834, 3, 1139, 569, 0, 4834, 4835, 3, 1177, 588, 0, 4835, 4836, 3, 1147, 573, 0, 4836, 874, 1, 0, 0, 0, 4837, 4838, 3, 1175, 587, 0, 4838, 4839, 3, 1155, 577, 0, 4839, 4840, 3, 1151, 575, 0, 4840, 4841, 3, 1165, 582, 0, 4841, 876, 1, 0, 0, 0, 4842, 4843, 3, 1175, 587, 0, 4843, 4844, 3, 1155, 577, 0, 4844, 4845, 3, 1189, 594, 0, 4845, 4846, 3, 1147, 573, 0, 4846, 878, 1, 0, 0, 0, 4847, 4848, 3, 1175, 587, 0, 4848, 4849, 3, 1167, 583, 0, 4849, 4850, 3, 1173, 586, 0, 4850, 4851, 3, 1177, 588, 0, 4851, 880, 1, 0, 0, 0, 4852, 4853, 3, 1175, 587, 0, 4853, 4854, 3, 1167, 583, 0, 4854, 4855, 3, 1173, 586, 0, 4855, 4856, 3, 1177, 588, 0, 4856, 4857, 3, 1085, 542, 0, 4857, 4858, 3, 1143, 571, 0, 4858, 4859, 3, 1167, 583, 0, 4859, 4860, 3, 1165, 582, 0, 4860, 4861, 3, 1177, 588, 0, 4861, 4862, 3, 1173, 586, 0, 4862, 4863, 3, 1167, 583, 0, 4863, 4864, 3, 1161, 580, 0, 4864, 882, 1, 0, 0, 0, 4865, 4866, 3, 1175, 587, 0, 4866, 4867, 3, 1167, 583, 0, 4867, 4868, 3, 1173, 586, 0, 4868, 4869, 3, 1177, 588, 0, 4869, 4870, 3, 1085, 542, 0, 4870, 4871, 3, 1143, 571, 0, 4871, 4872, 3, 1167, 583, 0, 4872, 4873, 3, 1173, 586, 0, 4873, 4874, 3, 1147, 573, 0, 4874, 4875, 3, 1085, 542, 0, 4875, 4876, 3, 1175, 587, 0, 4876, 4877, 3, 1155, 577, 0, 4877, 4878, 3, 1189, 594, 0, 4878, 4879, 3, 1147, 573, 0, 4879, 884, 1, 0, 0, 0, 4880, 4881, 3, 1175, 587, 0, 4881, 4882, 3, 1167, 583, 0, 4882, 4883, 3, 1173, 586, 0, 4883, 4884, 3, 1177, 588, 0, 4884, 4885, 3, 1085, 542, 0, 4885, 4886, 3, 1149, 574, 0, 4886, 4887, 3, 1155, 577, 0, 4887, 4888, 3, 1161, 580, 0, 4888, 4889, 3, 1147, 573, 0, 4889, 4890, 3, 1085, 542, 0, 4890, 4891, 3, 1175, 587, 0, 4891, 4892, 3, 1155, 577, 0, 4892, 4893, 3, 1189, 594, 0, 4893, 4894, 3, 1147, 573, 0, 4894, 886, 1, 0, 0, 0, 4895, 4896, 3, 1175, 587, 0, 4896, 4897, 3, 1167, 583, 0, 4897, 4898, 3, 1173, 586, 0, 4898, 4899, 3, 1177, 588, 0, 4899, 4900, 3, 1085, 542, 0, 4900, 4901, 3, 1163, 581, 0, 4901, 4902, 3, 1147, 573, 0, 4902, 4903, 3, 1173, 586, 0, 4903, 4904, 3, 1151, 575, 0, 4904, 4905, 3, 1147, 573, 0, 4905, 888, 1, 0, 0, 0, 4906, 4907, 3, 1175, 587, 0, 4907, 4908, 3, 1167, 583, 0, 4908, 4909, 3, 1173, 586, 0, 4909, 4910, 3, 1177, 588, 0, 4910, 4911, 3, 1085, 542, 0, 4911, 4912, 3, 1163, 581, 0, 4912, 4913, 3, 1147, 573, 0, 4913, 4914, 3, 1175, 587, 0, 4914, 4915, 3, 1175, 587, 0, 4915, 4916, 3, 1139, 569, 0, 4916, 4917, 3, 1151, 575, 0, 4917, 4918, 3, 1147, 573, 0, 4918, 890, 1, 0, 0, 0, 4919, 4920, 3, 1175, 587, 0, 4920, 4921, 3, 1167, 583, 0, 4921, 4922, 3, 1173, 586, 0, 4922, 4923, 3, 1177, 588, 0, 4923, 4924, 3, 1085, 542, 0, 4924, 4925, 3, 1163, 581, 0, 4925, 4926, 3, 1167, 583, 0, 4926, 4927, 3, 1145, 572, 0, 4927, 4928, 3, 1147, 573, 0, 4928, 4929, 3, 1085, 542, 0, 4929, 4930, 3, 1175, 587, 0, 4930, 4931, 3, 1155, 577, 0, 4931, 4932, 3, 1189, 594, 0, 4932, 4933, 3, 1147, 573, 0, 4933, 892, 1, 0, 0, 0, 4934, 4935, 3, 1175, 587, 0, 4935, 4936, 3, 1167, 583, 0, 4936, 4937, 3, 1173, 586, 0, 4937, 4938, 3, 1177, 588, 0, 4938, 4939, 3, 1085, 542, 0, 4939, 4940, 3, 1173, 586, 0, 4940, 4941, 3, 1147, 573, 0, 4941, 4942, 3, 1177, 588, 0, 4942, 4943, 3, 1179, 589, 0, 4943, 4944, 3, 1173, 586, 0, 4944, 4945, 3, 1165, 582, 0, 4945, 894, 1, 0, 0, 0, 4946, 4947, 3, 1175, 587, 0, 4947, 4948, 3, 1167, 583, 0, 4948, 4949, 3, 1179, 589, 0, 4949, 4950, 3, 1173, 586, 0, 4950, 4951, 3, 1143, 571, 0, 4951, 4952, 3, 1147, 573, 0, 4952, 896, 1, 0, 0, 0, 4953, 4954, 3, 1175, 587, 0, 4954, 4955, 3, 1167, 583, 0, 4955, 4956, 3, 1179, 589, 0, 4956, 4957, 3, 1173, 586, 0, 4957, 4958, 3, 1143, 571, 0, 4958, 4959, 3, 1147, 573, 0, 4959, 4960, 3, 1085, 542, 0, 4960, 4961, 3, 1143, 571, 0, 4961, 4962, 3, 1167, 583, 0, 4962, 4963, 3, 1163, 581, 0, 4963, 4964, 3, 1169, 584, 0, 4964, 4965, 3, 1179, 589, 0, 4965, 4966, 3, 1177, 588, 0, 4966, 4967, 3, 1147, 573, 0, 4967, 4968, 3, 1173, 586, 0, 4968, 898, 1, 0, 0, 0, 4969, 4970, 3, 1175, 587, 0, 4970, 4971, 3, 1169, 584, 0, 4971, 4972, 3, 1139, 569, 0, 4972, 4973, 3, 1143, 571, 0, 4973, 4974, 3, 1147, 573, 0, 4974, 900, 1, 0, 0, 0, 4975, 4976, 3, 1175, 587, 0, 4976, 4977, 3, 1169, 584, 0, 4977, 4978, 3, 1139, 569, 0, 4978, 4979, 3, 1143, 571, 0, 4979, 4980, 3, 1147, 573, 0, 4980, 4981, 3, 1175, 587, 0, 4981, 902, 1, 0, 0, 0, 4982, 4983, 3, 1175, 587, 0, 4983, 4984, 3, 1169, 584, 0, 4984, 4985, 3, 1147, 573, 0, 4985, 4986, 3, 1143, 571, 0, 4986, 4987, 3, 1155, 577, 0, 4987, 4988, 3, 1139, 569, 0, 4988, 4989, 3, 1161, 580, 0, 4989, 4990, 3, 1085, 542, 0, 4990, 4991, 3, 1165, 582, 0, 4991, 4992, 3, 1139, 569, 0, 4992, 4993, 3, 1163, 581, 0, 4993, 4994, 3, 1147, 573, 0, 4994, 4995, 3, 1175, 587, 0, 4995, 904, 1, 0, 0, 0, 4996, 4997, 3, 1175, 587, 0, 4997, 4998, 3, 1177, 588, 0, 4998, 4999, 3, 1139, 569, 0, 4999, 5000, 3, 1165, 582, 0, 5000, 5001, 3, 1145, 572, 0, 5001, 5002, 3, 1139, 569, 0, 5002, 5003, 3, 1173, 586, 0, 5003, 5004, 3, 1145, 572, 0, 5004, 906, 1, 0, 0, 0, 5005, 5006, 3, 1175, 587, 0, 5006, 5007, 3, 1177, 588, 0, 5007, 5008, 3, 1139, 569, 0, 5008, 5009, 3, 1165, 582, 0, 5009, 5010, 3, 1145, 572, 0, 5010, 5011, 3, 1139, 569, 0, 5011, 5012, 3, 1173, 586, 0, 5012, 5013, 3, 1145, 572, 0, 5013, 5014, 3, 1085, 542, 0, 5014, 5015, 5, 49, 0, 0, 5015, 908, 1, 0, 0, 0, 5016, 5017, 3, 1175, 587, 0, 5017, 5018, 3, 1177, 588, 0, 5018, 5019, 3, 1139, 569, 0, 5019, 5020, 3, 1165, 582, 0, 5020, 5021, 3, 1145, 572, 0, 5021, 5022, 3, 1139, 569, 0, 5022, 5023, 3, 1173, 586, 0, 5023, 5024, 3, 1145, 572, 0, 5024, 5025, 3, 1085, 542, 0, 5025, 5026, 5, 50, 0, 0, 5026, 910, 1, 0, 0, 0, 5027, 5028, 3, 1175, 587, 0, 5028, 5029, 3, 1177, 588, 0, 5029, 5030, 3, 1139, 569, 0, 5030, 5031, 3, 1173, 586, 0, 5031, 5032, 3, 1177, 588, 0, 5032, 912, 1, 0, 0, 0, 5033, 5034, 3, 1175, 587, 0, 5034, 5035, 3, 1177, 588, 0, 5035, 5036, 3, 1139, 569, 0, 5036, 5037, 3, 1177, 588, 0, 5037, 5038, 3, 1179, 589, 0, 5038, 5039, 3, 1175, 587, 0, 5039, 914, 1, 0, 0, 0, 5040, 5041, 3, 1175, 587, 0, 5041, 5042, 3, 1177, 588, 0, 5042, 5043, 3, 1167, 583, 0, 5043, 5044, 3, 1169, 584, 0, 5044, 916, 1, 0, 0, 0, 5045, 5046, 3, 1175, 587, 0, 5046, 5047, 3, 1177, 588, 0, 5047, 5048, 3, 1173, 586, 0, 5048, 5049, 3, 1155, 577, 0, 5049, 5050, 3, 1165, 582, 0, 5050, 5051, 3, 1151, 575, 0, 5051, 918, 1, 0, 0, 0, 5052, 5053, 3, 1175, 587, 0, 5053, 5054, 3, 1179, 589, 0, 5054, 5055, 3, 1141, 570, 0, 5055, 5056, 3, 1085, 542, 0, 5056, 5057, 3, 1171, 585, 0, 5057, 5058, 3, 1179, 589, 0, 5058, 5059, 3, 1147, 573, 0, 5059, 5060, 3, 1179, 589, 0, 5060, 5061, 3, 1147, 573, 0, 5061, 5062, 3, 1085, 542, 0, 5062, 5063, 5, 49, 0, 0, 5063, 920, 1, 0, 0, 0, 5064, 5065, 3, 1175, 587, 0, 5065, 5066, 3, 1179, 589, 0, 5066, 5067, 3, 1141, 570, 0, 5067, 5068, 3, 1085, 542, 0, 5068, 5069, 3, 1171, 585, 0, 5069, 5070, 3, 1179, 589, 0, 5070, 5071, 3, 1147, 573, 0, 5071, 5072, 3, 1179, 589, 0, 5072, 5073, 3, 1147, 573, 0, 5073, 5074, 3, 1085, 542, 0, 5074, 5075, 5, 50, 0, 0, 5075, 922, 1, 0, 0, 0, 5076, 5077, 3, 1175, 587, 0, 5077, 5078, 3, 1179, 589, 0, 5078, 5079, 3, 1141, 570, 0, 5079, 5080, 3, 1085, 542, 0, 5080, 5081, 3, 1171, 585, 0, 5081, 5082, 3, 1179, 589, 0, 5082, 5083, 3, 1147, 573, 0, 5083, 5084, 3, 1179, 589, 0, 5084, 5085, 3, 1147, 573, 0, 5085, 5086, 3, 1085, 542, 0, 5086, 5087, 5, 51, 0, 0, 5087, 924, 1, 0, 0, 0, 5088, 5089, 3, 1175, 587, 0, 5089, 5090, 3, 1179, 589, 0, 5090, 5091, 3, 1141, 570, 0, 5091, 5092, 3, 1177, 588, 0, 5092, 5093, 3, 1173, 586, 0, 5093, 5094, 3, 1139, 569, 0, 5094, 5095, 3, 1143, 571, 0, 5095, 5096, 3, 1177, 588, 0, 5096, 926, 1, 0, 0, 0, 5097, 5098, 3, 1175, 587, 0, 5098, 5099, 3, 1179, 589, 0, 5099, 5100, 3, 1163, 581, 0, 5100, 928, 1, 0, 0, 0, 5101, 5102, 3, 1175, 587, 0, 5102, 5103, 3, 1179, 589, 0, 5103, 5104, 3, 1169, 584, 0, 5104, 5105, 3, 1169, 584, 0, 5105, 5106, 3, 1173, 586, 0, 5106, 5107, 3, 1147, 573, 0, 5107, 5108, 3, 1175, 587, 0, 5108, 5109, 3, 1175, 587, 0, 5109, 930, 1, 0, 0, 0, 5110, 5111, 3, 1175, 587, 0, 5111, 5112, 3, 1187, 593, 0, 5112, 5113, 3, 1163, 581, 0, 5113, 5114, 3, 1141, 570, 0, 5114, 5115, 3, 1167, 583, 0, 5115, 5116, 3, 1161, 580, 0, 5116, 932, 1, 0, 0, 0, 5117, 5118, 3, 1175, 587, 0, 5118, 5119, 3, 1187, 593, 0, 5119, 5120, 3, 1163, 581, 0, 5120, 5121, 3, 1141, 570, 0, 5121, 5122, 3, 1167, 583, 0, 5122, 5123, 3, 1161, 580, 0, 5123, 5124, 3, 1155, 577, 0, 5124, 5125, 3, 1143, 571, 0, 5125, 934, 1, 0, 0, 0, 5126, 5127, 3, 1175, 587, 0, 5127, 5128, 3, 1187, 593, 0, 5128, 5129, 3, 1165, 582, 0, 5129, 5130, 3, 1143, 571, 0, 5130, 936, 1, 0, 0, 0, 5131, 5132, 3, 1175, 587, 0, 5132, 5133, 3, 1187, 593, 0, 5133, 5134, 3, 1165, 582, 0, 5134, 5135, 3, 1143, 571, 0, 5135, 5136, 3, 1153, 576, 0, 5136, 5137, 3, 1173, 586, 0, 5137, 5138, 3, 1167, 583, 0, 5138, 5139, 3, 1165, 582, 0, 5139, 5140, 3, 1155, 577, 0, 5140, 5141, 3, 1189, 594, 0, 5141, 5142, 3, 1147, 573, 0, 5142, 5143, 3, 1145, 572, 0, 5143, 938, 1, 0, 0, 0, 5144, 5145, 3, 1177, 588, 0, 5145, 5146, 3, 1139, 569, 0, 5146, 5147, 3, 1141, 570, 0, 5147, 5148, 3, 1161, 580, 0, 5148, 5149, 3, 1147, 573, 0, 5149, 940, 1, 0, 0, 0, 5150, 5151, 3, 1177, 588, 0, 5151, 5152, 3, 1139, 569, 0, 5152, 5153, 3, 1161, 580, 0, 5153, 5154, 3, 1161, 580, 0, 5154, 5155, 3, 1187, 593, 0, 5155, 942, 1, 0, 0, 0, 5156, 5157, 3, 1177, 588, 0, 5157, 5158, 3, 1139, 569, 0, 5158, 5159, 3, 1161, 580, 0, 5159, 5160, 3, 1161, 580, 0, 5160, 5161, 3, 1187, 593, 0, 5161, 5162, 3, 1155, 577, 0, 5162, 5163, 3, 1165, 582, 0, 5163, 5164, 3, 1151, 575, 0, 5164, 944, 1, 0, 0, 0, 5165, 5166, 3, 1177, 588, 0, 5166, 5167, 3, 1139, 569, 0, 5167, 5168, 3, 1175, 587, 0, 5168, 5169, 3, 1159, 579, 0, 5169, 946, 1, 0, 0, 0, 5170, 5171, 3, 1177, 588, 0, 5171, 5172, 3, 1139, 569, 0, 5172, 5173, 3, 1169, 584, 0, 5173, 5174, 3, 1147, 573, 0, 5174, 948, 1, 0, 0, 0, 5175, 5176, 3, 1177, 588, 0, 5176, 5177, 3, 1147, 573, 0, 5177, 5178, 3, 1173, 586, 0, 5178, 5179, 3, 1163, 581, 0, 5179, 5180, 3, 1155, 577, 0, 5180, 5181, 3, 1165, 582, 0, 5181, 5182, 3, 1139, 569, 0, 5182, 5183, 3, 1161, 580, 0, 5183, 950, 1, 0, 0, 0, 5184, 5185, 3, 1177, 588, 0, 5185, 5186, 3, 1147, 573, 0, 5186, 5187, 3, 1173, 586, 0, 5187, 5188, 3, 1163, 581, 0, 5188, 5189, 3, 1155, 577, 0, 5189, 5190, 3, 1165, 582, 0, 5190, 5191, 3, 1139, 569, 0, 5191, 5192, 3, 1177, 588, 0, 5192, 5193, 3, 1147, 573, 0, 5193, 952, 1, 0, 0, 0, 5194, 5195, 3, 1177, 588, 0, 5195, 5196, 3, 1147, 573, 0, 5196, 5197, 3, 1175, 587, 0, 5197, 5198, 3, 1177, 588, 0, 5198, 954, 1, 0, 0, 0, 5199, 5200, 3, 1177, 588, 0, 5200, 5201, 3, 1147, 573, 0, 5201, 5202, 3, 1185, 592, 0, 5202, 5203, 3, 1177, 588, 0, 5203, 956, 1, 0, 0, 0, 5204, 5205, 3, 1177, 588, 0, 5205, 5206, 3, 1153, 576, 0, 5206, 5207, 3, 1139, 569, 0, 5207, 5208, 3, 1165, 582, 0, 5208, 958, 1, 0, 0, 0, 5209, 5210, 3, 1177, 588, 0, 5210, 5211, 3, 1153, 576, 0, 5211, 5212, 3, 1147, 573, 0, 5212, 5213, 3, 1165, 582, 0, 5213, 960, 1, 0, 0, 0, 5214, 5215, 3, 1177, 588, 0, 5215, 5216, 3, 1153, 576, 0, 5216, 5217, 3, 1173, 586, 0, 5217, 5218, 3, 1147, 573, 0, 5218, 5219, 3, 1139, 569, 0, 5219, 5220, 3, 1145, 572, 0, 5220, 962, 1, 0, 0, 0, 5221, 5222, 3, 1177, 588, 0, 5222, 5223, 3, 1153, 576, 0, 5223, 5224, 3, 1173, 586, 0, 5224, 5225, 3, 1147, 573, 0, 5225, 5226, 3, 1139, 569, 0, 5226, 5227, 3, 1145, 572, 0, 5227, 5228, 3, 1085, 542, 0, 5228, 5229, 3, 1161, 580, 0, 5229, 5230, 3, 1167, 583, 0, 5230, 5231, 3, 1143, 571, 0, 5231, 5232, 3, 1139, 569, 0, 5232, 5233, 3, 1161, 580, 0, 5233, 964, 1, 0, 0, 0, 5234, 5235, 3, 1177, 588, 0, 5235, 5236, 3, 1153, 576, 0, 5236, 5237, 3, 1173, 586, 0, 5237, 5238, 3, 1167, 583, 0, 5238, 5239, 3, 1179, 589, 0, 5239, 5240, 3, 1151, 575, 0, 5240, 5241, 3, 1153, 576, 0, 5241, 966, 1, 0, 0, 0, 5242, 5243, 3, 1177, 588, 0, 5243, 5244, 3, 1153, 576, 0, 5244, 5245, 3, 1173, 586, 0, 5245, 5246, 3, 1179, 589, 0, 5246, 968, 1, 0, 0, 0, 5247, 5248, 3, 1177, 588, 0, 5248, 5249, 3, 1155, 577, 0, 5249, 5250, 3, 1163, 581, 0, 5250, 5251, 3, 1147, 573, 0, 5251, 970, 1, 0, 0, 0, 5252, 5253, 3, 1177, 588, 0, 5253, 5254, 3, 1155, 577, 0, 5254, 5255, 3, 1163, 581, 0, 5255, 5256, 3, 1147, 573, 0, 5256, 5257, 3, 1173, 586, 0, 5257, 972, 1, 0, 0, 0, 5258, 5259, 3, 1177, 588, 0, 5259, 5260, 3, 1155, 577, 0, 5260, 5261, 3, 1163, 581, 0, 5261, 5262, 3, 1147, 573, 0, 5262, 5263, 3, 1175, 587, 0, 5263, 974, 1, 0, 0, 0, 5264, 5265, 3, 1177, 588, 0, 5265, 5266, 3, 1155, 577, 0, 5266, 5267, 3, 1177, 588, 0, 5267, 5268, 3, 1161, 580, 0, 5268, 5269, 3, 1147, 573, 0, 5269, 976, 1, 0, 0, 0, 5270, 5271, 3, 1177, 588, 0, 5271, 5272, 3, 1167, 583, 0, 5272, 978, 1, 0, 0, 0, 5273, 5274, 3, 1177, 588, 0, 5274, 5275, 3, 1167, 583, 0, 5275, 5276, 3, 1145, 572, 0, 5276, 5277, 3, 1139, 569, 0, 5277, 5278, 3, 1187, 593, 0, 5278, 5279, 3, 1175, 587, 0, 5279, 5280, 3, 1085, 542, 0, 5280, 5281, 3, 1145, 572, 0, 5281, 5282, 3, 1139, 569, 0, 5282, 5283, 3, 1177, 588, 0, 5283, 5284, 3, 1147, 573, 0, 5284, 980, 1, 0, 0, 0, 5285, 5286, 3, 1177, 588, 0, 5286, 5287, 3, 1167, 583, 0, 5287, 5288, 3, 1145, 572, 0, 5288, 5289, 3, 1139, 569, 0, 5289, 5290, 3, 1187, 593, 0, 5290, 5291, 3, 1175, 587, 0, 5291, 5292, 3, 1085, 542, 0, 5292, 5293, 3, 1165, 582, 0, 5293, 5294, 3, 1139, 569, 0, 5294, 5295, 3, 1163, 581, 0, 5295, 5296, 3, 1147, 573, 0, 5296, 982, 1, 0, 0, 0, 5297, 5298, 3, 1177, 588, 0, 5298, 5299, 3, 1167, 583, 0, 5299, 5300, 3, 1169, 584, 0, 5300, 984, 1, 0, 0, 0, 5301, 5302, 3, 1177, 588, 0, 5302, 5303, 3, 1173, 586, 0, 5303, 5304, 3, 1139, 569, 0, 5304, 5305, 3, 1155, 577, 0, 5305, 5306, 3, 1161, 580, 0, 5306, 5307, 3, 1155, 577, 0, 5307, 5308, 3, 1165, 582, 0, 5308, 5309, 3, 1151, 575, 0, 5309, 986, 1, 0, 0, 0, 5310, 5311, 3, 1177, 588, 0, 5311, 5312, 3, 1173, 586, 0, 5312, 5313, 3, 1179, 589, 0, 5313, 5314, 3, 1147, 573, 0, 5314, 988, 1, 0, 0, 0, 5315, 5316, 3, 1177, 588, 0, 5316, 5317, 3, 1173, 586, 0, 5317, 5318, 3, 1179, 589, 0, 5318, 5319, 3, 1165, 582, 0, 5319, 5320, 3, 1143, 571, 0, 5320, 5321, 3, 1139, 569, 0, 5321, 5322, 3, 1177, 588, 0, 5322, 5323, 3, 1147, 573, 0, 5323, 5324, 3, 1145, 572, 0, 5324, 990, 1, 0, 0, 0, 5325, 5326, 3, 1177, 588, 0, 5326, 5327, 3, 1187, 593, 0, 5327, 5328, 3, 1169, 584, 0, 5328, 5329, 3, 1147, 573, 0, 5329, 992, 1, 0, 0, 0, 5330, 5331, 3, 1177, 588, 0, 5331, 5332, 3, 1187, 593, 0, 5332, 5333, 3, 1169, 584, 0, 5333, 5334, 3, 1147, 573, 0, 5334, 5335, 3, 1145, 572, 0, 5335, 5336, 3, 1147, 573, 0, 5336, 5337, 3, 1149, 574, 0, 5337, 994, 1, 0, 0, 0, 5338, 5339, 3, 1179, 589, 0, 5339, 5340, 3, 1165, 582, 0, 5340, 5341, 3, 1145, 572, 0, 5341, 5342, 3, 1147, 573, 0, 5342, 5343, 3, 1173, 586, 0, 5343, 5344, 3, 1161, 580, 0, 5344, 5345, 3, 1155, 577, 0, 5345, 5346, 3, 1165, 582, 0, 5346, 5347, 3, 1147, 573, 0, 5347, 996, 1, 0, 0, 0, 5348, 5349, 3, 1179, 589, 0, 5349, 5350, 3, 1165, 582, 0, 5350, 5351, 3, 1155, 577, 0, 5351, 5352, 3, 1177, 588, 0, 5352, 998, 1, 0, 0, 0, 5353, 5354, 3, 1179, 589, 0, 5354, 5355, 3, 1165, 582, 0, 5355, 5356, 3, 1175, 587, 0, 5356, 5357, 3, 1177, 588, 0, 5357, 5358, 3, 1173, 586, 0, 5358, 5359, 3, 1155, 577, 0, 5359, 5360, 3, 1165, 582, 0, 5360, 5361, 3, 1151, 575, 0, 5361, 1000, 1, 0, 0, 0, 5362, 5363, 3, 1179, 589, 0, 5363, 5364, 3, 1165, 582, 0, 5364, 5365, 3, 1177, 588, 0, 5365, 5366, 3, 1155, 577, 0, 5366, 5367, 3, 1161, 580, 0, 5367, 1002, 1, 0, 0, 0, 5368, 5369, 3, 1179, 589, 0, 5369, 5370, 3, 1169, 584, 0, 5370, 1004, 1, 0, 0, 0, 5371, 5372, 3, 1179, 589, 0, 5372, 5373, 3, 1169, 584, 0, 5373, 5374, 3, 1167, 583, 0, 5374, 5375, 3, 1165, 582, 0, 5375, 1006, 1, 0, 0, 0, 5376, 5377, 3, 1179, 589, 0, 5377, 5378, 3, 1175, 587, 0, 5378, 5379, 3, 1139, 569, 0, 5379, 5380, 3, 1151, 575, 0, 5380, 5381, 3, 1147, 573, 0, 5381, 1008, 1, 0, 0, 0, 5382, 5383, 3, 1179, 589, 0, 5383, 5384, 3, 1175, 587, 0, 5384, 5385, 3, 1147, 573, 0, 5385, 1010, 1, 0, 0, 0, 5386, 5387, 3, 1179, 589, 0, 5387, 5388, 3, 1175, 587, 0, 5388, 5389, 3, 1155, 577, 0, 5389, 5390, 3, 1165, 582, 0, 5390, 5391, 3, 1151, 575, 0, 5391, 1012, 1, 0, 0, 0, 5392, 5393, 3, 1181, 590, 0, 5393, 5394, 3, 1139, 569, 0, 5394, 5395, 3, 1161, 580, 0, 5395, 5396, 3, 1179, 589, 0, 5396, 5397, 3, 1147, 573, 0, 5397, 1014, 1, 0, 0, 0, 5398, 5399, 3, 1181, 590, 0, 5399, 5400, 3, 1139, 569, 0, 5400, 5401, 3, 1161, 580, 0, 5401, 5402, 3, 1179, 589, 0, 5402, 5403, 3, 1147, 573, 0, 5403, 5404, 3, 1175, 587, 0, 5404, 1016, 1, 0, 0, 0, 5405, 5406, 3, 1181, 590, 0, 5406, 5407, 3, 1139, 569, 0, 5407, 5408, 3, 1173, 586, 0, 5408, 5409, 3, 1187, 593, 0, 5409, 5410, 3, 1155, 577, 0, 5410, 5411, 3, 1165, 582, 0, 5411, 5412, 3, 1151, 575, 0, 5412, 1018, 1, 0, 0, 0, 5413, 5414, 3, 1181, 590, 0, 5414, 5415, 3, 1155, 577, 0, 5415, 5416, 3, 1173, 586, 0, 5416, 5417, 3, 1177, 588, 0, 5417, 5418, 3, 1179, 589, 0, 5418, 5419, 3, 1139, 569, 0, 5419, 5420, 3, 1161, 580, 0, 5420, 1020, 1, 0, 0, 0, 5421, 5422, 3, 1183, 591, 0, 5422, 5423, 3, 1139, 569, 0, 5423, 5424, 3, 1155, 577, 0, 5424, 5425, 3, 1177, 588, 0, 5425, 1022, 1, 0, 0, 0, 5426, 5427, 3, 1183, 591, 0, 5427, 5428, 3, 1153, 576, 0, 5428, 5429, 3, 1147, 573, 0, 5429, 5430, 3, 1165, 582, 0, 5430, 1024, 1, 0, 0, 0, 5431, 5432, 3, 1183, 591, 0, 5432, 5433, 3, 1153, 576, 0, 5433, 5434, 3, 1147, 573, 0, 5434, 5435, 3, 1165, 582, 0, 5435, 5436, 3, 1085, 542, 0, 5436, 5437, 3, 1143, 571, 0, 5437, 5438, 3, 1167, 583, 0, 5438, 5439, 3, 1163, 581, 0, 5439, 5440, 3, 1169, 584, 0, 5440, 5441, 3, 1155, 577, 0, 5441, 5442, 3, 1161, 580, 0, 5442, 5443, 3, 1147, 573, 0, 5443, 5444, 3, 1145, 572, 0, 5444, 1026, 1, 0, 0, 0, 5445, 5446, 3, 1183, 591, 0, 5446, 5447, 3, 1155, 577, 0, 5447, 5448, 3, 1177, 588, 0, 5448, 5449, 3, 1153, 576, 0, 5449, 1028, 1, 0, 0, 0, 5450, 5451, 3, 1183, 591, 0, 5451, 5452, 3, 1167, 583, 0, 5452, 5453, 3, 1173, 586, 0, 5453, 5454, 3, 1145, 572, 0, 5454, 5455, 3, 1175, 587, 0, 5455, 1030, 1, 0, 0, 0, 5456, 5457, 3, 1183, 591, 0, 5457, 5458, 3, 1167, 583, 0, 5458, 5459, 3, 1173, 586, 0, 5459, 5460, 3, 1159, 579, 0, 5460, 5461, 3, 1155, 577, 0, 5461, 5462, 3, 1165, 582, 0, 5462, 5463, 3, 1151, 575, 0, 5463, 5464, 3, 1085, 542, 0, 5464, 5465, 3, 1175, 587, 0, 5465, 5466, 3, 1177, 588, 0, 5466, 5467, 3, 1167, 583, 0, 5467, 5468, 3, 1173, 586, 0, 5468, 5469, 3, 1139, 569, 0, 5469, 5470, 3, 1151, 575, 0, 5470, 5471, 3, 1147, 573, 0, 5471, 1032, 1, 0, 0, 0, 5472, 5473, 3, 1183, 591, 0, 5473, 5474, 3, 1173, 586, 0, 5474, 5475, 3, 1155, 577, 0, 5475, 5476, 3, 1177, 588, 0, 5476, 5477, 3, 1147, 573, 0, 5477, 1034, 1, 0, 0, 0, 5478, 5479, 3, 1187, 593, 0, 5479, 5480, 3, 1147, 573, 0, 5480, 5481, 3, 1139, 569, 0, 5481, 5482, 3, 1173, 586, 0, 5482, 1036, 1, 0, 0, 0, 5483, 5484, 3, 1187, 593, 0, 5484, 5485, 3, 1187, 593, 0, 5485, 5486, 3, 1187, 593, 0, 5486, 5487, 3, 1187, 593, 0, 5487, 5488, 3, 1163, 581, 0, 5488, 5489, 3, 1163, 581, 0, 5489, 5490, 3, 1145, 572, 0, 5490, 5491, 3, 1145, 572, 0, 5491, 1038, 1, 0, 0, 0, 5492, 5493, 3, 1187, 593, 0, 5493, 5494, 3, 1187, 593, 0, 5494, 5495, 3, 1187, 593, 0, 5495, 5496, 3, 1187, 593, 0, 5496, 5497, 3, 1145, 572, 0, 5497, 5498, 3, 1145, 572, 0, 5498, 5499, 3, 1145, 572, 0, 5499, 1040, 1, 0, 0, 0, 5500, 5501, 3, 1189, 594, 0, 5501, 5502, 3, 1147, 573, 0, 5502, 5503, 3, 1173, 586, 0, 5503, 5504, 3, 1167, 583, 0, 5504, 1042, 1, 0, 0, 0, 5505, 5506, 3, 1189, 594, 0, 5506, 5507, 3, 1147, 573, 0, 5507, 5508, 3, 1173, 586, 0, 5508, 5509, 3, 1167, 583, 0, 5509, 5510, 3, 1085, 542, 0, 5510, 5511, 3, 1149, 574, 0, 5511, 5512, 3, 1155, 577, 0, 5512, 5513, 3, 1161, 580, 0, 5513, 5514, 3, 1161, 580, 0, 5514, 1044, 1, 0, 0, 0, 5515, 5516, 3, 1189, 594, 0, 5516, 5517, 3, 1147, 573, 0, 5517, 5518, 3, 1173, 586, 0, 5518, 5519, 3, 1167, 583, 0, 5519, 5520, 3, 1175, 587, 0, 5520, 1046, 1, 0, 0, 0, 5521, 5522, 3, 1189, 594, 0, 5522, 5523, 3, 1147, 573, 0, 5523, 5524, 3, 1173, 586, 0, 5524, 5525, 3, 1167, 583, 0, 5525, 5526, 3, 1147, 573, 0, 5526, 5527, 3, 1175, 587, 0, 5527, 1048, 1, 0, 0, 0, 5528, 5529, 5, 38, 0, 0, 5529, 1050, 1, 0, 0, 0, 5530, 5531, 5, 42, 0, 0, 5531, 1052, 1, 0, 0, 0, 5532, 5533, 5, 42, 0, 0, 5533, 5534, 5, 42, 0, 0, 5534, 1054, 1, 0, 0, 0, 5535, 5536, 5, 58, 0, 0, 5536, 1056, 1, 0, 0, 0, 5537, 5538, 5, 44, 0, 0, 5538, 1058, 1, 0, 0, 0, 5539, 5540, 5, 42, 0, 0, 5540, 5541, 5, 62, 0, 0, 5541, 5542, 5, 67, 0, 0, 5542, 5543, 5, 69, 0, 0, 5543, 1060, 1, 0, 0, 0, 5544, 5545, 5, 42, 0, 0, 5545, 5546, 5, 62, 0, 0, 5546, 1062, 1, 0, 0, 0, 5547, 5548, 5, 36, 0, 0, 5548, 1064, 1, 0, 0, 0, 5549, 5550, 5, 34, 0, 0, 5550, 1066, 1, 0, 0, 0, 5551, 5553, 5, 46, 0, 0, 5552, 5554, 7, 0, 0, 0, 5553, 5552, 1, 0, 0, 0, 5554, 5555, 1, 0, 0, 0, 5555, 5553, 1, 0, 0, 0, 5555, 5556, 1, 0, 0, 0, 5556, 5560, 1, 0, 0, 0, 5557, 5558, 5, 46, 0, 0, 5558, 5560, 5, 0, 0, 1, 5559, 5551, 1, 0, 0, 0, 5559, 5557, 1, 0, 0, 0, 5560, 1068, 1, 0, 0, 0, 5561, 5562, 5, 46, 0, 0, 5562, 1070, 1, 0, 0, 0, 5563, 5564, 5, 61, 0, 0, 5564, 1072, 1, 0, 0, 0, 5565, 5566, 5, 42, 0, 0, 5566, 5567, 5, 62, 0, 0, 5567, 5568, 5, 69, 0, 0, 5568, 5569, 5, 88, 0, 0, 5569, 5570, 5, 69, 0, 0, 5570, 5571, 5, 67, 0, 0, 5571, 5572, 5, 67, 0, 0, 5572, 5573, 5, 73, 0, 0, 5573, 5574, 5, 67, 0, 0, 5574, 5575, 5, 83, 0, 0, 5575, 1074, 1, 0, 0, 0, 5576, 5577, 5, 42, 0, 0, 5577, 5578, 5, 62, 0, 0, 5578, 5579, 5, 69, 0, 0, 5579, 5580, 5, 88, 0, 0, 5580, 5581, 5, 69, 0, 0, 5581, 5582, 5, 67, 0, 0, 5582, 5583, 5, 83, 0, 0, 5583, 5584, 5, 81, 0, 0, 5584, 5585, 5, 76, 0, 0, 5585, 1076, 1, 0, 0, 0, 5586, 5587, 5, 42, 0, 0, 5587, 5588, 5, 62, 0, 0, 5588, 5589, 5, 69, 0, 0, 5589, 5590, 5, 88, 0, 0, 5590, 5591, 5, 69, 0, 0, 5591, 5592, 5, 67, 0, 0, 5592, 5593, 5, 83, 0, 0, 5593, 5594, 5, 81, 0, 0, 5594, 5595, 5, 76, 0, 0, 5595, 5596, 5, 73, 0, 0, 5596, 5597, 5, 77, 0, 0, 5597, 5598, 5, 83, 0, 0, 5598, 1078, 1, 0, 0, 0, 5599, 5600, 5, 60, 0, 0, 5600, 1080, 1, 0, 0, 0, 5601, 5602, 5, 60, 0, 0, 5602, 5603, 5, 61, 0, 0, 5603, 1082, 1, 0, 0, 0, 5604, 5605, 5, 40, 0, 0, 5605, 1084, 1, 0, 0, 0, 5606, 5607, 5, 45, 0, 0, 5607, 1086, 1, 0, 0, 0, 5608, 5609, 5, 62, 0, 0, 5609, 1088, 1, 0, 0, 0, 5610, 5611, 5, 62, 0, 0, 5611, 5612, 5, 61, 0, 0, 5612, 1090, 1, 0, 0, 0, 5613, 5614, 5, 60, 0, 0, 5614, 5615, 5, 62, 0, 0, 5615, 1092, 1, 0, 0, 0, 5616, 5617, 5, 43, 0, 0, 5617, 1094, 1, 0, 0, 0, 5618, 5619, 5, 39, 0, 0, 5619, 1096, 1, 0, 0, 0, 5620, 5621, 5, 41, 0, 0, 5621, 1098, 1, 0, 0, 0, 5622, 5623, 5, 47, 0, 0, 5623, 1100, 1, 0, 0, 0, 5624, 5629, 3, 1107, 553, 0, 5625, 5629, 3, 1109, 554, 0, 5626, 5629, 3, 1103, 551, 0, 5627, 5629, 3, 1105, 552, 0, 5628, 5624, 1, 0, 0, 0, 5628, 5625, 1, 0, 0, 0, 5628, 5626, 1, 0, 0, 0, 5628, 5627, 1, 0, 0, 0, 5629, 1102, 1, 0, 0, 0, 5630, 5631, 3, 1185, 592, 0, 5631, 5633, 5, 34, 0, 0, 5632, 5634, 7, 1, 0, 0, 5633, 5632, 1, 0, 0, 0, 5634, 5635, 1, 0, 0, 0, 5635, 5633, 1, 0, 0, 0, 5635, 5636, 1, 0, 0, 0, 5636, 5637, 1, 0, 0, 0, 5637, 5638, 5, 34, 0, 0, 5638, 5649, 1, 0, 0, 0, 5639, 5640, 3, 1185, 592, 0, 5640, 5642, 5, 39, 0, 0, 5641, 5643, 7, 1, 0, 0, 5642, 5641, 1, 0, 0, 0, 5643, 5644, 1, 0, 0, 0, 5644, 5642, 1, 0, 0, 0, 5644, 5645, 1, 0, 0, 0, 5645, 5646, 1, 0, 0, 0, 5646, 5647, 5, 39, 0, 0, 5647, 5649, 1, 0, 0, 0, 5648, 5630, 1, 0, 0, 0, 5648, 5639, 1, 0, 0, 0, 5649, 1104, 1, 0, 0, 0, 5650, 5651, 3, 1189, 594, 0, 5651, 5658, 5, 34, 0, 0, 5652, 5657, 8, 2, 0, 0, 5653, 5654, 5, 34, 0, 0, 5654, 5657, 5, 34, 0, 0, 5655, 5657, 5, 39, 0, 0, 5656, 5652, 1, 0, 0, 0, 5656, 5653, 1, 0, 0, 0, 5656, 5655, 1, 0, 0, 0, 5657, 5660, 1, 0, 0, 0, 5658, 5656, 1, 0, 0, 0, 5658, 5659, 1, 0, 0, 0, 5659, 5661, 1, 0, 0, 0, 5660, 5658, 1, 0, 0, 0, 5661, 5662, 5, 34, 0, 0, 5662, 5677, 1, 0, 0, 0, 5663, 5664, 3, 1189, 594, 0, 5664, 5671, 5, 39, 0, 0, 5665, 5670, 8, 3, 0, 0, 5666, 5667, 5, 39, 0, 0, 5667, 5670, 5, 39, 0, 0, 5668, 5670, 5, 34, 0, 0, 5669, 5665, 1, 0, 0, 0, 5669, 5666, 1, 0, 0, 0, 5669, 5668, 1, 0, 0, 0, 5670, 5673, 1, 0, 0, 0, 5671, 5669, 1, 0, 0, 0, 5671, 5672, 1, 0, 0, 0, 5672, 5674, 1, 0, 0, 0, 5673, 5671, 1, 0, 0, 0, 5674, 5675, 5, 39, 0, 0, 5675, 5677, 1, 0, 0, 0, 5676, 5650, 1, 0, 0, 0, 5676, 5663, 1, 0, 0, 0, 5677, 1106, 1, 0, 0, 0, 5678, 5685, 5, 34, 0, 0, 5679, 5684, 8, 2, 0, 0, 5680, 5681, 5, 34, 0, 0, 5681, 5684, 5, 34, 0, 0, 5682, 5684, 5, 39, 0, 0, 5683, 5679, 1, 0, 0, 0, 5683, 5680, 1, 0, 0, 0, 5683, 5682, 1, 0, 0, 0, 5684, 5687, 1, 0, 0, 0, 5685, 5683, 1, 0, 0, 0, 5685, 5686, 1, 0, 0, 0, 5686, 5688, 1, 0, 0, 0, 5687, 5685, 1, 0, 0, 0, 5688, 5701, 5, 34, 0, 0, 5689, 5696, 5, 39, 0, 0, 5690, 5695, 8, 3, 0, 0, 5691, 5692, 5, 39, 0, 0, 5692, 5695, 5, 39, 0, 0, 5693, 5695, 5, 34, 0, 0, 5694, 5690, 1, 0, 0, 0, 5694, 5691, 1, 0, 0, 0, 5694, 5693, 1, 0, 0, 0, 5695, 5698, 1, 0, 0, 0, 5696, 5694, 1, 0, 0, 0, 5696, 5697, 1, 0, 0, 0, 5697, 5699, 1, 0, 0, 0, 5698, 5696, 1, 0, 0, 0, 5699, 5701, 5, 39, 0, 0, 5700, 5678, 1, 0, 0, 0, 5700, 5689, 1, 0, 0, 0, 5701, 1108, 1, 0, 0, 0, 5702, 5703, 7, 4, 0, 0, 5703, 5710, 5, 34, 0, 0, 5704, 5709, 8, 2, 0, 0, 5705, 5706, 5, 34, 0, 0, 5706, 5709, 5, 34, 0, 0, 5707, 5709, 5, 39, 0, 0, 5708, 5704, 1, 0, 0, 0, 5708, 5705, 1, 0, 0, 0, 5708, 5707, 1, 0, 0, 0, 5709, 5712, 1, 0, 0, 0, 5710, 5708, 1, 0, 0, 0, 5710, 5711, 1, 0, 0, 0, 5711, 5713, 1, 0, 0, 0, 5712, 5710, 1, 0, 0, 0, 5713, 5727, 5, 34, 0, 0, 5714, 5715, 7, 4, 0, 0, 5715, 5722, 5, 39, 0, 0, 5716, 5721, 8, 3, 0, 0, 5717, 5718, 5, 39, 0, 0, 5718, 5721, 5, 39, 0, 0, 5719, 5721, 5, 34, 0, 0, 5720, 5716, 1, 0, 0, 0, 5720, 5717, 1, 0, 0, 0, 5720, 5719, 1, 0, 0, 0, 5721, 5724, 1, 0, 0, 0, 5722, 5720, 1, 0, 0, 0, 5722, 5723, 1, 0, 0, 0, 5723, 5725, 1, 0, 0, 0, 5724, 5722, 1, 0, 0, 0, 5725, 5727, 5, 39, 0, 0, 5726, 5702, 1, 0, 0, 0, 5726, 5714, 1, 0, 0, 0, 5727, 1110, 1, 0, 0, 0, 5728, 5729, 5, 54, 0, 0, 5729, 5730, 5, 54, 0, 0, 5730, 1112, 1, 0, 0, 0, 5731, 5732, 5, 55, 0, 0, 5732, 5733, 5, 55, 0, 0, 5733, 1114, 1, 0, 0, 0, 5734, 5735, 5, 56, 0, 0, 5735, 5736, 5, 56, 0, 0, 5736, 1116, 1, 0, 0, 0, 5737, 5740, 3, 1093, 546, 0, 5738, 5740, 3, 1085, 542, 0, 5739, 5737, 1, 0, 0, 0, 5739, 5738, 1, 0, 0, 0, 5739, 5740, 1, 0, 0, 0, 5740, 5742, 1, 0, 0, 0, 5741, 5743, 7, 5, 0, 0, 5742, 5741, 1, 0, 0, 0, 5743, 5744, 1, 0, 0, 0, 5744, 5742, 1, 0, 0, 0, 5744, 5745, 1, 0, 0, 0, 5745, 1118, 1, 0, 0, 0, 5746, 5749, 3, 1093, 546, 0, 5747, 5749, 3, 1085, 542, 0, 5748, 5746, 1, 0, 0, 0, 5748, 5747, 1, 0, 0, 0, 5748, 5749, 1, 0, 0, 0, 5749, 5753, 1, 0, 0, 0, 5750, 5752, 7, 5, 0, 0, 5751, 5750, 1, 0, 0, 0, 5752, 5755, 1, 0, 0, 0, 5753, 5751, 1, 0, 0, 0, 5753, 5754, 1, 0, 0, 0, 5754, 5758, 1, 0, 0, 0, 5755, 5753, 1, 0, 0, 0, 5756, 5759, 3, 1069, 534, 0, 5757, 5759, 3, 1057, 528, 0, 5758, 5756, 1, 0, 0, 0, 5758, 5757, 1, 0, 0, 0, 5759, 5761, 1, 0, 0, 0, 5760, 5762, 7, 5, 0, 0, 5761, 5760, 1, 0, 0, 0, 5762, 5763, 1, 0, 0, 0, 5763, 5761, 1, 0, 0, 0, 5763, 5764, 1, 0, 0, 0, 5764, 5775, 1, 0, 0, 0, 5765, 5768, 7, 6, 0, 0, 5766, 5769, 3, 1093, 546, 0, 5767, 5769, 3, 1085, 542, 0, 5768, 5766, 1, 0, 0, 0, 5768, 5767, 1, 0, 0, 0, 5768, 5769, 1, 0, 0, 0, 5769, 5771, 1, 0, 0, 0, 5770, 5772, 7, 5, 0, 0, 5771, 5770, 1, 0, 0, 0, 5772, 5773, 1, 0, 0, 0, 5773, 5771, 1, 0, 0, 0, 5773, 5774, 1, 0, 0, 0, 5774, 5776, 1, 0, 0, 0, 5775, 5765, 1, 0, 0, 0, 5775, 5776, 1, 0, 0, 0, 5776, 1120, 1, 0, 0, 0, 5777, 5779, 7, 7, 0, 0, 5778, 5777, 1, 0, 0, 0, 5779, 5780, 1, 0, 0, 0, 5780, 5778, 1, 0, 0, 0, 5780, 5781, 1, 0, 0, 0, 5781, 5794, 1, 0, 0, 0, 5782, 5784, 7, 8, 0, 0, 5783, 5782, 1, 0, 0, 0, 5784, 5785, 1, 0, 0, 0, 5785, 5783, 1, 0, 0, 0, 5785, 5786, 1, 0, 0, 0, 5786, 5788, 1, 0, 0, 0, 5787, 5789, 7, 7, 0, 0, 5788, 5787, 1, 0, 0, 0, 5789, 5790, 1, 0, 0, 0, 5790, 5788, 1, 0, 0, 0, 5790, 5791, 1, 0, 0, 0, 5791, 5793, 1, 0, 0, 0, 5792, 5783, 1, 0, 0, 0, 5793, 5796, 1, 0, 0, 0, 5794, 5792, 1, 0, 0, 0, 5794, 5795, 1, 0, 0, 0, 5795, 1122, 1, 0, 0, 0, 5796, 5794, 1, 0, 0, 0, 5797, 5799, 5, 13, 0, 0, 5798, 5797, 1, 0, 0, 0, 5798, 5799, 1, 0, 0, 0, 5799, 5800, 1, 0, 0, 0, 5800, 5801, 5, 10, 0, 0, 5801, 5802, 1, 0, 0, 0, 5802, 5803, 6, 561, 0, 0, 5803, 1124, 1, 0, 0, 0, 5804, 5805, 3, 1073, 536, 0, 5805, 5809, 3, 1135, 567, 0, 5806, 5808, 8, 9, 0, 0, 5807, 5806, 1, 0, 0, 0, 5808, 5811, 1, 0, 0, 0, 5809, 5807, 1, 0, 0, 0, 5809, 5810, 1, 0, 0, 0, 5810, 5812, 1, 0, 0, 0, 5811, 5809, 1, 0, 0, 0, 5812, 5813, 7, 9, 0, 0, 5813, 1126, 1, 0, 0, 0, 5814, 5815, 3, 1077, 538, 0, 5815, 5819, 3, 1135, 567, 0, 5816, 5818, 8, 9, 0, 0, 5817, 5816, 1, 0, 0, 0, 5818, 5821, 1, 0, 0, 0, 5819, 5817, 1, 0, 0, 0, 5819, 5820, 1, 0, 0, 0, 5820, 5822, 1, 0, 0, 0, 5821, 5819, 1, 0, 0, 0, 5822, 5823, 7, 9, 0, 0, 5823, 1128, 1, 0, 0, 0, 5824, 5825, 3, 1075, 537, 0, 5825, 5829, 3, 1135, 567, 0, 5826, 5828, 8, 9, 0, 0, 5827, 5826, 1, 0, 0, 0, 5828, 5831, 1, 0, 0, 0, 5829, 5827, 1, 0, 0, 0, 5829, 5830, 1, 0, 0, 0, 5830, 5832, 1, 0, 0, 0, 5831, 5829, 1, 0, 0, 0, 5832, 5833, 7, 9, 0, 0, 5833, 1130, 1, 0, 0, 0, 5834, 5835, 3, 1059, 529, 0, 5835, 5839, 3, 1135, 567, 0, 5836, 5838, 8, 10, 0, 0, 5837, 5836, 1, 0, 0, 0, 5838, 5841, 1, 0, 0, 0, 5839, 5837, 1, 0, 0, 0, 5839, 5840, 1, 0, 0, 0, 5840, 1132, 1, 0, 0, 0, 5841, 5839, 1, 0, 0, 0, 5842, 5843, 3, 1061, 530, 0, 5843, 5847, 3, 1135, 567, 0, 5844, 5846, 8, 10, 0, 0, 5845, 5844, 1, 0, 0, 0, 5846, 5849, 1, 0, 0, 0, 5847, 5845, 1, 0, 0, 0, 5847, 5848, 1, 0, 0, 0, 5848, 5850, 1, 0, 0, 0, 5849, 5847, 1, 0, 0, 0, 5850, 5851, 6, 566, 0, 0, 5851, 1134, 1, 0, 0, 0, 5852, 5854, 7, 11, 0, 0, 5853, 5852, 1, 0, 0, 0, 5854, 5855, 1, 0, 0, 0, 5855, 5853, 1, 0, 0, 0, 5855, 5856, 1, 0, 0, 0, 5856, 5857, 1, 0, 0, 0, 5857, 5858, 6, 567, 0, 0, 5858, 1136, 1, 0, 0, 0, 5859, 5860, 5, 44, 0, 0, 5860, 5861, 5, 32, 0, 0, 5861, 5862, 1, 0, 0, 0, 5862, 5863, 6, 568, 0, 0, 5863, 1138, 1, 0, 0, 0, 5864, 5865, 7, 12, 0, 0, 5865, 1140, 1, 0, 0, 0, 5866, 5867, 7, 13, 0, 0, 5867, 1142, 1, 0, 0, 0, 5868, 5869, 7, 14, 0, 0, 5869, 1144, 1, 0, 0, 0, 5870, 5871, 7, 15, 0, 0, 5871, 1146, 1, 0, 0, 0, 5872, 5873, 7, 6, 0, 0, 5873, 1148, 1, 0, 0, 0, 5874, 5875, 7, 16, 0, 0, 5875, 1150, 1, 0, 0, 0, 5876, 5877, 7, 17, 0, 0, 5877, 1152, 1, 0, 0, 0, 5878, 5879, 7, 18, 0, 0, 5879, 1154, 1, 0, 0, 0, 5880, 5881, 7, 19, 0, 0, 5881, 1156, 1, 0, 0, 0, 5882, 5883, 7, 20, 0, 0, 5883, 1158, 1, 0, 0, 0, 5884, 5885, 7, 21, 0, 0, 5885, 1160, 1, 0, 0, 0, 5886, 5887, 7, 22, 0, 0, 5887, 1162, 1, 0, 0, 0, 5888, 5889, 7, 23, 0, 0, 5889, 1164, 1, 0, 0, 0, 5890, 5891, 7, 24, 0, 0, 5891, 1166, 1, 0, 0, 0, 5892, 5893, 7, 25, 0, 0, 5893, 1168, 1, 0, 0, 0, 5894, 5895, 7, 26, 0, 0, 5895, 1170, 1, 0, 0, 0, 5896, 5897, 7, 27, 0, 0, 5897, 1172, 1, 0, 0, 0, 5898, 5899, 7, 28, 0, 0, 5899, 1174, 1, 0, 0, 0, 5900, 5901, 7, 29, 0, 0, 5901, 1176, 1, 0, 0, 0, 5902, 5903, 7, 30, 0, 0, 5903, 1178, 1, 0, 0, 0, 5904, 5905, 7, 31, 0, 0, 5905, 1180, 1, 0, 0, 0, 5906, 5907, 7, 32, 0, 0, 5907, 1182, 1, 0, 0, 0, 5908, 5909, 7, 33, 0, 0, 5909, 1184, 1, 0, 0, 0, 5910, 5911, 7, 34, 0, 0, 5911, 1186, 1, 0, 0, 0, 5912, 5913, 7, 35, 0, 0, 5913, 1188, 1, 0, 0, 0, 5914, 5915, 7, 36, 0, 0, 5915, 1190, 1, 0, 0, 0, 42, 0, 5555, 5559, 5628, 5635, 5644, 5648, 5656, 5658, 5669, 5671, 5676, 5683, 5685, 5694, 5696, 5700, 5708, 5710, 5720, 5722, 5726, 5739, 5744, 5748, 5753, 5758, 5763, 5768, 5773, 5775, 5780, 5785, 5790, 5794, 5798, 5809, 5819, 5829, 5839, 5847, 5855, 1, 0, 1, 0] \ No newline at end of file diff --git a/src/Cobol85Lexer.py b/src/Cobol85Lexer.py new file mode 100644 index 0000000..c5ddf0d --- /dev/null +++ b/src/Cobol85Lexer.py @@ -0,0 +1,3306 @@ +# Generated from Cobol85.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,565,5916,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7, + 5,2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12, + 2,13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19, + 7,19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25, + 2,26,7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32, + 7,32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38, + 2,39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45, + 7,45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51, + 2,52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58, + 7,58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64, + 2,65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71, + 7,71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77, + 2,78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84, + 7,84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90, + 2,91,7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97, + 7,97,2,98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103, + 7,103,2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108, + 2,109,7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114, + 7,114,2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119, + 2,120,7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125, + 7,125,2,126,7,126,2,127,7,127,2,128,7,128,2,129,7,129,2,130,7,130, + 2,131,7,131,2,132,7,132,2,133,7,133,2,134,7,134,2,135,7,135,2,136, + 7,136,2,137,7,137,2,138,7,138,2,139,7,139,2,140,7,140,2,141,7,141, + 2,142,7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,7,146,2,147, + 7,147,2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,7,152, + 2,153,7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158, + 7,158,2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163, + 2,164,7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169, + 7,169,2,170,7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174, + 2,175,7,175,2,176,7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180, + 7,180,2,181,7,181,2,182,7,182,2,183,7,183,2,184,7,184,2,185,7,185, + 2,186,7,186,2,187,7,187,2,188,7,188,2,189,7,189,2,190,7,190,2,191, + 7,191,2,192,7,192,2,193,7,193,2,194,7,194,2,195,7,195,2,196,7,196, + 2,197,7,197,2,198,7,198,2,199,7,199,2,200,7,200,2,201,7,201,2,202, + 7,202,2,203,7,203,2,204,7,204,2,205,7,205,2,206,7,206,2,207,7,207, + 2,208,7,208,2,209,7,209,2,210,7,210,2,211,7,211,2,212,7,212,2,213, + 7,213,2,214,7,214,2,215,7,215,2,216,7,216,2,217,7,217,2,218,7,218, + 2,219,7,219,2,220,7,220,2,221,7,221,2,222,7,222,2,223,7,223,2,224, + 7,224,2,225,7,225,2,226,7,226,2,227,7,227,2,228,7,228,2,229,7,229, + 2,230,7,230,2,231,7,231,2,232,7,232,2,233,7,233,2,234,7,234,2,235, + 7,235,2,236,7,236,2,237,7,237,2,238,7,238,2,239,7,239,2,240,7,240, + 2,241,7,241,2,242,7,242,2,243,7,243,2,244,7,244,2,245,7,245,2,246, + 7,246,2,247,7,247,2,248,7,248,2,249,7,249,2,250,7,250,2,251,7,251, + 2,252,7,252,2,253,7,253,2,254,7,254,2,255,7,255,2,256,7,256,2,257, + 7,257,2,258,7,258,2,259,7,259,2,260,7,260,2,261,7,261,2,262,7,262, + 2,263,7,263,2,264,7,264,2,265,7,265,2,266,7,266,2,267,7,267,2,268, + 7,268,2,269,7,269,2,270,7,270,2,271,7,271,2,272,7,272,2,273,7,273, + 2,274,7,274,2,275,7,275,2,276,7,276,2,277,7,277,2,278,7,278,2,279, + 7,279,2,280,7,280,2,281,7,281,2,282,7,282,2,283,7,283,2,284,7,284, + 2,285,7,285,2,286,7,286,2,287,7,287,2,288,7,288,2,289,7,289,2,290, + 7,290,2,291,7,291,2,292,7,292,2,293,7,293,2,294,7,294,2,295,7,295, + 2,296,7,296,2,297,7,297,2,298,7,298,2,299,7,299,2,300,7,300,2,301, + 7,301,2,302,7,302,2,303,7,303,2,304,7,304,2,305,7,305,2,306,7,306, + 2,307,7,307,2,308,7,308,2,309,7,309,2,310,7,310,2,311,7,311,2,312, + 7,312,2,313,7,313,2,314,7,314,2,315,7,315,2,316,7,316,2,317,7,317, + 2,318,7,318,2,319,7,319,2,320,7,320,2,321,7,321,2,322,7,322,2,323, + 7,323,2,324,7,324,2,325,7,325,2,326,7,326,2,327,7,327,2,328,7,328, + 2,329,7,329,2,330,7,330,2,331,7,331,2,332,7,332,2,333,7,333,2,334, + 7,334,2,335,7,335,2,336,7,336,2,337,7,337,2,338,7,338,2,339,7,339, + 2,340,7,340,2,341,7,341,2,342,7,342,2,343,7,343,2,344,7,344,2,345, + 7,345,2,346,7,346,2,347,7,347,2,348,7,348,2,349,7,349,2,350,7,350, + 2,351,7,351,2,352,7,352,2,353,7,353,2,354,7,354,2,355,7,355,2,356, + 7,356,2,357,7,357,2,358,7,358,2,359,7,359,2,360,7,360,2,361,7,361, + 2,362,7,362,2,363,7,363,2,364,7,364,2,365,7,365,2,366,7,366,2,367, + 7,367,2,368,7,368,2,369,7,369,2,370,7,370,2,371,7,371,2,372,7,372, + 2,373,7,373,2,374,7,374,2,375,7,375,2,376,7,376,2,377,7,377,2,378, + 7,378,2,379,7,379,2,380,7,380,2,381,7,381,2,382,7,382,2,383,7,383, + 2,384,7,384,2,385,7,385,2,386,7,386,2,387,7,387,2,388,7,388,2,389, + 7,389,2,390,7,390,2,391,7,391,2,392,7,392,2,393,7,393,2,394,7,394, + 2,395,7,395,2,396,7,396,2,397,7,397,2,398,7,398,2,399,7,399,2,400, + 7,400,2,401,7,401,2,402,7,402,2,403,7,403,2,404,7,404,2,405,7,405, + 2,406,7,406,2,407,7,407,2,408,7,408,2,409,7,409,2,410,7,410,2,411, + 7,411,2,412,7,412,2,413,7,413,2,414,7,414,2,415,7,415,2,416,7,416, + 2,417,7,417,2,418,7,418,2,419,7,419,2,420,7,420,2,421,7,421,2,422, + 7,422,2,423,7,423,2,424,7,424,2,425,7,425,2,426,7,426,2,427,7,427, + 2,428,7,428,2,429,7,429,2,430,7,430,2,431,7,431,2,432,7,432,2,433, + 7,433,2,434,7,434,2,435,7,435,2,436,7,436,2,437,7,437,2,438,7,438, + 2,439,7,439,2,440,7,440,2,441,7,441,2,442,7,442,2,443,7,443,2,444, + 7,444,2,445,7,445,2,446,7,446,2,447,7,447,2,448,7,448,2,449,7,449, + 2,450,7,450,2,451,7,451,2,452,7,452,2,453,7,453,2,454,7,454,2,455, + 7,455,2,456,7,456,2,457,7,457,2,458,7,458,2,459,7,459,2,460,7,460, + 2,461,7,461,2,462,7,462,2,463,7,463,2,464,7,464,2,465,7,465,2,466, + 7,466,2,467,7,467,2,468,7,468,2,469,7,469,2,470,7,470,2,471,7,471, + 2,472,7,472,2,473,7,473,2,474,7,474,2,475,7,475,2,476,7,476,2,477, + 7,477,2,478,7,478,2,479,7,479,2,480,7,480,2,481,7,481,2,482,7,482, + 2,483,7,483,2,484,7,484,2,485,7,485,2,486,7,486,2,487,7,487,2,488, + 7,488,2,489,7,489,2,490,7,490,2,491,7,491,2,492,7,492,2,493,7,493, + 2,494,7,494,2,495,7,495,2,496,7,496,2,497,7,497,2,498,7,498,2,499, + 7,499,2,500,7,500,2,501,7,501,2,502,7,502,2,503,7,503,2,504,7,504, + 2,505,7,505,2,506,7,506,2,507,7,507,2,508,7,508,2,509,7,509,2,510, + 7,510,2,511,7,511,2,512,7,512,2,513,7,513,2,514,7,514,2,515,7,515, + 2,516,7,516,2,517,7,517,2,518,7,518,2,519,7,519,2,520,7,520,2,521, + 7,521,2,522,7,522,2,523,7,523,2,524,7,524,2,525,7,525,2,526,7,526, + 2,527,7,527,2,528,7,528,2,529,7,529,2,530,7,530,2,531,7,531,2,532, + 7,532,2,533,7,533,2,534,7,534,2,535,7,535,2,536,7,536,2,537,7,537, + 2,538,7,538,2,539,7,539,2,540,7,540,2,541,7,541,2,542,7,542,2,543, + 7,543,2,544,7,544,2,545,7,545,2,546,7,546,2,547,7,547,2,548,7,548, + 2,549,7,549,2,550,7,550,2,551,7,551,2,552,7,552,2,553,7,553,2,554, + 7,554,2,555,7,555,2,556,7,556,2,557,7,557,2,558,7,558,2,559,7,559, + 2,560,7,560,2,561,7,561,2,562,7,562,2,563,7,563,2,564,7,564,2,565, + 7,565,2,566,7,566,2,567,7,567,2,568,7,568,2,569,7,569,2,570,7,570, + 2,571,7,571,2,572,7,572,2,573,7,573,2,574,7,574,2,575,7,575,2,576, + 7,576,2,577,7,577,2,578,7,578,2,579,7,579,2,580,7,580,2,581,7,581, + 2,582,7,582,2,583,7,583,2,584,7,584,2,585,7,585,2,586,7,586,2,587, + 7,587,2,588,7,588,2,589,7,589,2,590,7,590,2,591,7,591,2,592,7,592, + 2,593,7,593,2,594,7,594,1,0,1,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,3,1,3,1,3,1,3,1,4,1,4, + 1,4,1,4,1,4,1,4,1,4,1,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5, + 1,6,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,8,1,8, + 1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,10,1,10,1,10,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,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,12,1,12, + 1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12, + 1,12,1,12,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13, + 1,13,1,13,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14, + 1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,15,1,15,1,15,1,15, + 1,15,1,16,1,16,1,16,1,16,1,16,1,16,1,17,1,17,1,17,1,17,1,17,1,17, + 1,17,1,17,1,17,1,17,1,18,1,18,1,18,1,18,1,19,1,19,1,19,1,19,1,20, + 1,20,1,20,1,20,1,21,1,21,1,21,1,21,1,21,1,22,1,22,1,22,1,22,1,22, + 1,22,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,24,1,25,1,25,1,25,1,25,1,25,1,25,1,26,1,26,1,26,1,26,1,26,1,26, + 1,26,1,27,1,27,1,27,1,27,1,27,1,27,1,27,1,27,1,27,1,27,1,27,1,27, + 1,27,1,27,1,27,1,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28, + 1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28, + 1,28,1,29,1,29,1,29,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30, + 1,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32, + 1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,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,1,34,1,34,1,34,1,34,1,34, + 1,34,1,35,1,35,1,35,1,35,1,35,1,35,1,35,1,35,1,35,1,35,1,35,1,35, + 1,35,1,35,1,35,1,35,1,35,1,35,1,36,1,36,1,36,1,36,1,36,1,36,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,39,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,40,1,40, + 1,41,1,41,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,46,1,46,1,46,1,46,1,46,1,46,1,46,1,47,1,47,1,47, + 1,47,1,47,1,47,1,47,1,48,1,48,1,48,1,49,1,49,1,49,1,49,1,49,1,49, + 1,49,1,49,1,49,1,49,1,49,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50, + 1,51,1,51,1,51,1,51,1,51,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,54,1,54,1,55,1,55,1,55,1,56,1,56,1,56,1,57,1,57, + 1,57,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,58,1,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,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,62,1,62,1,62, + 1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,63,1,63,1,63,1,63,1,63, + 1,63,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,65,1,65,1,65, + 1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,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,67,1,67,1,67,1,67, + 1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,68,1,68,1,68,1,68,1,68,1,68, + 1,69,1,69,1,69,1,69,1,69,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70, + 1,70,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,72,1,72, + 1,72,1,72,1,73,1,73,1,73,1,73,1,73,1,73,1,73,1,74,1,74,1,74,1,74, + 1,74,1,74,1,74,1,74,1,75,1,75,1,75,1,75,1,75,1,75,1,76,1,76,1,76, + 1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,77,1,77,1,77,1,77,1,77, + 1,77,1,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78, + 1,78,1,78,1,78,1,79,1,79,1,79,1,79,1,79,1,80,1,80,1,80,1,80,1,80, + 1,80,1,80,1,81,1,81,1,81,1,81,1,81,1,81,1,81,1,82,1,82,1,82,1,82, + 1,82,1,82,1,82,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,84,1,84,1,84, + 1,84,1,84,1,84,1,84,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85, + 1,85,1,85,1,85,1,85,1,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86, + 1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,87,1,87,1,87,1,87,1,87, + 1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,88,1,88, + 1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88, + 1,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89, + 1,89,1,89,1,89,1,89,1,90,1,90,1,90,1,90,1,90,1,90,1,90,1,90,1,90, + 1,90,1,90,1,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,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,93,1,94, + 1,94,1,94,1,94,1,94,1,94,1,94,1,94,1,95,1,95,1,95,1,95,1,95,1,95, + 1,95,1,95,1,95,1,96,1,96,1,96,1,96,1,96,1,96,1,96,1,96,1,97,1,97, + 1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,98, + 1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,99,1,99,1,99,1,99,1,99, + 1,99,1,99,1,99,1,99,1,99,1,99,1,100,1,100,1,100,1,100,1,100,1,100, + 1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101,1,101,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,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,107,1,107,1,107,1,107, + 1,107,1,107,1,107,1,108,1,108,1,108,1,108,1,108,1,109,1,109,1,109, + 1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,110,1,110,1,110,1,110, + 1,110,1,111,1,111,1,111,1,111,1,111,1,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,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,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,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,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,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,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,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,127,1,127,1,127, + 1,127,1,127,1,127,1,127,1,127,1,128,1,128,1,128,1,128,1,128,1,128, + 1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,129, + 1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,130, + 1,130,1,130,1,130,1,130,1,130,1,130,1,131,1,131,1,131,1,131,1,131, + 1,131,1,131,1,131,1,131,1,131,1,132,1,132,1,132,1,132,1,132,1,132, + 1,132,1,132,1,132,1,132,1,133,1,133,1,133,1,133,1,133,1,133,1,133, + 1,133,1,133,1,133,1,134,1,134,1,134,1,134,1,134,1,134,1,134,1,134, + 1,134,1,134,1,134,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135, + 1,135,1,135,1,135,1,135,1,136,1,136,1,136,1,136,1,136,1,136,1,136, + 1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,138,1,138,1,138, + 1,138,1,138,1,138,1,138,1,138,1,138,1,139,1,139,1,139,1,139,1,139, + 1,139,1,139,1,139,1,140,1,140,1,140,1,140,1,140,1,141,1,141,1,141, + 1,141,1,141,1,141,1,141,1,141,1,142,1,142,1,142,1,142,1,142,1,142, + 1,142,1,142,1,142,1,142,1,143,1,143,1,143,1,143,1,143,1,143,1,143, + 1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,145,1,145, + 1,145,1,145,1,145,1,145,1,145,1,145,1,145,1,146,1,146,1,146,1,146, + 1,146,1,146,1,146,1,147,1,147,1,147,1,147,1,147,1,148,1,148,1,148, + 1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,149,1,149,1,149, + 1,149,1,149,1,149,1,149,1,149,1,150,1,150,1,150,1,150,1,150,1,150, + 1,150,1,151,1,151,1,151,1,151,1,151,1,152,1,152,1,152,1,152,1,153, + 1,153,1,153,1,153,1,153,1,154,1,154,1,154,1,154,1,155,1,155,1,155, + 1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,155,1,156,1,156, + 1,156,1,156,1,156,1,156,1,156,1,157,1,157,1,157,1,157,1,158,1,158, + 1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,159,1,159, + 1,159,1,159,1,159,1,159,1,159,1,159,1,160,1,160,1,160,1,160,1,160, + 1,160,1,160,1,160,1,160,1,161,1,161,1,161,1,161,1,161,1,161,1,161, + 1,161,1,161,1,161,1,161,1,161,1,162,1,162,1,162,1,162,1,162,1,162, + 1,162,1,162,1,162,1,162,1,162,1,163,1,163,1,163,1,163,1,163,1,163, + 1,163,1,163,1,163,1,163,1,163,1,164,1,164,1,164,1,164,1,164,1,164, + 1,164,1,164,1,164,1,164,1,164,1,164,1,164,1,165,1,165,1,165,1,165, + 1,165,1,165,1,165,1,166,1,166,1,166,1,166,1,166,1,166,1,166,1,166, + 1,166,1,166,1,166,1,166,1,166,1,167,1,167,1,167,1,167,1,167,1,167, + 1,167,1,167,1,167,1,167,1,167,1,167,1,168,1,168,1,168,1,168,1,168, + 1,168,1,168,1,168,1,168,1,168,1,168,1,168,1,169,1,169,1,169,1,169, + 1,169,1,169,1,169,1,169,1,169,1,170,1,170,1,170,1,170,1,170,1,170, + 1,170,1,170,1,170,1,170,1,170,1,170,1,171,1,171,1,171,1,171,1,171, + 1,171,1,171,1,171,1,171,1,171,1,171,1,172,1,172,1,172,1,172,1,172, + 1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,173,1,173,1,173,1,173, + 1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,174,1,174,1,174,1,174, + 1,174,1,174,1,174,1,174,1,174,1,174,1,175,1,175,1,175,1,175,1,175, + 1,175,1,175,1,175,1,175,1,175,1,175,1,176,1,176,1,176,1,176,1,176, + 1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,176,1,177,1,177,1,177, + 1,177,1,177,1,177,1,177,1,177,1,177,1,177,1,177,1,177,1,177,1,178, + 1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,178,1,179,1,179, + 1,179,1,179,1,179,1,179,1,179,1,180,1,180,1,180,1,180,1,180,1,180, + 1,181,1,181,1,181,1,181,1,181,1,181,1,182,1,182,1,182,1,182,1,182, + 1,182,1,182,1,182,1,182,1,182,1,182,1,182,1,182,1,182,1,182,1,182, + 1,183,1,183,1,183,1,183,1,183,1,183,1,183,1,183,1,183,1,183,1,183, + 1,183,1,184,1,184,1,184,1,184,1,185,1,185,1,185,1,185,1,185,1,185, + 1,186,1,186,1,186,1,186,1,186,1,186,1,187,1,187,1,187,1,187,1,187, + 1,187,1,188,1,188,1,188,1,188,1,189,1,189,1,189,1,189,1,190,1,190, + 1,190,1,190,1,190,1,190,1,190,1,191,1,191,1,191,1,191,1,192,1,192, + 1,192,1,192,1,192,1,192,1,192,1,192,1,192,1,193,1,193,1,193,1,193, + 1,193,1,193,1,194,1,194,1,194,1,194,1,194,1,194,1,195,1,195,1,195, + 1,195,1,195,1,195,1,195,1,195,1,195,1,195,1,196,1,196,1,196,1,196, + 1,196,1,196,1,196,1,196,1,196,1,196,1,197,1,197,1,197,1,197,1,197, + 1,197,1,197,1,197,1,198,1,198,1,198,1,198,1,198,1,199,1,199,1,199, + 1,199,1,199,1,199,1,199,1,200,1,200,1,200,1,200,1,200,1,200,1,200, + 1,201,1,201,1,201,1,201,1,201,1,201,1,201,1,201,1,201,1,202,1,202, + 1,202,1,202,1,202,1,202,1,202,1,202,1,202,1,203,1,203,1,203,1,203, + 1,203,1,203,1,204,1,204,1,204,1,205,1,205,1,205,1,205,1,205,1,206, + 1,206,1,206,1,206,1,206,1,206,1,206,1,206,1,206,1,206,1,206,1,206, + 1,206,1,207,1,207,1,207,1,207,1,207,1,207,1,207,1,208,1,208,1,208, + 1,208,1,208,1,208,1,209,1,209,1,209,1,209,1,209,1,209,1,210,1,210, + 1,210,1,210,1,210,1,210,1,210,1,210,1,211,1,211,1,211,1,211,1,212, + 1,212,1,212,1,212,1,212,1,212,1,212,1,212,1,212,1,212,1,212,1,212, + 1,212,1,212,1,212,1,212,1,212,1,213,1,213,1,213,1,213,1,213,1,213, + 1,213,1,213,1,213,1,213,1,213,1,213,1,213,1,213,1,213,1,213,1,213, + 1,213,1,214,1,214,1,214,1,214,1,214,1,215,1,215,1,215,1,215,1,215, + 1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,216,1,217,1,217, + 1,217,1,217,1,217,1,217,1,217,1,217,1,217,1,217,1,217,1,217,1,217, + 1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218, + 1,218,1,218,1,218,1,218,1,218,1,218,1,219,1,219,1,219,1,219,1,219, + 1,219,1,219,1,219,1,219,1,220,1,220,1,220,1,220,1,220,1,220,1,220, + 1,221,1,221,1,221,1,221,1,221,1,221,1,221,1,222,1,222,1,222,1,222, + 1,222,1,222,1,222,1,223,1,223,1,223,1,224,1,224,1,224,1,224,1,224, + 1,224,1,224,1,224,1,225,1,225,1,225,1,225,1,225,1,226,1,226,1,226, + 1,226,1,226,1,226,1,227,1,227,1,227,1,227,1,227,1,227,1,227,1,227, + 1,228,1,228,1,228,1,228,1,228,1,228,1,228,1,228,1,228,1,228,1,229, + 1,229,1,229,1,229,1,229,1,229,1,229,1,229,1,229,1,229,1,229,1,230, + 1,230,1,230,1,230,1,230,1,230,1,230,1,230,1,230,1,230,1,230,1,230, + 1,231,1,231,1,231,1,231,1,232,1,232,1,232,1,232,1,232,1,232,1,232, + 1,232,1,232,1,232,1,232,1,232,1,233,1,233,1,233,1,234,1,234,1,234, + 1,234,1,234,1,234,1,234,1,234,1,234,1,234,1,234,1,234,1,234,1,234, + 1,234,1,235,1,235,1,235,1,236,1,236,1,236,1,236,1,236,1,236,1,236, + 1,236,1,236,1,237,1,237,1,237,1,237,1,237,1,237,1,237,1,238,1,238, + 1,238,1,239,1,239,1,239,1,239,1,239,1,239,1,240,1,240,1,240,1,240, + 1,240,1,240,1,240,1,240,1,241,1,241,1,241,1,241,1,241,1,241,1,241, + 1,241,1,241,1,242,1,242,1,242,1,242,1,242,1,242,1,242,1,242,1,243, + 1,243,1,243,1,243,1,243,1,243,1,243,1,243,1,243,1,243,1,243,1,244, + 1,244,1,244,1,244,1,244,1,244,1,244,1,244,1,244,1,245,1,245,1,245, + 1,245,1,245,1,245,1,246,1,246,1,246,1,246,1,246,1,246,1,246,1,246, + 1,246,1,246,1,246,1,246,1,246,1,247,1,247,1,247,1,247,1,247,1,247, + 1,247,1,247,1,248,1,248,1,248,1,248,1,248,1,248,1,248,1,248,1,248, + 1,248,1,248,1,248,1,248,1,249,1,249,1,249,1,249,1,249,1,249,1,249, + 1,249,1,250,1,250,1,250,1,250,1,250,1,251,1,251,1,251,1,251,1,251, + 1,251,1,251,1,251,1,252,1,252,1,252,1,252,1,252,1,252,1,252,1,253, + 1,253,1,253,1,254,1,254,1,254,1,254,1,254,1,255,1,255,1,255,1,255, + 1,255,1,255,1,255,1,255,1,255,1,255,1,256,1,256,1,256,1,256,1,256, + 1,256,1,257,1,257,1,257,1,257,1,257,1,258,1,258,1,258,1,258,1,259, + 1,259,1,259,1,259,1,259,1,259,1,259,1,259,1,259,1,260,1,260,1,260, + 1,260,1,260,1,260,1,261,1,261,1,261,1,261,1,261,1,261,1,261,1,261, + 1,261,1,262,1,262,1,262,1,262,1,262,1,263,1,263,1,263,1,264,1,264, + 1,264,1,265,1,265,1,265,1,265,1,265,1,265,1,265,1,265,1,266,1,266, + 1,266,1,266,1,266,1,267,1,267,1,267,1,267,1,267,1,267,1,267,1,267, + 1,267,1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,269,1,269,1,269, + 1,269,1,269,1,269,1,269,1,269,1,269,1,269,1,269,1,269,1,269,1,270, + 1,270,1,270,1,270,1,270,1,271,1,271,1,271,1,271,1,271,1,271,1,271, + 1,271,1,271,1,271,1,272,1,272,1,272,1,272,1,272,1,272,1,272,1,272, + 1,272,1,272,1,272,1,272,1,272,1,273,1,273,1,273,1,273,1,273,1,273, + 1,273,1,273,1,274,1,274,1,274,1,274,1,274,1,274,1,275,1,275,1,275, + 1,275,1,275,1,275,1,275,1,276,1,276,1,276,1,276,1,276,1,276,1,276, + 1,277,1,277,1,277,1,277,1,277,1,277,1,277,1,277,1,277,1,277,1,277, + 1,277,1,277,1,277,1,277,1,278,1,278,1,278,1,278,1,278,1,279,1,279, + 1,279,1,279,1,279,1,279,1,280,1,280,1,280,1,280,1,280,1,280,1,280, + 1,280,1,280,1,280,1,280,1,280,1,280,1,281,1,281,1,281,1,281,1,281, + 1,281,1,281,1,281,1,282,1,282,1,282,1,282,1,282,1,283,1,283,1,283, + 1,283,1,283,1,283,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284, + 1,284,1,284,1,284,1,284,1,284,1,284,1,285,1,285,1,285,1,285,1,285, + 1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,287, + 1,287,1,287,1,287,1,287,1,287,1,287,1,287,1,287,1,287,1,288,1,288, + 1,288,1,288,1,288,1,288,1,289,1,289,1,289,1,289,1,289,1,289,1,289, + 1,289,1,289,1,290,1,290,1,290,1,290,1,290,1,290,1,290,1,290,1,290, + 1,290,1,291,1,291,1,291,1,291,1,291,1,291,1,291,1,291,1,291,1,291, + 1,291,1,292,1,292,1,292,1,292,1,292,1,292,1,292,1,293,1,293,1,293, + 1,293,1,293,1,293,1,294,1,294,1,294,1,294,1,294,1,294,1,294,1,294, + 1,295,1,295,1,295,1,295,1,295,1,295,1,295,1,295,1,295,1,296,1,296, + 1,296,1,296,1,296,1,297,1,297,1,297,1,297,1,297,1,297,1,297,1,297, + 1,298,1,298,1,298,1,298,1,298,1,298,1,298,1,298,1,298,1,298,1,298, + 1,298,1,299,1,299,1,299,1,299,1,299,1,300,1,300,1,300,1,300,1,300, + 1,300,1,300,1,300,1,300,1,301,1,301,1,301,1,301,1,301,1,301,1,301, + 1,301,1,301,1,302,1,302,1,302,1,302,1,302,1,302,1,303,1,303,1,303, + 1,303,1,303,1,303,1,303,1,303,1,303,1,304,1,304,1,304,1,304,1,304, + 1,304,1,304,1,304,1,304,1,304,1,304,1,304,1,304,1,304,1,304,1,304, + 1,305,1,305,1,305,1,305,1,305,1,305,1,305,1,306,1,306,1,306,1,306, + 1,306,1,306,1,306,1,306,1,306,1,307,1,307,1,307,1,307,1,307,1,307, + 1,307,1,307,1,308,1,308,1,308,1,308,1,308,1,309,1,309,1,309,1,310, + 1,310,1,310,1,310,1,310,1,310,1,310,1,310,1,311,1,311,1,311,1,311, + 1,312,1,312,1,312,1,312,1,312,1,313,1,313,1,313,1,313,1,313,1,313, + 1,314,1,314,1,314,1,314,1,314,1,314,1,314,1,315,1,315,1,315,1,315, + 1,315,1,315,1,315,1,315,1,316,1,316,1,316,1,316,1,316,1,316,1,316, + 1,316,1,316,1,316,1,316,1,316,1,316,1,317,1,317,1,317,1,317,1,317, + 1,317,1,317,1,317,1,317,1,317,1,317,1,317,1,317,1,317,1,317,1,318, + 1,318,1,318,1,318,1,318,1,318,1,318,1,318,1,318,1,318,1,318,1,318, + 1,318,1,319,1,319,1,319,1,319,1,319,1,319,1,319,1,319,1,319,1,319, + 1,319,1,319,1,319,1,319,1,319,1,319,1,320,1,320,1,320,1,320,1,320, + 1,320,1,320,1,321,1,321,1,321,1,321,1,322,1,322,1,322,1,323,1,323, + 1,323,1,323,1,324,1,324,1,324,1,324,1,324,1,324,1,324,1,324,1,325, + 1,325,1,325,1,326,1,326,1,326,1,326,1,326,1,327,1,327,1,327,1,327, + 1,327,1,327,1,327,1,327,1,327,1,328,1,328,1,328,1,329,1,329,1,329, + 1,329,1,329,1,329,1,330,1,330,1,330,1,330,1,330,1,330,1,330,1,330, + 1,331,1,331,1,331,1,331,1,331,1,331,1,331,1,331,1,331,1,331,1,331, + 1,331,1,331,1,332,1,332,1,332,1,332,1,332,1,332,1,333,1,333,1,333, + 1,333,1,333,1,333,1,333,1,334,1,334,1,334,1,334,1,334,1,334,1,334, + 1,334,1,334,1,335,1,335,1,335,1,335,1,335,1,335,1,335,1,335,1,335, + 1,336,1,336,1,336,1,336,1,337,1,337,1,337,1,337,1,337,1,337,1,337, + 1,337,1,337,1,337,1,337,1,337,1,337,1,337,1,337,1,338,1,338,1,338, + 1,338,1,338,1,338,1,338,1,338,1,339,1,339,1,339,1,339,1,339,1,340, + 1,340,1,340,1,340,1,340,1,340,1,340,1,340,1,340,1,340,1,340,1,340, + 1,340,1,341,1,341,1,341,1,341,1,341,1,341,1,341,1,341,1,341,1,342, + 1,342,1,342,1,342,1,342,1,342,1,342,1,342,1,343,1,343,1,343,1,344, + 1,344,1,344,1,345,1,345,1,345,1,345,1,346,1,346,1,346,1,346,1,346, + 1,346,1,346,1,346,1,347,1,347,1,347,1,347,1,347,1,348,1,348,1,348, + 1,348,1,348,1,348,1,348,1,348,1,349,1,349,1,349,1,349,1,349,1,349, + 1,349,1,349,1,349,1,350,1,350,1,350,1,350,1,350,1,350,1,350,1,350, + 1,350,1,351,1,351,1,351,1,351,1,351,1,352,1,352,1,352,1,352,1,352, + 1,352,1,352,1,352,1,353,1,353,1,353,1,353,1,353,1,353,1,353,1,353, + 1,353,1,354,1,354,1,354,1,354,1,354,1,354,1,354,1,354,1,355,1,355, + 1,355,1,355,1,355,1,355,1,355,1,355,1,355,1,355,1,356,1,356,1,356, + 1,356,1,356,1,356,1,356,1,356,1,356,1,356,1,356,1,356,1,356,1,356, + 1,356,1,356,1,356,1,356,1,357,1,357,1,357,1,357,1,357,1,357,1,357, + 1,357,1,357,1,357,1,357,1,358,1,358,1,358,1,358,1,358,1,358,1,358, + 1,358,1,359,1,359,1,359,1,359,1,359,1,359,1,359,1,359,1,360,1,360, + 1,360,1,360,1,360,1,360,1,360,1,360,1,361,1,361,1,361,1,361,1,361, + 1,361,1,361,1,361,1,361,1,361,1,361,1,362,1,362,1,362,1,362,1,362, + 1,362,1,362,1,362,1,362,1,362,1,362,1,362,1,362,1,362,1,362,1,362, + 1,363,1,363,1,363,1,363,1,363,1,363,1,363,1,364,1,364,1,364,1,364, + 1,364,1,364,1,365,1,365,1,365,1,365,1,365,1,365,1,366,1,366,1,366, + 1,366,1,366,1,366,1,367,1,367,1,367,1,367,1,367,1,367,1,367,1,368, + 1,368,1,368,1,368,1,368,1,368,1,368,1,369,1,369,1,369,1,369,1,369, + 1,369,1,369,1,370,1,370,1,370,1,370,1,370,1,370,1,370,1,371,1,371, + 1,371,1,372,1,372,1,372,1,372,1,372,1,373,1,373,1,373,1,373,1,373, + 1,374,1,374,1,374,1,374,1,374,1,374,1,374,1,374,1,375,1,375,1,375, + 1,375,1,375,1,375,1,375,1,375,1,375,1,376,1,376,1,376,1,376,1,376, + 1,376,1,376,1,377,1,377,1,377,1,377,1,377,1,377,1,377,1,377,1,377, + 1,377,1,378,1,378,1,378,1,378,1,378,1,378,1,378,1,378,1,379,1,379, + 1,379,1,379,1,379,1,379,1,379,1,379,1,379,1,379,1,380,1,380,1,380, + 1,380,1,380,1,380,1,380,1,380,1,380,1,380,1,381,1,381,1,381,1,381, + 1,381,1,382,1,382,1,382,1,382,1,383,1,383,1,383,1,383,1,383,1,383, + 1,383,1,383,1,383,1,383,1,384,1,384,1,384,1,384,1,384,1,384,1,384, + 1,384,1,384,1,384,1,384,1,385,1,385,1,385,1,385,1,385,1,385,1,385, + 1,385,1,385,1,386,1,386,1,386,1,386,1,386,1,386,1,386,1,386,1,387, + 1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,387,1,388,1,388, + 1,388,1,388,1,388,1,388,1,388,1,388,1,389,1,389,1,389,1,389,1,389, + 1,389,1,389,1,389,1,390,1,390,1,390,1,390,1,390,1,390,1,390,1,391, + 1,391,1,391,1,391,1,391,1,391,1,391,1,391,1,392,1,392,1,392,1,392, + 1,392,1,392,1,392,1,392,1,393,1,393,1,393,1,393,1,393,1,393,1,393, + 1,393,1,393,1,393,1,394,1,394,1,394,1,394,1,394,1,394,1,394,1,395, + 1,395,1,395,1,395,1,395,1,395,1,395,1,395,1,395,1,395,1,396,1,396, + 1,396,1,396,1,396,1,396,1,396,1,396,1,397,1,397,1,397,1,397,1,397, + 1,397,1,397,1,397,1,397,1,398,1,398,1,398,1,398,1,398,1,398,1,399, + 1,399,1,399,1,399,1,399,1,399,1,399,1,399,1,400,1,400,1,400,1,400, + 1,400,1,400,1,400,1,400,1,400,1,400,1,400,1,400,1,400,1,400,1,401, + 1,401,1,401,1,401,1,401,1,401,1,402,1,402,1,402,1,402,1,402,1,402, + 1,402,1,403,1,403,1,403,1,403,1,403,1,403,1,403,1,403,1,403,1,403, + 1,403,1,403,1,404,1,404,1,404,1,404,1,404,1,404,1,404,1,404,1,404, + 1,404,1,405,1,405,1,405,1,405,1,405,1,405,1,405,1,405,1,405,1,406, + 1,406,1,406,1,406,1,406,1,406,1,406,1,407,1,407,1,407,1,407,1,407, + 1,407,1,407,1,407,1,408,1,408,1,408,1,409,1,409,1,409,1,410,1,410, + 1,410,1,410,1,410,1,410,1,411,1,411,1,411,1,411,1,411,1,411,1,411, + 1,411,1,412,1,412,1,412,1,412,1,413,1,413,1,413,1,413,1,413,1,414, + 1,414,1,414,1,414,1,414,1,415,1,415,1,415,1,415,1,415,1,415,1,415, + 1,416,1,416,1,416,1,417,1,417,1,417,1,417,1,417,1,417,1,417,1,418, + 1,418,1,418,1,418,1,418,1,418,1,418,1,418,1,419,1,419,1,419,1,419, + 1,419,1,419,1,419,1,420,1,420,1,420,1,420,1,420,1,420,1,420,1,420, + 1,420,1,421,1,421,1,421,1,421,1,421,1,421,1,421,1,421,1,422,1,422, + 1,422,1,422,1,422,1,422,1,422,1,422,1,422,1,422,1,422,1,422,1,422, + 1,422,1,423,1,423,1,423,1,423,1,423,1,423,1,423,1,424,1,424,1,424, + 1,424,1,424,1,425,1,425,1,425,1,425,1,425,1,425,1,425,1,425,1,425, + 1,426,1,426,1,426,1,426,1,426,1,426,1,426,1,426,1,426,1,427,1,427, + 1,427,1,427,1,427,1,427,1,427,1,427,1,427,1,428,1,428,1,428,1,428, + 1,428,1,428,1,428,1,428,1,428,1,428,1,428,1,429,1,429,1,429,1,429, + 1,430,1,430,1,430,1,430,1,430,1,430,1,430,1,431,1,431,1,431,1,431, + 1,431,1,431,1,431,1,431,1,431,1,431,1,431,1,431,1,432,1,432,1,432, + 1,432,1,432,1,432,1,432,1,432,1,432,1,432,1,432,1,432,1,432,1,432, + 1,432,1,432,1,433,1,433,1,433,1,433,1,433,1,433,1,433,1,433,1,434, + 1,434,1,434,1,434,1,434,1,434,1,434,1,434,1,434,1,435,1,435,1,435, + 1,435,1,435,1,435,1,435,1,435,1,435,1,435,1,436,1,436,1,436,1,436, + 1,436,1,436,1,436,1,436,1,436,1,436,1,436,1,437,1,437,1,437,1,437, + 1,437,1,438,1,438,1,438,1,438,1,438,1,439,1,439,1,439,1,439,1,439, + 1,440,1,440,1,440,1,440,1,440,1,440,1,440,1,440,1,440,1,440,1,440, + 1,440,1,440,1,441,1,441,1,441,1,441,1,441,1,441,1,441,1,441,1,441, + 1,441,1,441,1,441,1,441,1,441,1,441,1,442,1,442,1,442,1,442,1,442, + 1,442,1,442,1,442,1,442,1,442,1,442,1,442,1,442,1,442,1,442,1,443, + 1,443,1,443,1,443,1,443,1,443,1,443,1,443,1,443,1,443,1,443,1,444, + 1,444,1,444,1,444,1,444,1,444,1,444,1,444,1,444,1,444,1,444,1,444, + 1,444,1,445,1,445,1,445,1,445,1,445,1,445,1,445,1,445,1,445,1,445, + 1,445,1,445,1,445,1,445,1,445,1,446,1,446,1,446,1,446,1,446,1,446, + 1,446,1,446,1,446,1,446,1,446,1,446,1,447,1,447,1,447,1,447,1,447, + 1,447,1,447,1,448,1,448,1,448,1,448,1,448,1,448,1,448,1,448,1,448, + 1,448,1,448,1,448,1,448,1,448,1,448,1,448,1,449,1,449,1,449,1,449, + 1,449,1,449,1,450,1,450,1,450,1,450,1,450,1,450,1,450,1,451,1,451, + 1,451,1,451,1,451,1,451,1,451,1,451,1,451,1,451,1,451,1,451,1,451, + 1,451,1,452,1,452,1,452,1,452,1,452,1,452,1,452,1,452,1,452,1,453, + 1,453,1,453,1,453,1,453,1,453,1,453,1,453,1,453,1,453,1,453,1,454, + 1,454,1,454,1,454,1,454,1,454,1,454,1,454,1,454,1,454,1,454,1,455, + 1,455,1,455,1,455,1,455,1,455,1,456,1,456,1,456,1,456,1,456,1,456, + 1,456,1,457,1,457,1,457,1,457,1,457,1,458,1,458,1,458,1,458,1,458, + 1,458,1,458,1,459,1,459,1,459,1,459,1,459,1,459,1,459,1,459,1,459, + 1,459,1,459,1,459,1,460,1,460,1,460,1,460,1,460,1,460,1,460,1,460, + 1,460,1,460,1,460,1,460,1,461,1,461,1,461,1,461,1,461,1,461,1,461, + 1,461,1,461,1,461,1,461,1,461,1,462,1,462,1,462,1,462,1,462,1,462, + 1,462,1,462,1,462,1,463,1,463,1,463,1,463,1,464,1,464,1,464,1,464, + 1,464,1,464,1,464,1,464,1,464,1,465,1,465,1,465,1,465,1,465,1,465, + 1,465,1,466,1,466,1,466,1,466,1,466,1,466,1,466,1,466,1,466,1,467, + 1,467,1,467,1,467,1,467,1,468,1,468,1,468,1,468,1,468,1,468,1,468, + 1,468,1,468,1,468,1,468,1,468,1,468,1,469,1,469,1,469,1,469,1,469, + 1,469,1,470,1,470,1,470,1,470,1,470,1,470,1,471,1,471,1,471,1,471, + 1,471,1,471,1,471,1,471,1,471,1,472,1,472,1,472,1,472,1,472,1,473, + 1,473,1,473,1,473,1,473,1,474,1,474,1,474,1,474,1,474,1,474,1,474, + 1,474,1,474,1,475,1,475,1,475,1,475,1,475,1,475,1,475,1,475,1,475, + 1,475,1,476,1,476,1,476,1,476,1,476,1,477,1,477,1,477,1,477,1,477, + 1,478,1,478,1,478,1,478,1,478,1,479,1,479,1,479,1,479,1,479,1,480, + 1,480,1,480,1,480,1,480,1,480,1,480,1,481,1,481,1,481,1,481,1,481, + 1,481,1,481,1,481,1,481,1,481,1,481,1,481,1,481,1,482,1,482,1,482, + 1,482,1,482,1,482,1,482,1,482,1,483,1,483,1,483,1,483,1,483,1,484, + 1,484,1,484,1,484,1,484,1,485,1,485,1,485,1,485,1,485,1,485,1,486, + 1,486,1,486,1,486,1,486,1,486,1,487,1,487,1,487,1,487,1,487,1,487, + 1,488,1,488,1,488,1,489,1,489,1,489,1,489,1,489,1,489,1,489,1,489, + 1,489,1,489,1,489,1,489,1,490,1,490,1,490,1,490,1,490,1,490,1,490, + 1,490,1,490,1,490,1,490,1,490,1,491,1,491,1,491,1,491,1,492,1,492, + 1,492,1,492,1,492,1,492,1,492,1,492,1,492,1,493,1,493,1,493,1,493, + 1,493,1,494,1,494,1,494,1,494,1,494,1,494,1,494,1,494,1,494,1,494, + 1,495,1,495,1,495,1,495,1,495,1,496,1,496,1,496,1,496,1,496,1,496, + 1,496,1,496,1,497,1,497,1,497,1,497,1,497,1,497,1,497,1,497,1,497, + 1,497,1,498,1,498,1,498,1,498,1,498,1,499,1,499,1,499,1,499,1,499, + 1,499,1,499,1,499,1,499,1,500,1,500,1,500,1,500,1,500,1,500,1,501, + 1,501,1,501,1,502,1,502,1,502,1,502,1,502,1,503,1,503,1,503,1,503, + 1,503,1,503,1,504,1,504,1,504,1,504,1,505,1,505,1,505,1,505,1,505, + 1,505,1,506,1,506,1,506,1,506,1,506,1,506,1,507,1,507,1,507,1,507, + 1,507,1,507,1,507,1,508,1,508,1,508,1,508,1,508,1,508,1,508,1,508, + 1,509,1,509,1,509,1,509,1,509,1,509,1,509,1,509,1,510,1,510,1,510, + 1,510,1,510,1,511,1,511,1,511,1,511,1,511,1,512,1,512,1,512,1,512, + 1,512,1,512,1,512,1,512,1,512,1,512,1,512,1,512,1,512,1,512,1,513, + 1,513,1,513,1,513,1,513,1,514,1,514,1,514,1,514,1,514,1,514,1,515, + 1,515,1,515,1,515,1,515,1,515,1,515,1,515,1,515,1,515,1,515,1,515, + 1,515,1,515,1,515,1,515,1,516,1,516,1,516,1,516,1,516,1,516,1,517, + 1,517,1,517,1,517,1,517,1,518,1,518,1,518,1,518,1,518,1,518,1,518, + 1,518,1,518,1,519,1,519,1,519,1,519,1,519,1,519,1,519,1,519,1,520, + 1,520,1,520,1,520,1,520,1,521,1,521,1,521,1,521,1,521,1,521,1,521, + 1,521,1,521,1,521,1,522,1,522,1,522,1,522,1,522,1,522,1,523,1,523, + 1,523,1,523,1,523,1,523,1,523,1,524,1,524,1,525,1,525,1,526,1,526, + 1,526,1,527,1,527,1,528,1,528,1,529,1,529,1,529,1,529,1,529,1,530, + 1,530,1,530,1,531,1,531,1,532,1,532,1,533,1,533,4,533,5554,8,533, + 11,533,12,533,5555,1,533,1,533,3,533,5560,8,533,1,534,1,534,1,535, + 1,535,1,536,1,536,1,536,1,536,1,536,1,536,1,536,1,536,1,536,1,536, + 1,536,1,537,1,537,1,537,1,537,1,537,1,537,1,537,1,537,1,537,1,537, + 1,538,1,538,1,538,1,538,1,538,1,538,1,538,1,538,1,538,1,538,1,538, + 1,538,1,538,1,539,1,539,1,540,1,540,1,540,1,541,1,541,1,542,1,542, + 1,543,1,543,1,544,1,544,1,544,1,545,1,545,1,545,1,546,1,546,1,547, + 1,547,1,548,1,548,1,549,1,549,1,550,1,550,1,550,1,550,3,550,5629, + 8,550,1,551,1,551,1,551,4,551,5634,8,551,11,551,12,551,5635,1,551, + 1,551,1,551,1,551,1,551,4,551,5643,8,551,11,551,12,551,5644,1,551, + 1,551,3,551,5649,8,551,1,552,1,552,1,552,1,552,1,552,1,552,5,552, + 5657,8,552,10,552,12,552,5660,9,552,1,552,1,552,1,552,1,552,1,552, + 1,552,1,552,1,552,5,552,5670,8,552,10,552,12,552,5673,9,552,1,552, + 1,552,3,552,5677,8,552,1,553,1,553,1,553,1,553,1,553,5,553,5684, + 8,553,10,553,12,553,5687,9,553,1,553,1,553,1,553,1,553,1,553,1,553, + 5,553,5695,8,553,10,553,12,553,5698,9,553,1,553,3,553,5701,8,553, + 1,554,1,554,1,554,1,554,1,554,1,554,5,554,5709,8,554,10,554,12,554, + 5712,9,554,1,554,1,554,1,554,1,554,1,554,1,554,1,554,5,554,5721, + 8,554,10,554,12,554,5724,9,554,1,554,3,554,5727,8,554,1,555,1,555, + 1,555,1,556,1,556,1,556,1,557,1,557,1,557,1,558,1,558,3,558,5740, + 8,558,1,558,4,558,5743,8,558,11,558,12,558,5744,1,559,1,559,3,559, + 5749,8,559,1,559,5,559,5752,8,559,10,559,12,559,5755,9,559,1,559, + 1,559,3,559,5759,8,559,1,559,4,559,5762,8,559,11,559,12,559,5763, + 1,559,1,559,1,559,3,559,5769,8,559,1,559,4,559,5772,8,559,11,559, + 12,559,5773,3,559,5776,8,559,1,560,4,560,5779,8,560,11,560,12,560, + 5780,1,560,4,560,5784,8,560,11,560,12,560,5785,1,560,4,560,5789, + 8,560,11,560,12,560,5790,5,560,5793,8,560,10,560,12,560,5796,9,560, + 1,561,3,561,5799,8,561,1,561,1,561,1,561,1,561,1,562,1,562,1,562, + 5,562,5808,8,562,10,562,12,562,5811,9,562,1,562,1,562,1,563,1,563, + 1,563,5,563,5818,8,563,10,563,12,563,5821,9,563,1,563,1,563,1,564, + 1,564,1,564,5,564,5828,8,564,10,564,12,564,5831,9,564,1,564,1,564, + 1,565,1,565,1,565,5,565,5838,8,565,10,565,12,565,5841,9,565,1,566, + 1,566,1,566,5,566,5846,8,566,10,566,12,566,5849,9,566,1,566,1,566, + 1,567,4,567,5854,8,567,11,567,12,567,5855,1,567,1,567,1,568,1,568, + 1,568,1,568,1,568,1,569,1,569,1,570,1,570,1,571,1,571,1,572,1,572, + 1,573,1,573,1,574,1,574,1,575,1,575,1,576,1,576,1,577,1,577,1,578, + 1,578,1,579,1,579,1,580,1,580,1,581,1,581,1,582,1,582,1,583,1,583, + 1,584,1,584,1,585,1,585,1,586,1,586,1,587,1,587,1,588,1,588,1,589, + 1,589,1,590,1,590,1,591,1,591,1,592,1,592,1,593,1,593,1,594,1,594, + 0,0,595,1,1,3,2,5,3,7,4,9,5,11,6,13,7,15,8,17,9,19,10,21,11,23,12, + 25,13,27,14,29,15,31,16,33,17,35,18,37,19,39,20,41,21,43,22,45,23, + 47,24,49,25,51,26,53,27,55,28,57,29,59,30,61,31,63,32,65,33,67,34, + 69,35,71,36,73,37,75,38,77,39,79,40,81,41,83,42,85,43,87,44,89,45, + 91,46,93,47,95,48,97,49,99,50,101,51,103,52,105,53,107,54,109,55, + 111,56,113,57,115,58,117,59,119,60,121,61,123,62,125,63,127,64,129, + 65,131,66,133,67,135,68,137,69,139,70,141,71,143,72,145,73,147,74, + 149,75,151,76,153,77,155,78,157,79,159,80,161,81,163,82,165,83,167, + 84,169,85,171,86,173,87,175,88,177,89,179,90,181,91,183,92,185,93, + 187,94,189,95,191,96,193,97,195,98,197,99,199,100,201,101,203,102, + 205,103,207,104,209,105,211,106,213,107,215,108,217,109,219,110, + 221,111,223,112,225,113,227,114,229,115,231,116,233,117,235,118, + 237,119,239,120,241,121,243,122,245,123,247,124,249,125,251,126, + 253,127,255,128,257,129,259,130,261,131,263,132,265,133,267,134, + 269,135,271,136,273,137,275,138,277,139,279,140,281,141,283,142, + 285,143,287,144,289,145,291,146,293,147,295,148,297,149,299,150, + 301,151,303,152,305,153,307,154,309,155,311,156,313,157,315,158, + 317,159,319,160,321,161,323,162,325,163,327,164,329,165,331,166, + 333,167,335,168,337,169,339,170,341,171,343,172,345,173,347,174, + 349,175,351,176,353,177,355,178,357,179,359,180,361,181,363,182, + 365,183,367,184,369,185,371,186,373,187,375,188,377,189,379,190, + 381,191,383,192,385,193,387,194,389,195,391,196,393,197,395,198, + 397,199,399,200,401,201,403,202,405,203,407,204,409,205,411,206, + 413,207,415,208,417,209,419,210,421,211,423,212,425,213,427,214, + 429,215,431,216,433,217,435,218,437,219,439,220,441,221,443,222, + 445,223,447,224,449,225,451,226,453,227,455,228,457,229,459,230, + 461,231,463,232,465,233,467,234,469,235,471,236,473,237,475,238, + 477,239,479,240,481,241,483,242,485,243,487,244,489,245,491,246, + 493,247,495,248,497,249,499,250,501,251,503,252,505,253,507,254, + 509,255,511,256,513,257,515,258,517,259,519,260,521,261,523,262, + 525,263,527,264,529,265,531,266,533,267,535,268,537,269,539,270, + 541,271,543,272,545,273,547,274,549,275,551,276,553,277,555,278, + 557,279,559,280,561,281,563,282,565,283,567,284,569,285,571,286, + 573,287,575,288,577,289,579,290,581,291,583,292,585,293,587,294, + 589,295,591,296,593,297,595,298,597,299,599,300,601,301,603,302, + 605,303,607,304,609,305,611,306,613,307,615,308,617,309,619,310, + 621,311,623,312,625,313,627,314,629,315,631,316,633,317,635,318, + 637,319,639,320,641,321,643,322,645,323,647,324,649,325,651,326, + 653,327,655,328,657,329,659,330,661,331,663,332,665,333,667,334, + 669,335,671,336,673,337,675,338,677,339,679,340,681,341,683,342, + 685,343,687,344,689,345,691,346,693,347,695,348,697,349,699,350, + 701,351,703,352,705,353,707,354,709,355,711,356,713,357,715,358, + 717,359,719,360,721,361,723,362,725,363,727,364,729,365,731,366, + 733,367,735,368,737,369,739,370,741,371,743,372,745,373,747,374, + 749,375,751,376,753,377,755,378,757,379,759,380,761,381,763,382, + 765,383,767,384,769,385,771,386,773,387,775,388,777,389,779,390, + 781,391,783,392,785,393,787,394,789,395,791,396,793,397,795,398, + 797,399,799,400,801,401,803,402,805,403,807,404,809,405,811,406, + 813,407,815,408,817,409,819,410,821,411,823,412,825,413,827,414, + 829,415,831,416,833,417,835,418,837,419,839,420,841,421,843,422, + 845,423,847,424,849,425,851,426,853,427,855,428,857,429,859,430, + 861,431,863,432,865,433,867,434,869,435,871,436,873,437,875,438, + 877,439,879,440,881,441,883,442,885,443,887,444,889,445,891,446, + 893,447,895,448,897,449,899,450,901,451,903,452,905,453,907,454, + 909,455,911,456,913,457,915,458,917,459,919,460,921,461,923,462, + 925,463,927,464,929,465,931,466,933,467,935,468,937,469,939,470, + 941,471,943,472,945,473,947,474,949,475,951,476,953,477,955,478, + 957,479,959,480,961,481,963,482,965,483,967,484,969,485,971,486, + 973,487,975,488,977,489,979,490,981,491,983,492,985,493,987,494, + 989,495,991,496,993,497,995,498,997,499,999,500,1001,501,1003,502, + 1005,503,1007,504,1009,505,1011,506,1013,507,1015,508,1017,509,1019, + 510,1021,511,1023,512,1025,513,1027,514,1029,515,1031,516,1033,517, + 1035,518,1037,519,1039,520,1041,521,1043,522,1045,523,1047,524,1049, + 525,1051,526,1053,527,1055,528,1057,529,1059,530,1061,531,1063,532, + 1065,533,1067,534,1069,535,1071,536,1073,537,1075,538,1077,539,1079, + 540,1081,541,1083,542,1085,543,1087,544,1089,545,1091,546,1093,547, + 1095,548,1097,549,1099,550,1101,551,1103,0,1105,0,1107,0,1109,0, + 1111,552,1113,553,1115,554,1117,555,1119,556,1121,557,1123,558,1125, + 559,1127,560,1129,561,1131,562,1133,563,1135,564,1137,565,1139,0, + 1141,0,1143,0,1145,0,1147,0,1149,0,1151,0,1153,0,1155,0,1157,0,1159, + 0,1161,0,1163,0,1165,0,1167,0,1169,0,1171,0,1173,0,1175,0,1177,0, + 1179,0,1181,0,1183,0,1185,0,1187,0,1189,0,1,0,37,3,0,9,10,12,13, + 32,32,2,0,48,57,65,70,3,0,10,10,13,13,34,34,3,0,10,10,13,13,39,39, + 2,0,71,71,78,78,1,0,48,57,2,0,69,69,101,101,3,0,48,57,65,90,97,122, + 2,0,45,45,95,95,3,0,10,10,13,13,125,125,2,0,10,10,13,13,4,0,9,9, + 12,12,32,32,59,59,2,0,65,65,97,97,2,0,66,66,98,98,2,0,67,67,99,99, + 2,0,68,68,100,100,2,0,70,70,102,102,2,0,71,71,103,103,2,0,72,72, + 104,104,2,0,73,73,105,105,2,0,74,74,106,106,2,0,75,75,107,107,2, + 0,76,76,108,108,2,0,77,77,109,109,2,0,78,78,110,110,2,0,79,79,111, + 111,2,0,80,80,112,112,2,0,81,81,113,113,2,0,82,82,114,114,2,0,83, + 83,115,115,2,0,84,84,116,116,2,0,85,85,117,117,2,0,86,86,118,118, + 2,0,87,87,119,119,2,0,88,88,120,120,2,0,89,89,121,121,2,0,90,90, + 122,122,5937,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,7,1,0,0,0,0,9, + 1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0,0,0,0,17,1,0,0,0,0,19, + 1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25,1,0,0,0,0,27,1,0,0,0,0,29, + 1,0,0,0,0,31,1,0,0,0,0,33,1,0,0,0,0,35,1,0,0,0,0,37,1,0,0,0,0,39, + 1,0,0,0,0,41,1,0,0,0,0,43,1,0,0,0,0,45,1,0,0,0,0,47,1,0,0,0,0,49, + 1,0,0,0,0,51,1,0,0,0,0,53,1,0,0,0,0,55,1,0,0,0,0,57,1,0,0,0,0,59, + 1,0,0,0,0,61,1,0,0,0,0,63,1,0,0,0,0,65,1,0,0,0,0,67,1,0,0,0,0,69, + 1,0,0,0,0,71,1,0,0,0,0,73,1,0,0,0,0,75,1,0,0,0,0,77,1,0,0,0,0,79, + 1,0,0,0,0,81,1,0,0,0,0,83,1,0,0,0,0,85,1,0,0,0,0,87,1,0,0,0,0,89, + 1,0,0,0,0,91,1,0,0,0,0,93,1,0,0,0,0,95,1,0,0,0,0,97,1,0,0,0,0,99, + 1,0,0,0,0,101,1,0,0,0,0,103,1,0,0,0,0,105,1,0,0,0,0,107,1,0,0,0, + 0,109,1,0,0,0,0,111,1,0,0,0,0,113,1,0,0,0,0,115,1,0,0,0,0,117,1, + 0,0,0,0,119,1,0,0,0,0,121,1,0,0,0,0,123,1,0,0,0,0,125,1,0,0,0,0, + 127,1,0,0,0,0,129,1,0,0,0,0,131,1,0,0,0,0,133,1,0,0,0,0,135,1,0, + 0,0,0,137,1,0,0,0,0,139,1,0,0,0,0,141,1,0,0,0,0,143,1,0,0,0,0,145, + 1,0,0,0,0,147,1,0,0,0,0,149,1,0,0,0,0,151,1,0,0,0,0,153,1,0,0,0, + 0,155,1,0,0,0,0,157,1,0,0,0,0,159,1,0,0,0,0,161,1,0,0,0,0,163,1, + 0,0,0,0,165,1,0,0,0,0,167,1,0,0,0,0,169,1,0,0,0,0,171,1,0,0,0,0, + 173,1,0,0,0,0,175,1,0,0,0,0,177,1,0,0,0,0,179,1,0,0,0,0,181,1,0, + 0,0,0,183,1,0,0,0,0,185,1,0,0,0,0,187,1,0,0,0,0,189,1,0,0,0,0,191, + 1,0,0,0,0,193,1,0,0,0,0,195,1,0,0,0,0,197,1,0,0,0,0,199,1,0,0,0, + 0,201,1,0,0,0,0,203,1,0,0,0,0,205,1,0,0,0,0,207,1,0,0,0,0,209,1, + 0,0,0,0,211,1,0,0,0,0,213,1,0,0,0,0,215,1,0,0,0,0,217,1,0,0,0,0, + 219,1,0,0,0,0,221,1,0,0,0,0,223,1,0,0,0,0,225,1,0,0,0,0,227,1,0, + 0,0,0,229,1,0,0,0,0,231,1,0,0,0,0,233,1,0,0,0,0,235,1,0,0,0,0,237, + 1,0,0,0,0,239,1,0,0,0,0,241,1,0,0,0,0,243,1,0,0,0,0,245,1,0,0,0, + 0,247,1,0,0,0,0,249,1,0,0,0,0,251,1,0,0,0,0,253,1,0,0,0,0,255,1, + 0,0,0,0,257,1,0,0,0,0,259,1,0,0,0,0,261,1,0,0,0,0,263,1,0,0,0,0, + 265,1,0,0,0,0,267,1,0,0,0,0,269,1,0,0,0,0,271,1,0,0,0,0,273,1,0, + 0,0,0,275,1,0,0,0,0,277,1,0,0,0,0,279,1,0,0,0,0,281,1,0,0,0,0,283, + 1,0,0,0,0,285,1,0,0,0,0,287,1,0,0,0,0,289,1,0,0,0,0,291,1,0,0,0, + 0,293,1,0,0,0,0,295,1,0,0,0,0,297,1,0,0,0,0,299,1,0,0,0,0,301,1, + 0,0,0,0,303,1,0,0,0,0,305,1,0,0,0,0,307,1,0,0,0,0,309,1,0,0,0,0, + 311,1,0,0,0,0,313,1,0,0,0,0,315,1,0,0,0,0,317,1,0,0,0,0,319,1,0, + 0,0,0,321,1,0,0,0,0,323,1,0,0,0,0,325,1,0,0,0,0,327,1,0,0,0,0,329, + 1,0,0,0,0,331,1,0,0,0,0,333,1,0,0,0,0,335,1,0,0,0,0,337,1,0,0,0, + 0,339,1,0,0,0,0,341,1,0,0,0,0,343,1,0,0,0,0,345,1,0,0,0,0,347,1, + 0,0,0,0,349,1,0,0,0,0,351,1,0,0,0,0,353,1,0,0,0,0,355,1,0,0,0,0, + 357,1,0,0,0,0,359,1,0,0,0,0,361,1,0,0,0,0,363,1,0,0,0,0,365,1,0, + 0,0,0,367,1,0,0,0,0,369,1,0,0,0,0,371,1,0,0,0,0,373,1,0,0,0,0,375, + 1,0,0,0,0,377,1,0,0,0,0,379,1,0,0,0,0,381,1,0,0,0,0,383,1,0,0,0, + 0,385,1,0,0,0,0,387,1,0,0,0,0,389,1,0,0,0,0,391,1,0,0,0,0,393,1, + 0,0,0,0,395,1,0,0,0,0,397,1,0,0,0,0,399,1,0,0,0,0,401,1,0,0,0,0, + 403,1,0,0,0,0,405,1,0,0,0,0,407,1,0,0,0,0,409,1,0,0,0,0,411,1,0, + 0,0,0,413,1,0,0,0,0,415,1,0,0,0,0,417,1,0,0,0,0,419,1,0,0,0,0,421, + 1,0,0,0,0,423,1,0,0,0,0,425,1,0,0,0,0,427,1,0,0,0,0,429,1,0,0,0, + 0,431,1,0,0,0,0,433,1,0,0,0,0,435,1,0,0,0,0,437,1,0,0,0,0,439,1, + 0,0,0,0,441,1,0,0,0,0,443,1,0,0,0,0,445,1,0,0,0,0,447,1,0,0,0,0, + 449,1,0,0,0,0,451,1,0,0,0,0,453,1,0,0,0,0,455,1,0,0,0,0,457,1,0, + 0,0,0,459,1,0,0,0,0,461,1,0,0,0,0,463,1,0,0,0,0,465,1,0,0,0,0,467, + 1,0,0,0,0,469,1,0,0,0,0,471,1,0,0,0,0,473,1,0,0,0,0,475,1,0,0,0, + 0,477,1,0,0,0,0,479,1,0,0,0,0,481,1,0,0,0,0,483,1,0,0,0,0,485,1, + 0,0,0,0,487,1,0,0,0,0,489,1,0,0,0,0,491,1,0,0,0,0,493,1,0,0,0,0, + 495,1,0,0,0,0,497,1,0,0,0,0,499,1,0,0,0,0,501,1,0,0,0,0,503,1,0, + 0,0,0,505,1,0,0,0,0,507,1,0,0,0,0,509,1,0,0,0,0,511,1,0,0,0,0,513, + 1,0,0,0,0,515,1,0,0,0,0,517,1,0,0,0,0,519,1,0,0,0,0,521,1,0,0,0, + 0,523,1,0,0,0,0,525,1,0,0,0,0,527,1,0,0,0,0,529,1,0,0,0,0,531,1, + 0,0,0,0,533,1,0,0,0,0,535,1,0,0,0,0,537,1,0,0,0,0,539,1,0,0,0,0, + 541,1,0,0,0,0,543,1,0,0,0,0,545,1,0,0,0,0,547,1,0,0,0,0,549,1,0, + 0,0,0,551,1,0,0,0,0,553,1,0,0,0,0,555,1,0,0,0,0,557,1,0,0,0,0,559, + 1,0,0,0,0,561,1,0,0,0,0,563,1,0,0,0,0,565,1,0,0,0,0,567,1,0,0,0, + 0,569,1,0,0,0,0,571,1,0,0,0,0,573,1,0,0,0,0,575,1,0,0,0,0,577,1, + 0,0,0,0,579,1,0,0,0,0,581,1,0,0,0,0,583,1,0,0,0,0,585,1,0,0,0,0, + 587,1,0,0,0,0,589,1,0,0,0,0,591,1,0,0,0,0,593,1,0,0,0,0,595,1,0, + 0,0,0,597,1,0,0,0,0,599,1,0,0,0,0,601,1,0,0,0,0,603,1,0,0,0,0,605, + 1,0,0,0,0,607,1,0,0,0,0,609,1,0,0,0,0,611,1,0,0,0,0,613,1,0,0,0, + 0,615,1,0,0,0,0,617,1,0,0,0,0,619,1,0,0,0,0,621,1,0,0,0,0,623,1, + 0,0,0,0,625,1,0,0,0,0,627,1,0,0,0,0,629,1,0,0,0,0,631,1,0,0,0,0, + 633,1,0,0,0,0,635,1,0,0,0,0,637,1,0,0,0,0,639,1,0,0,0,0,641,1,0, + 0,0,0,643,1,0,0,0,0,645,1,0,0,0,0,647,1,0,0,0,0,649,1,0,0,0,0,651, + 1,0,0,0,0,653,1,0,0,0,0,655,1,0,0,0,0,657,1,0,0,0,0,659,1,0,0,0, + 0,661,1,0,0,0,0,663,1,0,0,0,0,665,1,0,0,0,0,667,1,0,0,0,0,669,1, + 0,0,0,0,671,1,0,0,0,0,673,1,0,0,0,0,675,1,0,0,0,0,677,1,0,0,0,0, + 679,1,0,0,0,0,681,1,0,0,0,0,683,1,0,0,0,0,685,1,0,0,0,0,687,1,0, + 0,0,0,689,1,0,0,0,0,691,1,0,0,0,0,693,1,0,0,0,0,695,1,0,0,0,0,697, + 1,0,0,0,0,699,1,0,0,0,0,701,1,0,0,0,0,703,1,0,0,0,0,705,1,0,0,0, + 0,707,1,0,0,0,0,709,1,0,0,0,0,711,1,0,0,0,0,713,1,0,0,0,0,715,1, + 0,0,0,0,717,1,0,0,0,0,719,1,0,0,0,0,721,1,0,0,0,0,723,1,0,0,0,0, + 725,1,0,0,0,0,727,1,0,0,0,0,729,1,0,0,0,0,731,1,0,0,0,0,733,1,0, + 0,0,0,735,1,0,0,0,0,737,1,0,0,0,0,739,1,0,0,0,0,741,1,0,0,0,0,743, + 1,0,0,0,0,745,1,0,0,0,0,747,1,0,0,0,0,749,1,0,0,0,0,751,1,0,0,0, + 0,753,1,0,0,0,0,755,1,0,0,0,0,757,1,0,0,0,0,759,1,0,0,0,0,761,1, + 0,0,0,0,763,1,0,0,0,0,765,1,0,0,0,0,767,1,0,0,0,0,769,1,0,0,0,0, + 771,1,0,0,0,0,773,1,0,0,0,0,775,1,0,0,0,0,777,1,0,0,0,0,779,1,0, + 0,0,0,781,1,0,0,0,0,783,1,0,0,0,0,785,1,0,0,0,0,787,1,0,0,0,0,789, + 1,0,0,0,0,791,1,0,0,0,0,793,1,0,0,0,0,795,1,0,0,0,0,797,1,0,0,0, + 0,799,1,0,0,0,0,801,1,0,0,0,0,803,1,0,0,0,0,805,1,0,0,0,0,807,1, + 0,0,0,0,809,1,0,0,0,0,811,1,0,0,0,0,813,1,0,0,0,0,815,1,0,0,0,0, + 817,1,0,0,0,0,819,1,0,0,0,0,821,1,0,0,0,0,823,1,0,0,0,0,825,1,0, + 0,0,0,827,1,0,0,0,0,829,1,0,0,0,0,831,1,0,0,0,0,833,1,0,0,0,0,835, + 1,0,0,0,0,837,1,0,0,0,0,839,1,0,0,0,0,841,1,0,0,0,0,843,1,0,0,0, + 0,845,1,0,0,0,0,847,1,0,0,0,0,849,1,0,0,0,0,851,1,0,0,0,0,853,1, + 0,0,0,0,855,1,0,0,0,0,857,1,0,0,0,0,859,1,0,0,0,0,861,1,0,0,0,0, + 863,1,0,0,0,0,865,1,0,0,0,0,867,1,0,0,0,0,869,1,0,0,0,0,871,1,0, + 0,0,0,873,1,0,0,0,0,875,1,0,0,0,0,877,1,0,0,0,0,879,1,0,0,0,0,881, + 1,0,0,0,0,883,1,0,0,0,0,885,1,0,0,0,0,887,1,0,0,0,0,889,1,0,0,0, + 0,891,1,0,0,0,0,893,1,0,0,0,0,895,1,0,0,0,0,897,1,0,0,0,0,899,1, + 0,0,0,0,901,1,0,0,0,0,903,1,0,0,0,0,905,1,0,0,0,0,907,1,0,0,0,0, + 909,1,0,0,0,0,911,1,0,0,0,0,913,1,0,0,0,0,915,1,0,0,0,0,917,1,0, + 0,0,0,919,1,0,0,0,0,921,1,0,0,0,0,923,1,0,0,0,0,925,1,0,0,0,0,927, + 1,0,0,0,0,929,1,0,0,0,0,931,1,0,0,0,0,933,1,0,0,0,0,935,1,0,0,0, + 0,937,1,0,0,0,0,939,1,0,0,0,0,941,1,0,0,0,0,943,1,0,0,0,0,945,1, + 0,0,0,0,947,1,0,0,0,0,949,1,0,0,0,0,951,1,0,0,0,0,953,1,0,0,0,0, + 955,1,0,0,0,0,957,1,0,0,0,0,959,1,0,0,0,0,961,1,0,0,0,0,963,1,0, + 0,0,0,965,1,0,0,0,0,967,1,0,0,0,0,969,1,0,0,0,0,971,1,0,0,0,0,973, + 1,0,0,0,0,975,1,0,0,0,0,977,1,0,0,0,0,979,1,0,0,0,0,981,1,0,0,0, + 0,983,1,0,0,0,0,985,1,0,0,0,0,987,1,0,0,0,0,989,1,0,0,0,0,991,1, + 0,0,0,0,993,1,0,0,0,0,995,1,0,0,0,0,997,1,0,0,0,0,999,1,0,0,0,0, + 1001,1,0,0,0,0,1003,1,0,0,0,0,1005,1,0,0,0,0,1007,1,0,0,0,0,1009, + 1,0,0,0,0,1011,1,0,0,0,0,1013,1,0,0,0,0,1015,1,0,0,0,0,1017,1,0, + 0,0,0,1019,1,0,0,0,0,1021,1,0,0,0,0,1023,1,0,0,0,0,1025,1,0,0,0, + 0,1027,1,0,0,0,0,1029,1,0,0,0,0,1031,1,0,0,0,0,1033,1,0,0,0,0,1035, + 1,0,0,0,0,1037,1,0,0,0,0,1039,1,0,0,0,0,1041,1,0,0,0,0,1043,1,0, + 0,0,0,1045,1,0,0,0,0,1047,1,0,0,0,0,1049,1,0,0,0,0,1051,1,0,0,0, + 0,1053,1,0,0,0,0,1055,1,0,0,0,0,1057,1,0,0,0,0,1059,1,0,0,0,0,1061, + 1,0,0,0,0,1063,1,0,0,0,0,1065,1,0,0,0,0,1067,1,0,0,0,0,1069,1,0, + 0,0,0,1071,1,0,0,0,0,1073,1,0,0,0,0,1075,1,0,0,0,0,1077,1,0,0,0, + 0,1079,1,0,0,0,0,1081,1,0,0,0,0,1083,1,0,0,0,0,1085,1,0,0,0,0,1087, + 1,0,0,0,0,1089,1,0,0,0,0,1091,1,0,0,0,0,1093,1,0,0,0,0,1095,1,0, + 0,0,0,1097,1,0,0,0,0,1099,1,0,0,0,0,1101,1,0,0,0,0,1111,1,0,0,0, + 0,1113,1,0,0,0,0,1115,1,0,0,0,0,1117,1,0,0,0,0,1119,1,0,0,0,0,1121, + 1,0,0,0,0,1123,1,0,0,0,0,1125,1,0,0,0,0,1127,1,0,0,0,0,1129,1,0, + 0,0,0,1131,1,0,0,0,0,1133,1,0,0,0,0,1135,1,0,0,0,0,1137,1,0,0,0, + 1,1191,1,0,0,0,3,1197,1,0,0,0,5,1204,1,0,0,0,7,1211,1,0,0,0,9,1215, + 1,0,0,0,11,1223,1,0,0,0,13,1233,1,0,0,0,15,1239,1,0,0,0,17,1247, + 1,0,0,0,19,1251,1,0,0,0,21,1260,1,0,0,0,23,1271,1,0,0,0,25,1288, + 1,0,0,0,27,1305,1,0,0,0,29,1318,1,0,0,0,31,1338,1,0,0,0,33,1343, + 1,0,0,0,35,1349,1,0,0,0,37,1359,1,0,0,0,39,1363,1,0,0,0,41,1367, + 1,0,0,0,43,1371,1,0,0,0,45,1376,1,0,0,0,47,1382,1,0,0,0,49,1385, + 1,0,0,0,51,1395,1,0,0,0,53,1401,1,0,0,0,55,1408,1,0,0,0,57,1424, + 1,0,0,0,59,1447,1,0,0,0,61,1450,1,0,0,0,63,1460,1,0,0,0,65,1467, + 1,0,0,0,67,1472,1,0,0,0,69,1482,1,0,0,0,71,1499,1,0,0,0,73,1517, + 1,0,0,0,75,1523,1,0,0,0,77,1528,1,0,0,0,79,1535,1,0,0,0,81,1545, + 1,0,0,0,83,1550,1,0,0,0,85,1557,1,0,0,0,87,1561,1,0,0,0,89,1567, + 1,0,0,0,91,1573,1,0,0,0,93,1579,1,0,0,0,95,1586,1,0,0,0,97,1593, + 1,0,0,0,99,1596,1,0,0,0,101,1607,1,0,0,0,103,1615,1,0,0,0,105,1620, + 1,0,0,0,107,1627,1,0,0,0,109,1635,1,0,0,0,111,1646,1,0,0,0,113,1649, + 1,0,0,0,115,1652,1,0,0,0,117,1655,1,0,0,0,119,1664,1,0,0,0,121,1672, + 1,0,0,0,123,1680,1,0,0,0,125,1690,1,0,0,0,127,1701,1,0,0,0,129,1707, + 1,0,0,0,131,1716,1,0,0,0,133,1728,1,0,0,0,135,1734,1,0,0,0,137,1752, + 1,0,0,0,139,1758,1,0,0,0,141,1763,1,0,0,0,143,1772,1,0,0,0,145,1782, + 1,0,0,0,147,1786,1,0,0,0,149,1793,1,0,0,0,151,1801,1,0,0,0,153,1807, + 1,0,0,0,155,1818,1,0,0,0,157,1825,1,0,0,0,159,1839,1,0,0,0,161,1844, + 1,0,0,0,163,1851,1,0,0,0,165,1858,1,0,0,0,167,1865,1,0,0,0,169,1872, + 1,0,0,0,171,1879,1,0,0,0,173,1893,1,0,0,0,175,1909,1,0,0,0,177,1925, + 1,0,0,0,179,1941,1,0,0,0,181,1957,1,0,0,0,183,1973,1,0,0,0,185,1981, + 1,0,0,0,187,1995,1,0,0,0,189,2004,1,0,0,0,191,2012,1,0,0,0,193,2021, + 1,0,0,0,195,2029,1,0,0,0,197,2043,1,0,0,0,199,2052,1,0,0,0,201,2063, + 1,0,0,0,203,2074,1,0,0,0,205,2079,1,0,0,0,207,2084,1,0,0,0,209,2098, + 1,0,0,0,211,2104,1,0,0,0,213,2111,1,0,0,0,215,2120,1,0,0,0,217,2127, + 1,0,0,0,219,2132,1,0,0,0,221,2142,1,0,0,0,223,2147,1,0,0,0,225,2161, + 1,0,0,0,227,2174,1,0,0,0,229,2178,1,0,0,0,231,2190,1,0,0,0,233,2195, + 1,0,0,0,235,2198,1,0,0,0,237,2213,1,0,0,0,239,2224,1,0,0,0,241,2235, + 1,0,0,0,243,2246,1,0,0,0,245,2258,1,0,0,0,247,2270,1,0,0,0,249,2282, + 1,0,0,0,251,2292,1,0,0,0,253,2306,1,0,0,0,255,2319,1,0,0,0,257,2327, + 1,0,0,0,259,2343,1,0,0,0,261,2354,1,0,0,0,263,2361,1,0,0,0,265,2371, + 1,0,0,0,267,2381,1,0,0,0,269,2391,1,0,0,0,271,2402,1,0,0,0,273,2414, + 1,0,0,0,275,2421,1,0,0,0,277,2429,1,0,0,0,279,2438,1,0,0,0,281,2446, + 1,0,0,0,283,2451,1,0,0,0,285,2459,1,0,0,0,287,2469,1,0,0,0,289,2476, + 1,0,0,0,291,2485,1,0,0,0,293,2494,1,0,0,0,295,2501,1,0,0,0,297,2506, + 1,0,0,0,299,2517,1,0,0,0,301,2525,1,0,0,0,303,2532,1,0,0,0,305,2537, + 1,0,0,0,307,2541,1,0,0,0,309,2546,1,0,0,0,311,2550,1,0,0,0,313,2562, + 1,0,0,0,315,2569,1,0,0,0,317,2573,1,0,0,0,319,2584,1,0,0,0,321,2592, + 1,0,0,0,323,2601,1,0,0,0,325,2613,1,0,0,0,327,2624,1,0,0,0,329,2635, + 1,0,0,0,331,2648,1,0,0,0,333,2655,1,0,0,0,335,2668,1,0,0,0,337,2680, + 1,0,0,0,339,2692,1,0,0,0,341,2701,1,0,0,0,343,2713,1,0,0,0,345,2724, + 1,0,0,0,347,2736,1,0,0,0,349,2747,1,0,0,0,351,2757,1,0,0,0,353,2768, + 1,0,0,0,355,2781,1,0,0,0,357,2794,1,0,0,0,359,2804,1,0,0,0,361,2811, + 1,0,0,0,363,2817,1,0,0,0,365,2823,1,0,0,0,367,2839,1,0,0,0,369,2851, + 1,0,0,0,371,2855,1,0,0,0,373,2861,1,0,0,0,375,2867,1,0,0,0,377,2873, + 1,0,0,0,379,2877,1,0,0,0,381,2881,1,0,0,0,383,2888,1,0,0,0,385,2892, + 1,0,0,0,387,2901,1,0,0,0,389,2907,1,0,0,0,391,2913,1,0,0,0,393,2923, + 1,0,0,0,395,2933,1,0,0,0,397,2941,1,0,0,0,399,2946,1,0,0,0,401,2953, + 1,0,0,0,403,2960,1,0,0,0,405,2969,1,0,0,0,407,2978,1,0,0,0,409,2984, + 1,0,0,0,411,2987,1,0,0,0,413,2992,1,0,0,0,415,3005,1,0,0,0,417,3012, + 1,0,0,0,419,3018,1,0,0,0,421,3024,1,0,0,0,423,3032,1,0,0,0,425,3036, + 1,0,0,0,427,3053,1,0,0,0,429,3071,1,0,0,0,431,3076,1,0,0,0,433,3081, + 1,0,0,0,435,3090,1,0,0,0,437,3103,1,0,0,0,439,3120,1,0,0,0,441,3129, + 1,0,0,0,443,3136,1,0,0,0,445,3143,1,0,0,0,447,3150,1,0,0,0,449,3153, + 1,0,0,0,451,3161,1,0,0,0,453,3166,1,0,0,0,455,3172,1,0,0,0,457,3180, + 1,0,0,0,459,3190,1,0,0,0,461,3201,1,0,0,0,463,3213,1,0,0,0,465,3217, + 1,0,0,0,467,3229,1,0,0,0,469,3232,1,0,0,0,471,3247,1,0,0,0,473,3250, + 1,0,0,0,475,3259,1,0,0,0,477,3266,1,0,0,0,479,3269,1,0,0,0,481,3275, + 1,0,0,0,483,3283,1,0,0,0,485,3292,1,0,0,0,487,3300,1,0,0,0,489,3311, + 1,0,0,0,491,3320,1,0,0,0,493,3326,1,0,0,0,495,3339,1,0,0,0,497,3347, + 1,0,0,0,499,3360,1,0,0,0,501,3368,1,0,0,0,503,3373,1,0,0,0,505,3381, + 1,0,0,0,507,3388,1,0,0,0,509,3391,1,0,0,0,511,3396,1,0,0,0,513,3406, + 1,0,0,0,515,3412,1,0,0,0,517,3417,1,0,0,0,519,3421,1,0,0,0,521,3430, + 1,0,0,0,523,3436,1,0,0,0,525,3445,1,0,0,0,527,3450,1,0,0,0,529,3453, + 1,0,0,0,531,3456,1,0,0,0,533,3464,1,0,0,0,535,3469,1,0,0,0,537,3478, + 1,0,0,0,539,3485,1,0,0,0,541,3498,1,0,0,0,543,3503,1,0,0,0,545,3513, + 1,0,0,0,547,3526,1,0,0,0,549,3534,1,0,0,0,551,3540,1,0,0,0,553,3547, + 1,0,0,0,555,3554,1,0,0,0,557,3569,1,0,0,0,559,3574,1,0,0,0,561,3580, + 1,0,0,0,563,3593,1,0,0,0,565,3601,1,0,0,0,567,3606,1,0,0,0,569,3612, + 1,0,0,0,571,3626,1,0,0,0,573,3631,1,0,0,0,575,3641,1,0,0,0,577,3651, + 1,0,0,0,579,3657,1,0,0,0,581,3666,1,0,0,0,583,3676,1,0,0,0,585,3687, + 1,0,0,0,587,3694,1,0,0,0,589,3700,1,0,0,0,591,3708,1,0,0,0,593,3717, + 1,0,0,0,595,3722,1,0,0,0,597,3730,1,0,0,0,599,3742,1,0,0,0,601,3747, + 1,0,0,0,603,3756,1,0,0,0,605,3765,1,0,0,0,607,3771,1,0,0,0,609,3780, + 1,0,0,0,611,3796,1,0,0,0,613,3803,1,0,0,0,615,3812,1,0,0,0,617,3820, + 1,0,0,0,619,3825,1,0,0,0,621,3828,1,0,0,0,623,3836,1,0,0,0,625,3840, + 1,0,0,0,627,3845,1,0,0,0,629,3851,1,0,0,0,631,3858,1,0,0,0,633,3866, + 1,0,0,0,635,3879,1,0,0,0,637,3894,1,0,0,0,639,3907,1,0,0,0,641,3923, + 1,0,0,0,643,3930,1,0,0,0,645,3934,1,0,0,0,647,3937,1,0,0,0,649,3941, + 1,0,0,0,651,3949,1,0,0,0,653,3952,1,0,0,0,655,3957,1,0,0,0,657,3966, + 1,0,0,0,659,3969,1,0,0,0,661,3975,1,0,0,0,663,3983,1,0,0,0,665,3996, + 1,0,0,0,667,4002,1,0,0,0,669,4009,1,0,0,0,671,4018,1,0,0,0,673,4027, + 1,0,0,0,675,4031,1,0,0,0,677,4046,1,0,0,0,679,4054,1,0,0,0,681,4059, + 1,0,0,0,683,4072,1,0,0,0,685,4081,1,0,0,0,687,4089,1,0,0,0,689,4092, + 1,0,0,0,691,4095,1,0,0,0,693,4099,1,0,0,0,695,4107,1,0,0,0,697,4112, + 1,0,0,0,699,4120,1,0,0,0,701,4129,1,0,0,0,703,4138,1,0,0,0,705,4143, + 1,0,0,0,707,4151,1,0,0,0,709,4160,1,0,0,0,711,4168,1,0,0,0,713,4178, + 1,0,0,0,715,4196,1,0,0,0,717,4207,1,0,0,0,719,4215,1,0,0,0,721,4223, + 1,0,0,0,723,4231,1,0,0,0,725,4242,1,0,0,0,727,4258,1,0,0,0,729,4265, + 1,0,0,0,731,4271,1,0,0,0,733,4277,1,0,0,0,735,4283,1,0,0,0,737,4290, + 1,0,0,0,739,4297,1,0,0,0,741,4304,1,0,0,0,743,4311,1,0,0,0,745,4314, + 1,0,0,0,747,4319,1,0,0,0,749,4324,1,0,0,0,751,4332,1,0,0,0,753,4341, + 1,0,0,0,755,4348,1,0,0,0,757,4358,1,0,0,0,759,4366,1,0,0,0,761,4376, + 1,0,0,0,763,4386,1,0,0,0,765,4391,1,0,0,0,767,4395,1,0,0,0,769,4405, + 1,0,0,0,771,4416,1,0,0,0,773,4425,1,0,0,0,775,4433,1,0,0,0,777,4443, + 1,0,0,0,779,4451,1,0,0,0,781,4459,1,0,0,0,783,4466,1,0,0,0,785,4474, + 1,0,0,0,787,4482,1,0,0,0,789,4492,1,0,0,0,791,4499,1,0,0,0,793,4509, + 1,0,0,0,795,4517,1,0,0,0,797,4526,1,0,0,0,799,4532,1,0,0,0,801,4540, + 1,0,0,0,803,4554,1,0,0,0,805,4560,1,0,0,0,807,4567,1,0,0,0,809,4579, + 1,0,0,0,811,4589,1,0,0,0,813,4598,1,0,0,0,815,4605,1,0,0,0,817,4613, + 1,0,0,0,819,4616,1,0,0,0,821,4619,1,0,0,0,823,4625,1,0,0,0,825,4633, + 1,0,0,0,827,4637,1,0,0,0,829,4642,1,0,0,0,831,4647,1,0,0,0,833,4654, + 1,0,0,0,835,4657,1,0,0,0,837,4664,1,0,0,0,839,4672,1,0,0,0,841,4679, + 1,0,0,0,843,4688,1,0,0,0,845,4696,1,0,0,0,847,4710,1,0,0,0,849,4717, + 1,0,0,0,851,4722,1,0,0,0,853,4731,1,0,0,0,855,4740,1,0,0,0,857,4749, + 1,0,0,0,859,4760,1,0,0,0,861,4764,1,0,0,0,863,4771,1,0,0,0,865,4783, + 1,0,0,0,867,4799,1,0,0,0,869,4807,1,0,0,0,871,4816,1,0,0,0,873,4826, + 1,0,0,0,875,4837,1,0,0,0,877,4842,1,0,0,0,879,4847,1,0,0,0,881,4852, + 1,0,0,0,883,4865,1,0,0,0,885,4880,1,0,0,0,887,4895,1,0,0,0,889,4906, + 1,0,0,0,891,4919,1,0,0,0,893,4934,1,0,0,0,895,4946,1,0,0,0,897,4953, + 1,0,0,0,899,4969,1,0,0,0,901,4975,1,0,0,0,903,4982,1,0,0,0,905,4996, + 1,0,0,0,907,5005,1,0,0,0,909,5016,1,0,0,0,911,5027,1,0,0,0,913,5033, + 1,0,0,0,915,5040,1,0,0,0,917,5045,1,0,0,0,919,5052,1,0,0,0,921,5064, + 1,0,0,0,923,5076,1,0,0,0,925,5088,1,0,0,0,927,5097,1,0,0,0,929,5101, + 1,0,0,0,931,5110,1,0,0,0,933,5117,1,0,0,0,935,5126,1,0,0,0,937,5131, + 1,0,0,0,939,5144,1,0,0,0,941,5150,1,0,0,0,943,5156,1,0,0,0,945,5165, + 1,0,0,0,947,5170,1,0,0,0,949,5175,1,0,0,0,951,5184,1,0,0,0,953,5194, + 1,0,0,0,955,5199,1,0,0,0,957,5204,1,0,0,0,959,5209,1,0,0,0,961,5214, + 1,0,0,0,963,5221,1,0,0,0,965,5234,1,0,0,0,967,5242,1,0,0,0,969,5247, + 1,0,0,0,971,5252,1,0,0,0,973,5258,1,0,0,0,975,5264,1,0,0,0,977,5270, + 1,0,0,0,979,5273,1,0,0,0,981,5285,1,0,0,0,983,5297,1,0,0,0,985,5301, + 1,0,0,0,987,5310,1,0,0,0,989,5315,1,0,0,0,991,5325,1,0,0,0,993,5330, + 1,0,0,0,995,5338,1,0,0,0,997,5348,1,0,0,0,999,5353,1,0,0,0,1001, + 5362,1,0,0,0,1003,5368,1,0,0,0,1005,5371,1,0,0,0,1007,5376,1,0,0, + 0,1009,5382,1,0,0,0,1011,5386,1,0,0,0,1013,5392,1,0,0,0,1015,5398, + 1,0,0,0,1017,5405,1,0,0,0,1019,5413,1,0,0,0,1021,5421,1,0,0,0,1023, + 5426,1,0,0,0,1025,5431,1,0,0,0,1027,5445,1,0,0,0,1029,5450,1,0,0, + 0,1031,5456,1,0,0,0,1033,5472,1,0,0,0,1035,5478,1,0,0,0,1037,5483, + 1,0,0,0,1039,5492,1,0,0,0,1041,5500,1,0,0,0,1043,5505,1,0,0,0,1045, + 5515,1,0,0,0,1047,5521,1,0,0,0,1049,5528,1,0,0,0,1051,5530,1,0,0, + 0,1053,5532,1,0,0,0,1055,5535,1,0,0,0,1057,5537,1,0,0,0,1059,5539, + 1,0,0,0,1061,5544,1,0,0,0,1063,5547,1,0,0,0,1065,5549,1,0,0,0,1067, + 5559,1,0,0,0,1069,5561,1,0,0,0,1071,5563,1,0,0,0,1073,5565,1,0,0, + 0,1075,5576,1,0,0,0,1077,5586,1,0,0,0,1079,5599,1,0,0,0,1081,5601, + 1,0,0,0,1083,5604,1,0,0,0,1085,5606,1,0,0,0,1087,5608,1,0,0,0,1089, + 5610,1,0,0,0,1091,5613,1,0,0,0,1093,5616,1,0,0,0,1095,5618,1,0,0, + 0,1097,5620,1,0,0,0,1099,5622,1,0,0,0,1101,5628,1,0,0,0,1103,5648, + 1,0,0,0,1105,5676,1,0,0,0,1107,5700,1,0,0,0,1109,5726,1,0,0,0,1111, + 5728,1,0,0,0,1113,5731,1,0,0,0,1115,5734,1,0,0,0,1117,5739,1,0,0, + 0,1119,5748,1,0,0,0,1121,5778,1,0,0,0,1123,5798,1,0,0,0,1125,5804, + 1,0,0,0,1127,5814,1,0,0,0,1129,5824,1,0,0,0,1131,5834,1,0,0,0,1133, + 5842,1,0,0,0,1135,5853,1,0,0,0,1137,5859,1,0,0,0,1139,5864,1,0,0, + 0,1141,5866,1,0,0,0,1143,5868,1,0,0,0,1145,5870,1,0,0,0,1147,5872, + 1,0,0,0,1149,5874,1,0,0,0,1151,5876,1,0,0,0,1153,5878,1,0,0,0,1155, + 5880,1,0,0,0,1157,5882,1,0,0,0,1159,5884,1,0,0,0,1161,5886,1,0,0, + 0,1163,5888,1,0,0,0,1165,5890,1,0,0,0,1167,5892,1,0,0,0,1169,5894, + 1,0,0,0,1171,5896,1,0,0,0,1173,5898,1,0,0,0,1175,5900,1,0,0,0,1177, + 5902,1,0,0,0,1179,5904,1,0,0,0,1181,5906,1,0,0,0,1183,5908,1,0,0, + 0,1185,5910,1,0,0,0,1187,5912,1,0,0,0,1189,5914,1,0,0,0,1191,1192, + 3,1139,569,0,1192,1193,3,1141,570,0,1193,1194,3,1167,583,0,1194, + 1195,3,1173,586,0,1195,1196,3,1177,588,0,1196,2,1,0,0,0,1197,1198, + 3,1139,569,0,1198,1199,3,1143,571,0,1199,1200,3,1143,571,0,1200, + 1201,3,1147,573,0,1201,1202,3,1169,584,0,1202,1203,3,1177,588,0, + 1203,4,1,0,0,0,1204,1205,3,1139,569,0,1205,1206,3,1143,571,0,1206, + 1207,3,1143,571,0,1207,1208,3,1147,573,0,1208,1209,3,1175,587,0, + 1209,1210,3,1175,587,0,1210,6,1,0,0,0,1211,1212,3,1139,569,0,1212, + 1213,3,1145,572,0,1213,1214,3,1145,572,0,1214,8,1,0,0,0,1215,1216, + 3,1139,569,0,1216,1217,3,1145,572,0,1217,1218,3,1145,572,0,1218, + 1219,3,1173,586,0,1219,1220,3,1147,573,0,1220,1221,3,1175,587,0, + 1221,1222,3,1175,587,0,1222,10,1,0,0,0,1223,1224,3,1139,569,0,1224, + 1225,3,1145,572,0,1225,1226,3,1181,590,0,1226,1227,3,1139,569,0, + 1227,1228,3,1165,582,0,1228,1229,3,1143,571,0,1229,1230,3,1155,577, + 0,1230,1231,3,1165,582,0,1231,1232,3,1151,575,0,1232,12,1,0,0,0, + 1233,1234,3,1139,569,0,1234,1235,3,1149,574,0,1235,1236,3,1177,588, + 0,1236,1237,3,1147,573,0,1237,1238,3,1173,586,0,1238,14,1,0,0,0, + 1239,1240,3,1139,569,0,1240,1241,3,1161,580,0,1241,1242,3,1155,577, + 0,1242,1243,3,1151,575,0,1243,1244,3,1165,582,0,1244,1245,3,1147, + 573,0,1245,1246,3,1145,572,0,1246,16,1,0,0,0,1247,1248,3,1139,569, + 0,1248,1249,3,1161,580,0,1249,1250,3,1161,580,0,1250,18,1,0,0,0, + 1251,1252,3,1139,569,0,1252,1253,3,1161,580,0,1253,1254,3,1169,584, + 0,1254,1255,3,1153,576,0,1255,1256,3,1139,569,0,1256,1257,3,1141, + 570,0,1257,1258,3,1147,573,0,1258,1259,3,1177,588,0,1259,20,1,0, + 0,0,1260,1261,3,1139,569,0,1261,1262,3,1161,580,0,1262,1263,3,1169, + 584,0,1263,1264,3,1153,576,0,1264,1265,3,1139,569,0,1265,1266,3, + 1141,570,0,1266,1267,3,1147,573,0,1267,1268,3,1177,588,0,1268,1269, + 3,1155,577,0,1269,1270,3,1143,571,0,1270,22,1,0,0,0,1271,1272,3, + 1139,569,0,1272,1273,3,1161,580,0,1273,1274,3,1169,584,0,1274,1275, + 3,1153,576,0,1275,1276,3,1139,569,0,1276,1277,3,1141,570,0,1277, + 1278,3,1147,573,0,1278,1279,3,1177,588,0,1279,1280,3,1155,577,0, + 1280,1281,3,1143,571,0,1281,1282,3,1085,542,0,1282,1283,3,1161,580, + 0,1283,1284,3,1167,583,0,1284,1285,3,1183,591,0,1285,1286,3,1147, + 573,0,1286,1287,3,1173,586,0,1287,24,1,0,0,0,1288,1289,3,1139,569, + 0,1289,1290,3,1161,580,0,1290,1291,3,1169,584,0,1291,1292,3,1153, + 576,0,1292,1293,3,1139,569,0,1293,1294,3,1141,570,0,1294,1295,3, + 1147,573,0,1295,1296,3,1177,588,0,1296,1297,3,1155,577,0,1297,1298, + 3,1143,571,0,1298,1299,3,1085,542,0,1299,1300,3,1179,589,0,1300, + 1301,3,1169,584,0,1301,1302,3,1169,584,0,1302,1303,3,1147,573,0, + 1303,1304,3,1173,586,0,1304,26,1,0,0,0,1305,1306,3,1139,569,0,1306, + 1307,3,1161,580,0,1307,1308,3,1169,584,0,1308,1309,3,1153,576,0, + 1309,1310,3,1139,569,0,1310,1311,3,1165,582,0,1311,1312,3,1179,589, + 0,1312,1313,3,1163,581,0,1313,1314,3,1147,573,0,1314,1315,3,1173, + 586,0,1315,1316,3,1155,577,0,1316,1317,3,1143,571,0,1317,28,1,0, + 0,0,1318,1319,3,1139,569,0,1319,1320,3,1161,580,0,1320,1321,3,1169, + 584,0,1321,1322,3,1153,576,0,1322,1323,3,1139,569,0,1323,1324,3, + 1165,582,0,1324,1325,3,1179,589,0,1325,1326,3,1163,581,0,1326,1327, + 3,1147,573,0,1327,1328,3,1173,586,0,1328,1329,3,1155,577,0,1329, + 1330,3,1143,571,0,1330,1331,3,1085,542,0,1331,1332,3,1147,573,0, + 1332,1333,3,1145,572,0,1333,1334,3,1155,577,0,1334,1335,3,1177,588, + 0,1335,1336,3,1147,573,0,1336,1337,3,1145,572,0,1337,30,1,0,0,0, + 1338,1339,3,1139,569,0,1339,1340,3,1161,580,0,1340,1341,3,1175,587, + 0,1341,1342,3,1167,583,0,1342,32,1,0,0,0,1343,1344,3,1139,569,0, + 1344,1345,3,1161,580,0,1345,1346,3,1177,588,0,1346,1347,3,1147,573, + 0,1347,1348,3,1173,586,0,1348,34,1,0,0,0,1349,1350,3,1139,569,0, + 1350,1351,3,1161,580,0,1351,1352,3,1177,588,0,1352,1353,3,1147,573, + 0,1353,1354,3,1173,586,0,1354,1355,3,1165,582,0,1355,1356,3,1139, + 569,0,1356,1357,3,1177,588,0,1357,1358,3,1147,573,0,1358,36,1,0, + 0,0,1359,1360,3,1139,569,0,1360,1361,3,1165,582,0,1361,1362,3,1145, + 572,0,1362,38,1,0,0,0,1363,1364,3,1139,569,0,1364,1365,3,1165,582, + 0,1365,1366,3,1187,593,0,1366,40,1,0,0,0,1367,1368,3,1139,569,0, + 1368,1369,3,1173,586,0,1369,1370,3,1147,573,0,1370,42,1,0,0,0,1371, + 1372,3,1139,569,0,1372,1373,3,1173,586,0,1373,1374,3,1147,573,0, + 1374,1375,3,1139,569,0,1375,44,1,0,0,0,1376,1377,3,1139,569,0,1377, + 1378,3,1173,586,0,1378,1379,3,1147,573,0,1379,1380,3,1139,569,0, + 1380,1381,3,1175,587,0,1381,46,1,0,0,0,1382,1383,3,1139,569,0,1383, + 1384,3,1175,587,0,1384,48,1,0,0,0,1385,1386,3,1139,569,0,1386,1387, + 3,1175,587,0,1387,1388,3,1143,571,0,1388,1389,3,1147,573,0,1389, + 1390,3,1165,582,0,1390,1391,3,1145,572,0,1391,1392,3,1155,577,0, + 1392,1393,3,1165,582,0,1393,1394,3,1151,575,0,1394,50,1,0,0,0,1395, + 1396,3,1139,569,0,1396,1397,3,1175,587,0,1397,1398,3,1143,571,0, + 1398,1399,3,1155,577,0,1399,1400,3,1155,577,0,1400,52,1,0,0,0,1401, + 1402,3,1139,569,0,1402,1403,3,1175,587,0,1403,1404,3,1175,587,0, + 1404,1405,3,1155,577,0,1405,1406,3,1151,575,0,1406,1407,3,1165,582, + 0,1407,54,1,0,0,0,1408,1409,3,1139,569,0,1409,1410,3,1175,587,0, + 1410,1411,3,1175,587,0,1411,1412,3,1167,583,0,1412,1413,3,1143,571, + 0,1413,1414,3,1155,577,0,1414,1415,3,1139,569,0,1415,1416,3,1177, + 588,0,1416,1417,3,1147,573,0,1417,1418,3,1145,572,0,1418,1419,3, + 1085,542,0,1419,1420,3,1145,572,0,1420,1421,3,1139,569,0,1421,1422, + 3,1177,588,0,1422,1423,3,1139,569,0,1423,56,1,0,0,0,1424,1425,3, + 1139,569,0,1425,1426,3,1175,587,0,1426,1427,3,1175,587,0,1427,1428, + 3,1167,583,0,1428,1429,3,1143,571,0,1429,1430,3,1155,577,0,1430, + 1431,3,1139,569,0,1431,1432,3,1177,588,0,1432,1433,3,1147,573,0, + 1433,1434,3,1145,572,0,1434,1435,3,1085,542,0,1435,1436,3,1145,572, + 0,1436,1437,3,1139,569,0,1437,1438,3,1177,588,0,1438,1439,3,1139, + 569,0,1439,1440,3,1085,542,0,1440,1441,3,1161,580,0,1441,1442,3, + 1147,573,0,1442,1443,3,1165,582,0,1443,1444,3,1151,575,0,1444,1445, + 3,1177,588,0,1445,1446,3,1153,576,0,1446,58,1,0,0,0,1447,1448,3, + 1139,569,0,1448,1449,3,1177,588,0,1449,60,1,0,0,0,1450,1451,3,1139, + 569,0,1451,1452,3,1177,588,0,1452,1453,3,1177,588,0,1453,1454,3, + 1173,586,0,1454,1455,3,1155,577,0,1455,1456,3,1141,570,0,1456,1457, + 3,1179,589,0,1457,1458,3,1177,588,0,1458,1459,3,1147,573,0,1459, + 62,1,0,0,0,1460,1461,3,1139,569,0,1461,1462,3,1179,589,0,1462,1463, + 3,1177,588,0,1463,1464,3,1153,576,0,1464,1465,3,1167,583,0,1465, + 1466,3,1173,586,0,1466,64,1,0,0,0,1467,1468,3,1139,569,0,1468,1469, + 3,1179,589,0,1469,1470,3,1177,588,0,1470,1471,3,1167,583,0,1471, + 66,1,0,0,0,1472,1473,3,1139,569,0,1473,1474,3,1179,589,0,1474,1475, + 3,1177,588,0,1475,1476,3,1167,583,0,1476,1477,3,1085,542,0,1477, + 1478,3,1175,587,0,1478,1479,3,1159,579,0,1479,1480,3,1155,577,0, + 1480,1481,3,1169,584,0,1481,68,1,0,0,0,1482,1483,3,1141,570,0,1483, + 1484,3,1139,569,0,1484,1485,3,1143,571,0,1485,1486,3,1159,579,0, + 1486,1487,3,1151,575,0,1487,1488,3,1173,586,0,1488,1489,3,1167,583, + 0,1489,1490,3,1179,589,0,1490,1491,3,1165,582,0,1491,1492,3,1145, + 572,0,1492,1493,3,1085,542,0,1493,1494,3,1143,571,0,1494,1495,3, + 1167,583,0,1495,1496,3,1161,580,0,1496,1497,3,1167,583,0,1497,1498, + 3,1173,586,0,1498,70,1,0,0,0,1499,1500,3,1141,570,0,1500,1501,3, + 1139,569,0,1501,1502,3,1143,571,0,1502,1503,3,1159,579,0,1503,1504, + 3,1151,575,0,1504,1505,3,1173,586,0,1505,1506,3,1167,583,0,1506, + 1507,3,1179,589,0,1507,1508,3,1165,582,0,1508,1509,3,1145,572,0, + 1509,1510,3,1085,542,0,1510,1511,3,1143,571,0,1511,1512,3,1167,583, + 0,1512,1513,3,1161,580,0,1513,1514,3,1167,583,0,1514,1515,3,1179, + 589,0,1515,1516,3,1173,586,0,1516,72,1,0,0,0,1517,1518,3,1141,570, + 0,1518,1519,3,1139,569,0,1519,1520,3,1175,587,0,1520,1521,3,1155, + 577,0,1521,1522,3,1175,587,0,1522,74,1,0,0,0,1523,1524,3,1141,570, + 0,1524,1525,3,1147,573,0,1525,1526,3,1147,573,0,1526,1527,3,1169, + 584,0,1527,76,1,0,0,0,1528,1529,3,1141,570,0,1529,1530,3,1147,573, + 0,1530,1531,3,1149,574,0,1531,1532,3,1167,583,0,1532,1533,3,1173, + 586,0,1533,1534,3,1147,573,0,1534,78,1,0,0,0,1535,1536,3,1141,570, + 0,1536,1537,3,1147,573,0,1537,1538,3,1151,575,0,1538,1539,3,1155, + 577,0,1539,1540,3,1165,582,0,1540,1541,3,1165,582,0,1541,1542,3, + 1155,577,0,1542,1543,3,1165,582,0,1543,1544,3,1151,575,0,1544,80, + 1,0,0,0,1545,1546,3,1141,570,0,1546,1547,3,1147,573,0,1547,1548, + 3,1161,580,0,1548,1549,3,1161,580,0,1549,82,1,0,0,0,1550,1551,3, + 1141,570,0,1551,1552,3,1155,577,0,1552,1553,3,1165,582,0,1553,1554, + 3,1139,569,0,1554,1555,3,1173,586,0,1555,1556,3,1187,593,0,1556, + 84,1,0,0,0,1557,1558,3,1141,570,0,1558,1559,3,1155,577,0,1559,1560, + 3,1177,588,0,1560,86,1,0,0,0,1561,1562,3,1141,570,0,1562,1563,3, + 1161,580,0,1563,1564,3,1139,569,0,1564,1565,3,1165,582,0,1565,1566, + 3,1159,579,0,1566,88,1,0,0,0,1567,1568,3,1141,570,0,1568,1569,3, + 1161,580,0,1569,1570,3,1155,577,0,1570,1571,3,1165,582,0,1571,1572, + 3,1159,579,0,1572,90,1,0,0,0,1573,1574,3,1141,570,0,1574,1575,3, + 1161,580,0,1575,1576,3,1167,583,0,1576,1577,3,1143,571,0,1577,1578, + 3,1159,579,0,1578,92,1,0,0,0,1579,1580,3,1141,570,0,1580,1581,3, + 1167,583,0,1581,1582,3,1179,589,0,1582,1583,3,1165,582,0,1583,1584, + 3,1145,572,0,1584,1585,3,1175,587,0,1585,94,1,0,0,0,1586,1587,3, + 1141,570,0,1587,1588,3,1167,583,0,1588,1589,3,1177,588,0,1589,1590, + 3,1177,588,0,1590,1591,3,1167,583,0,1591,1592,3,1163,581,0,1592, + 96,1,0,0,0,1593,1594,3,1141,570,0,1594,1595,3,1187,593,0,1595,98, + 1,0,0,0,1596,1597,3,1141,570,0,1597,1598,3,1187,593,0,1598,1599, + 3,1149,574,0,1599,1600,3,1179,589,0,1600,1601,3,1165,582,0,1601, + 1602,3,1143,571,0,1602,1603,3,1177,588,0,1603,1604,3,1155,577,0, + 1604,1605,3,1167,583,0,1605,1606,3,1165,582,0,1606,100,1,0,0,0,1607, + 1608,3,1141,570,0,1608,1609,3,1187,593,0,1609,1610,3,1177,588,0, + 1610,1611,3,1155,577,0,1611,1612,3,1177,588,0,1612,1613,3,1161,580, + 0,1613,1614,3,1147,573,0,1614,102,1,0,0,0,1615,1616,3,1143,571,0, + 1616,1617,3,1139,569,0,1617,1618,3,1161,580,0,1618,1619,3,1161,580, + 0,1619,104,1,0,0,0,1620,1621,3,1143,571,0,1621,1622,3,1139,569,0, + 1622,1623,3,1165,582,0,1623,1624,3,1143,571,0,1624,1625,3,1147,573, + 0,1625,1626,3,1161,580,0,1626,106,1,0,0,0,1627,1628,3,1143,571,0, + 1628,1629,3,1139,569,0,1629,1630,3,1169,584,0,1630,1631,3,1139,569, + 0,1631,1632,3,1141,570,0,1632,1633,3,1161,580,0,1633,1634,3,1147, + 573,0,1634,108,1,0,0,0,1635,1636,3,1143,571,0,1636,1637,3,1143,571, + 0,1637,1638,3,1175,587,0,1638,1639,3,1181,590,0,1639,1640,3,1147, + 573,0,1640,1641,3,1173,586,0,1641,1642,3,1175,587,0,1642,1643,3, + 1155,577,0,1643,1644,3,1167,583,0,1644,1645,3,1165,582,0,1645,110, + 1,0,0,0,1646,1647,3,1143,571,0,1647,1648,3,1145,572,0,1648,112,1, + 0,0,0,1649,1650,3,1143,571,0,1650,1651,3,1149,574,0,1651,114,1,0, + 0,0,1652,1653,3,1143,571,0,1653,1654,3,1153,576,0,1654,116,1,0,0, + 0,1655,1656,3,1143,571,0,1656,1657,3,1153,576,0,1657,1658,3,1139, + 569,0,1658,1659,3,1155,577,0,1659,1660,3,1165,582,0,1660,1661,3, + 1155,577,0,1661,1662,3,1165,582,0,1662,1663,3,1151,575,0,1663,118, + 1,0,0,0,1664,1665,3,1143,571,0,1665,1666,3,1153,576,0,1666,1667, + 3,1139,569,0,1667,1668,3,1165,582,0,1668,1669,3,1151,575,0,1669, + 1670,3,1147,573,0,1670,1671,3,1145,572,0,1671,120,1,0,0,0,1672,1673, + 3,1143,571,0,1673,1674,3,1153,576,0,1674,1675,3,1139,569,0,1675, + 1676,3,1165,582,0,1676,1677,3,1165,582,0,1677,1678,3,1147,573,0, + 1678,1679,3,1161,580,0,1679,122,1,0,0,0,1680,1681,3,1143,571,0,1681, + 1682,3,1153,576,0,1682,1683,3,1139,569,0,1683,1684,3,1173,586,0, + 1684,1685,3,1139,569,0,1685,1686,3,1143,571,0,1686,1687,3,1177,588, + 0,1687,1688,3,1147,573,0,1688,1689,3,1173,586,0,1689,124,1,0,0,0, + 1690,1691,3,1143,571,0,1691,1692,3,1153,576,0,1692,1693,3,1139,569, + 0,1693,1694,3,1173,586,0,1694,1695,3,1139,569,0,1695,1696,3,1143, + 571,0,1696,1697,3,1177,588,0,1697,1698,3,1147,573,0,1698,1699,3, + 1173,586,0,1699,1700,3,1175,587,0,1700,126,1,0,0,0,1701,1702,3,1143, + 571,0,1702,1703,3,1161,580,0,1703,1704,3,1139,569,0,1704,1705,3, + 1175,587,0,1705,1706,3,1175,587,0,1706,128,1,0,0,0,1707,1708,3,1143, + 571,0,1708,1709,3,1161,580,0,1709,1710,3,1139,569,0,1710,1711,3, + 1175,587,0,1711,1712,3,1175,587,0,1712,1713,3,1085,542,0,1713,1714, + 3,1155,577,0,1714,1715,3,1145,572,0,1715,130,1,0,0,0,1716,1717,3, + 1143,571,0,1717,1718,3,1161,580,0,1718,1719,3,1167,583,0,1719,1720, + 3,1143,571,0,1720,1721,3,1159,579,0,1721,1722,3,1085,542,0,1722, + 1723,3,1179,589,0,1723,1724,3,1165,582,0,1724,1725,3,1155,577,0, + 1725,1726,3,1177,588,0,1726,1727,3,1175,587,0,1727,132,1,0,0,0,1728, + 1729,3,1143,571,0,1729,1730,3,1161,580,0,1730,1731,3,1167,583,0, + 1731,1732,3,1175,587,0,1732,1733,3,1147,573,0,1733,134,1,0,0,0,1734, + 1735,3,1143,571,0,1735,1736,3,1161,580,0,1736,1737,3,1167,583,0, + 1737,1738,3,1175,587,0,1738,1739,3,1147,573,0,1739,1740,3,1085,542, + 0,1740,1741,3,1145,572,0,1741,1742,3,1155,577,0,1742,1743,3,1175, + 587,0,1743,1744,3,1169,584,0,1744,1745,3,1167,583,0,1745,1746,3, + 1175,587,0,1746,1747,3,1155,577,0,1747,1748,3,1177,588,0,1748,1749, + 3,1155,577,0,1749,1750,3,1167,583,0,1750,1751,3,1165,582,0,1751, + 136,1,0,0,0,1752,1753,3,1143,571,0,1753,1754,3,1167,583,0,1754,1755, + 3,1141,570,0,1755,1756,3,1167,583,0,1756,1757,3,1161,580,0,1757, + 138,1,0,0,0,1758,1759,3,1143,571,0,1759,1760,3,1167,583,0,1760,1761, + 3,1145,572,0,1761,1762,3,1147,573,0,1762,140,1,0,0,0,1763,1764,3, + 1143,571,0,1764,1765,3,1167,583,0,1765,1766,3,1145,572,0,1766,1767, + 3,1147,573,0,1767,1768,3,1085,542,0,1768,1769,3,1175,587,0,1769, + 1770,3,1147,573,0,1770,1771,3,1177,588,0,1771,142,1,0,0,0,1772,1773, + 3,1143,571,0,1773,1774,3,1167,583,0,1774,1775,3,1161,580,0,1775, + 1776,3,1161,580,0,1776,1777,3,1139,569,0,1777,1778,3,1177,588,0, + 1778,1779,3,1155,577,0,1779,1780,3,1165,582,0,1780,1781,3,1151,575, + 0,1781,144,1,0,0,0,1782,1783,3,1143,571,0,1783,1784,3,1167,583,0, + 1784,1785,3,1161,580,0,1785,146,1,0,0,0,1786,1787,3,1143,571,0,1787, + 1788,3,1167,583,0,1788,1789,3,1161,580,0,1789,1790,3,1179,589,0, + 1790,1791,3,1163,581,0,1791,1792,3,1165,582,0,1792,148,1,0,0,0,1793, + 1794,3,1143,571,0,1794,1795,3,1167,583,0,1795,1796,3,1163,581,0, + 1796,1797,3,1085,542,0,1797,1798,3,1173,586,0,1798,1799,3,1147,573, + 0,1799,1800,3,1151,575,0,1800,150,1,0,0,0,1801,1802,3,1143,571,0, + 1802,1803,3,1167,583,0,1803,1804,3,1163,581,0,1804,1805,3,1163,581, + 0,1805,1806,3,1139,569,0,1806,152,1,0,0,0,1807,1808,3,1143,571,0, + 1808,1809,3,1167,583,0,1809,1810,3,1163,581,0,1810,1811,3,1163,581, + 0,1811,1812,3,1155,577,0,1812,1813,3,1177,588,0,1813,1814,3,1163, + 581,0,1814,1815,3,1147,573,0,1815,1816,3,1165,582,0,1816,1817,3, + 1177,588,0,1817,154,1,0,0,0,1818,1819,3,1143,571,0,1819,1820,3,1167, + 583,0,1820,1821,3,1163,581,0,1821,1822,3,1163,581,0,1822,1823,3, + 1167,583,0,1823,1824,3,1165,582,0,1824,156,1,0,0,0,1825,1826,3,1143, + 571,0,1826,1827,3,1167,583,0,1827,1828,3,1163,581,0,1828,1829,3, + 1163,581,0,1829,1830,3,1179,589,0,1830,1831,3,1165,582,0,1831,1832, + 3,1155,577,0,1832,1833,3,1143,571,0,1833,1834,3,1139,569,0,1834, + 1835,3,1177,588,0,1835,1836,3,1155,577,0,1836,1837,3,1167,583,0, + 1837,1838,3,1165,582,0,1838,158,1,0,0,0,1839,1840,3,1143,571,0,1840, + 1841,3,1167,583,0,1841,1842,3,1163,581,0,1842,1843,3,1169,584,0, + 1843,160,1,0,0,0,1844,1845,3,1143,571,0,1845,1846,3,1167,583,0,1846, + 1847,3,1163,581,0,1847,1848,3,1169,584,0,1848,1849,3,1085,542,0, + 1849,1850,5,49,0,0,1850,162,1,0,0,0,1851,1852,3,1143,571,0,1852, + 1853,3,1167,583,0,1853,1854,3,1163,581,0,1854,1855,3,1169,584,0, + 1855,1856,3,1085,542,0,1856,1857,5,50,0,0,1857,164,1,0,0,0,1858, + 1859,3,1143,571,0,1859,1860,3,1167,583,0,1860,1861,3,1163,581,0, + 1861,1862,3,1169,584,0,1862,1863,3,1085,542,0,1863,1864,5,51,0,0, + 1864,166,1,0,0,0,1865,1866,3,1143,571,0,1866,1867,3,1167,583,0,1867, + 1868,3,1163,581,0,1868,1869,3,1169,584,0,1869,1870,3,1085,542,0, + 1870,1871,5,52,0,0,1871,168,1,0,0,0,1872,1873,3,1143,571,0,1873, + 1874,3,1167,583,0,1874,1875,3,1163,581,0,1875,1876,3,1169,584,0, + 1876,1877,3,1085,542,0,1877,1878,5,53,0,0,1878,170,1,0,0,0,1879, + 1880,3,1143,571,0,1880,1881,3,1167,583,0,1881,1882,3,1163,581,0, + 1882,1883,3,1169,584,0,1883,1884,3,1179,589,0,1884,1885,3,1177,588, + 0,1885,1886,3,1139,569,0,1886,1887,3,1177,588,0,1887,1888,3,1155, + 577,0,1888,1889,3,1167,583,0,1889,1890,3,1165,582,0,1890,1891,3, + 1139,569,0,1891,1892,3,1161,580,0,1892,172,1,0,0,0,1893,1894,3,1143, + 571,0,1894,1895,3,1167,583,0,1895,1896,3,1163,581,0,1896,1897,3, + 1169,584,0,1897,1898,3,1179,589,0,1898,1899,3,1177,588,0,1899,1900, + 3,1139,569,0,1900,1901,3,1177,588,0,1901,1902,3,1155,577,0,1902, + 1903,3,1167,583,0,1903,1904,3,1165,582,0,1904,1905,3,1139,569,0, + 1905,1906,3,1161,580,0,1906,1907,3,1085,542,0,1907,1908,5,49,0,0, + 1908,174,1,0,0,0,1909,1910,3,1143,571,0,1910,1911,3,1167,583,0,1911, + 1912,3,1163,581,0,1912,1913,3,1169,584,0,1913,1914,3,1179,589,0, + 1914,1915,3,1177,588,0,1915,1916,3,1139,569,0,1916,1917,3,1177,588, + 0,1917,1918,3,1155,577,0,1918,1919,3,1167,583,0,1919,1920,3,1165, + 582,0,1920,1921,3,1139,569,0,1921,1922,3,1161,580,0,1922,1923,3, + 1085,542,0,1923,1924,5,50,0,0,1924,176,1,0,0,0,1925,1926,3,1143, + 571,0,1926,1927,3,1167,583,0,1927,1928,3,1163,581,0,1928,1929,3, + 1169,584,0,1929,1930,3,1179,589,0,1930,1931,3,1177,588,0,1931,1932, + 3,1139,569,0,1932,1933,3,1177,588,0,1933,1934,3,1155,577,0,1934, + 1935,3,1167,583,0,1935,1936,3,1165,582,0,1936,1937,3,1139,569,0, + 1937,1938,3,1161,580,0,1938,1939,3,1085,542,0,1939,1940,5,51,0,0, + 1940,178,1,0,0,0,1941,1942,3,1143,571,0,1942,1943,3,1167,583,0,1943, + 1944,3,1163,581,0,1944,1945,3,1169,584,0,1945,1946,3,1179,589,0, + 1946,1947,3,1177,588,0,1947,1948,3,1139,569,0,1948,1949,3,1177,588, + 0,1949,1950,3,1155,577,0,1950,1951,3,1167,583,0,1951,1952,3,1165, + 582,0,1952,1953,3,1139,569,0,1953,1954,3,1161,580,0,1954,1955,3, + 1085,542,0,1955,1956,5,52,0,0,1956,180,1,0,0,0,1957,1958,3,1143, + 571,0,1958,1959,3,1167,583,0,1959,1960,3,1163,581,0,1960,1961,3, + 1169,584,0,1961,1962,3,1179,589,0,1962,1963,3,1177,588,0,1963,1964, + 3,1139,569,0,1964,1965,3,1177,588,0,1965,1966,3,1155,577,0,1966, + 1967,3,1167,583,0,1967,1968,3,1165,582,0,1968,1969,3,1139,569,0, + 1969,1970,3,1161,580,0,1970,1971,3,1085,542,0,1971,1972,5,53,0,0, + 1972,182,1,0,0,0,1973,1974,3,1143,571,0,1974,1975,3,1167,583,0,1975, + 1976,3,1163,581,0,1976,1977,3,1169,584,0,1977,1978,3,1179,589,0, + 1978,1979,3,1177,588,0,1979,1980,3,1147,573,0,1980,184,1,0,0,0,1981, + 1982,3,1143,571,0,1982,1983,3,1167,583,0,1983,1984,3,1165,582,0, + 1984,1985,3,1149,574,0,1985,1986,3,1155,577,0,1986,1987,3,1151,575, + 0,1987,1988,3,1179,589,0,1988,1989,3,1173,586,0,1989,1990,3,1139, + 569,0,1990,1991,3,1177,588,0,1991,1992,3,1155,577,0,1992,1993,3, + 1167,583,0,1993,1994,3,1165,582,0,1994,186,1,0,0,0,1995,1996,3,1143, + 571,0,1996,1997,3,1167,583,0,1997,1998,3,1165,582,0,1998,1999,3, + 1177,588,0,1999,2000,3,1139,569,0,2000,2001,3,1155,577,0,2001,2002, + 3,1165,582,0,2002,2003,3,1175,587,0,2003,188,1,0,0,0,2004,2005,3, + 1143,571,0,2005,2006,3,1167,583,0,2006,2007,3,1165,582,0,2007,2008, + 3,1177,588,0,2008,2009,3,1147,573,0,2009,2010,3,1165,582,0,2010, + 2011,3,1177,588,0,2011,190,1,0,0,0,2012,2013,3,1143,571,0,2013,2014, + 3,1167,583,0,2014,2015,3,1165,582,0,2015,2016,3,1177,588,0,2016, + 2017,3,1155,577,0,2017,2018,3,1165,582,0,2018,2019,3,1179,589,0, + 2019,2020,3,1147,573,0,2020,192,1,0,0,0,2021,2022,3,1143,571,0,2022, + 2023,3,1167,583,0,2023,2024,3,1165,582,0,2024,2025,3,1177,588,0, + 2025,2026,3,1173,586,0,2026,2027,3,1167,583,0,2027,2028,3,1161,580, + 0,2028,194,1,0,0,0,2029,2030,3,1143,571,0,2030,2031,3,1167,583,0, + 2031,2032,3,1165,582,0,2032,2033,3,1177,588,0,2033,2034,3,1173,586, + 0,2034,2035,3,1167,583,0,2035,2036,3,1161,580,0,2036,2037,3,1085, + 542,0,2037,2038,3,1169,584,0,2038,2039,3,1167,583,0,2039,2040,3, + 1155,577,0,2040,2041,3,1165,582,0,2041,2042,3,1177,588,0,2042,196, + 1,0,0,0,2043,2044,3,1143,571,0,2044,2045,3,1167,583,0,2045,2046, + 3,1165,582,0,2046,2047,3,1177,588,0,2047,2048,3,1173,586,0,2048, + 2049,3,1167,583,0,2049,2050,3,1161,580,0,2050,2051,3,1175,587,0, + 2051,198,1,0,0,0,2052,2053,3,1143,571,0,2053,2054,3,1167,583,0,2054, + 2055,3,1165,582,0,2055,2056,3,1181,590,0,2056,2057,3,1147,573,0, + 2057,2058,3,1165,582,0,2058,2059,3,1177,588,0,2059,2060,3,1155,577, + 0,2060,2061,3,1167,583,0,2061,2062,3,1165,582,0,2062,200,1,0,0,0, + 2063,2064,3,1143,571,0,2064,2065,3,1167,583,0,2065,2066,3,1165,582, + 0,2066,2067,3,1181,590,0,2067,2068,3,1147,573,0,2068,2069,3,1173, + 586,0,2069,2070,3,1177,588,0,2070,2071,3,1155,577,0,2071,2072,3, + 1165,582,0,2072,2073,3,1151,575,0,2073,202,1,0,0,0,2074,2075,3,1143, + 571,0,2075,2076,3,1167,583,0,2076,2077,3,1169,584,0,2077,2078,3, + 1187,593,0,2078,204,1,0,0,0,2079,2080,3,1143,571,0,2080,2081,3,1167, + 583,0,2081,2082,3,1173,586,0,2082,2083,3,1173,586,0,2083,206,1,0, + 0,0,2084,2085,3,1143,571,0,2085,2086,3,1167,583,0,2086,2087,3,1173, + 586,0,2087,2088,3,1173,586,0,2088,2089,3,1147,573,0,2089,2090,3, + 1175,587,0,2090,2091,3,1169,584,0,2091,2092,3,1167,583,0,2092,2093, + 3,1165,582,0,2093,2094,3,1145,572,0,2094,2095,3,1155,577,0,2095, + 2096,3,1165,582,0,2096,2097,3,1151,575,0,2097,208,1,0,0,0,2098,2099, + 3,1143,571,0,2099,2100,3,1167,583,0,2100,2101,3,1179,589,0,2101, + 2102,3,1165,582,0,2102,2103,3,1177,588,0,2103,210,1,0,0,0,2104,2105, + 3,1143,571,0,2105,2106,3,1173,586,0,2106,2107,3,1179,589,0,2107, + 2108,3,1165,582,0,2108,2109,3,1143,571,0,2109,2110,3,1153,576,0, + 2110,212,1,0,0,0,2111,2112,3,1143,571,0,2112,2113,3,1179,589,0,2113, + 2114,3,1173,586,0,2114,2115,3,1173,586,0,2115,2116,3,1147,573,0, + 2116,2117,3,1165,582,0,2117,2118,3,1143,571,0,2118,2119,3,1187,593, + 0,2119,214,1,0,0,0,2120,2121,3,1143,571,0,2121,2122,3,1179,589,0, + 2122,2123,3,1173,586,0,2123,2124,3,1175,587,0,2124,2125,3,1167,583, + 0,2125,2126,3,1173,586,0,2126,216,1,0,0,0,2127,2128,3,1145,572,0, + 2128,2129,3,1139,569,0,2129,2130,3,1177,588,0,2130,2131,3,1139,569, + 0,2131,218,1,0,0,0,2132,2133,3,1145,572,0,2133,2134,3,1139,569,0, + 2134,2135,3,1177,588,0,2135,2136,3,1139,569,0,2136,2137,3,1085,542, + 0,2137,2138,3,1141,570,0,2138,2139,3,1139,569,0,2139,2140,3,1175, + 587,0,2140,2141,3,1147,573,0,2141,220,1,0,0,0,2142,2143,3,1145,572, + 0,2143,2144,3,1139,569,0,2144,2145,3,1177,588,0,2145,2146,3,1147, + 573,0,2146,222,1,0,0,0,2147,2148,3,1145,572,0,2148,2149,3,1139,569, + 0,2149,2150,3,1177,588,0,2150,2151,3,1147,573,0,2151,2152,3,1085, + 542,0,2152,2153,3,1143,571,0,2153,2154,3,1167,583,0,2154,2155,3, + 1163,581,0,2155,2156,3,1169,584,0,2156,2157,3,1155,577,0,2157,2158, + 3,1161,580,0,2158,2159,3,1147,573,0,2159,2160,3,1145,572,0,2160, + 224,1,0,0,0,2161,2162,3,1145,572,0,2162,2163,3,1139,569,0,2163,2164, + 3,1177,588,0,2164,2165,3,1147,573,0,2165,2166,3,1085,542,0,2166, + 2167,3,1183,591,0,2167,2168,3,1173,586,0,2168,2169,3,1155,577,0, + 2169,2170,3,1177,588,0,2170,2171,3,1177,588,0,2171,2172,3,1147,573, + 0,2172,2173,3,1165,582,0,2173,226,1,0,0,0,2174,2175,3,1145,572,0, + 2175,2176,3,1139,569,0,2176,2177,3,1187,593,0,2177,228,1,0,0,0,2178, + 2179,3,1145,572,0,2179,2180,3,1139,569,0,2180,2181,3,1187,593,0, + 2181,2182,3,1085,542,0,2182,2183,3,1167,583,0,2183,2184,3,1149,574, + 0,2184,2185,3,1085,542,0,2185,2186,3,1183,591,0,2186,2187,3,1147, + 573,0,2187,2188,3,1147,573,0,2188,2189,3,1159,579,0,2189,230,1,0, + 0,0,2190,2191,3,1145,572,0,2191,2192,3,1141,570,0,2192,2193,3,1143, + 571,0,2193,2194,3,1175,587,0,2194,232,1,0,0,0,2195,2196,3,1145,572, + 0,2196,2197,3,1147,573,0,2197,234,1,0,0,0,2198,2199,3,1145,572,0, + 2199,2200,3,1147,573,0,2200,2201,3,1141,570,0,2201,2202,3,1179,589, + 0,2202,2203,3,1151,575,0,2203,2204,3,1085,542,0,2204,2205,3,1143, + 571,0,2205,2206,3,1167,583,0,2206,2207,3,1165,582,0,2207,2208,3, + 1177,588,0,2208,2209,3,1147,573,0,2209,2210,3,1165,582,0,2210,2211, + 3,1177,588,0,2211,2212,3,1175,587,0,2212,236,1,0,0,0,2213,2214,3, + 1145,572,0,2214,2215,3,1147,573,0,2215,2216,3,1141,570,0,2216,2217, + 3,1179,589,0,2217,2218,3,1151,575,0,2218,2219,3,1085,542,0,2219, + 2220,3,1155,577,0,2220,2221,3,1177,588,0,2221,2222,3,1147,573,0, + 2222,2223,3,1163,581,0,2223,238,1,0,0,0,2224,2225,3,1145,572,0,2225, + 2226,3,1147,573,0,2226,2227,3,1141,570,0,2227,2228,3,1179,589,0, + 2228,2229,3,1151,575,0,2229,2230,3,1085,542,0,2230,2231,3,1161,580, + 0,2231,2232,3,1155,577,0,2232,2233,3,1165,582,0,2233,2234,3,1147, + 573,0,2234,240,1,0,0,0,2235,2236,3,1145,572,0,2236,2237,3,1147,573, + 0,2237,2238,3,1141,570,0,2238,2239,3,1179,589,0,2239,2240,3,1151, + 575,0,2240,2241,3,1085,542,0,2241,2242,3,1165,582,0,2242,2243,3, + 1139,569,0,2243,2244,3,1163,581,0,2244,2245,3,1147,573,0,2245,242, + 1,0,0,0,2246,2247,3,1145,572,0,2247,2248,3,1147,573,0,2248,2249, + 3,1141,570,0,2249,2250,3,1179,589,0,2250,2251,3,1151,575,0,2251, + 2252,3,1085,542,0,2252,2253,3,1175,587,0,2253,2254,3,1179,589,0, + 2254,2255,3,1141,570,0,2255,2256,3,1085,542,0,2256,2257,5,49,0,0, + 2257,244,1,0,0,0,2258,2259,3,1145,572,0,2259,2260,3,1147,573,0,2260, + 2261,3,1141,570,0,2261,2262,3,1179,589,0,2262,2263,3,1151,575,0, + 2263,2264,3,1085,542,0,2264,2265,3,1175,587,0,2265,2266,3,1179,589, + 0,2266,2267,3,1141,570,0,2267,2268,3,1085,542,0,2268,2269,5,50,0, + 0,2269,246,1,0,0,0,2270,2271,3,1145,572,0,2271,2272,3,1147,573,0, + 2272,2273,3,1141,570,0,2273,2274,3,1179,589,0,2274,2275,3,1151,575, + 0,2275,2276,3,1085,542,0,2276,2277,3,1175,587,0,2277,2278,3,1179, + 589,0,2278,2279,3,1141,570,0,2279,2280,3,1085,542,0,2280,2281,5, + 51,0,0,2281,248,1,0,0,0,2282,2283,3,1145,572,0,2283,2284,3,1147, + 573,0,2284,2285,3,1141,570,0,2285,2286,3,1179,589,0,2286,2287,3, + 1151,575,0,2287,2288,3,1151,575,0,2288,2289,3,1155,577,0,2289,2290, + 3,1165,582,0,2290,2291,3,1151,575,0,2291,250,1,0,0,0,2292,2293,3, + 1145,572,0,2293,2294,3,1147,573,0,2294,2295,3,1143,571,0,2295,2296, + 3,1155,577,0,2296,2297,3,1163,581,0,2297,2298,3,1139,569,0,2298, + 2299,3,1161,580,0,2299,2300,3,1085,542,0,2300,2301,3,1169,584,0, + 2301,2302,3,1167,583,0,2302,2303,3,1155,577,0,2303,2304,3,1165,582, + 0,2304,2305,3,1177,588,0,2305,252,1,0,0,0,2306,2307,3,1145,572,0, + 2307,2308,3,1147,573,0,2308,2309,3,1143,571,0,2309,2310,3,1161,580, + 0,2310,2311,3,1139,569,0,2311,2312,3,1173,586,0,2312,2313,3,1139, + 569,0,2313,2314,3,1177,588,0,2314,2315,3,1155,577,0,2315,2316,3, + 1181,590,0,2316,2317,3,1147,573,0,2317,2318,3,1175,587,0,2318,254, + 1,0,0,0,2319,2320,3,1145,572,0,2320,2321,3,1147,573,0,2321,2322, + 3,1149,574,0,2322,2323,3,1139,569,0,2323,2324,3,1179,589,0,2324, + 2325,3,1161,580,0,2325,2326,3,1177,588,0,2326,256,1,0,0,0,2327,2328, + 3,1145,572,0,2328,2329,3,1147,573,0,2329,2330,3,1149,574,0,2330, + 2331,3,1139,569,0,2331,2332,3,1179,589,0,2332,2333,3,1161,580,0, + 2333,2334,3,1177,588,0,2334,2335,3,1085,542,0,2335,2336,3,1145,572, + 0,2336,2337,3,1155,577,0,2337,2338,3,1175,587,0,2338,2339,3,1169, + 584,0,2339,2340,3,1161,580,0,2340,2341,3,1139,569,0,2341,2342,3, + 1187,593,0,2342,258,1,0,0,0,2343,2344,3,1145,572,0,2344,2345,3,1147, + 573,0,2345,2346,3,1149,574,0,2346,2347,3,1155,577,0,2347,2348,3, + 1165,582,0,2348,2349,3,1155,577,0,2349,2350,3,1177,588,0,2350,2351, + 3,1155,577,0,2351,2352,3,1167,583,0,2352,2353,3,1165,582,0,2353, + 260,1,0,0,0,2354,2355,3,1145,572,0,2355,2356,3,1147,573,0,2356,2357, + 3,1161,580,0,2357,2358,3,1147,573,0,2358,2359,3,1177,588,0,2359, + 2360,3,1147,573,0,2360,262,1,0,0,0,2361,2362,3,1145,572,0,2362,2363, + 3,1147,573,0,2363,2364,3,1161,580,0,2364,2365,3,1155,577,0,2365, + 2366,3,1163,581,0,2366,2367,3,1155,577,0,2367,2368,3,1177,588,0, + 2368,2369,3,1147,573,0,2369,2370,3,1145,572,0,2370,264,1,0,0,0,2371, + 2372,3,1145,572,0,2372,2373,3,1147,573,0,2373,2374,3,1161,580,0, + 2374,2375,3,1155,577,0,2375,2376,3,1163,581,0,2376,2377,3,1155,577, + 0,2377,2378,3,1177,588,0,2378,2379,3,1147,573,0,2379,2380,3,1173, + 586,0,2380,266,1,0,0,0,2381,2382,3,1145,572,0,2382,2383,3,1147,573, + 0,2383,2384,3,1169,584,0,2384,2385,3,1147,573,0,2385,2386,3,1165, + 582,0,2386,2387,3,1145,572,0,2387,2388,3,1155,577,0,2388,2389,3, + 1165,582,0,2389,2390,3,1151,575,0,2390,268,1,0,0,0,2391,2392,3,1145, + 572,0,2392,2393,3,1147,573,0,2393,2394,3,1175,587,0,2394,2395,3, + 1143,571,0,2395,2396,3,1147,573,0,2396,2397,3,1165,582,0,2397,2398, + 3,1145,572,0,2398,2399,3,1155,577,0,2399,2400,3,1165,582,0,2400, + 2401,3,1151,575,0,2401,270,1,0,0,0,2402,2403,3,1145,572,0,2403,2404, + 3,1147,573,0,2404,2405,3,1175,587,0,2405,2406,3,1177,588,0,2406, + 2407,3,1155,577,0,2407,2408,3,1165,582,0,2408,2409,3,1139,569,0, + 2409,2410,3,1177,588,0,2410,2411,3,1155,577,0,2411,2412,3,1167,583, + 0,2412,2413,3,1165,582,0,2413,272,1,0,0,0,2414,2415,3,1145,572,0, + 2415,2416,3,1147,573,0,2416,2417,3,1177,588,0,2417,2418,3,1139,569, + 0,2418,2419,3,1155,577,0,2419,2420,3,1161,580,0,2420,274,1,0,0,0, + 2421,2422,3,1145,572,0,2422,2423,3,1149,574,0,2423,2424,3,1153,576, + 0,2424,2425,3,1173,586,0,2425,2426,3,1147,573,0,2426,2427,3,1175, + 587,0,2427,2428,3,1169,584,0,2428,276,1,0,0,0,2429,2430,3,1145,572, + 0,2430,2431,3,1149,574,0,2431,2432,3,1153,576,0,2432,2433,3,1181, + 590,0,2433,2434,3,1139,569,0,2434,2435,3,1161,580,0,2435,2436,3, + 1179,589,0,2436,2437,3,1147,573,0,2437,278,1,0,0,0,2438,2439,3,1145, + 572,0,2439,2440,3,1155,577,0,2440,2441,3,1175,587,0,2441,2442,3, + 1139,569,0,2442,2443,3,1141,570,0,2443,2444,3,1161,580,0,2444,2445, + 3,1147,573,0,2445,280,1,0,0,0,2446,2447,3,1145,572,0,2447,2448,3, + 1155,577,0,2448,2449,3,1175,587,0,2449,2450,3,1159,579,0,2450,282, + 1,0,0,0,2451,2452,3,1145,572,0,2452,2453,3,1155,577,0,2453,2454, + 3,1175,587,0,2454,2455,3,1169,584,0,2455,2456,3,1161,580,0,2456, + 2457,3,1139,569,0,2457,2458,3,1187,593,0,2458,284,1,0,0,0,2459,2460, + 3,1145,572,0,2460,2461,3,1155,577,0,2461,2462,3,1175,587,0,2462, + 2463,3,1169,584,0,2463,2464,3,1161,580,0,2464,2465,3,1139,569,0, + 2465,2466,3,1187,593,0,2466,2467,3,1085,542,0,2467,2468,5,49,0,0, + 2468,286,1,0,0,0,2469,2470,3,1145,572,0,2470,2471,3,1155,577,0,2471, + 2472,3,1181,590,0,2472,2473,3,1155,577,0,2473,2474,3,1145,572,0, + 2474,2475,3,1147,573,0,2475,288,1,0,0,0,2476,2477,3,1145,572,0,2477, + 2478,3,1155,577,0,2478,2479,3,1181,590,0,2479,2480,3,1155,577,0, + 2480,2481,3,1175,587,0,2481,2482,3,1155,577,0,2482,2483,3,1167,583, + 0,2483,2484,3,1165,582,0,2484,290,1,0,0,0,2485,2486,3,1145,572,0, + 2486,2487,3,1167,583,0,2487,2488,3,1165,582,0,2488,2489,3,1177,588, + 0,2489,2490,3,1143,571,0,2490,2491,3,1139,569,0,2491,2492,3,1173, + 586,0,2492,2493,3,1147,573,0,2493,292,1,0,0,0,2494,2495,3,1145,572, + 0,2495,2496,3,1167,583,0,2496,2497,3,1179,589,0,2497,2498,3,1141, + 570,0,2498,2499,3,1161,580,0,2499,2500,3,1147,573,0,2500,294,1,0, + 0,0,2501,2502,3,1145,572,0,2502,2503,3,1167,583,0,2503,2504,3,1183, + 591,0,2504,2505,3,1165,582,0,2505,296,1,0,0,0,2506,2507,3,1145,572, + 0,2507,2508,3,1179,589,0,2508,2509,3,1169,584,0,2509,2510,3,1161, + 580,0,2510,2511,3,1155,577,0,2511,2512,3,1143,571,0,2512,2513,3, + 1139,569,0,2513,2514,3,1177,588,0,2514,2515,3,1147,573,0,2515,2516, + 3,1175,587,0,2516,298,1,0,0,0,2517,2518,3,1145,572,0,2518,2519,3, + 1187,593,0,2519,2520,3,1165,582,0,2520,2521,3,1139,569,0,2521,2522, + 3,1163,581,0,2522,2523,3,1155,577,0,2523,2524,3,1143,571,0,2524, + 300,1,0,0,0,2525,2526,3,1147,573,0,2526,2527,3,1141,570,0,2527,2528, + 3,1143,571,0,2528,2529,3,1145,572,0,2529,2530,3,1155,577,0,2530, + 2531,3,1143,571,0,2531,302,1,0,0,0,2532,2533,3,1147,573,0,2533,2534, + 3,1151,575,0,2534,2535,3,1143,571,0,2535,2536,3,1175,587,0,2536, + 304,1,0,0,0,2537,2538,3,1147,573,0,2538,2539,3,1151,575,0,2539,2540, + 3,1155,577,0,2540,306,1,0,0,0,2541,2542,3,1147,573,0,2542,2543,3, + 1161,580,0,2543,2544,3,1175,587,0,2544,2545,3,1147,573,0,2545,308, + 1,0,0,0,2546,2547,3,1147,573,0,2547,2548,3,1163,581,0,2548,2549, + 3,1155,577,0,2549,310,1,0,0,0,2550,2551,3,1147,573,0,2551,2552,3, + 1163,581,0,2552,2553,3,1169,584,0,2553,2554,3,1177,588,0,2554,2555, + 3,1187,593,0,2555,2556,3,1085,542,0,2556,2557,3,1143,571,0,2557, + 2558,3,1153,576,0,2558,2559,3,1147,573,0,2559,2560,3,1143,571,0, + 2560,2561,3,1159,579,0,2561,312,1,0,0,0,2562,2563,3,1147,573,0,2563, + 2564,3,1165,582,0,2564,2565,3,1139,569,0,2565,2566,3,1141,570,0, + 2566,2567,3,1161,580,0,2567,2568,3,1147,573,0,2568,314,1,0,0,0,2569, + 2570,3,1147,573,0,2570,2571,3,1165,582,0,2571,2572,3,1145,572,0, + 2572,316,1,0,0,0,2573,2574,3,1147,573,0,2574,2575,3,1165,582,0,2575, + 2576,3,1145,572,0,2576,2577,3,1085,542,0,2577,2578,3,1139,569,0, + 2578,2579,3,1143,571,0,2579,2580,3,1143,571,0,2580,2581,3,1147,573, + 0,2581,2582,3,1169,584,0,2582,2583,3,1177,588,0,2583,318,1,0,0,0, + 2584,2585,3,1147,573,0,2585,2586,3,1165,582,0,2586,2587,3,1145,572, + 0,2587,2588,3,1085,542,0,2588,2589,3,1139,569,0,2589,2590,3,1145, + 572,0,2590,2591,3,1145,572,0,2591,320,1,0,0,0,2592,2593,3,1147,573, + 0,2593,2594,3,1165,582,0,2594,2595,3,1145,572,0,2595,2596,3,1085, + 542,0,2596,2597,3,1143,571,0,2597,2598,3,1139,569,0,2598,2599,3, + 1161,580,0,2599,2600,3,1161,580,0,2600,322,1,0,0,0,2601,2602,3,1147, + 573,0,2602,2603,3,1165,582,0,2603,2604,3,1145,572,0,2604,2605,3, + 1085,542,0,2605,2606,3,1143,571,0,2606,2607,3,1167,583,0,2607,2608, + 3,1163,581,0,2608,2609,3,1169,584,0,2609,2610,3,1179,589,0,2610, + 2611,3,1177,588,0,2611,2612,3,1147,573,0,2612,324,1,0,0,0,2613,2614, + 3,1147,573,0,2614,2615,3,1165,582,0,2615,2616,3,1145,572,0,2616, + 2617,3,1085,542,0,2617,2618,3,1145,572,0,2618,2619,3,1147,573,0, + 2619,2620,3,1161,580,0,2620,2621,3,1147,573,0,2621,2622,3,1177,588, + 0,2622,2623,3,1147,573,0,2623,326,1,0,0,0,2624,2625,3,1147,573,0, + 2625,2626,3,1165,582,0,2626,2627,3,1145,572,0,2627,2628,3,1085,542, + 0,2628,2629,3,1145,572,0,2629,2630,3,1155,577,0,2630,2631,3,1181, + 590,0,2631,2632,3,1155,577,0,2632,2633,3,1145,572,0,2633,2634,3, + 1147,573,0,2634,328,1,0,0,0,2635,2636,3,1147,573,0,2636,2637,3,1165, + 582,0,2637,2638,3,1145,572,0,2638,2639,3,1085,542,0,2639,2640,3, + 1147,573,0,2640,2641,3,1181,590,0,2641,2642,3,1139,569,0,2642,2643, + 3,1161,580,0,2643,2644,3,1179,589,0,2644,2645,3,1139,569,0,2645, + 2646,3,1177,588,0,2646,2647,3,1147,573,0,2647,330,1,0,0,0,2648,2649, + 3,1147,573,0,2649,2650,3,1165,582,0,2650,2651,3,1145,572,0,2651, + 2652,3,1085,542,0,2652,2653,3,1155,577,0,2653,2654,3,1149,574,0, + 2654,332,1,0,0,0,2655,2656,3,1147,573,0,2656,2657,3,1165,582,0,2657, + 2658,3,1145,572,0,2658,2659,3,1085,542,0,2659,2660,3,1163,581,0, + 2660,2661,3,1179,589,0,2661,2662,3,1161,580,0,2662,2663,3,1177,588, + 0,2663,2664,3,1155,577,0,2664,2665,3,1169,584,0,2665,2666,3,1161, + 580,0,2666,2667,3,1187,593,0,2667,334,1,0,0,0,2668,2669,3,1147,573, + 0,2669,2670,3,1165,582,0,2670,2671,3,1145,572,0,2671,2672,3,1085, + 542,0,2672,2673,3,1167,583,0,2673,2674,3,1149,574,0,2674,2675,3, + 1085,542,0,2675,2676,3,1169,584,0,2676,2677,3,1139,569,0,2677,2678, + 3,1151,575,0,2678,2679,3,1147,573,0,2679,336,1,0,0,0,2680,2681,3, + 1147,573,0,2681,2682,3,1165,582,0,2682,2683,3,1145,572,0,2683,2684, + 3,1085,542,0,2684,2685,3,1169,584,0,2685,2686,3,1147,573,0,2686, + 2687,3,1173,586,0,2687,2688,3,1149,574,0,2688,2689,3,1167,583,0, + 2689,2690,3,1173,586,0,2690,2691,3,1163,581,0,2691,338,1,0,0,0,2692, + 2693,3,1147,573,0,2693,2694,3,1165,582,0,2694,2695,3,1145,572,0, + 2695,2696,3,1085,542,0,2696,2697,3,1173,586,0,2697,2698,3,1147,573, + 0,2698,2699,3,1139,569,0,2699,2700,3,1145,572,0,2700,340,1,0,0,0, + 2701,2702,3,1147,573,0,2702,2703,3,1165,582,0,2703,2704,3,1145,572, + 0,2704,2705,3,1085,542,0,2705,2706,3,1173,586,0,2706,2707,3,1147, + 573,0,2707,2708,3,1143,571,0,2708,2709,3,1147,573,0,2709,2710,3, + 1155,577,0,2710,2711,3,1181,590,0,2711,2712,3,1147,573,0,2712,342, + 1,0,0,0,2713,2714,3,1147,573,0,2714,2715,3,1165,582,0,2715,2716, + 3,1145,572,0,2716,2717,3,1085,542,0,2717,2718,3,1173,586,0,2718, + 2719,3,1147,573,0,2719,2720,3,1177,588,0,2720,2721,3,1179,589,0, + 2721,2722,3,1173,586,0,2722,2723,3,1165,582,0,2723,344,1,0,0,0,2724, + 2725,3,1147,573,0,2725,2726,3,1165,582,0,2726,2727,3,1145,572,0, + 2727,2728,3,1085,542,0,2728,2729,3,1173,586,0,2729,2730,3,1147,573, + 0,2730,2731,3,1183,591,0,2731,2732,3,1173,586,0,2732,2733,3,1155, + 577,0,2733,2734,3,1177,588,0,2734,2735,3,1147,573,0,2735,346,1,0, + 0,0,2736,2737,3,1147,573,0,2737,2738,3,1165,582,0,2738,2739,3,1145, + 572,0,2739,2740,3,1085,542,0,2740,2741,3,1175,587,0,2741,2742,3, + 1147,573,0,2742,2743,3,1139,569,0,2743,2744,3,1173,586,0,2744,2745, + 3,1143,571,0,2745,2746,3,1153,576,0,2746,348,1,0,0,0,2747,2748,3, + 1147,573,0,2748,2749,3,1165,582,0,2749,2750,3,1145,572,0,2750,2751, + 3,1085,542,0,2751,2752,3,1175,587,0,2752,2753,3,1177,588,0,2753, + 2754,3,1139,569,0,2754,2755,3,1173,586,0,2755,2756,3,1177,588,0, + 2756,350,1,0,0,0,2757,2758,3,1147,573,0,2758,2759,3,1165,582,0,2759, + 2760,3,1145,572,0,2760,2761,3,1085,542,0,2761,2762,3,1175,587,0, + 2762,2763,3,1177,588,0,2763,2764,3,1173,586,0,2764,2765,3,1155,577, + 0,2765,2766,3,1165,582,0,2766,2767,3,1151,575,0,2767,352,1,0,0,0, + 2768,2769,3,1147,573,0,2769,2770,3,1165,582,0,2770,2771,3,1145,572, + 0,2771,2772,3,1085,542,0,2772,2773,3,1175,587,0,2773,2774,3,1179, + 589,0,2774,2775,3,1141,570,0,2775,2776,3,1177,588,0,2776,2777,3, + 1173,586,0,2777,2778,3,1139,569,0,2778,2779,3,1143,571,0,2779,2780, + 3,1177,588,0,2780,354,1,0,0,0,2781,2782,3,1147,573,0,2782,2783,3, + 1165,582,0,2783,2784,3,1145,572,0,2784,2785,3,1085,542,0,2785,2786, + 3,1179,589,0,2786,2787,3,1165,582,0,2787,2788,3,1175,587,0,2788, + 2789,3,1177,588,0,2789,2790,3,1173,586,0,2790,2791,3,1155,577,0, + 2791,2792,3,1165,582,0,2792,2793,3,1151,575,0,2793,356,1,0,0,0,2794, + 2795,3,1147,573,0,2795,2796,3,1165,582,0,2796,2797,3,1145,572,0, + 2797,2798,3,1085,542,0,2798,2799,3,1183,591,0,2799,2800,3,1173,586, + 0,2800,2801,3,1155,577,0,2801,2802,3,1177,588,0,2802,2803,3,1147, + 573,0,2803,358,1,0,0,0,2804,2805,3,1147,573,0,2805,2806,3,1165,582, + 0,2806,2807,3,1145,572,0,2807,2808,3,1155,577,0,2808,2809,3,1165, + 582,0,2809,2810,3,1149,574,0,2810,360,1,0,0,0,2811,2812,3,1147,573, + 0,2812,2813,3,1165,582,0,2813,2814,3,1177,588,0,2814,2815,3,1147, + 573,0,2815,2816,3,1173,586,0,2816,362,1,0,0,0,2817,2818,3,1147,573, + 0,2818,2819,3,1165,582,0,2819,2820,3,1177,588,0,2820,2821,3,1173, + 586,0,2821,2822,3,1187,593,0,2822,364,1,0,0,0,2823,2824,3,1147,573, + 0,2824,2825,3,1165,582,0,2825,2826,3,1177,588,0,2826,2827,3,1173, + 586,0,2827,2828,3,1187,593,0,2828,2829,3,1085,542,0,2829,2830,3, + 1169,584,0,2830,2831,3,1173,586,0,2831,2832,3,1167,583,0,2832,2833, + 3,1143,571,0,2833,2834,3,1147,573,0,2834,2835,3,1145,572,0,2835, + 2836,3,1179,589,0,2836,2837,3,1173,586,0,2837,2838,3,1147,573,0, + 2838,366,1,0,0,0,2839,2840,3,1147,573,0,2840,2841,3,1165,582,0,2841, + 2842,3,1181,590,0,2842,2843,3,1155,577,0,2843,2844,3,1173,586,0, + 2844,2845,3,1167,583,0,2845,2846,3,1165,582,0,2846,2847,3,1163,581, + 0,2847,2848,3,1147,573,0,2848,2849,3,1165,582,0,2849,2850,3,1177, + 588,0,2850,368,1,0,0,0,2851,2852,3,1147,573,0,2852,2853,3,1167,583, + 0,2853,2854,3,1169,584,0,2854,370,1,0,0,0,2855,2856,3,1147,573,0, + 2856,2857,3,1171,585,0,2857,2858,3,1179,589,0,2858,2859,3,1139,569, + 0,2859,2860,3,1161,580,0,2860,372,1,0,0,0,2861,2862,3,1147,573,0, + 2862,2863,3,1173,586,0,2863,2864,3,1139,569,0,2864,2865,3,1175,587, + 0,2865,2866,3,1147,573,0,2866,374,1,0,0,0,2867,2868,3,1147,573,0, + 2868,2869,3,1173,586,0,2869,2870,3,1173,586,0,2870,2871,3,1167,583, + 0,2871,2872,3,1173,586,0,2872,376,1,0,0,0,2873,2874,3,1147,573,0, + 2874,2875,3,1167,583,0,2875,2876,3,1161,580,0,2876,378,1,0,0,0,2877, + 2878,3,1147,573,0,2878,2879,3,1167,583,0,2879,2880,3,1175,587,0, + 2880,380,1,0,0,0,2881,2882,3,1147,573,0,2882,2883,3,1175,587,0,2883, + 2884,3,1143,571,0,2884,2885,3,1139,569,0,2885,2886,3,1169,584,0, + 2886,2887,3,1147,573,0,2887,382,1,0,0,0,2888,2889,3,1147,573,0,2889, + 2890,3,1175,587,0,2890,2891,3,1155,577,0,2891,384,1,0,0,0,2892,2893, + 3,1147,573,0,2893,2894,3,1181,590,0,2894,2895,3,1139,569,0,2895, + 2896,3,1161,580,0,2896,2897,3,1179,589,0,2897,2898,3,1139,569,0, + 2898,2899,3,1177,588,0,2899,2900,3,1147,573,0,2900,386,1,0,0,0,2901, + 2902,3,1147,573,0,2902,2903,3,1181,590,0,2903,2904,3,1147,573,0, + 2904,2905,3,1165,582,0,2905,2906,3,1177,588,0,2906,388,1,0,0,0,2907, + 2908,3,1147,573,0,2908,2909,3,1181,590,0,2909,2910,3,1147,573,0, + 2910,2911,3,1173,586,0,2911,2912,3,1187,593,0,2912,390,1,0,0,0,2913, + 2914,3,1147,573,0,2914,2915,3,1185,592,0,2915,2916,3,1143,571,0, + 2916,2917,3,1147,573,0,2917,2918,3,1169,584,0,2918,2919,3,1177,588, + 0,2919,2920,3,1155,577,0,2920,2921,3,1167,583,0,2921,2922,3,1165, + 582,0,2922,392,1,0,0,0,2923,2924,3,1147,573,0,2924,2925,3,1185,592, + 0,2925,2926,3,1143,571,0,2926,2927,3,1161,580,0,2927,2928,3,1179, + 589,0,2928,2929,3,1175,587,0,2929,2930,3,1155,577,0,2930,2931,3, + 1181,590,0,2931,2932,3,1147,573,0,2932,394,1,0,0,0,2933,2934,3,1147, + 573,0,2934,2935,3,1185,592,0,2935,2936,3,1153,576,0,2936,2937,3, + 1155,577,0,2937,2938,3,1141,570,0,2938,2939,3,1155,577,0,2939,2940, + 3,1177,588,0,2940,396,1,0,0,0,2941,2942,3,1147,573,0,2942,2943,3, + 1185,592,0,2943,2944,3,1155,577,0,2944,2945,3,1177,588,0,2945,398, + 1,0,0,0,2946,2947,3,1147,573,0,2947,2948,3,1185,592,0,2948,2949, + 3,1169,584,0,2949,2950,3,1167,583,0,2950,2951,3,1173,586,0,2951, + 2952,3,1177,588,0,2952,400,1,0,0,0,2953,2954,3,1147,573,0,2954,2955, + 3,1185,592,0,2955,2956,3,1177,588,0,2956,2957,3,1147,573,0,2957, + 2958,3,1165,582,0,2958,2959,3,1145,572,0,2959,402,1,0,0,0,2960,2961, + 3,1147,573,0,2961,2962,3,1185,592,0,2962,2963,3,1177,588,0,2963, + 2964,3,1147,573,0,2964,2965,3,1165,582,0,2965,2966,3,1145,572,0, + 2966,2967,3,1147,573,0,2967,2968,3,1145,572,0,2968,404,1,0,0,0,2969, + 2970,3,1147,573,0,2970,2971,3,1185,592,0,2971,2972,3,1177,588,0, + 2972,2973,3,1147,573,0,2973,2974,3,1173,586,0,2974,2975,3,1165,582, + 0,2975,2976,3,1139,569,0,2976,2977,3,1161,580,0,2977,406,1,0,0,0, + 2978,2979,3,1149,574,0,2979,2980,3,1139,569,0,2980,2981,3,1161,580, + 0,2981,2982,3,1175,587,0,2982,2983,3,1147,573,0,2983,408,1,0,0,0, + 2984,2985,3,1149,574,0,2985,2986,3,1145,572,0,2986,410,1,0,0,0,2987, + 2988,3,1149,574,0,2988,2989,3,1155,577,0,2989,2990,3,1161,580,0, + 2990,2991,3,1147,573,0,2991,412,1,0,0,0,2992,2993,3,1149,574,0,2993, + 2994,3,1155,577,0,2994,2995,3,1161,580,0,2995,2996,3,1147,573,0, + 2996,2997,3,1085,542,0,2997,2998,3,1143,571,0,2998,2999,3,1167,583, + 0,2999,3000,3,1165,582,0,3000,3001,3,1177,588,0,3001,3002,3,1173, + 586,0,3002,3003,3,1167,583,0,3003,3004,3,1161,580,0,3004,414,1,0, + 0,0,3005,3006,3,1149,574,0,3006,3007,3,1155,577,0,3007,3008,3,1161, + 580,0,3008,3009,3,1161,580,0,3009,3010,3,1147,573,0,3010,3011,3, + 1173,586,0,3011,416,1,0,0,0,3012,3013,3,1149,574,0,3013,3014,3,1155, + 577,0,3014,3015,3,1165,582,0,3015,3016,3,1139,569,0,3016,3017,3, + 1161,580,0,3017,418,1,0,0,0,3018,3019,3,1149,574,0,3019,3020,3,1155, + 577,0,3020,3021,3,1173,586,0,3021,3022,3,1175,587,0,3022,3023,3, + 1177,588,0,3023,420,1,0,0,0,3024,3025,3,1149,574,0,3025,3026,3,1167, + 583,0,3026,3027,3,1167,583,0,3027,3028,3,1177,588,0,3028,3029,3, + 1155,577,0,3029,3030,3,1165,582,0,3030,3031,3,1151,575,0,3031,422, + 1,0,0,0,3032,3033,3,1149,574,0,3033,3034,3,1167,583,0,3034,3035, + 3,1173,586,0,3035,424,1,0,0,0,3036,3037,3,1149,574,0,3037,3038,3, + 1167,583,0,3038,3039,3,1173,586,0,3039,3040,3,1147,573,0,3040,3041, + 3,1151,575,0,3041,3042,3,1173,586,0,3042,3043,3,1167,583,0,3043, + 3044,3,1179,589,0,3044,3045,3,1165,582,0,3045,3046,3,1145,572,0, + 3046,3047,3,1085,542,0,3047,3048,3,1143,571,0,3048,3049,3,1167,583, + 0,3049,3050,3,1161,580,0,3050,3051,3,1167,583,0,3051,3052,3,1173, + 586,0,3052,426,1,0,0,0,3053,3054,3,1149,574,0,3054,3055,3,1167,583, + 0,3055,3056,3,1173,586,0,3056,3057,3,1147,573,0,3057,3058,3,1151, + 575,0,3058,3059,3,1173,586,0,3059,3060,3,1167,583,0,3060,3061,3, + 1179,589,0,3061,3062,3,1165,582,0,3062,3063,3,1145,572,0,3063,3064, + 3,1085,542,0,3064,3065,3,1143,571,0,3065,3066,3,1167,583,0,3066, + 3067,3,1161,580,0,3067,3068,3,1167,583,0,3068,3069,3,1179,589,0, + 3069,3070,3,1173,586,0,3070,428,1,0,0,0,3071,3072,3,1149,574,0,3072, + 3073,3,1173,586,0,3073,3074,3,1167,583,0,3074,3075,3,1163,581,0, + 3075,430,1,0,0,0,3076,3077,3,1149,574,0,3077,3078,3,1179,589,0,3078, + 3079,3,1161,580,0,3079,3080,3,1161,580,0,3080,432,1,0,0,0,3081,3082, + 3,1149,574,0,3082,3083,3,1179,589,0,3083,3084,3,1165,582,0,3084, + 3085,3,1143,571,0,3085,3086,3,1177,588,0,3086,3087,3,1155,577,0, + 3087,3088,3,1167,583,0,3088,3089,3,1165,582,0,3089,434,1,0,0,0,3090, + 3091,3,1149,574,0,3091,3092,3,1179,589,0,3092,3093,3,1165,582,0, + 3093,3094,3,1143,571,0,3094,3095,3,1177,588,0,3095,3096,3,1155,577, + 0,3096,3097,3,1167,583,0,3097,3098,3,1165,582,0,3098,3099,3,1165, + 582,0,3099,3100,3,1139,569,0,3100,3101,3,1163,581,0,3101,3102,3, + 1147,573,0,3102,436,1,0,0,0,3103,3104,3,1149,574,0,3104,3105,3,1179, + 589,0,3105,3106,3,1165,582,0,3106,3107,3,1143,571,0,3107,3108,3, + 1177,588,0,3108,3109,3,1155,577,0,3109,3110,3,1167,583,0,3110,3111, + 3,1165,582,0,3111,3112,3,1085,542,0,3112,3113,3,1169,584,0,3113, + 3114,3,1167,583,0,3114,3115,3,1155,577,0,3115,3116,3,1165,582,0, + 3116,3117,3,1177,588,0,3117,3118,3,1147,573,0,3118,3119,3,1173,586, + 0,3119,438,1,0,0,0,3120,3121,3,1151,575,0,3121,3122,3,1147,573,0, + 3122,3123,3,1165,582,0,3123,3124,3,1147,573,0,3124,3125,3,1173,586, + 0,3125,3126,3,1139,569,0,3126,3127,3,1177,588,0,3127,3128,3,1147, + 573,0,3128,440,1,0,0,0,3129,3130,3,1151,575,0,3130,3131,3,1167,583, + 0,3131,3132,3,1141,570,0,3132,3133,3,1139,569,0,3133,3134,3,1143, + 571,0,3134,3135,3,1159,579,0,3135,442,1,0,0,0,3136,3137,3,1151,575, + 0,3137,3138,3,1155,577,0,3138,3139,3,1181,590,0,3139,3140,3,1155, + 577,0,3140,3141,3,1165,582,0,3141,3142,3,1151,575,0,3142,444,1,0, + 0,0,3143,3144,3,1151,575,0,3144,3145,3,1161,580,0,3145,3146,3,1167, + 583,0,3146,3147,3,1141,570,0,3147,3148,3,1139,569,0,3148,3149,3, + 1161,580,0,3149,446,1,0,0,0,3150,3151,3,1151,575,0,3151,3152,3,1167, + 583,0,3152,448,1,0,0,0,3153,3154,3,1151,575,0,3154,3155,3,1173,586, + 0,3155,3156,3,1147,573,0,3156,3157,3,1139,569,0,3157,3158,3,1177, + 588,0,3158,3159,3,1147,573,0,3159,3160,3,1173,586,0,3160,450,1,0, + 0,0,3161,3162,3,1151,575,0,3162,3163,3,1173,586,0,3163,3164,3,1155, + 577,0,3164,3165,3,1145,572,0,3165,452,1,0,0,0,3166,3167,3,1151,575, + 0,3167,3168,3,1173,586,0,3168,3169,3,1167,583,0,3169,3170,3,1179, + 589,0,3170,3171,3,1169,584,0,3171,454,1,0,0,0,3172,3173,3,1153,576, + 0,3173,3174,3,1147,573,0,3174,3175,3,1139,569,0,3175,3176,3,1145, + 572,0,3176,3177,3,1155,577,0,3177,3178,3,1165,582,0,3178,3179,3, + 1151,575,0,3179,456,1,0,0,0,3180,3181,3,1153,576,0,3181,3182,3,1155, + 577,0,3182,3183,3,1151,575,0,3183,3184,3,1153,576,0,3184,3185,3, + 1161,580,0,3185,3186,3,1155,577,0,3186,3187,3,1151,575,0,3187,3188, + 3,1153,576,0,3188,3189,3,1177,588,0,3189,458,1,0,0,0,3190,3191,3, + 1153,576,0,3191,3192,3,1155,577,0,3192,3193,3,1151,575,0,3193,3194, + 3,1153,576,0,3194,3195,3,1085,542,0,3195,3196,3,1181,590,0,3196, + 3197,3,1139,569,0,3197,3198,3,1161,580,0,3198,3199,3,1179,589,0, + 3199,3200,3,1147,573,0,3200,460,1,0,0,0,3201,3202,3,1153,576,0,3202, + 3203,3,1155,577,0,3203,3204,3,1151,575,0,3204,3205,3,1153,576,0, + 3205,3206,3,1085,542,0,3206,3207,3,1181,590,0,3207,3208,3,1139,569, + 0,3208,3209,3,1161,580,0,3209,3210,3,1179,589,0,3210,3211,3,1147, + 573,0,3211,3212,3,1175,587,0,3212,462,1,0,0,0,3213,3214,3,1155,577, + 0,3214,3215,3,1085,542,0,3215,3216,3,1167,583,0,3216,464,1,0,0,0, + 3217,3218,3,1155,577,0,3218,3219,3,1085,542,0,3219,3220,3,1167,583, + 0,3220,3221,3,1085,542,0,3221,3222,3,1143,571,0,3222,3223,3,1167, + 583,0,3223,3224,3,1165,582,0,3224,3225,3,1177,588,0,3225,3226,3, + 1173,586,0,3226,3227,3,1167,583,0,3227,3228,3,1161,580,0,3228,466, + 1,0,0,0,3229,3230,3,1155,577,0,3230,3231,3,1145,572,0,3231,468,1, + 0,0,0,3232,3233,3,1155,577,0,3233,3234,3,1145,572,0,3234,3235,3, + 1147,573,0,3235,3236,3,1165,582,0,3236,3237,3,1177,588,0,3237,3238, + 3,1155,577,0,3238,3239,3,1149,574,0,3239,3240,3,1155,577,0,3240, + 3241,3,1143,571,0,3241,3242,3,1139,569,0,3242,3243,3,1177,588,0, + 3243,3244,3,1155,577,0,3244,3245,3,1167,583,0,3245,3246,3,1165,582, + 0,3246,470,1,0,0,0,3247,3248,3,1155,577,0,3248,3249,3,1149,574,0, + 3249,472,1,0,0,0,3250,3251,3,1155,577,0,3251,3252,3,1163,581,0,3252, + 3253,3,1169,584,0,3253,3254,3,1161,580,0,3254,3255,3,1155,577,0, + 3255,3256,3,1143,571,0,3256,3257,3,1155,577,0,3257,3258,3,1177,588, + 0,3258,474,1,0,0,0,3259,3260,3,1155,577,0,3260,3261,3,1163,581,0, + 3261,3262,3,1169,584,0,3262,3263,3,1167,583,0,3263,3264,3,1173,586, + 0,3264,3265,3,1177,588,0,3265,476,1,0,0,0,3266,3267,3,1155,577,0, + 3267,3268,3,1165,582,0,3268,478,1,0,0,0,3269,3270,3,1155,577,0,3270, + 3271,3,1165,582,0,3271,3272,3,1145,572,0,3272,3273,3,1147,573,0, + 3273,3274,3,1185,592,0,3274,480,1,0,0,0,3275,3276,3,1155,577,0,3276, + 3277,3,1165,582,0,3277,3278,3,1145,572,0,3278,3279,3,1147,573,0, + 3279,3280,3,1185,592,0,3280,3281,3,1147,573,0,3281,3282,3,1145,572, + 0,3282,482,1,0,0,0,3283,3284,3,1155,577,0,3284,3285,3,1165,582,0, + 3285,3286,3,1145,572,0,3286,3287,3,1155,577,0,3287,3288,3,1143,571, + 0,3288,3289,3,1139,569,0,3289,3290,3,1177,588,0,3290,3291,3,1147, + 573,0,3291,484,1,0,0,0,3292,3293,3,1155,577,0,3293,3294,3,1165,582, + 0,3294,3295,3,1155,577,0,3295,3296,3,1177,588,0,3296,3297,3,1155, + 577,0,3297,3298,3,1139,569,0,3298,3299,3,1161,580,0,3299,486,1,0, + 0,0,3300,3301,3,1155,577,0,3301,3302,3,1165,582,0,3302,3303,3,1155, + 577,0,3303,3304,3,1177,588,0,3304,3305,3,1155,577,0,3305,3306,3, + 1139,569,0,3306,3307,3,1161,580,0,3307,3308,3,1155,577,0,3308,3309, + 3,1189,594,0,3309,3310,3,1147,573,0,3310,488,1,0,0,0,3311,3312,3, + 1155,577,0,3312,3313,3,1165,582,0,3313,3314,3,1155,577,0,3314,3315, + 3,1177,588,0,3315,3316,3,1155,577,0,3316,3317,3,1139,569,0,3317, + 3318,3,1177,588,0,3318,3319,3,1147,573,0,3319,490,1,0,0,0,3320,3321, + 3,1155,577,0,3321,3322,3,1165,582,0,3322,3323,3,1169,584,0,3323, + 3324,3,1179,589,0,3324,3325,3,1177,588,0,3325,492,1,0,0,0,3326,3327, + 3,1155,577,0,3327,3328,3,1165,582,0,3328,3329,3,1169,584,0,3329, + 3330,3,1179,589,0,3330,3331,3,1177,588,0,3331,3332,3,1085,542,0, + 3332,3333,3,1167,583,0,3333,3334,3,1179,589,0,3334,3335,3,1177,588, + 0,3335,3336,3,1169,584,0,3336,3337,3,1179,589,0,3337,3338,3,1177, + 588,0,3338,494,1,0,0,0,3339,3340,3,1155,577,0,3340,3341,3,1165,582, + 0,3341,3342,3,1175,587,0,3342,3343,3,1169,584,0,3343,3344,3,1147, + 573,0,3344,3345,3,1143,571,0,3345,3346,3,1177,588,0,3346,496,1,0, + 0,0,3347,3348,3,1155,577,0,3348,3349,3,1165,582,0,3349,3350,3,1175, + 587,0,3350,3351,3,1177,588,0,3351,3352,3,1139,569,0,3352,3353,3, + 1161,580,0,3353,3354,3,1161,580,0,3354,3355,3,1139,569,0,3355,3356, + 3,1177,588,0,3356,3357,3,1155,577,0,3357,3358,3,1167,583,0,3358, + 3359,3,1165,582,0,3359,498,1,0,0,0,3360,3361,3,1155,577,0,3361,3362, + 3,1165,582,0,3362,3363,3,1177,588,0,3363,3364,3,1147,573,0,3364, + 3365,3,1151,575,0,3365,3366,3,1147,573,0,3366,3367,3,1173,586,0, + 3367,500,1,0,0,0,3368,3369,3,1155,577,0,3369,3370,3,1165,582,0,3370, + 3371,3,1177,588,0,3371,3372,3,1167,583,0,3372,502,1,0,0,0,3373,3374, + 3,1155,577,0,3374,3375,3,1165,582,0,3375,3376,3,1181,590,0,3376, + 3377,3,1139,569,0,3377,3378,3,1161,580,0,3378,3379,3,1155,577,0, + 3379,3380,3,1145,572,0,3380,504,1,0,0,0,3381,3382,3,1155,577,0,3382, + 3383,3,1165,582,0,3383,3384,3,1181,590,0,3384,3385,3,1167,583,0, + 3385,3386,3,1159,579,0,3386,3387,3,1147,573,0,3387,506,1,0,0,0,3388, + 3389,3,1155,577,0,3389,3390,3,1175,587,0,3390,508,1,0,0,0,3391,3392, + 3,1157,578,0,3392,3393,3,1179,589,0,3393,3394,3,1175,587,0,3394, + 3395,3,1177,588,0,3395,510,1,0,0,0,3396,3397,3,1157,578,0,3397,3398, + 3,1179,589,0,3398,3399,3,1175,587,0,3399,3400,3,1177,588,0,3400, + 3401,3,1155,577,0,3401,3402,3,1149,574,0,3402,3403,3,1155,577,0, + 3403,3404,3,1147,573,0,3404,3405,3,1145,572,0,3405,512,1,0,0,0,3406, + 3407,3,1159,579,0,3407,3408,3,1139,569,0,3408,3409,3,1165,582,0, + 3409,3410,3,1157,578,0,3410,3411,3,1155,577,0,3411,514,1,0,0,0,3412, + 3413,3,1159,579,0,3413,3414,3,1147,573,0,3414,3415,3,1169,584,0, + 3415,3416,3,1177,588,0,3416,516,1,0,0,0,3417,3418,3,1159,579,0,3418, + 3419,3,1147,573,0,3419,3420,3,1187,593,0,3420,518,1,0,0,0,3421,3422, + 3,1159,579,0,3422,3423,3,1147,573,0,3423,3424,3,1187,593,0,3424, + 3425,3,1141,570,0,3425,3426,3,1167,583,0,3426,3427,3,1139,569,0, + 3427,3428,3,1173,586,0,3428,3429,3,1145,572,0,3429,520,1,0,0,0,3430, + 3431,3,1161,580,0,3431,3432,3,1139,569,0,3432,3433,3,1141,570,0, + 3433,3434,3,1147,573,0,3434,3435,3,1161,580,0,3435,522,1,0,0,0,3436, + 3437,3,1161,580,0,3437,3438,3,1139,569,0,3438,3439,3,1165,582,0, + 3439,3440,3,1151,575,0,3440,3441,3,1179,589,0,3441,3442,3,1139,569, + 0,3442,3443,3,1151,575,0,3443,3444,3,1147,573,0,3444,524,1,0,0,0, + 3445,3446,3,1161,580,0,3446,3447,3,1139,569,0,3447,3448,3,1175,587, + 0,3448,3449,3,1177,588,0,3449,526,1,0,0,0,3450,3451,3,1161,580,0, + 3451,3452,3,1141,570,0,3452,528,1,0,0,0,3453,3454,3,1161,580,0,3454, + 3455,3,1145,572,0,3455,530,1,0,0,0,3456,3457,3,1161,580,0,3457,3458, + 3,1147,573,0,3458,3459,3,1139,569,0,3459,3460,3,1145,572,0,3460, + 3461,3,1155,577,0,3461,3462,3,1165,582,0,3462,3463,3,1151,575,0, + 3463,532,1,0,0,0,3464,3465,3,1161,580,0,3465,3466,3,1147,573,0,3466, + 3467,3,1149,574,0,3467,3468,3,1177,588,0,3468,534,1,0,0,0,3469,3470, + 3,1161,580,0,3470,3471,3,1147,573,0,3471,3472,3,1149,574,0,3472, + 3473,3,1177,588,0,3473,3474,3,1161,580,0,3474,3475,3,1155,577,0, + 3475,3476,3,1165,582,0,3476,3477,3,1147,573,0,3477,536,1,0,0,0,3478, + 3479,3,1161,580,0,3479,3480,3,1147,573,0,3480,3481,3,1165,582,0, + 3481,3482,3,1151,575,0,3482,3483,3,1177,588,0,3483,3484,3,1153,576, + 0,3484,538,1,0,0,0,3485,3486,3,1161,580,0,3486,3487,3,1147,573,0, + 3487,3488,3,1165,582,0,3488,3489,3,1151,575,0,3489,3490,3,1177,588, + 0,3490,3491,3,1153,576,0,3491,3492,3,1085,542,0,3492,3493,3,1143, + 571,0,3493,3494,3,1153,576,0,3494,3495,3,1147,573,0,3495,3496,3, + 1143,571,0,3496,3497,3,1159,579,0,3497,540,1,0,0,0,3498,3499,3,1161, + 580,0,3499,3500,3,1147,573,0,3500,3501,3,1175,587,0,3501,3502,3, + 1175,587,0,3502,542,1,0,0,0,3503,3504,3,1161,580,0,3504,3505,3,1155, + 577,0,3505,3506,3,1141,570,0,3506,3507,3,1139,569,0,3507,3508,3, + 1143,571,0,3508,3509,3,1143,571,0,3509,3510,3,1147,573,0,3510,3511, + 3,1175,587,0,3511,3512,3,1175,587,0,3512,544,1,0,0,0,3513,3514,3, + 1161,580,0,3514,3515,3,1155,577,0,3515,3516,3,1141,570,0,3516,3517, + 3,1169,584,0,3517,3518,3,1139,569,0,3518,3519,3,1173,586,0,3519, + 3520,3,1139,569,0,3520,3521,3,1163,581,0,3521,3522,3,1147,573,0, + 3522,3523,3,1177,588,0,3523,3524,3,1147,573,0,3524,3525,3,1173,586, + 0,3525,546,1,0,0,0,3526,3527,3,1161,580,0,3527,3528,3,1155,577,0, + 3528,3529,3,1141,570,0,3529,3530,3,1173,586,0,3530,3531,3,1139,569, + 0,3531,3532,3,1173,586,0,3532,3533,3,1187,593,0,3533,548,1,0,0,0, + 3534,3535,3,1161,580,0,3535,3536,3,1155,577,0,3536,3537,3,1163,581, + 0,3537,3538,3,1155,577,0,3538,3539,3,1177,588,0,3539,550,1,0,0,0, + 3540,3541,3,1161,580,0,3541,3542,3,1155,577,0,3542,3543,3,1163,581, + 0,3543,3544,3,1155,577,0,3544,3545,3,1177,588,0,3545,3546,3,1175, + 587,0,3546,552,1,0,0,0,3547,3548,3,1161,580,0,3548,3549,3,1155,577, + 0,3549,3550,3,1165,582,0,3550,3551,3,1139,569,0,3551,3552,3,1151, + 575,0,3552,3553,3,1147,573,0,3553,554,1,0,0,0,3554,3555,3,1161,580, + 0,3555,3556,3,1155,577,0,3556,3557,3,1165,582,0,3557,3558,3,1139, + 569,0,3558,3559,3,1151,575,0,3559,3560,3,1147,573,0,3560,3561,3, + 1085,542,0,3561,3562,3,1143,571,0,3562,3563,3,1167,583,0,3563,3564, + 3,1179,589,0,3564,3565,3,1165,582,0,3565,3566,3,1177,588,0,3566, + 3567,3,1147,573,0,3567,3568,3,1173,586,0,3568,556,1,0,0,0,3569,3570, + 3,1161,580,0,3570,3571,3,1155,577,0,3571,3572,3,1165,582,0,3572, + 3573,3,1147,573,0,3573,558,1,0,0,0,3574,3575,3,1161,580,0,3575,3576, + 3,1155,577,0,3576,3577,3,1165,582,0,3577,3578,3,1147,573,0,3578, + 3579,3,1175,587,0,3579,560,1,0,0,0,3580,3581,3,1161,580,0,3581,3582, + 3,1155,577,0,3582,3583,3,1165,582,0,3583,3584,3,1147,573,0,3584, + 3585,3,1085,542,0,3585,3586,3,1143,571,0,3586,3587,3,1167,583,0, + 3587,3588,3,1179,589,0,3588,3589,3,1165,582,0,3589,3590,3,1177,588, + 0,3590,3591,3,1147,573,0,3591,3592,3,1173,586,0,3592,562,1,0,0,0, + 3593,3594,3,1161,580,0,3594,3595,3,1155,577,0,3595,3596,3,1165,582, + 0,3596,3597,3,1159,579,0,3597,3598,3,1139,569,0,3598,3599,3,1151, + 575,0,3599,3600,3,1147,573,0,3600,564,1,0,0,0,3601,3602,3,1161,580, + 0,3602,3603,3,1155,577,0,3603,3604,3,1175,587,0,3604,3605,3,1177, + 588,0,3605,566,1,0,0,0,3606,3607,3,1161,580,0,3607,3608,3,1167,583, + 0,3608,3609,3,1143,571,0,3609,3610,3,1139,569,0,3610,3611,3,1161, + 580,0,3611,568,1,0,0,0,3612,3613,3,1161,580,0,3613,3614,3,1167,583, + 0,3614,3615,3,1143,571,0,3615,3616,3,1139,569,0,3616,3617,3,1161, + 580,0,3617,3618,3,1085,542,0,3618,3619,3,1175,587,0,3619,3620,3, + 1177,588,0,3620,3621,3,1167,583,0,3621,3622,3,1173,586,0,3622,3623, + 3,1139,569,0,3623,3624,3,1151,575,0,3624,3625,3,1147,573,0,3625, + 570,1,0,0,0,3626,3627,3,1161,580,0,3627,3628,3,1167,583,0,3628,3629, + 3,1143,571,0,3629,3630,3,1159,579,0,3630,572,1,0,0,0,3631,3632,3, + 1161,580,0,3632,3633,3,1167,583,0,3633,3634,3,1165,582,0,3634,3635, + 3,1151,575,0,3635,3636,3,1085,542,0,3636,3637,3,1145,572,0,3637, + 3638,3,1139,569,0,3638,3639,3,1177,588,0,3639,3640,3,1147,573,0, + 3640,574,1,0,0,0,3641,3642,3,1161,580,0,3642,3643,3,1167,583,0,3643, + 3644,3,1165,582,0,3644,3645,3,1151,575,0,3645,3646,3,1085,542,0, + 3646,3647,3,1177,588,0,3647,3648,3,1155,577,0,3648,3649,3,1163,581, + 0,3649,3650,3,1147,573,0,3650,576,1,0,0,0,3651,3652,3,1161,580,0, + 3652,3653,3,1167,583,0,3653,3654,3,1183,591,0,3654,3655,3,1147,573, + 0,3655,3656,3,1173,586,0,3656,578,1,0,0,0,3657,3658,3,1161,580,0, + 3658,3659,3,1167,583,0,3659,3660,3,1183,591,0,3660,3661,3,1161,580, + 0,3661,3662,3,1155,577,0,3662,3663,3,1151,575,0,3663,3664,3,1153, + 576,0,3664,3665,3,1177,588,0,3665,580,1,0,0,0,3666,3667,3,1161,580, + 0,3667,3668,3,1167,583,0,3668,3669,3,1183,591,0,3669,3670,3,1085, + 542,0,3670,3671,3,1181,590,0,3671,3672,3,1139,569,0,3672,3673,3, + 1161,580,0,3673,3674,3,1179,589,0,3674,3675,3,1147,573,0,3675,582, + 1,0,0,0,3676,3677,3,1161,580,0,3677,3678,3,1167,583,0,3678,3679, + 3,1183,591,0,3679,3680,3,1085,542,0,3680,3681,3,1181,590,0,3681, + 3682,3,1139,569,0,3682,3683,3,1161,580,0,3683,3684,3,1179,589,0, + 3684,3685,3,1147,573,0,3685,3686,3,1175,587,0,3686,584,1,0,0,0,3687, + 3688,3,1163,581,0,3688,3689,3,1147,573,0,3689,3690,3,1163,581,0, + 3690,3691,3,1167,583,0,3691,3692,3,1173,586,0,3692,3693,3,1187,593, + 0,3693,586,1,0,0,0,3694,3695,3,1163,581,0,3695,3696,3,1147,573,0, + 3696,3697,3,1173,586,0,3697,3698,3,1151,575,0,3698,3699,3,1147,573, + 0,3699,588,1,0,0,0,3700,3701,3,1163,581,0,3701,3702,3,1147,573,0, + 3702,3703,3,1175,587,0,3703,3704,3,1175,587,0,3704,3705,3,1139,569, + 0,3705,3706,3,1151,575,0,3706,3707,3,1147,573,0,3707,590,1,0,0,0, + 3708,3709,3,1163,581,0,3709,3710,3,1163,581,0,3710,3711,3,1145,572, + 0,3711,3712,3,1145,572,0,3712,3713,3,1187,593,0,3713,3714,3,1187, + 593,0,3714,3715,3,1187,593,0,3715,3716,3,1187,593,0,3716,592,1,0, + 0,0,3717,3718,3,1163,581,0,3718,3719,3,1167,583,0,3719,3720,3,1145, + 572,0,3720,3721,3,1147,573,0,3721,594,1,0,0,0,3722,3723,3,1163,581, + 0,3723,3724,3,1167,583,0,3724,3725,3,1145,572,0,3725,3726,3,1179, + 589,0,3726,3727,3,1161,580,0,3727,3728,3,1147,573,0,3728,3729,3, + 1175,587,0,3729,596,1,0,0,0,3730,3731,3,1163,581,0,3731,3732,3,1167, + 583,0,3732,3733,3,1173,586,0,3733,3734,3,1147,573,0,3734,3735,3, + 1085,542,0,3735,3736,3,1161,580,0,3736,3737,3,1139,569,0,3737,3738, + 3,1141,570,0,3738,3739,3,1147,573,0,3739,3740,3,1161,580,0,3740, + 3741,3,1175,587,0,3741,598,1,0,0,0,3742,3743,3,1163,581,0,3743,3744, + 3,1167,583,0,3744,3745,3,1181,590,0,3745,3746,3,1147,573,0,3746, + 600,1,0,0,0,3747,3748,3,1163,581,0,3748,3749,3,1179,589,0,3749,3750, + 3,1161,580,0,3750,3751,3,1177,588,0,3751,3752,3,1155,577,0,3752, + 3753,3,1169,584,0,3753,3754,3,1161,580,0,3754,3755,3,1147,573,0, + 3755,602,1,0,0,0,3756,3757,3,1163,581,0,3757,3758,3,1179,589,0,3758, + 3759,3,1161,580,0,3759,3760,3,1177,588,0,3760,3761,3,1155,577,0, + 3761,3762,3,1169,584,0,3762,3763,3,1161,580,0,3763,3764,3,1187,593, + 0,3764,604,1,0,0,0,3765,3766,3,1165,582,0,3766,3767,3,1139,569,0, + 3767,3768,3,1163,581,0,3768,3769,3,1147,573,0,3769,3770,3,1145,572, + 0,3770,606,1,0,0,0,3771,3772,3,1165,582,0,3772,3773,3,1139,569,0, + 3773,3774,3,1177,588,0,3774,3775,3,1155,577,0,3775,3776,3,1167,583, + 0,3776,3777,3,1165,582,0,3777,3778,3,1139,569,0,3778,3779,3,1161, + 580,0,3779,608,1,0,0,0,3780,3781,3,1165,582,0,3781,3782,3,1139,569, + 0,3782,3783,3,1177,588,0,3783,3784,3,1155,577,0,3784,3785,3,1167, + 583,0,3785,3786,3,1165,582,0,3786,3787,3,1139,569,0,3787,3788,3, + 1161,580,0,3788,3789,3,1085,542,0,3789,3790,3,1147,573,0,3790,3791, + 3,1145,572,0,3791,3792,3,1155,577,0,3792,3793,3,1177,588,0,3793, + 3794,3,1147,573,0,3794,3795,3,1145,572,0,3795,610,1,0,0,0,3796,3797, + 3,1165,582,0,3797,3798,3,1139,569,0,3798,3799,3,1177,588,0,3799, + 3800,3,1155,577,0,3800,3801,3,1181,590,0,3801,3802,3,1147,573,0, + 3802,612,1,0,0,0,3803,3804,3,1165,582,0,3804,3805,3,1147,573,0,3805, + 3806,3,1151,575,0,3806,3807,3,1139,569,0,3807,3808,3,1177,588,0, + 3808,3809,3,1155,577,0,3809,3810,3,1181,590,0,3810,3811,3,1147,573, + 0,3811,614,1,0,0,0,3812,3813,3,1165,582,0,3813,3814,3,1147,573,0, + 3814,3815,3,1177,588,0,3815,3816,3,1183,591,0,3816,3817,3,1167,583, + 0,3817,3818,3,1173,586,0,3818,3819,3,1159,579,0,3819,616,1,0,0,0, + 3820,3821,3,1165,582,0,3821,3822,3,1147,573,0,3822,3823,3,1185,592, + 0,3823,3824,3,1177,588,0,3824,618,1,0,0,0,3825,3826,3,1165,582,0, + 3826,3827,3,1167,583,0,3827,620,1,0,0,0,3828,3829,3,1165,582,0,3829, + 3830,3,1167,583,0,3830,3831,3,1085,542,0,3831,3832,3,1147,573,0, + 3832,3833,3,1143,571,0,3833,3834,3,1153,576,0,3834,3835,3,1167,583, + 0,3835,622,1,0,0,0,3836,3837,3,1165,582,0,3837,3838,3,1167,583,0, + 3838,3839,3,1177,588,0,3839,624,1,0,0,0,3840,3841,3,1165,582,0,3841, + 3842,3,1179,589,0,3842,3843,3,1161,580,0,3843,3844,3,1161,580,0, + 3844,626,1,0,0,0,3845,3846,3,1165,582,0,3846,3847,3,1179,589,0,3847, + 3848,3,1161,580,0,3848,3849,3,1161,580,0,3849,3850,3,1175,587,0, + 3850,628,1,0,0,0,3851,3852,3,1165,582,0,3852,3853,3,1179,589,0,3853, + 3854,3,1163,581,0,3854,3855,3,1141,570,0,3855,3856,3,1147,573,0, + 3856,3857,3,1173,586,0,3857,630,1,0,0,0,3858,3859,3,1165,582,0,3859, + 3860,3,1179,589,0,3860,3861,3,1163,581,0,3861,3862,3,1147,573,0, + 3862,3863,3,1173,586,0,3863,3864,3,1155,577,0,3864,3865,3,1143,571, + 0,3865,632,1,0,0,0,3866,3867,3,1165,582,0,3867,3868,3,1179,589,0, + 3868,3869,3,1163,581,0,3869,3870,3,1147,573,0,3870,3871,3,1173,586, + 0,3871,3872,3,1155,577,0,3872,3873,3,1143,571,0,3873,3874,3,1085, + 542,0,3874,3875,3,1145,572,0,3875,3876,3,1139,569,0,3876,3877,3, + 1177,588,0,3877,3878,3,1147,573,0,3878,634,1,0,0,0,3879,3880,3,1165, + 582,0,3880,3881,3,1179,589,0,3881,3882,3,1163,581,0,3882,3883,3, + 1147,573,0,3883,3884,3,1173,586,0,3884,3885,3,1155,577,0,3885,3886, + 3,1143,571,0,3886,3887,3,1085,542,0,3887,3888,3,1147,573,0,3888, + 3889,3,1145,572,0,3889,3890,3,1155,577,0,3890,3891,3,1177,588,0, + 3891,3892,3,1147,573,0,3892,3893,3,1145,572,0,3893,636,1,0,0,0,3894, + 3895,3,1165,582,0,3895,3896,3,1179,589,0,3896,3897,3,1163,581,0, + 3897,3898,3,1147,573,0,3898,3899,3,1173,586,0,3899,3900,3,1155,577, + 0,3900,3901,3,1143,571,0,3901,3902,3,1085,542,0,3902,3903,3,1177, + 588,0,3903,3904,3,1155,577,0,3904,3905,3,1163,581,0,3905,3906,3, + 1147,573,0,3906,638,1,0,0,0,3907,3908,3,1167,583,0,3908,3909,3,1141, + 570,0,3909,3910,3,1157,578,0,3910,3911,3,1147,573,0,3911,3912,3, + 1143,571,0,3912,3913,3,1177,588,0,3913,3914,3,1085,542,0,3914,3915, + 3,1143,571,0,3915,3916,3,1167,583,0,3916,3917,3,1163,581,0,3917, + 3918,3,1169,584,0,3918,3919,3,1179,589,0,3919,3920,3,1177,588,0, + 3920,3921,3,1147,573,0,3921,3922,3,1173,586,0,3922,640,1,0,0,0,3923, + 3924,3,1167,583,0,3924,3925,3,1143,571,0,3925,3926,3,1143,571,0, + 3926,3927,3,1179,589,0,3927,3928,3,1173,586,0,3928,3929,3,1175,587, + 0,3929,642,1,0,0,0,3930,3931,3,1167,583,0,3931,3932,3,1145,572,0, + 3932,3933,3,1177,588,0,3933,644,1,0,0,0,3934,3935,3,1167,583,0,3935, + 3936,3,1149,574,0,3936,646,1,0,0,0,3937,3938,3,1167,583,0,3938,3939, + 3,1149,574,0,3939,3940,3,1149,574,0,3940,648,1,0,0,0,3941,3942,3, + 1167,583,0,3942,3943,3,1163,581,0,3943,3944,3,1155,577,0,3944,3945, + 3,1177,588,0,3945,3946,3,1177,588,0,3946,3947,3,1147,573,0,3947, + 3948,3,1145,572,0,3948,650,1,0,0,0,3949,3950,3,1167,583,0,3950,3951, + 3,1165,582,0,3951,652,1,0,0,0,3952,3953,3,1167,583,0,3953,3954,3, + 1169,584,0,3954,3955,3,1147,573,0,3955,3956,3,1165,582,0,3956,654, + 1,0,0,0,3957,3958,3,1167,583,0,3958,3959,3,1169,584,0,3959,3960, + 3,1177,588,0,3960,3961,3,1155,577,0,3961,3962,3,1167,583,0,3962, + 3963,3,1165,582,0,3963,3964,3,1139,569,0,3964,3965,3,1161,580,0, + 3965,656,1,0,0,0,3966,3967,3,1167,583,0,3967,3968,3,1173,586,0,3968, + 658,1,0,0,0,3969,3970,3,1167,583,0,3970,3971,3,1173,586,0,3971,3972, + 3,1145,572,0,3972,3973,3,1147,573,0,3973,3974,3,1173,586,0,3974, + 660,1,0,0,0,3975,3976,3,1167,583,0,3976,3977,3,1173,586,0,3977,3978, + 3,1145,572,0,3978,3979,3,1147,573,0,3979,3980,3,1173,586,0,3980, + 3981,3,1161,580,0,3981,3982,3,1187,593,0,3982,662,1,0,0,0,3983,3984, + 3,1167,583,0,3984,3985,3,1173,586,0,3985,3986,3,1151,575,0,3986, + 3987,3,1139,569,0,3987,3988,3,1165,582,0,3988,3989,3,1155,577,0, + 3989,3990,3,1189,594,0,3990,3991,3,1139,569,0,3991,3992,3,1177,588, + 0,3992,3993,3,1155,577,0,3993,3994,3,1167,583,0,3994,3995,3,1165, + 582,0,3995,664,1,0,0,0,3996,3997,3,1167,583,0,3997,3998,3,1177,588, + 0,3998,3999,3,1153,576,0,3999,4000,3,1147,573,0,4000,4001,3,1173, + 586,0,4001,666,1,0,0,0,4002,4003,3,1167,583,0,4003,4004,3,1179,589, + 0,4004,4005,3,1177,588,0,4005,4006,3,1169,584,0,4006,4007,3,1179, + 589,0,4007,4008,3,1177,588,0,4008,668,1,0,0,0,4009,4010,3,1167,583, + 0,4010,4011,3,1181,590,0,4011,4012,3,1147,573,0,4012,4013,3,1173, + 586,0,4013,4014,3,1149,574,0,4014,4015,3,1161,580,0,4015,4016,3, + 1167,583,0,4016,4017,3,1183,591,0,4017,670,1,0,0,0,4018,4019,3,1167, + 583,0,4019,4020,3,1181,590,0,4020,4021,3,1147,573,0,4021,4022,3, + 1173,586,0,4022,4023,3,1161,580,0,4023,4024,3,1155,577,0,4024,4025, + 3,1165,582,0,4025,4026,3,1147,573,0,4026,672,1,0,0,0,4027,4028,3, + 1167,583,0,4028,4029,3,1183,591,0,4029,4030,3,1165,582,0,4030,674, + 1,0,0,0,4031,4032,3,1169,584,0,4032,4033,3,1139,569,0,4033,4034, + 3,1143,571,0,4034,4035,3,1159,579,0,4035,4036,3,1147,573,0,4036, + 4037,3,1145,572,0,4037,4038,3,1085,542,0,4038,4039,3,1145,572,0, + 4039,4040,3,1147,573,0,4040,4041,3,1143,571,0,4041,4042,3,1155,577, + 0,4042,4043,3,1163,581,0,4043,4044,3,1139,569,0,4044,4045,3,1161, + 580,0,4045,676,1,0,0,0,4046,4047,3,1169,584,0,4047,4048,3,1139,569, + 0,4048,4049,3,1145,572,0,4049,4050,3,1145,572,0,4050,4051,3,1155, + 577,0,4051,4052,3,1165,582,0,4052,4053,3,1151,575,0,4053,678,1,0, + 0,0,4054,4055,3,1169,584,0,4055,4056,3,1139,569,0,4056,4057,3,1151, + 575,0,4057,4058,3,1147,573,0,4058,680,1,0,0,0,4059,4060,3,1169,584, + 0,4060,4061,3,1139,569,0,4061,4062,3,1151,575,0,4062,4063,3,1147, + 573,0,4063,4064,3,1085,542,0,4064,4065,3,1143,571,0,4065,4066,3, + 1167,583,0,4066,4067,3,1179,589,0,4067,4068,3,1165,582,0,4068,4069, + 3,1177,588,0,4069,4070,3,1147,573,0,4070,4071,3,1173,586,0,4071, + 682,1,0,0,0,4072,4073,3,1169,584,0,4073,4074,3,1139,569,0,4074,4075, + 3,1175,587,0,4075,4076,3,1175,587,0,4076,4077,3,1183,591,0,4077, + 4078,3,1167,583,0,4078,4079,3,1173,586,0,4079,4080,3,1145,572,0, + 4080,684,1,0,0,0,4081,4082,3,1169,584,0,4082,4083,3,1147,573,0,4083, + 4084,3,1173,586,0,4084,4085,3,1149,574,0,4085,4086,3,1167,583,0, + 4086,4087,3,1173,586,0,4087,4088,3,1163,581,0,4088,686,1,0,0,0,4089, + 4090,3,1169,584,0,4090,4091,3,1149,574,0,4091,688,1,0,0,0,4092,4093, + 3,1169,584,0,4093,4094,3,1153,576,0,4094,690,1,0,0,0,4095,4096,3, + 1169,584,0,4096,4097,3,1155,577,0,4097,4098,3,1143,571,0,4098,692, + 1,0,0,0,4099,4100,3,1169,584,0,4100,4101,3,1155,577,0,4101,4102, + 3,1143,571,0,4102,4103,3,1177,588,0,4103,4104,3,1179,589,0,4104, + 4105,3,1173,586,0,4105,4106,3,1147,573,0,4106,694,1,0,0,0,4107,4108, + 3,1169,584,0,4108,4109,3,1161,580,0,4109,4110,3,1179,589,0,4110, + 4111,3,1175,587,0,4111,696,1,0,0,0,4112,4113,3,1169,584,0,4113,4114, + 3,1167,583,0,4114,4115,3,1155,577,0,4115,4116,3,1165,582,0,4116, + 4117,3,1177,588,0,4117,4118,3,1147,573,0,4118,4119,3,1173,586,0, + 4119,698,1,0,0,0,4120,4121,3,1169,584,0,4121,4122,3,1167,583,0,4122, + 4123,3,1175,587,0,4123,4124,3,1155,577,0,4124,4125,3,1177,588,0, + 4125,4126,3,1155,577,0,4126,4127,3,1167,583,0,4127,4128,3,1165,582, + 0,4128,700,1,0,0,0,4129,4130,3,1169,584,0,4130,4131,3,1167,583,0, + 4131,4132,3,1175,587,0,4132,4133,3,1155,577,0,4133,4134,3,1177,588, + 0,4134,4135,3,1155,577,0,4135,4136,3,1181,590,0,4136,4137,3,1147, + 573,0,4137,702,1,0,0,0,4138,4139,3,1169,584,0,4139,4140,3,1167,583, + 0,4140,4141,3,1173,586,0,4141,4142,3,1177,588,0,4142,704,1,0,0,0, + 4143,4144,3,1169,584,0,4144,4145,3,1173,586,0,4145,4146,3,1155,577, + 0,4146,4147,3,1165,582,0,4147,4148,3,1177,588,0,4148,4149,3,1147, + 573,0,4149,4150,3,1173,586,0,4150,706,1,0,0,0,4151,4152,3,1169,584, + 0,4152,4153,3,1173,586,0,4153,4154,3,1155,577,0,4154,4155,3,1165, + 582,0,4155,4156,3,1177,588,0,4156,4157,3,1155,577,0,4157,4158,3, + 1165,582,0,4158,4159,3,1151,575,0,4159,708,1,0,0,0,4160,4161,3,1169, + 584,0,4161,4162,3,1173,586,0,4162,4163,3,1155,577,0,4163,4164,3, + 1181,590,0,4164,4165,3,1139,569,0,4165,4166,3,1177,588,0,4166,4167, + 3,1147,573,0,4167,710,1,0,0,0,4168,4169,3,1169,584,0,4169,4170,3, + 1173,586,0,4170,4171,3,1167,583,0,4171,4172,3,1143,571,0,4172,4173, + 3,1147,573,0,4173,4174,3,1145,572,0,4174,4175,3,1179,589,0,4175, + 4176,3,1173,586,0,4176,4177,3,1147,573,0,4177,712,1,0,0,0,4178,4179, + 3,1169,584,0,4179,4180,3,1173,586,0,4180,4181,3,1167,583,0,4181, + 4182,3,1143,571,0,4182,4183,3,1147,573,0,4183,4184,3,1145,572,0, + 4184,4185,3,1179,589,0,4185,4186,3,1173,586,0,4186,4187,3,1147,573, + 0,4187,4188,3,1085,542,0,4188,4189,3,1169,584,0,4189,4190,3,1167, + 583,0,4190,4191,3,1155,577,0,4191,4192,3,1165,582,0,4192,4193,3, + 1177,588,0,4193,4194,3,1147,573,0,4194,4195,3,1173,586,0,4195,714, + 1,0,0,0,4196,4197,3,1169,584,0,4197,4198,3,1173,586,0,4198,4199, + 3,1167,583,0,4199,4200,3,1143,571,0,4200,4201,3,1147,573,0,4201, + 4202,3,1145,572,0,4202,4203,3,1179,589,0,4203,4204,3,1173,586,0, + 4204,4205,3,1147,573,0,4205,4206,3,1175,587,0,4206,716,1,0,0,0,4207, + 4208,3,1169,584,0,4208,4209,3,1173,586,0,4209,4210,3,1167,583,0, + 4210,4211,3,1143,571,0,4211,4212,3,1147,573,0,4212,4213,3,1147,573, + 0,4213,4214,3,1145,572,0,4214,718,1,0,0,0,4215,4216,3,1169,584,0, + 4216,4217,3,1173,586,0,4217,4218,3,1167,583,0,4218,4219,3,1143,571, + 0,4219,4220,3,1147,573,0,4220,4221,3,1175,587,0,4221,4222,3,1175, + 587,0,4222,720,1,0,0,0,4223,4224,3,1169,584,0,4224,4225,3,1173,586, + 0,4225,4226,3,1167,583,0,4226,4227,3,1151,575,0,4227,4228,3,1173, + 586,0,4228,4229,3,1139,569,0,4229,4230,3,1163,581,0,4230,722,1,0, + 0,0,4231,4232,3,1169,584,0,4232,4233,3,1173,586,0,4233,4234,3,1167, + 583,0,4234,4235,3,1151,575,0,4235,4236,3,1173,586,0,4236,4237,3, + 1139,569,0,4237,4238,3,1163,581,0,4238,4239,3,1085,542,0,4239,4240, + 3,1155,577,0,4240,4241,3,1145,572,0,4241,724,1,0,0,0,4242,4243,3, + 1169,584,0,4243,4244,3,1173,586,0,4244,4245,3,1167,583,0,4245,4246, + 3,1151,575,0,4246,4247,3,1173,586,0,4247,4248,3,1139,569,0,4248, + 4249,3,1163,581,0,4249,4250,3,1085,542,0,4250,4251,3,1161,580,0, + 4251,4252,3,1155,577,0,4252,4253,3,1141,570,0,4253,4254,3,1173,586, + 0,4254,4255,3,1139,569,0,4255,4256,3,1173,586,0,4256,4257,3,1187, + 593,0,4257,726,1,0,0,0,4258,4259,3,1169,584,0,4259,4260,3,1173,586, + 0,4260,4261,3,1167,583,0,4261,4262,3,1163,581,0,4262,4263,3,1169, + 584,0,4263,4264,3,1177,588,0,4264,728,1,0,0,0,4265,4266,3,1169,584, + 0,4266,4267,3,1179,589,0,4267,4268,3,1173,586,0,4268,4269,3,1151, + 575,0,4269,4270,3,1147,573,0,4270,730,1,0,0,0,4271,4272,3,1171,585, + 0,4272,4273,3,1179,589,0,4273,4274,3,1147,573,0,4274,4275,3,1179, + 589,0,4275,4276,3,1147,573,0,4276,732,1,0,0,0,4277,4278,3,1171,585, + 0,4278,4279,3,1179,589,0,4279,4280,3,1167,583,0,4280,4281,3,1177, + 588,0,4281,4282,3,1147,573,0,4282,734,1,0,0,0,4283,4284,3,1171,585, + 0,4284,4285,3,1179,589,0,4285,4286,3,1167,583,0,4286,4287,3,1177, + 588,0,4287,4288,3,1147,573,0,4288,4289,3,1175,587,0,4289,736,1,0, + 0,0,4290,4291,3,1173,586,0,4291,4292,3,1139,569,0,4292,4293,3,1165, + 582,0,4293,4294,3,1145,572,0,4294,4295,3,1167,583,0,4295,4296,3, + 1163,581,0,4296,738,1,0,0,0,4297,4298,3,1173,586,0,4298,4299,3,1147, + 573,0,4299,4300,3,1139,569,0,4300,4301,3,1145,572,0,4301,4302,3, + 1147,573,0,4302,4303,3,1173,586,0,4303,740,1,0,0,0,4304,4305,3,1173, + 586,0,4305,4306,3,1147,573,0,4306,4307,3,1163,581,0,4307,4308,3, + 1167,583,0,4308,4309,3,1177,588,0,4309,4310,3,1147,573,0,4310,742, + 1,0,0,0,4311,4312,3,1173,586,0,4312,4313,3,1145,572,0,4313,744,1, + 0,0,0,4314,4315,3,1173,586,0,4315,4316,3,1147,573,0,4316,4317,3, + 1139,569,0,4317,4318,3,1161,580,0,4318,746,1,0,0,0,4319,4320,3,1173, + 586,0,4320,4321,3,1147,573,0,4321,4322,3,1139,569,0,4322,4323,3, + 1145,572,0,4323,748,1,0,0,0,4324,4325,3,1173,586,0,4325,4326,3,1147, + 573,0,4326,4327,3,1143,571,0,4327,4328,3,1147,573,0,4328,4329,3, + 1155,577,0,4329,4330,3,1181,590,0,4330,4331,3,1147,573,0,4331,750, + 1,0,0,0,4332,4333,3,1173,586,0,4333,4334,3,1147,573,0,4334,4335, + 3,1143,571,0,4335,4336,3,1147,573,0,4336,4337,3,1155,577,0,4337, + 4338,3,1181,590,0,4338,4339,3,1147,573,0,4339,4340,3,1145,572,0, + 4340,752,1,0,0,0,4341,4342,3,1173,586,0,4342,4343,3,1147,573,0,4343, + 4344,3,1143,571,0,4344,4345,3,1167,583,0,4345,4346,3,1173,586,0, + 4346,4347,3,1145,572,0,4347,754,1,0,0,0,4348,4349,3,1173,586,0,4349, + 4350,3,1147,573,0,4350,4351,3,1143,571,0,4351,4352,3,1167,583,0, + 4352,4353,3,1173,586,0,4353,4354,3,1145,572,0,4354,4355,3,1155,577, + 0,4355,4356,3,1165,582,0,4356,4357,3,1151,575,0,4357,756,1,0,0,0, + 4358,4359,3,1173,586,0,4359,4360,3,1147,573,0,4360,4361,3,1143,571, + 0,4361,4362,3,1167,583,0,4362,4363,3,1173,586,0,4363,4364,3,1145, + 572,0,4364,4365,3,1175,587,0,4365,758,1,0,0,0,4366,4367,3,1173,586, + 0,4367,4368,3,1147,573,0,4368,4369,3,1143,571,0,4369,4370,3,1179, + 589,0,4370,4371,3,1173,586,0,4371,4372,3,1175,587,0,4372,4373,3, + 1155,577,0,4373,4374,3,1181,590,0,4374,4375,3,1147,573,0,4375,760, + 1,0,0,0,4376,4377,3,1173,586,0,4377,4378,3,1147,573,0,4378,4379, + 3,1145,572,0,4379,4380,3,1147,573,0,4380,4381,3,1149,574,0,4381, + 4382,3,1155,577,0,4382,4383,3,1165,582,0,4383,4384,3,1147,573,0, + 4384,4385,3,1175,587,0,4385,762,1,0,0,0,4386,4387,3,1173,586,0,4387, + 4388,3,1147,573,0,4388,4389,3,1147,573,0,4389,4390,3,1161,580,0, + 4390,764,1,0,0,0,4391,4392,3,1173,586,0,4392,4393,3,1147,573,0,4393, + 4394,3,1149,574,0,4394,766,1,0,0,0,4395,4396,3,1173,586,0,4396,4397, + 3,1147,573,0,4397,4398,3,1149,574,0,4398,4399,3,1147,573,0,4399, + 4400,3,1173,586,0,4400,4401,3,1147,573,0,4401,4402,3,1165,582,0, + 4402,4403,3,1143,571,0,4403,4404,3,1147,573,0,4404,768,1,0,0,0,4405, + 4406,3,1173,586,0,4406,4407,3,1147,573,0,4407,4408,3,1149,574,0, + 4408,4409,3,1147,573,0,4409,4410,3,1173,586,0,4410,4411,3,1147,573, + 0,4411,4412,3,1165,582,0,4412,4413,3,1143,571,0,4413,4414,3,1147, + 573,0,4414,4415,3,1175,587,0,4415,770,1,0,0,0,4416,4417,3,1173,586, + 0,4417,4418,3,1147,573,0,4418,4419,3,1161,580,0,4419,4420,3,1139, + 569,0,4420,4421,3,1177,588,0,4421,4422,3,1155,577,0,4422,4423,3, + 1181,590,0,4423,4424,3,1147,573,0,4424,772,1,0,0,0,4425,4426,3,1173, + 586,0,4426,4427,3,1147,573,0,4427,4428,3,1161,580,0,4428,4429,3, + 1147,573,0,4429,4430,3,1139,569,0,4430,4431,3,1175,587,0,4431,4432, + 3,1147,573,0,4432,774,1,0,0,0,4433,4434,3,1173,586,0,4434,4435,3, + 1147,573,0,4435,4436,3,1163,581,0,4436,4437,3,1139,569,0,4437,4438, + 3,1155,577,0,4438,4439,3,1165,582,0,4439,4440,3,1145,572,0,4440, + 4441,3,1147,573,0,4441,4442,3,1173,586,0,4442,776,1,0,0,0,4443,4444, + 3,1173,586,0,4444,4445,3,1147,573,0,4445,4446,3,1163,581,0,4446, + 4447,3,1139,569,0,4447,4448,3,1173,586,0,4448,4449,3,1159,579,0, + 4449,4450,3,1175,587,0,4450,778,1,0,0,0,4451,4452,3,1173,586,0,4452, + 4453,3,1147,573,0,4453,4454,3,1163,581,0,4454,4455,3,1167,583,0, + 4455,4456,3,1181,590,0,4456,4457,3,1139,569,0,4457,4458,3,1161,580, + 0,4458,780,1,0,0,0,4459,4460,3,1173,586,0,4460,4461,3,1147,573,0, + 4461,4462,3,1163,581,0,4462,4463,3,1167,583,0,4463,4464,3,1181,590, + 0,4464,4465,3,1147,573,0,4465,782,1,0,0,0,4466,4467,3,1173,586,0, + 4467,4468,3,1147,573,0,4468,4469,3,1165,582,0,4469,4470,3,1139,569, + 0,4470,4471,3,1163,581,0,4471,4472,3,1147,573,0,4472,4473,3,1175, + 587,0,4473,784,1,0,0,0,4474,4475,3,1173,586,0,4475,4476,3,1147,573, + 0,4476,4477,3,1169,584,0,4477,4478,3,1161,580,0,4478,4479,3,1139, + 569,0,4479,4480,3,1143,571,0,4480,4481,3,1147,573,0,4481,786,1,0, + 0,0,4482,4483,3,1173,586,0,4483,4484,3,1147,573,0,4484,4485,3,1169, + 584,0,4485,4486,3,1161,580,0,4486,4487,3,1139,569,0,4487,4488,3, + 1143,571,0,4488,4489,3,1155,577,0,4489,4490,3,1165,582,0,4490,4491, + 3,1151,575,0,4491,788,1,0,0,0,4492,4493,3,1173,586,0,4493,4494,3, + 1147,573,0,4494,4495,3,1169,584,0,4495,4496,3,1167,583,0,4496,4497, + 3,1173,586,0,4497,4498,3,1177,588,0,4498,790,1,0,0,0,4499,4500,3, + 1173,586,0,4500,4501,3,1147,573,0,4501,4502,3,1169,584,0,4502,4503, + 3,1167,583,0,4503,4504,3,1173,586,0,4504,4505,3,1177,588,0,4505, + 4506,3,1155,577,0,4506,4507,3,1165,582,0,4507,4508,3,1151,575,0, + 4508,792,1,0,0,0,4509,4510,3,1173,586,0,4510,4511,3,1147,573,0,4511, + 4512,3,1169,584,0,4512,4513,3,1167,583,0,4513,4514,3,1173,586,0, + 4514,4515,3,1177,588,0,4515,4516,3,1175,587,0,4516,794,1,0,0,0,4517, + 4518,3,1173,586,0,4518,4519,3,1147,573,0,4519,4520,3,1171,585,0, + 4520,4521,3,1179,589,0,4521,4522,3,1155,577,0,4522,4523,3,1173,586, + 0,4523,4524,3,1147,573,0,4524,4525,3,1145,572,0,4525,796,1,0,0,0, + 4526,4527,3,1173,586,0,4527,4528,3,1147,573,0,4528,4529,3,1173,586, + 0,4529,4530,3,1179,589,0,4530,4531,3,1165,582,0,4531,798,1,0,0,0, + 4532,4533,3,1173,586,0,4533,4534,3,1147,573,0,4534,4535,3,1175,587, + 0,4535,4536,3,1147,573,0,4536,4537,3,1173,586,0,4537,4538,3,1181, + 590,0,4538,4539,3,1147,573,0,4539,800,1,0,0,0,4540,4541,3,1173,586, + 0,4541,4542,3,1147,573,0,4542,4543,3,1175,587,0,4543,4544,3,1147, + 573,0,4544,4545,3,1173,586,0,4545,4546,3,1181,590,0,4546,4547,3, + 1147,573,0,4547,4548,3,1085,542,0,4548,4549,3,1181,590,0,4549,4550, + 3,1155,577,0,4550,4551,3,1145,572,0,4551,4552,3,1147,573,0,4552, + 4553,3,1167,583,0,4553,802,1,0,0,0,4554,4555,3,1173,586,0,4555,4556, + 3,1147,573,0,4556,4557,3,1175,587,0,4557,4558,3,1147,573,0,4558, + 4559,3,1177,588,0,4559,804,1,0,0,0,4560,4561,3,1173,586,0,4561,4562, + 3,1147,573,0,4562,4563,3,1177,588,0,4563,4564,3,1179,589,0,4564, + 4565,3,1173,586,0,4565,4566,3,1165,582,0,4566,806,1,0,0,0,4567,4568, + 3,1173,586,0,4568,4569,3,1147,573,0,4569,4570,3,1177,588,0,4570, + 4571,3,1179,589,0,4571,4572,3,1173,586,0,4572,4573,3,1165,582,0, + 4573,4574,3,1085,542,0,4574,4575,3,1143,571,0,4575,4576,3,1167,583, + 0,4576,4577,3,1145,572,0,4577,4578,3,1147,573,0,4578,808,1,0,0,0, + 4579,4580,3,1173,586,0,4580,4581,3,1147,573,0,4581,4582,3,1177,588, + 0,4582,4583,3,1179,589,0,4583,4584,3,1173,586,0,4584,4585,3,1165, + 582,0,4585,4586,3,1155,577,0,4586,4587,3,1165,582,0,4587,4588,3, + 1151,575,0,4588,810,1,0,0,0,4589,4590,3,1173,586,0,4590,4591,3,1147, + 573,0,4591,4592,3,1181,590,0,4592,4593,3,1147,573,0,4593,4594,3, + 1173,586,0,4594,4595,3,1175,587,0,4595,4596,3,1147,573,0,4596,4597, + 3,1145,572,0,4597,812,1,0,0,0,4598,4599,3,1173,586,0,4599,4600,3, + 1147,573,0,4600,4601,3,1183,591,0,4601,4602,3,1155,577,0,4602,4603, + 3,1165,582,0,4603,4604,3,1145,572,0,4604,814,1,0,0,0,4605,4606,3, + 1173,586,0,4606,4607,3,1147,573,0,4607,4608,3,1183,591,0,4608,4609, + 3,1173,586,0,4609,4610,3,1155,577,0,4610,4611,3,1177,588,0,4611, + 4612,3,1147,573,0,4612,816,1,0,0,0,4613,4614,3,1173,586,0,4614,4615, + 3,1149,574,0,4615,818,1,0,0,0,4616,4617,3,1173,586,0,4617,4618,3, + 1153,576,0,4618,820,1,0,0,0,4619,4620,3,1173,586,0,4620,4621,3,1155, + 577,0,4621,4622,3,1151,575,0,4622,4623,3,1153,576,0,4623,4624,3, + 1177,588,0,4624,822,1,0,0,0,4625,4626,3,1173,586,0,4626,4627,3,1167, + 583,0,4627,4628,3,1179,589,0,4628,4629,3,1165,582,0,4629,4630,3, + 1145,572,0,4630,4631,3,1147,573,0,4631,4632,3,1145,572,0,4632,824, + 1,0,0,0,4633,4634,3,1173,586,0,4634,4635,3,1179,589,0,4635,4636, + 3,1165,582,0,4636,826,1,0,0,0,4637,4638,3,1175,587,0,4638,4639,3, + 1139,569,0,4639,4640,3,1163,581,0,4640,4641,3,1147,573,0,4641,828, + 1,0,0,0,4642,4643,3,1175,587,0,4643,4644,3,1139,569,0,4644,4645, + 3,1181,590,0,4645,4646,3,1147,573,0,4646,830,1,0,0,0,4647,4648,3, + 1175,587,0,4648,4649,3,1143,571,0,4649,4650,3,1173,586,0,4650,4651, + 3,1147,573,0,4651,4652,3,1147,573,0,4652,4653,3,1165,582,0,4653, + 832,1,0,0,0,4654,4655,3,1175,587,0,4655,4656,3,1145,572,0,4656,834, + 1,0,0,0,4657,4658,3,1175,587,0,4658,4659,3,1147,573,0,4659,4660, + 3,1139,569,0,4660,4661,3,1173,586,0,4661,4662,3,1143,571,0,4662, + 4663,3,1153,576,0,4663,836,1,0,0,0,4664,4665,3,1175,587,0,4665,4666, + 3,1147,573,0,4666,4667,3,1143,571,0,4667,4668,3,1177,588,0,4668, + 4669,3,1155,577,0,4669,4670,3,1167,583,0,4670,4671,3,1165,582,0, + 4671,838,1,0,0,0,4672,4673,3,1175,587,0,4673,4674,3,1147,573,0,4674, + 4675,3,1143,571,0,4675,4676,3,1179,589,0,4676,4677,3,1173,586,0, + 4677,4678,3,1147,573,0,4678,840,1,0,0,0,4679,4680,3,1175,587,0,4680, + 4681,3,1147,573,0,4681,4682,3,1143,571,0,4682,4683,3,1179,589,0, + 4683,4684,3,1173,586,0,4684,4685,3,1155,577,0,4685,4686,3,1177,588, + 0,4686,4687,3,1187,593,0,4687,842,1,0,0,0,4688,4689,3,1175,587,0, + 4689,4690,3,1147,573,0,4690,4691,3,1151,575,0,4691,4692,3,1163,581, + 0,4692,4693,3,1147,573,0,4693,4694,3,1165,582,0,4694,4695,3,1177, + 588,0,4695,844,1,0,0,0,4696,4697,3,1175,587,0,4697,4698,3,1147,573, + 0,4698,4699,3,1151,575,0,4699,4700,3,1163,581,0,4700,4701,3,1147, + 573,0,4701,4702,3,1165,582,0,4702,4703,3,1177,588,0,4703,4704,3, + 1085,542,0,4704,4705,3,1161,580,0,4705,4706,3,1155,577,0,4706,4707, + 3,1163,581,0,4707,4708,3,1155,577,0,4708,4709,3,1177,588,0,4709, + 846,1,0,0,0,4710,4711,3,1175,587,0,4711,4712,3,1147,573,0,4712,4713, + 3,1161,580,0,4713,4714,3,1147,573,0,4714,4715,3,1143,571,0,4715, + 4716,3,1177,588,0,4716,848,1,0,0,0,4717,4718,3,1175,587,0,4718,4719, + 3,1147,573,0,4719,4720,3,1165,582,0,4720,4721,3,1145,572,0,4721, + 850,1,0,0,0,4722,4723,3,1175,587,0,4723,4724,3,1147,573,0,4724,4725, + 3,1165,582,0,4725,4726,3,1177,588,0,4726,4727,3,1147,573,0,4727, + 4728,3,1165,582,0,4728,4729,3,1143,571,0,4729,4730,3,1147,573,0, + 4730,852,1,0,0,0,4731,4732,3,1175,587,0,4732,4733,3,1147,573,0,4733, + 4734,3,1169,584,0,4734,4735,3,1139,569,0,4735,4736,3,1173,586,0, + 4736,4737,3,1139,569,0,4737,4738,3,1177,588,0,4738,4739,3,1147,573, + 0,4739,854,1,0,0,0,4740,4741,3,1175,587,0,4741,4742,3,1147,573,0, + 4742,4743,3,1171,585,0,4743,4744,3,1179,589,0,4744,4745,3,1147,573, + 0,4745,4746,3,1165,582,0,4746,4747,3,1143,571,0,4747,4748,3,1147, + 573,0,4748,856,1,0,0,0,4749,4750,3,1175,587,0,4750,4751,3,1147,573, + 0,4751,4752,3,1171,585,0,4752,4753,3,1179,589,0,4753,4754,3,1147, + 573,0,4754,4755,3,1165,582,0,4755,4756,3,1177,588,0,4756,4757,3, + 1155,577,0,4757,4758,3,1139,569,0,4758,4759,3,1161,580,0,4759,858, + 1,0,0,0,4760,4761,3,1175,587,0,4761,4762,3,1147,573,0,4762,4763, + 3,1177,588,0,4763,860,1,0,0,0,4764,4765,3,1175,587,0,4765,4766,3, + 1153,576,0,4766,4767,3,1139,569,0,4767,4768,3,1173,586,0,4768,4769, + 3,1147,573,0,4769,4770,3,1145,572,0,4770,862,1,0,0,0,4771,4772,3, + 1175,587,0,4772,4773,3,1153,576,0,4773,4774,3,1139,569,0,4774,4775, + 3,1173,586,0,4775,4776,3,1147,573,0,4776,4777,3,1145,572,0,4777, + 4778,3,1141,570,0,4778,4779,3,1187,593,0,4779,4780,3,1139,569,0, + 4780,4781,3,1161,580,0,4781,4782,3,1161,580,0,4782,864,1,0,0,0,4783, + 4784,3,1175,587,0,4784,4785,3,1153,576,0,4785,4786,3,1139,569,0, + 4786,4787,3,1173,586,0,4787,4788,3,1147,573,0,4788,4789,3,1145,572, + 0,4789,4790,3,1141,570,0,4790,4791,3,1187,593,0,4791,4792,3,1173, + 586,0,4792,4793,3,1179,589,0,4793,4794,3,1165,582,0,4794,4795,3, + 1179,589,0,4795,4796,3,1165,582,0,4796,4797,3,1155,577,0,4797,4798, + 3,1177,588,0,4798,866,1,0,0,0,4799,4800,3,1175,587,0,4800,4801,3, + 1153,576,0,4801,4802,3,1139,569,0,4802,4803,3,1173,586,0,4803,4804, + 3,1155,577,0,4804,4805,3,1165,582,0,4805,4806,3,1151,575,0,4806, + 868,1,0,0,0,4807,4808,3,1175,587,0,4808,4809,3,1153,576,0,4809,4810, + 3,1155,577,0,4810,4811,3,1149,574,0,4811,4812,3,1177,588,0,4812, + 4813,3,1085,542,0,4813,4814,3,1155,577,0,4814,4815,3,1165,582,0, + 4815,870,1,0,0,0,4816,4817,3,1175,587,0,4817,4818,3,1153,576,0,4818, + 4819,3,1155,577,0,4819,4820,3,1149,574,0,4820,4821,3,1177,588,0, + 4821,4822,3,1085,542,0,4822,4823,3,1167,583,0,4823,4824,3,1179,589, + 0,4824,4825,3,1177,588,0,4825,872,1,0,0,0,4826,4827,3,1175,587,0, + 4827,4828,3,1153,576,0,4828,4829,3,1167,583,0,4829,4830,3,1173,586, + 0,4830,4831,3,1177,588,0,4831,4832,3,1085,542,0,4832,4833,3,1145, + 572,0,4833,4834,3,1139,569,0,4834,4835,3,1177,588,0,4835,4836,3, + 1147,573,0,4836,874,1,0,0,0,4837,4838,3,1175,587,0,4838,4839,3,1155, + 577,0,4839,4840,3,1151,575,0,4840,4841,3,1165,582,0,4841,876,1,0, + 0,0,4842,4843,3,1175,587,0,4843,4844,3,1155,577,0,4844,4845,3,1189, + 594,0,4845,4846,3,1147,573,0,4846,878,1,0,0,0,4847,4848,3,1175,587, + 0,4848,4849,3,1167,583,0,4849,4850,3,1173,586,0,4850,4851,3,1177, + 588,0,4851,880,1,0,0,0,4852,4853,3,1175,587,0,4853,4854,3,1167,583, + 0,4854,4855,3,1173,586,0,4855,4856,3,1177,588,0,4856,4857,3,1085, + 542,0,4857,4858,3,1143,571,0,4858,4859,3,1167,583,0,4859,4860,3, + 1165,582,0,4860,4861,3,1177,588,0,4861,4862,3,1173,586,0,4862,4863, + 3,1167,583,0,4863,4864,3,1161,580,0,4864,882,1,0,0,0,4865,4866,3, + 1175,587,0,4866,4867,3,1167,583,0,4867,4868,3,1173,586,0,4868,4869, + 3,1177,588,0,4869,4870,3,1085,542,0,4870,4871,3,1143,571,0,4871, + 4872,3,1167,583,0,4872,4873,3,1173,586,0,4873,4874,3,1147,573,0, + 4874,4875,3,1085,542,0,4875,4876,3,1175,587,0,4876,4877,3,1155,577, + 0,4877,4878,3,1189,594,0,4878,4879,3,1147,573,0,4879,884,1,0,0,0, + 4880,4881,3,1175,587,0,4881,4882,3,1167,583,0,4882,4883,3,1173,586, + 0,4883,4884,3,1177,588,0,4884,4885,3,1085,542,0,4885,4886,3,1149, + 574,0,4886,4887,3,1155,577,0,4887,4888,3,1161,580,0,4888,4889,3, + 1147,573,0,4889,4890,3,1085,542,0,4890,4891,3,1175,587,0,4891,4892, + 3,1155,577,0,4892,4893,3,1189,594,0,4893,4894,3,1147,573,0,4894, + 886,1,0,0,0,4895,4896,3,1175,587,0,4896,4897,3,1167,583,0,4897,4898, + 3,1173,586,0,4898,4899,3,1177,588,0,4899,4900,3,1085,542,0,4900, + 4901,3,1163,581,0,4901,4902,3,1147,573,0,4902,4903,3,1173,586,0, + 4903,4904,3,1151,575,0,4904,4905,3,1147,573,0,4905,888,1,0,0,0,4906, + 4907,3,1175,587,0,4907,4908,3,1167,583,0,4908,4909,3,1173,586,0, + 4909,4910,3,1177,588,0,4910,4911,3,1085,542,0,4911,4912,3,1163,581, + 0,4912,4913,3,1147,573,0,4913,4914,3,1175,587,0,4914,4915,3,1175, + 587,0,4915,4916,3,1139,569,0,4916,4917,3,1151,575,0,4917,4918,3, + 1147,573,0,4918,890,1,0,0,0,4919,4920,3,1175,587,0,4920,4921,3,1167, + 583,0,4921,4922,3,1173,586,0,4922,4923,3,1177,588,0,4923,4924,3, + 1085,542,0,4924,4925,3,1163,581,0,4925,4926,3,1167,583,0,4926,4927, + 3,1145,572,0,4927,4928,3,1147,573,0,4928,4929,3,1085,542,0,4929, + 4930,3,1175,587,0,4930,4931,3,1155,577,0,4931,4932,3,1189,594,0, + 4932,4933,3,1147,573,0,4933,892,1,0,0,0,4934,4935,3,1175,587,0,4935, + 4936,3,1167,583,0,4936,4937,3,1173,586,0,4937,4938,3,1177,588,0, + 4938,4939,3,1085,542,0,4939,4940,3,1173,586,0,4940,4941,3,1147,573, + 0,4941,4942,3,1177,588,0,4942,4943,3,1179,589,0,4943,4944,3,1173, + 586,0,4944,4945,3,1165,582,0,4945,894,1,0,0,0,4946,4947,3,1175,587, + 0,4947,4948,3,1167,583,0,4948,4949,3,1179,589,0,4949,4950,3,1173, + 586,0,4950,4951,3,1143,571,0,4951,4952,3,1147,573,0,4952,896,1,0, + 0,0,4953,4954,3,1175,587,0,4954,4955,3,1167,583,0,4955,4956,3,1179, + 589,0,4956,4957,3,1173,586,0,4957,4958,3,1143,571,0,4958,4959,3, + 1147,573,0,4959,4960,3,1085,542,0,4960,4961,3,1143,571,0,4961,4962, + 3,1167,583,0,4962,4963,3,1163,581,0,4963,4964,3,1169,584,0,4964, + 4965,3,1179,589,0,4965,4966,3,1177,588,0,4966,4967,3,1147,573,0, + 4967,4968,3,1173,586,0,4968,898,1,0,0,0,4969,4970,3,1175,587,0,4970, + 4971,3,1169,584,0,4971,4972,3,1139,569,0,4972,4973,3,1143,571,0, + 4973,4974,3,1147,573,0,4974,900,1,0,0,0,4975,4976,3,1175,587,0,4976, + 4977,3,1169,584,0,4977,4978,3,1139,569,0,4978,4979,3,1143,571,0, + 4979,4980,3,1147,573,0,4980,4981,3,1175,587,0,4981,902,1,0,0,0,4982, + 4983,3,1175,587,0,4983,4984,3,1169,584,0,4984,4985,3,1147,573,0, + 4985,4986,3,1143,571,0,4986,4987,3,1155,577,0,4987,4988,3,1139,569, + 0,4988,4989,3,1161,580,0,4989,4990,3,1085,542,0,4990,4991,3,1165, + 582,0,4991,4992,3,1139,569,0,4992,4993,3,1163,581,0,4993,4994,3, + 1147,573,0,4994,4995,3,1175,587,0,4995,904,1,0,0,0,4996,4997,3,1175, + 587,0,4997,4998,3,1177,588,0,4998,4999,3,1139,569,0,4999,5000,3, + 1165,582,0,5000,5001,3,1145,572,0,5001,5002,3,1139,569,0,5002,5003, + 3,1173,586,0,5003,5004,3,1145,572,0,5004,906,1,0,0,0,5005,5006,3, + 1175,587,0,5006,5007,3,1177,588,0,5007,5008,3,1139,569,0,5008,5009, + 3,1165,582,0,5009,5010,3,1145,572,0,5010,5011,3,1139,569,0,5011, + 5012,3,1173,586,0,5012,5013,3,1145,572,0,5013,5014,3,1085,542,0, + 5014,5015,5,49,0,0,5015,908,1,0,0,0,5016,5017,3,1175,587,0,5017, + 5018,3,1177,588,0,5018,5019,3,1139,569,0,5019,5020,3,1165,582,0, + 5020,5021,3,1145,572,0,5021,5022,3,1139,569,0,5022,5023,3,1173,586, + 0,5023,5024,3,1145,572,0,5024,5025,3,1085,542,0,5025,5026,5,50,0, + 0,5026,910,1,0,0,0,5027,5028,3,1175,587,0,5028,5029,3,1177,588,0, + 5029,5030,3,1139,569,0,5030,5031,3,1173,586,0,5031,5032,3,1177,588, + 0,5032,912,1,0,0,0,5033,5034,3,1175,587,0,5034,5035,3,1177,588,0, + 5035,5036,3,1139,569,0,5036,5037,3,1177,588,0,5037,5038,3,1179,589, + 0,5038,5039,3,1175,587,0,5039,914,1,0,0,0,5040,5041,3,1175,587,0, + 5041,5042,3,1177,588,0,5042,5043,3,1167,583,0,5043,5044,3,1169,584, + 0,5044,916,1,0,0,0,5045,5046,3,1175,587,0,5046,5047,3,1177,588,0, + 5047,5048,3,1173,586,0,5048,5049,3,1155,577,0,5049,5050,3,1165,582, + 0,5050,5051,3,1151,575,0,5051,918,1,0,0,0,5052,5053,3,1175,587,0, + 5053,5054,3,1179,589,0,5054,5055,3,1141,570,0,5055,5056,3,1085,542, + 0,5056,5057,3,1171,585,0,5057,5058,3,1179,589,0,5058,5059,3,1147, + 573,0,5059,5060,3,1179,589,0,5060,5061,3,1147,573,0,5061,5062,3, + 1085,542,0,5062,5063,5,49,0,0,5063,920,1,0,0,0,5064,5065,3,1175, + 587,0,5065,5066,3,1179,589,0,5066,5067,3,1141,570,0,5067,5068,3, + 1085,542,0,5068,5069,3,1171,585,0,5069,5070,3,1179,589,0,5070,5071, + 3,1147,573,0,5071,5072,3,1179,589,0,5072,5073,3,1147,573,0,5073, + 5074,3,1085,542,0,5074,5075,5,50,0,0,5075,922,1,0,0,0,5076,5077, + 3,1175,587,0,5077,5078,3,1179,589,0,5078,5079,3,1141,570,0,5079, + 5080,3,1085,542,0,5080,5081,3,1171,585,0,5081,5082,3,1179,589,0, + 5082,5083,3,1147,573,0,5083,5084,3,1179,589,0,5084,5085,3,1147,573, + 0,5085,5086,3,1085,542,0,5086,5087,5,51,0,0,5087,924,1,0,0,0,5088, + 5089,3,1175,587,0,5089,5090,3,1179,589,0,5090,5091,3,1141,570,0, + 5091,5092,3,1177,588,0,5092,5093,3,1173,586,0,5093,5094,3,1139,569, + 0,5094,5095,3,1143,571,0,5095,5096,3,1177,588,0,5096,926,1,0,0,0, + 5097,5098,3,1175,587,0,5098,5099,3,1179,589,0,5099,5100,3,1163,581, + 0,5100,928,1,0,0,0,5101,5102,3,1175,587,0,5102,5103,3,1179,589,0, + 5103,5104,3,1169,584,0,5104,5105,3,1169,584,0,5105,5106,3,1173,586, + 0,5106,5107,3,1147,573,0,5107,5108,3,1175,587,0,5108,5109,3,1175, + 587,0,5109,930,1,0,0,0,5110,5111,3,1175,587,0,5111,5112,3,1187,593, + 0,5112,5113,3,1163,581,0,5113,5114,3,1141,570,0,5114,5115,3,1167, + 583,0,5115,5116,3,1161,580,0,5116,932,1,0,0,0,5117,5118,3,1175,587, + 0,5118,5119,3,1187,593,0,5119,5120,3,1163,581,0,5120,5121,3,1141, + 570,0,5121,5122,3,1167,583,0,5122,5123,3,1161,580,0,5123,5124,3, + 1155,577,0,5124,5125,3,1143,571,0,5125,934,1,0,0,0,5126,5127,3,1175, + 587,0,5127,5128,3,1187,593,0,5128,5129,3,1165,582,0,5129,5130,3, + 1143,571,0,5130,936,1,0,0,0,5131,5132,3,1175,587,0,5132,5133,3,1187, + 593,0,5133,5134,3,1165,582,0,5134,5135,3,1143,571,0,5135,5136,3, + 1153,576,0,5136,5137,3,1173,586,0,5137,5138,3,1167,583,0,5138,5139, + 3,1165,582,0,5139,5140,3,1155,577,0,5140,5141,3,1189,594,0,5141, + 5142,3,1147,573,0,5142,5143,3,1145,572,0,5143,938,1,0,0,0,5144,5145, + 3,1177,588,0,5145,5146,3,1139,569,0,5146,5147,3,1141,570,0,5147, + 5148,3,1161,580,0,5148,5149,3,1147,573,0,5149,940,1,0,0,0,5150,5151, + 3,1177,588,0,5151,5152,3,1139,569,0,5152,5153,3,1161,580,0,5153, + 5154,3,1161,580,0,5154,5155,3,1187,593,0,5155,942,1,0,0,0,5156,5157, + 3,1177,588,0,5157,5158,3,1139,569,0,5158,5159,3,1161,580,0,5159, + 5160,3,1161,580,0,5160,5161,3,1187,593,0,5161,5162,3,1155,577,0, + 5162,5163,3,1165,582,0,5163,5164,3,1151,575,0,5164,944,1,0,0,0,5165, + 5166,3,1177,588,0,5166,5167,3,1139,569,0,5167,5168,3,1175,587,0, + 5168,5169,3,1159,579,0,5169,946,1,0,0,0,5170,5171,3,1177,588,0,5171, + 5172,3,1139,569,0,5172,5173,3,1169,584,0,5173,5174,3,1147,573,0, + 5174,948,1,0,0,0,5175,5176,3,1177,588,0,5176,5177,3,1147,573,0,5177, + 5178,3,1173,586,0,5178,5179,3,1163,581,0,5179,5180,3,1155,577,0, + 5180,5181,3,1165,582,0,5181,5182,3,1139,569,0,5182,5183,3,1161,580, + 0,5183,950,1,0,0,0,5184,5185,3,1177,588,0,5185,5186,3,1147,573,0, + 5186,5187,3,1173,586,0,5187,5188,3,1163,581,0,5188,5189,3,1155,577, + 0,5189,5190,3,1165,582,0,5190,5191,3,1139,569,0,5191,5192,3,1177, + 588,0,5192,5193,3,1147,573,0,5193,952,1,0,0,0,5194,5195,3,1177,588, + 0,5195,5196,3,1147,573,0,5196,5197,3,1175,587,0,5197,5198,3,1177, + 588,0,5198,954,1,0,0,0,5199,5200,3,1177,588,0,5200,5201,3,1147,573, + 0,5201,5202,3,1185,592,0,5202,5203,3,1177,588,0,5203,956,1,0,0,0, + 5204,5205,3,1177,588,0,5205,5206,3,1153,576,0,5206,5207,3,1139,569, + 0,5207,5208,3,1165,582,0,5208,958,1,0,0,0,5209,5210,3,1177,588,0, + 5210,5211,3,1153,576,0,5211,5212,3,1147,573,0,5212,5213,3,1165,582, + 0,5213,960,1,0,0,0,5214,5215,3,1177,588,0,5215,5216,3,1153,576,0, + 5216,5217,3,1173,586,0,5217,5218,3,1147,573,0,5218,5219,3,1139,569, + 0,5219,5220,3,1145,572,0,5220,962,1,0,0,0,5221,5222,3,1177,588,0, + 5222,5223,3,1153,576,0,5223,5224,3,1173,586,0,5224,5225,3,1147,573, + 0,5225,5226,3,1139,569,0,5226,5227,3,1145,572,0,5227,5228,3,1085, + 542,0,5228,5229,3,1161,580,0,5229,5230,3,1167,583,0,5230,5231,3, + 1143,571,0,5231,5232,3,1139,569,0,5232,5233,3,1161,580,0,5233,964, + 1,0,0,0,5234,5235,3,1177,588,0,5235,5236,3,1153,576,0,5236,5237, + 3,1173,586,0,5237,5238,3,1167,583,0,5238,5239,3,1179,589,0,5239, + 5240,3,1151,575,0,5240,5241,3,1153,576,0,5241,966,1,0,0,0,5242,5243, + 3,1177,588,0,5243,5244,3,1153,576,0,5244,5245,3,1173,586,0,5245, + 5246,3,1179,589,0,5246,968,1,0,0,0,5247,5248,3,1177,588,0,5248,5249, + 3,1155,577,0,5249,5250,3,1163,581,0,5250,5251,3,1147,573,0,5251, + 970,1,0,0,0,5252,5253,3,1177,588,0,5253,5254,3,1155,577,0,5254,5255, + 3,1163,581,0,5255,5256,3,1147,573,0,5256,5257,3,1173,586,0,5257, + 972,1,0,0,0,5258,5259,3,1177,588,0,5259,5260,3,1155,577,0,5260,5261, + 3,1163,581,0,5261,5262,3,1147,573,0,5262,5263,3,1175,587,0,5263, + 974,1,0,0,0,5264,5265,3,1177,588,0,5265,5266,3,1155,577,0,5266,5267, + 3,1177,588,0,5267,5268,3,1161,580,0,5268,5269,3,1147,573,0,5269, + 976,1,0,0,0,5270,5271,3,1177,588,0,5271,5272,3,1167,583,0,5272,978, + 1,0,0,0,5273,5274,3,1177,588,0,5274,5275,3,1167,583,0,5275,5276, + 3,1145,572,0,5276,5277,3,1139,569,0,5277,5278,3,1187,593,0,5278, + 5279,3,1175,587,0,5279,5280,3,1085,542,0,5280,5281,3,1145,572,0, + 5281,5282,3,1139,569,0,5282,5283,3,1177,588,0,5283,5284,3,1147,573, + 0,5284,980,1,0,0,0,5285,5286,3,1177,588,0,5286,5287,3,1167,583,0, + 5287,5288,3,1145,572,0,5288,5289,3,1139,569,0,5289,5290,3,1187,593, + 0,5290,5291,3,1175,587,0,5291,5292,3,1085,542,0,5292,5293,3,1165, + 582,0,5293,5294,3,1139,569,0,5294,5295,3,1163,581,0,5295,5296,3, + 1147,573,0,5296,982,1,0,0,0,5297,5298,3,1177,588,0,5298,5299,3,1167, + 583,0,5299,5300,3,1169,584,0,5300,984,1,0,0,0,5301,5302,3,1177,588, + 0,5302,5303,3,1173,586,0,5303,5304,3,1139,569,0,5304,5305,3,1155, + 577,0,5305,5306,3,1161,580,0,5306,5307,3,1155,577,0,5307,5308,3, + 1165,582,0,5308,5309,3,1151,575,0,5309,986,1,0,0,0,5310,5311,3,1177, + 588,0,5311,5312,3,1173,586,0,5312,5313,3,1179,589,0,5313,5314,3, + 1147,573,0,5314,988,1,0,0,0,5315,5316,3,1177,588,0,5316,5317,3,1173, + 586,0,5317,5318,3,1179,589,0,5318,5319,3,1165,582,0,5319,5320,3, + 1143,571,0,5320,5321,3,1139,569,0,5321,5322,3,1177,588,0,5322,5323, + 3,1147,573,0,5323,5324,3,1145,572,0,5324,990,1,0,0,0,5325,5326,3, + 1177,588,0,5326,5327,3,1187,593,0,5327,5328,3,1169,584,0,5328,5329, + 3,1147,573,0,5329,992,1,0,0,0,5330,5331,3,1177,588,0,5331,5332,3, + 1187,593,0,5332,5333,3,1169,584,0,5333,5334,3,1147,573,0,5334,5335, + 3,1145,572,0,5335,5336,3,1147,573,0,5336,5337,3,1149,574,0,5337, + 994,1,0,0,0,5338,5339,3,1179,589,0,5339,5340,3,1165,582,0,5340,5341, + 3,1145,572,0,5341,5342,3,1147,573,0,5342,5343,3,1173,586,0,5343, + 5344,3,1161,580,0,5344,5345,3,1155,577,0,5345,5346,3,1165,582,0, + 5346,5347,3,1147,573,0,5347,996,1,0,0,0,5348,5349,3,1179,589,0,5349, + 5350,3,1165,582,0,5350,5351,3,1155,577,0,5351,5352,3,1177,588,0, + 5352,998,1,0,0,0,5353,5354,3,1179,589,0,5354,5355,3,1165,582,0,5355, + 5356,3,1175,587,0,5356,5357,3,1177,588,0,5357,5358,3,1173,586,0, + 5358,5359,3,1155,577,0,5359,5360,3,1165,582,0,5360,5361,3,1151,575, + 0,5361,1000,1,0,0,0,5362,5363,3,1179,589,0,5363,5364,3,1165,582, + 0,5364,5365,3,1177,588,0,5365,5366,3,1155,577,0,5366,5367,3,1161, + 580,0,5367,1002,1,0,0,0,5368,5369,3,1179,589,0,5369,5370,3,1169, + 584,0,5370,1004,1,0,0,0,5371,5372,3,1179,589,0,5372,5373,3,1169, + 584,0,5373,5374,3,1167,583,0,5374,5375,3,1165,582,0,5375,1006,1, + 0,0,0,5376,5377,3,1179,589,0,5377,5378,3,1175,587,0,5378,5379,3, + 1139,569,0,5379,5380,3,1151,575,0,5380,5381,3,1147,573,0,5381,1008, + 1,0,0,0,5382,5383,3,1179,589,0,5383,5384,3,1175,587,0,5384,5385, + 3,1147,573,0,5385,1010,1,0,0,0,5386,5387,3,1179,589,0,5387,5388, + 3,1175,587,0,5388,5389,3,1155,577,0,5389,5390,3,1165,582,0,5390, + 5391,3,1151,575,0,5391,1012,1,0,0,0,5392,5393,3,1181,590,0,5393, + 5394,3,1139,569,0,5394,5395,3,1161,580,0,5395,5396,3,1179,589,0, + 5396,5397,3,1147,573,0,5397,1014,1,0,0,0,5398,5399,3,1181,590,0, + 5399,5400,3,1139,569,0,5400,5401,3,1161,580,0,5401,5402,3,1179,589, + 0,5402,5403,3,1147,573,0,5403,5404,3,1175,587,0,5404,1016,1,0,0, + 0,5405,5406,3,1181,590,0,5406,5407,3,1139,569,0,5407,5408,3,1173, + 586,0,5408,5409,3,1187,593,0,5409,5410,3,1155,577,0,5410,5411,3, + 1165,582,0,5411,5412,3,1151,575,0,5412,1018,1,0,0,0,5413,5414,3, + 1181,590,0,5414,5415,3,1155,577,0,5415,5416,3,1173,586,0,5416,5417, + 3,1177,588,0,5417,5418,3,1179,589,0,5418,5419,3,1139,569,0,5419, + 5420,3,1161,580,0,5420,1020,1,0,0,0,5421,5422,3,1183,591,0,5422, + 5423,3,1139,569,0,5423,5424,3,1155,577,0,5424,5425,3,1177,588,0, + 5425,1022,1,0,0,0,5426,5427,3,1183,591,0,5427,5428,3,1153,576,0, + 5428,5429,3,1147,573,0,5429,5430,3,1165,582,0,5430,1024,1,0,0,0, + 5431,5432,3,1183,591,0,5432,5433,3,1153,576,0,5433,5434,3,1147,573, + 0,5434,5435,3,1165,582,0,5435,5436,3,1085,542,0,5436,5437,3,1143, + 571,0,5437,5438,3,1167,583,0,5438,5439,3,1163,581,0,5439,5440,3, + 1169,584,0,5440,5441,3,1155,577,0,5441,5442,3,1161,580,0,5442,5443, + 3,1147,573,0,5443,5444,3,1145,572,0,5444,1026,1,0,0,0,5445,5446, + 3,1183,591,0,5446,5447,3,1155,577,0,5447,5448,3,1177,588,0,5448, + 5449,3,1153,576,0,5449,1028,1,0,0,0,5450,5451,3,1183,591,0,5451, + 5452,3,1167,583,0,5452,5453,3,1173,586,0,5453,5454,3,1145,572,0, + 5454,5455,3,1175,587,0,5455,1030,1,0,0,0,5456,5457,3,1183,591,0, + 5457,5458,3,1167,583,0,5458,5459,3,1173,586,0,5459,5460,3,1159,579, + 0,5460,5461,3,1155,577,0,5461,5462,3,1165,582,0,5462,5463,3,1151, + 575,0,5463,5464,3,1085,542,0,5464,5465,3,1175,587,0,5465,5466,3, + 1177,588,0,5466,5467,3,1167,583,0,5467,5468,3,1173,586,0,5468,5469, + 3,1139,569,0,5469,5470,3,1151,575,0,5470,5471,3,1147,573,0,5471, + 1032,1,0,0,0,5472,5473,3,1183,591,0,5473,5474,3,1173,586,0,5474, + 5475,3,1155,577,0,5475,5476,3,1177,588,0,5476,5477,3,1147,573,0, + 5477,1034,1,0,0,0,5478,5479,3,1187,593,0,5479,5480,3,1147,573,0, + 5480,5481,3,1139,569,0,5481,5482,3,1173,586,0,5482,1036,1,0,0,0, + 5483,5484,3,1187,593,0,5484,5485,3,1187,593,0,5485,5486,3,1187,593, + 0,5486,5487,3,1187,593,0,5487,5488,3,1163,581,0,5488,5489,3,1163, + 581,0,5489,5490,3,1145,572,0,5490,5491,3,1145,572,0,5491,1038,1, + 0,0,0,5492,5493,3,1187,593,0,5493,5494,3,1187,593,0,5494,5495,3, + 1187,593,0,5495,5496,3,1187,593,0,5496,5497,3,1145,572,0,5497,5498, + 3,1145,572,0,5498,5499,3,1145,572,0,5499,1040,1,0,0,0,5500,5501, + 3,1189,594,0,5501,5502,3,1147,573,0,5502,5503,3,1173,586,0,5503, + 5504,3,1167,583,0,5504,1042,1,0,0,0,5505,5506,3,1189,594,0,5506, + 5507,3,1147,573,0,5507,5508,3,1173,586,0,5508,5509,3,1167,583,0, + 5509,5510,3,1085,542,0,5510,5511,3,1149,574,0,5511,5512,3,1155,577, + 0,5512,5513,3,1161,580,0,5513,5514,3,1161,580,0,5514,1044,1,0,0, + 0,5515,5516,3,1189,594,0,5516,5517,3,1147,573,0,5517,5518,3,1173, + 586,0,5518,5519,3,1167,583,0,5519,5520,3,1175,587,0,5520,1046,1, + 0,0,0,5521,5522,3,1189,594,0,5522,5523,3,1147,573,0,5523,5524,3, + 1173,586,0,5524,5525,3,1167,583,0,5525,5526,3,1147,573,0,5526,5527, + 3,1175,587,0,5527,1048,1,0,0,0,5528,5529,5,38,0,0,5529,1050,1,0, + 0,0,5530,5531,5,42,0,0,5531,1052,1,0,0,0,5532,5533,5,42,0,0,5533, + 5534,5,42,0,0,5534,1054,1,0,0,0,5535,5536,5,58,0,0,5536,1056,1,0, + 0,0,5537,5538,5,44,0,0,5538,1058,1,0,0,0,5539,5540,5,42,0,0,5540, + 5541,5,62,0,0,5541,5542,5,67,0,0,5542,5543,5,69,0,0,5543,1060,1, + 0,0,0,5544,5545,5,42,0,0,5545,5546,5,62,0,0,5546,1062,1,0,0,0,5547, + 5548,5,36,0,0,5548,1064,1,0,0,0,5549,5550,5,34,0,0,5550,1066,1,0, + 0,0,5551,5553,5,46,0,0,5552,5554,7,0,0,0,5553,5552,1,0,0,0,5554, + 5555,1,0,0,0,5555,5553,1,0,0,0,5555,5556,1,0,0,0,5556,5560,1,0,0, + 0,5557,5558,5,46,0,0,5558,5560,5,0,0,1,5559,5551,1,0,0,0,5559,5557, + 1,0,0,0,5560,1068,1,0,0,0,5561,5562,5,46,0,0,5562,1070,1,0,0,0,5563, + 5564,5,61,0,0,5564,1072,1,0,0,0,5565,5566,5,42,0,0,5566,5567,5,62, + 0,0,5567,5568,5,69,0,0,5568,5569,5,88,0,0,5569,5570,5,69,0,0,5570, + 5571,5,67,0,0,5571,5572,5,67,0,0,5572,5573,5,73,0,0,5573,5574,5, + 67,0,0,5574,5575,5,83,0,0,5575,1074,1,0,0,0,5576,5577,5,42,0,0,5577, + 5578,5,62,0,0,5578,5579,5,69,0,0,5579,5580,5,88,0,0,5580,5581,5, + 69,0,0,5581,5582,5,67,0,0,5582,5583,5,83,0,0,5583,5584,5,81,0,0, + 5584,5585,5,76,0,0,5585,1076,1,0,0,0,5586,5587,5,42,0,0,5587,5588, + 5,62,0,0,5588,5589,5,69,0,0,5589,5590,5,88,0,0,5590,5591,5,69,0, + 0,5591,5592,5,67,0,0,5592,5593,5,83,0,0,5593,5594,5,81,0,0,5594, + 5595,5,76,0,0,5595,5596,5,73,0,0,5596,5597,5,77,0,0,5597,5598,5, + 83,0,0,5598,1078,1,0,0,0,5599,5600,5,60,0,0,5600,1080,1,0,0,0,5601, + 5602,5,60,0,0,5602,5603,5,61,0,0,5603,1082,1,0,0,0,5604,5605,5,40, + 0,0,5605,1084,1,0,0,0,5606,5607,5,45,0,0,5607,1086,1,0,0,0,5608, + 5609,5,62,0,0,5609,1088,1,0,0,0,5610,5611,5,62,0,0,5611,5612,5,61, + 0,0,5612,1090,1,0,0,0,5613,5614,5,60,0,0,5614,5615,5,62,0,0,5615, + 1092,1,0,0,0,5616,5617,5,43,0,0,5617,1094,1,0,0,0,5618,5619,5,39, + 0,0,5619,1096,1,0,0,0,5620,5621,5,41,0,0,5621,1098,1,0,0,0,5622, + 5623,5,47,0,0,5623,1100,1,0,0,0,5624,5629,3,1107,553,0,5625,5629, + 3,1109,554,0,5626,5629,3,1103,551,0,5627,5629,3,1105,552,0,5628, + 5624,1,0,0,0,5628,5625,1,0,0,0,5628,5626,1,0,0,0,5628,5627,1,0,0, + 0,5629,1102,1,0,0,0,5630,5631,3,1185,592,0,5631,5633,5,34,0,0,5632, + 5634,7,1,0,0,5633,5632,1,0,0,0,5634,5635,1,0,0,0,5635,5633,1,0,0, + 0,5635,5636,1,0,0,0,5636,5637,1,0,0,0,5637,5638,5,34,0,0,5638,5649, + 1,0,0,0,5639,5640,3,1185,592,0,5640,5642,5,39,0,0,5641,5643,7,1, + 0,0,5642,5641,1,0,0,0,5643,5644,1,0,0,0,5644,5642,1,0,0,0,5644,5645, + 1,0,0,0,5645,5646,1,0,0,0,5646,5647,5,39,0,0,5647,5649,1,0,0,0,5648, + 5630,1,0,0,0,5648,5639,1,0,0,0,5649,1104,1,0,0,0,5650,5651,3,1189, + 594,0,5651,5658,5,34,0,0,5652,5657,8,2,0,0,5653,5654,5,34,0,0,5654, + 5657,5,34,0,0,5655,5657,5,39,0,0,5656,5652,1,0,0,0,5656,5653,1,0, + 0,0,5656,5655,1,0,0,0,5657,5660,1,0,0,0,5658,5656,1,0,0,0,5658,5659, + 1,0,0,0,5659,5661,1,0,0,0,5660,5658,1,0,0,0,5661,5662,5,34,0,0,5662, + 5677,1,0,0,0,5663,5664,3,1189,594,0,5664,5671,5,39,0,0,5665,5670, + 8,3,0,0,5666,5667,5,39,0,0,5667,5670,5,39,0,0,5668,5670,5,34,0,0, + 5669,5665,1,0,0,0,5669,5666,1,0,0,0,5669,5668,1,0,0,0,5670,5673, + 1,0,0,0,5671,5669,1,0,0,0,5671,5672,1,0,0,0,5672,5674,1,0,0,0,5673, + 5671,1,0,0,0,5674,5675,5,39,0,0,5675,5677,1,0,0,0,5676,5650,1,0, + 0,0,5676,5663,1,0,0,0,5677,1106,1,0,0,0,5678,5685,5,34,0,0,5679, + 5684,8,2,0,0,5680,5681,5,34,0,0,5681,5684,5,34,0,0,5682,5684,5,39, + 0,0,5683,5679,1,0,0,0,5683,5680,1,0,0,0,5683,5682,1,0,0,0,5684,5687, + 1,0,0,0,5685,5683,1,0,0,0,5685,5686,1,0,0,0,5686,5688,1,0,0,0,5687, + 5685,1,0,0,0,5688,5701,5,34,0,0,5689,5696,5,39,0,0,5690,5695,8,3, + 0,0,5691,5692,5,39,0,0,5692,5695,5,39,0,0,5693,5695,5,34,0,0,5694, + 5690,1,0,0,0,5694,5691,1,0,0,0,5694,5693,1,0,0,0,5695,5698,1,0,0, + 0,5696,5694,1,0,0,0,5696,5697,1,0,0,0,5697,5699,1,0,0,0,5698,5696, + 1,0,0,0,5699,5701,5,39,0,0,5700,5678,1,0,0,0,5700,5689,1,0,0,0,5701, + 1108,1,0,0,0,5702,5703,7,4,0,0,5703,5710,5,34,0,0,5704,5709,8,2, + 0,0,5705,5706,5,34,0,0,5706,5709,5,34,0,0,5707,5709,5,39,0,0,5708, + 5704,1,0,0,0,5708,5705,1,0,0,0,5708,5707,1,0,0,0,5709,5712,1,0,0, + 0,5710,5708,1,0,0,0,5710,5711,1,0,0,0,5711,5713,1,0,0,0,5712,5710, + 1,0,0,0,5713,5727,5,34,0,0,5714,5715,7,4,0,0,5715,5722,5,39,0,0, + 5716,5721,8,3,0,0,5717,5718,5,39,0,0,5718,5721,5,39,0,0,5719,5721, + 5,34,0,0,5720,5716,1,0,0,0,5720,5717,1,0,0,0,5720,5719,1,0,0,0,5721, + 5724,1,0,0,0,5722,5720,1,0,0,0,5722,5723,1,0,0,0,5723,5725,1,0,0, + 0,5724,5722,1,0,0,0,5725,5727,5,39,0,0,5726,5702,1,0,0,0,5726,5714, + 1,0,0,0,5727,1110,1,0,0,0,5728,5729,5,54,0,0,5729,5730,5,54,0,0, + 5730,1112,1,0,0,0,5731,5732,5,55,0,0,5732,5733,5,55,0,0,5733,1114, + 1,0,0,0,5734,5735,5,56,0,0,5735,5736,5,56,0,0,5736,1116,1,0,0,0, + 5737,5740,3,1093,546,0,5738,5740,3,1085,542,0,5739,5737,1,0,0,0, + 5739,5738,1,0,0,0,5739,5740,1,0,0,0,5740,5742,1,0,0,0,5741,5743, + 7,5,0,0,5742,5741,1,0,0,0,5743,5744,1,0,0,0,5744,5742,1,0,0,0,5744, + 5745,1,0,0,0,5745,1118,1,0,0,0,5746,5749,3,1093,546,0,5747,5749, + 3,1085,542,0,5748,5746,1,0,0,0,5748,5747,1,0,0,0,5748,5749,1,0,0, + 0,5749,5753,1,0,0,0,5750,5752,7,5,0,0,5751,5750,1,0,0,0,5752,5755, + 1,0,0,0,5753,5751,1,0,0,0,5753,5754,1,0,0,0,5754,5758,1,0,0,0,5755, + 5753,1,0,0,0,5756,5759,3,1069,534,0,5757,5759,3,1057,528,0,5758, + 5756,1,0,0,0,5758,5757,1,0,0,0,5759,5761,1,0,0,0,5760,5762,7,5,0, + 0,5761,5760,1,0,0,0,5762,5763,1,0,0,0,5763,5761,1,0,0,0,5763,5764, + 1,0,0,0,5764,5775,1,0,0,0,5765,5768,7,6,0,0,5766,5769,3,1093,546, + 0,5767,5769,3,1085,542,0,5768,5766,1,0,0,0,5768,5767,1,0,0,0,5768, + 5769,1,0,0,0,5769,5771,1,0,0,0,5770,5772,7,5,0,0,5771,5770,1,0,0, + 0,5772,5773,1,0,0,0,5773,5771,1,0,0,0,5773,5774,1,0,0,0,5774,5776, + 1,0,0,0,5775,5765,1,0,0,0,5775,5776,1,0,0,0,5776,1120,1,0,0,0,5777, + 5779,7,7,0,0,5778,5777,1,0,0,0,5779,5780,1,0,0,0,5780,5778,1,0,0, + 0,5780,5781,1,0,0,0,5781,5794,1,0,0,0,5782,5784,7,8,0,0,5783,5782, + 1,0,0,0,5784,5785,1,0,0,0,5785,5783,1,0,0,0,5785,5786,1,0,0,0,5786, + 5788,1,0,0,0,5787,5789,7,7,0,0,5788,5787,1,0,0,0,5789,5790,1,0,0, + 0,5790,5788,1,0,0,0,5790,5791,1,0,0,0,5791,5793,1,0,0,0,5792,5783, + 1,0,0,0,5793,5796,1,0,0,0,5794,5792,1,0,0,0,5794,5795,1,0,0,0,5795, + 1122,1,0,0,0,5796,5794,1,0,0,0,5797,5799,5,13,0,0,5798,5797,1,0, + 0,0,5798,5799,1,0,0,0,5799,5800,1,0,0,0,5800,5801,5,10,0,0,5801, + 5802,1,0,0,0,5802,5803,6,561,0,0,5803,1124,1,0,0,0,5804,5805,3,1073, + 536,0,5805,5809,3,1135,567,0,5806,5808,8,9,0,0,5807,5806,1,0,0,0, + 5808,5811,1,0,0,0,5809,5807,1,0,0,0,5809,5810,1,0,0,0,5810,5812, + 1,0,0,0,5811,5809,1,0,0,0,5812,5813,7,9,0,0,5813,1126,1,0,0,0,5814, + 5815,3,1077,538,0,5815,5819,3,1135,567,0,5816,5818,8,9,0,0,5817, + 5816,1,0,0,0,5818,5821,1,0,0,0,5819,5817,1,0,0,0,5819,5820,1,0,0, + 0,5820,5822,1,0,0,0,5821,5819,1,0,0,0,5822,5823,7,9,0,0,5823,1128, + 1,0,0,0,5824,5825,3,1075,537,0,5825,5829,3,1135,567,0,5826,5828, + 8,9,0,0,5827,5826,1,0,0,0,5828,5831,1,0,0,0,5829,5827,1,0,0,0,5829, + 5830,1,0,0,0,5830,5832,1,0,0,0,5831,5829,1,0,0,0,5832,5833,7,9,0, + 0,5833,1130,1,0,0,0,5834,5835,3,1059,529,0,5835,5839,3,1135,567, + 0,5836,5838,8,10,0,0,5837,5836,1,0,0,0,5838,5841,1,0,0,0,5839,5837, + 1,0,0,0,5839,5840,1,0,0,0,5840,1132,1,0,0,0,5841,5839,1,0,0,0,5842, + 5843,3,1061,530,0,5843,5847,3,1135,567,0,5844,5846,8,10,0,0,5845, + 5844,1,0,0,0,5846,5849,1,0,0,0,5847,5845,1,0,0,0,5847,5848,1,0,0, + 0,5848,5850,1,0,0,0,5849,5847,1,0,0,0,5850,5851,6,566,0,0,5851,1134, + 1,0,0,0,5852,5854,7,11,0,0,5853,5852,1,0,0,0,5854,5855,1,0,0,0,5855, + 5853,1,0,0,0,5855,5856,1,0,0,0,5856,5857,1,0,0,0,5857,5858,6,567, + 0,0,5858,1136,1,0,0,0,5859,5860,5,44,0,0,5860,5861,5,32,0,0,5861, + 5862,1,0,0,0,5862,5863,6,568,0,0,5863,1138,1,0,0,0,5864,5865,7,12, + 0,0,5865,1140,1,0,0,0,5866,5867,7,13,0,0,5867,1142,1,0,0,0,5868, + 5869,7,14,0,0,5869,1144,1,0,0,0,5870,5871,7,15,0,0,5871,1146,1,0, + 0,0,5872,5873,7,6,0,0,5873,1148,1,0,0,0,5874,5875,7,16,0,0,5875, + 1150,1,0,0,0,5876,5877,7,17,0,0,5877,1152,1,0,0,0,5878,5879,7,18, + 0,0,5879,1154,1,0,0,0,5880,5881,7,19,0,0,5881,1156,1,0,0,0,5882, + 5883,7,20,0,0,5883,1158,1,0,0,0,5884,5885,7,21,0,0,5885,1160,1,0, + 0,0,5886,5887,7,22,0,0,5887,1162,1,0,0,0,5888,5889,7,23,0,0,5889, + 1164,1,0,0,0,5890,5891,7,24,0,0,5891,1166,1,0,0,0,5892,5893,7,25, + 0,0,5893,1168,1,0,0,0,5894,5895,7,26,0,0,5895,1170,1,0,0,0,5896, + 5897,7,27,0,0,5897,1172,1,0,0,0,5898,5899,7,28,0,0,5899,1174,1,0, + 0,0,5900,5901,7,29,0,0,5901,1176,1,0,0,0,5902,5903,7,30,0,0,5903, + 1178,1,0,0,0,5904,5905,7,31,0,0,5905,1180,1,0,0,0,5906,5907,7,32, + 0,0,5907,1182,1,0,0,0,5908,5909,7,33,0,0,5909,1184,1,0,0,0,5910, + 5911,7,34,0,0,5911,1186,1,0,0,0,5912,5913,7,35,0,0,5913,1188,1,0, + 0,0,5914,5915,7,36,0,0,5915,1190,1,0,0,0,42,0,5555,5559,5628,5635, + 5644,5648,5656,5658,5669,5671,5676,5683,5685,5694,5696,5700,5708, + 5710,5720,5722,5726,5739,5744,5748,5753,5758,5763,5768,5773,5775, + 5780,5785,5790,5794,5798,5809,5819,5829,5839,5847,5855,1,0,1,0 + ] + +class Cobol85Lexer(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + ABORT = 1 + ACCEPT = 2 + ACCESS = 3 + ADD = 4 + ADDRESS = 5 + ADVANCING = 6 + AFTER = 7 + ALIGNED = 8 + ALL = 9 + ALPHABET = 10 + ALPHABETIC = 11 + ALPHABETIC_LOWER = 12 + ALPHABETIC_UPPER = 13 + ALPHANUMERIC = 14 + ALPHANUMERIC_EDITED = 15 + ALSO = 16 + ALTER = 17 + ALTERNATE = 18 + AND = 19 + ANY = 20 + ARE = 21 + AREA = 22 + AREAS = 23 + AS = 24 + ASCENDING = 25 + ASCII = 26 + ASSIGN = 27 + ASSOCIATED_DATA = 28 + ASSOCIATED_DATA_LENGTH = 29 + AT = 30 + ATTRIBUTE = 31 + AUTHOR = 32 + AUTO = 33 + AUTO_SKIP = 34 + BACKGROUND_COLOR = 35 + BACKGROUND_COLOUR = 36 + BASIS = 37 + BEEP = 38 + BEFORE = 39 + BEGINNING = 40 + BELL = 41 + BINARY = 42 + BIT = 43 + BLANK = 44 + BLINK = 45 + BLOCK = 46 + BOUNDS = 47 + BOTTOM = 48 + BY = 49 + BYFUNCTION = 50 + BYTITLE = 51 + CALL = 52 + CANCEL = 53 + CAPABLE = 54 + CCSVERSION = 55 + CD = 56 + CF = 57 + CH = 58 + CHAINING = 59 + CHANGED = 60 + CHANNEL = 61 + CHARACTER = 62 + CHARACTERS = 63 + CLASS = 64 + CLASS_ID = 65 + CLOCK_UNITS = 66 + CLOSE = 67 + CLOSE_DISPOSITION = 68 + COBOL = 69 + CODE = 70 + CODE_SET = 71 + COLLATING = 72 + COL = 73 + COLUMN = 74 + COM_REG = 75 + COMMA = 76 + COMMITMENT = 77 + COMMON = 78 + COMMUNICATION = 79 + COMP = 80 + COMP_1 = 81 + COMP_2 = 82 + COMP_3 = 83 + COMP_4 = 84 + COMP_5 = 85 + COMPUTATIONAL = 86 + COMPUTATIONAL_1 = 87 + COMPUTATIONAL_2 = 88 + COMPUTATIONAL_3 = 89 + COMPUTATIONAL_4 = 90 + COMPUTATIONAL_5 = 91 + COMPUTE = 92 + CONFIGURATION = 93 + CONTAINS = 94 + CONTENT = 95 + CONTINUE = 96 + CONTROL = 97 + CONTROL_POINT = 98 + CONTROLS = 99 + CONVENTION = 100 + CONVERTING = 101 + COPY = 102 + CORR = 103 + CORRESPONDING = 104 + COUNT = 105 + CRUNCH = 106 + CURRENCY = 107 + CURSOR = 108 + DATA = 109 + DATA_BASE = 110 + DATE = 111 + DATE_COMPILED = 112 + DATE_WRITTEN = 113 + DAY = 114 + DAY_OF_WEEK = 115 + DBCS = 116 + DE = 117 + DEBUG_CONTENTS = 118 + DEBUG_ITEM = 119 + DEBUG_LINE = 120 + DEBUG_NAME = 121 + DEBUG_SUB_1 = 122 + DEBUG_SUB_2 = 123 + DEBUG_SUB_3 = 124 + DEBUGGING = 125 + DECIMAL_POINT = 126 + DECLARATIVES = 127 + DEFAULT = 128 + DEFAULT_DISPLAY = 129 + DEFINITION = 130 + DELETE = 131 + DELIMITED = 132 + DELIMITER = 133 + DEPENDING = 134 + DESCENDING = 135 + DESTINATION = 136 + DETAIL = 137 + DFHRESP = 138 + DFHVALUE = 139 + DISABLE = 140 + DISK = 141 + DISPLAY = 142 + DISPLAY_1 = 143 + DIVIDE = 144 + DIVISION = 145 + DONTCARE = 146 + DOUBLE = 147 + DOWN = 148 + DUPLICATES = 149 + DYNAMIC = 150 + EBCDIC = 151 + EGCS = 152 + EGI = 153 + ELSE = 154 + EMI = 155 + EMPTY_CHECK = 156 + ENABLE = 157 + END = 158 + END_ACCEPT = 159 + END_ADD = 160 + END_CALL = 161 + END_COMPUTE = 162 + END_DELETE = 163 + END_DIVIDE = 164 + END_EVALUATE = 165 + END_IF = 166 + END_MULTIPLY = 167 + END_OF_PAGE = 168 + END_PERFORM = 169 + END_READ = 170 + END_RECEIVE = 171 + END_RETURN = 172 + END_REWRITE = 173 + END_SEARCH = 174 + END_START = 175 + END_STRING = 176 + END_SUBTRACT = 177 + END_UNSTRING = 178 + END_WRITE = 179 + ENDING = 180 + ENTER = 181 + ENTRY = 182 + ENTRY_PROCEDURE = 183 + ENVIRONMENT = 184 + EOP = 185 + EQUAL = 186 + ERASE = 187 + ERROR = 188 + EOL = 189 + EOS = 190 + ESCAPE = 191 + ESI = 192 + EVALUATE = 193 + EVENT = 194 + EVERY = 195 + EXCEPTION = 196 + EXCLUSIVE = 197 + EXHIBIT = 198 + EXIT = 199 + EXPORT = 200 + EXTEND = 201 + EXTENDED = 202 + EXTERNAL = 203 + FALSE = 204 + FD = 205 + FILE = 206 + FILE_CONTROL = 207 + FILLER = 208 + FINAL = 209 + FIRST = 210 + FOOTING = 211 + FOR = 212 + FOREGROUND_COLOR = 213 + FOREGROUND_COLOUR = 214 + FROM = 215 + FULL = 216 + FUNCTION = 217 + FUNCTIONNAME = 218 + FUNCTION_POINTER = 219 + GENERATE = 220 + GOBACK = 221 + GIVING = 222 + GLOBAL = 223 + GO = 224 + GREATER = 225 + GRID = 226 + GROUP = 227 + HEADING = 228 + HIGHLIGHT = 229 + HIGH_VALUE = 230 + HIGH_VALUES = 231 + I_O = 232 + I_O_CONTROL = 233 + ID = 234 + IDENTIFICATION = 235 + IF = 236 + IMPLICIT = 237 + IMPORT = 238 + IN = 239 + INDEX = 240 + INDEXED = 241 + INDICATE = 242 + INITIAL = 243 + INITIALIZE = 244 + INITIATE = 245 + INPUT = 246 + INPUT_OUTPUT = 247 + INSPECT = 248 + INSTALLATION = 249 + INTEGER = 250 + INTO = 251 + INVALID = 252 + INVOKE = 253 + IS = 254 + JUST = 255 + JUSTIFIED = 256 + KANJI = 257 + KEPT = 258 + KEY = 259 + KEYBOARD = 260 + LABEL = 261 + LANGUAGE = 262 + LAST = 263 + LB = 264 + LD = 265 + LEADING = 266 + LEFT = 267 + LEFTLINE = 268 + LENGTH = 269 + LENGTH_CHECK = 270 + LESS = 271 + LIBACCESS = 272 + LIBPARAMETER = 273 + LIBRARY = 274 + LIMIT = 275 + LIMITS = 276 + LINAGE = 277 + LINAGE_COUNTER = 278 + LINE = 279 + LINES = 280 + LINE_COUNTER = 281 + LINKAGE = 282 + LIST = 283 + LOCAL = 284 + LOCAL_STORAGE = 285 + LOCK = 286 + LONG_DATE = 287 + LONG_TIME = 288 + LOWER = 289 + LOWLIGHT = 290 + LOW_VALUE = 291 + LOW_VALUES = 292 + MEMORY = 293 + MERGE = 294 + MESSAGE = 295 + MMDDYYYY = 296 + MODE = 297 + MODULES = 298 + MORE_LABELS = 299 + MOVE = 300 + MULTIPLE = 301 + MULTIPLY = 302 + NAMED = 303 + NATIONAL = 304 + NATIONAL_EDITED = 305 + NATIVE = 306 + NEGATIVE = 307 + NETWORK = 308 + NEXT = 309 + NO = 310 + NO_ECHO = 311 + NOT = 312 + NULL_ = 313 + NULLS = 314 + NUMBER = 315 + NUMERIC = 316 + NUMERIC_DATE = 317 + NUMERIC_EDITED = 318 + NUMERIC_TIME = 319 + OBJECT_COMPUTER = 320 + OCCURS = 321 + ODT = 322 + OF = 323 + OFF = 324 + OMITTED = 325 + ON = 326 + OPEN = 327 + OPTIONAL = 328 + OR = 329 + ORDER = 330 + ORDERLY = 331 + ORGANIZATION = 332 + OTHER = 333 + OUTPUT = 334 + OVERFLOW = 335 + OVERLINE = 336 + OWN = 337 + PACKED_DECIMAL = 338 + PADDING = 339 + PAGE = 340 + PAGE_COUNTER = 341 + PASSWORD = 342 + PERFORM = 343 + PF = 344 + PH = 345 + PIC = 346 + PICTURE = 347 + PLUS = 348 + POINTER = 349 + POSITION = 350 + POSITIVE = 351 + PORT = 352 + PRINTER = 353 + PRINTING = 354 + PRIVATE = 355 + PROCEDURE = 356 + PROCEDURE_POINTER = 357 + PROCEDURES = 358 + PROCEED = 359 + PROCESS = 360 + PROGRAM = 361 + PROGRAM_ID = 362 + PROGRAM_LIBRARY = 363 + PROMPT = 364 + PURGE = 365 + QUEUE = 366 + QUOTE = 367 + QUOTES = 368 + RANDOM = 369 + READER = 370 + REMOTE = 371 + RD = 372 + REAL = 373 + READ = 374 + RECEIVE = 375 + RECEIVED = 376 + RECORD = 377 + RECORDING = 378 + RECORDS = 379 + RECURSIVE = 380 + REDEFINES = 381 + REEL = 382 + REF = 383 + REFERENCE = 384 + REFERENCES = 385 + RELATIVE = 386 + RELEASE = 387 + REMAINDER = 388 + REMARKS = 389 + REMOVAL = 390 + REMOVE = 391 + RENAMES = 392 + REPLACE = 393 + REPLACING = 394 + REPORT = 395 + REPORTING = 396 + REPORTS = 397 + REQUIRED = 398 + RERUN = 399 + RESERVE = 400 + REVERSE_VIDEO = 401 + RESET = 402 + RETURN = 403 + RETURN_CODE = 404 + RETURNING = 405 + REVERSED = 406 + REWIND = 407 + REWRITE = 408 + RF = 409 + RH = 410 + RIGHT = 411 + ROUNDED = 412 + RUN = 413 + SAME = 414 + SAVE = 415 + SCREEN = 416 + SD = 417 + SEARCH = 418 + SECTION = 419 + SECURE = 420 + SECURITY = 421 + SEGMENT = 422 + SEGMENT_LIMIT = 423 + SELECT = 424 + SEND = 425 + SENTENCE = 426 + SEPARATE = 427 + SEQUENCE = 428 + SEQUENTIAL = 429 + SET = 430 + SHARED = 431 + SHAREDBYALL = 432 + SHAREDBYRUNUNIT = 433 + SHARING = 434 + SHIFT_IN = 435 + SHIFT_OUT = 436 + SHORT_DATE = 437 + SIGN = 438 + SIZE = 439 + SORT = 440 + SORT_CONTROL = 441 + SORT_CORE_SIZE = 442 + SORT_FILE_SIZE = 443 + SORT_MERGE = 444 + SORT_MESSAGE = 445 + SORT_MODE_SIZE = 446 + SORT_RETURN = 447 + SOURCE = 448 + SOURCE_COMPUTER = 449 + SPACE = 450 + SPACES = 451 + SPECIAL_NAMES = 452 + STANDARD = 453 + STANDARD_1 = 454 + STANDARD_2 = 455 + START = 456 + STATUS = 457 + STOP = 458 + STRING = 459 + SUB_QUEUE_1 = 460 + SUB_QUEUE_2 = 461 + SUB_QUEUE_3 = 462 + SUBTRACT = 463 + SUM = 464 + SUPPRESS = 465 + SYMBOL = 466 + SYMBOLIC = 467 + SYNC = 468 + SYNCHRONIZED = 469 + TABLE = 470 + TALLY = 471 + TALLYING = 472 + TASK = 473 + TAPE = 474 + TERMINAL = 475 + TERMINATE = 476 + TEST = 477 + TEXT = 478 + THAN = 479 + THEN = 480 + THREAD = 481 + THREAD_LOCAL = 482 + THROUGH = 483 + THRU = 484 + TIME = 485 + TIMER = 486 + TIMES = 487 + TITLE = 488 + TO = 489 + TODAYS_DATE = 490 + TODAYS_NAME = 491 + TOP = 492 + TRAILING = 493 + TRUE = 494 + TRUNCATED = 495 + TYPE = 496 + TYPEDEF = 497 + UNDERLINE = 498 + UNIT = 499 + UNSTRING = 500 + UNTIL = 501 + UP = 502 + UPON = 503 + USAGE = 504 + USE = 505 + USING = 506 + VALUE = 507 + VALUES = 508 + VARYING = 509 + VIRTUAL = 510 + WAIT = 511 + WHEN = 512 + WHEN_COMPILED = 513 + WITH = 514 + WORDS = 515 + WORKING_STORAGE = 516 + WRITE = 517 + YEAR = 518 + YYYYMMDD = 519 + YYYYDDD = 520 + ZERO = 521 + ZERO_FILL = 522 + ZEROS = 523 + ZEROES = 524 + AMPCHAR = 525 + ASTERISKCHAR = 526 + DOUBLEASTERISKCHAR = 527 + COLONCHAR = 528 + COMMACHAR = 529 + COMMENTENTRYTAG = 530 + COMMENTTAG = 531 + DOLLARCHAR = 532 + DOUBLEQUOTE = 533 + DOT_FS = 534 + DOT = 535 + EQUALCHAR = 536 + EXECCICSTAG = 537 + EXECSQLTAG = 538 + EXECSQLIMSTAG = 539 + LESSTHANCHAR = 540 + LESSTHANOREQUAL = 541 + LPARENCHAR = 542 + MINUSCHAR = 543 + MORETHANCHAR = 544 + MORETHANOREQUAL = 545 + NOTEQUALCHAR = 546 + PLUSCHAR = 547 + SINGLEQUOTE = 548 + RPARENCHAR = 549 + SLASHCHAR = 550 + NONNUMERICLITERAL = 551 + LEVEL_NUMBER_66 = 552 + LEVEL_NUMBER_77 = 553 + LEVEL_NUMBER_88 = 554 + INTEGERLITERAL = 555 + NUMERICLITERAL = 556 + IDENTIFIER = 557 + NEWLINE = 558 + EXECCICSLINE = 559 + EXECSQLIMSLINE = 560 + EXECSQLLINE = 561 + COMMENTENTRYLINE = 562 + COMMENTLINE = 563 + WS = 564 + SEPARATOR = 565 + + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + + modeNames = [ "DEFAULT_MODE" ] + + literalNames = [ "", + "'&'", "'*'", "'**'", "':'", "','", "'*>CE'", "'*>'", "'$'", + "'\"'", "'.'", "'='", "'*>EXECCICS'", "'*>EXECSQL'", "'*>EXECSQLIMS'", + "'<'", "'<='", "'('", "'-'", "'>'", "'>='", "'<>'", "'+'", "'''", + "')'", "'/'", "'66'", "'77'", "'88'", "', '" ] + + symbolicNames = [ "", + "ABORT", "ACCEPT", "ACCESS", "ADD", "ADDRESS", "ADVANCING", + "AFTER", "ALIGNED", "ALL", "ALPHABET", "ALPHABETIC", "ALPHABETIC_LOWER", + "ALPHABETIC_UPPER", "ALPHANUMERIC", "ALPHANUMERIC_EDITED", "ALSO", + "ALTER", "ALTERNATE", "AND", "ANY", "ARE", "AREA", "AREAS", + "AS", "ASCENDING", "ASCII", "ASSIGN", "ASSOCIATED_DATA", "ASSOCIATED_DATA_LENGTH", + "AT", "ATTRIBUTE", "AUTHOR", "AUTO", "AUTO_SKIP", "BACKGROUND_COLOR", + "BACKGROUND_COLOUR", "BASIS", "BEEP", "BEFORE", "BEGINNING", + "BELL", "BINARY", "BIT", "BLANK", "BLINK", "BLOCK", "BOUNDS", + "BOTTOM", "BY", "BYFUNCTION", "BYTITLE", "CALL", "CANCEL", "CAPABLE", + "CCSVERSION", "CD", "CF", "CH", "CHAINING", "CHANGED", "CHANNEL", + "CHARACTER", "CHARACTERS", "CLASS", "CLASS_ID", "CLOCK_UNITS", + "CLOSE", "CLOSE_DISPOSITION", "COBOL", "CODE", "CODE_SET", "COLLATING", + "COL", "COLUMN", "COM_REG", "COMMA", "COMMITMENT", "COMMON", + "COMMUNICATION", "COMP", "COMP_1", "COMP_2", "COMP_3", "COMP_4", + "COMP_5", "COMPUTATIONAL", "COMPUTATIONAL_1", "COMPUTATIONAL_2", + "COMPUTATIONAL_3", "COMPUTATIONAL_4", "COMPUTATIONAL_5", "COMPUTE", + "CONFIGURATION", "CONTAINS", "CONTENT", "CONTINUE", "CONTROL", + "CONTROL_POINT", "CONTROLS", "CONVENTION", "CONVERTING", "COPY", + "CORR", "CORRESPONDING", "COUNT", "CRUNCH", "CURRENCY", "CURSOR", + "DATA", "DATA_BASE", "DATE", "DATE_COMPILED", "DATE_WRITTEN", + "DAY", "DAY_OF_WEEK", "DBCS", "DE", "DEBUG_CONTENTS", "DEBUG_ITEM", + "DEBUG_LINE", "DEBUG_NAME", "DEBUG_SUB_1", "DEBUG_SUB_2", "DEBUG_SUB_3", + "DEBUGGING", "DECIMAL_POINT", "DECLARATIVES", "DEFAULT", "DEFAULT_DISPLAY", + "DEFINITION", "DELETE", "DELIMITED", "DELIMITER", "DEPENDING", + "DESCENDING", "DESTINATION", "DETAIL", "DFHRESP", "DFHVALUE", + "DISABLE", "DISK", "DISPLAY", "DISPLAY_1", "DIVIDE", "DIVISION", + "DONTCARE", "DOUBLE", "DOWN", "DUPLICATES", "DYNAMIC", "EBCDIC", + "EGCS", "EGI", "ELSE", "EMI", "EMPTY_CHECK", "ENABLE", "END", + "END_ACCEPT", "END_ADD", "END_CALL", "END_COMPUTE", "END_DELETE", + "END_DIVIDE", "END_EVALUATE", "END_IF", "END_MULTIPLY", "END_OF_PAGE", + "END_PERFORM", "END_READ", "END_RECEIVE", "END_RETURN", "END_REWRITE", + "END_SEARCH", "END_START", "END_STRING", "END_SUBTRACT", "END_UNSTRING", + "END_WRITE", "ENDING", "ENTER", "ENTRY", "ENTRY_PROCEDURE", + "ENVIRONMENT", "EOP", "EQUAL", "ERASE", "ERROR", "EOL", "EOS", + "ESCAPE", "ESI", "EVALUATE", "EVENT", "EVERY", "EXCEPTION", + "EXCLUSIVE", "EXHIBIT", "EXIT", "EXPORT", "EXTEND", "EXTENDED", + "EXTERNAL", "FALSE", "FD", "FILE", "FILE_CONTROL", "FILLER", + "FINAL", "FIRST", "FOOTING", "FOR", "FOREGROUND_COLOR", "FOREGROUND_COLOUR", + "FROM", "FULL", "FUNCTION", "FUNCTIONNAME", "FUNCTION_POINTER", + "GENERATE", "GOBACK", "GIVING", "GLOBAL", "GO", "GREATER", "GRID", + "GROUP", "HEADING", "HIGHLIGHT", "HIGH_VALUE", "HIGH_VALUES", + "I_O", "I_O_CONTROL", "ID", "IDENTIFICATION", "IF", "IMPLICIT", + "IMPORT", "IN", "INDEX", "INDEXED", "INDICATE", "INITIAL", "INITIALIZE", + "INITIATE", "INPUT", "INPUT_OUTPUT", "INSPECT", "INSTALLATION", + "INTEGER", "INTO", "INVALID", "INVOKE", "IS", "JUST", "JUSTIFIED", + "KANJI", "KEPT", "KEY", "KEYBOARD", "LABEL", "LANGUAGE", "LAST", + "LB", "LD", "LEADING", "LEFT", "LEFTLINE", "LENGTH", "LENGTH_CHECK", + "LESS", "LIBACCESS", "LIBPARAMETER", "LIBRARY", "LIMIT", "LIMITS", + "LINAGE", "LINAGE_COUNTER", "LINE", "LINES", "LINE_COUNTER", + "LINKAGE", "LIST", "LOCAL", "LOCAL_STORAGE", "LOCK", "LONG_DATE", + "LONG_TIME", "LOWER", "LOWLIGHT", "LOW_VALUE", "LOW_VALUES", + "MEMORY", "MERGE", "MESSAGE", "MMDDYYYY", "MODE", "MODULES", + "MORE_LABELS", "MOVE", "MULTIPLE", "MULTIPLY", "NAMED", "NATIONAL", + "NATIONAL_EDITED", "NATIVE", "NEGATIVE", "NETWORK", "NEXT", + "NO", "NO_ECHO", "NOT", "NULL_", "NULLS", "NUMBER", "NUMERIC", + "NUMERIC_DATE", "NUMERIC_EDITED", "NUMERIC_TIME", "OBJECT_COMPUTER", + "OCCURS", "ODT", "OF", "OFF", "OMITTED", "ON", "OPEN", "OPTIONAL", + "OR", "ORDER", "ORDERLY", "ORGANIZATION", "OTHER", "OUTPUT", + "OVERFLOW", "OVERLINE", "OWN", "PACKED_DECIMAL", "PADDING", + "PAGE", "PAGE_COUNTER", "PASSWORD", "PERFORM", "PF", "PH", "PIC", + "PICTURE", "PLUS", "POINTER", "POSITION", "POSITIVE", "PORT", + "PRINTER", "PRINTING", "PRIVATE", "PROCEDURE", "PROCEDURE_POINTER", + "PROCEDURES", "PROCEED", "PROCESS", "PROGRAM", "PROGRAM_ID", + "PROGRAM_LIBRARY", "PROMPT", "PURGE", "QUEUE", "QUOTE", "QUOTES", + "RANDOM", "READER", "REMOTE", "RD", "REAL", "READ", "RECEIVE", + "RECEIVED", "RECORD", "RECORDING", "RECORDS", "RECURSIVE", "REDEFINES", + "REEL", "REF", "REFERENCE", "REFERENCES", "RELATIVE", "RELEASE", + "REMAINDER", "REMARKS", "REMOVAL", "REMOVE", "RENAMES", "REPLACE", + "REPLACING", "REPORT", "REPORTING", "REPORTS", "REQUIRED", "RERUN", + "RESERVE", "REVERSE_VIDEO", "RESET", "RETURN", "RETURN_CODE", + "RETURNING", "REVERSED", "REWIND", "REWRITE", "RF", "RH", "RIGHT", + "ROUNDED", "RUN", "SAME", "SAVE", "SCREEN", "SD", "SEARCH", + "SECTION", "SECURE", "SECURITY", "SEGMENT", "SEGMENT_LIMIT", + "SELECT", "SEND", "SENTENCE", "SEPARATE", "SEQUENCE", "SEQUENTIAL", + "SET", "SHARED", "SHAREDBYALL", "SHAREDBYRUNUNIT", "SHARING", + "SHIFT_IN", "SHIFT_OUT", "SHORT_DATE", "SIGN", "SIZE", "SORT", + "SORT_CONTROL", "SORT_CORE_SIZE", "SORT_FILE_SIZE", "SORT_MERGE", + "SORT_MESSAGE", "SORT_MODE_SIZE", "SORT_RETURN", "SOURCE", "SOURCE_COMPUTER", + "SPACE", "SPACES", "SPECIAL_NAMES", "STANDARD", "STANDARD_1", + "STANDARD_2", "START", "STATUS", "STOP", "STRING", "SUB_QUEUE_1", + "SUB_QUEUE_2", "SUB_QUEUE_3", "SUBTRACT", "SUM", "SUPPRESS", + "SYMBOL", "SYMBOLIC", "SYNC", "SYNCHRONIZED", "TABLE", "TALLY", + "TALLYING", "TASK", "TAPE", "TERMINAL", "TERMINATE", "TEST", + "TEXT", "THAN", "THEN", "THREAD", "THREAD_LOCAL", "THROUGH", + "THRU", "TIME", "TIMER", "TIMES", "TITLE", "TO", "TODAYS_DATE", + "TODAYS_NAME", "TOP", "TRAILING", "TRUE", "TRUNCATED", "TYPE", + "TYPEDEF", "UNDERLINE", "UNIT", "UNSTRING", "UNTIL", "UP", "UPON", + "USAGE", "USE", "USING", "VALUE", "VALUES", "VARYING", "VIRTUAL", + "WAIT", "WHEN", "WHEN_COMPILED", "WITH", "WORDS", "WORKING_STORAGE", + "WRITE", "YEAR", "YYYYMMDD", "YYYYDDD", "ZERO", "ZERO_FILL", + "ZEROS", "ZEROES", "AMPCHAR", "ASTERISKCHAR", "DOUBLEASTERISKCHAR", + "COLONCHAR", "COMMACHAR", "COMMENTENTRYTAG", "COMMENTTAG", "DOLLARCHAR", + "DOUBLEQUOTE", "DOT_FS", "DOT", "EQUALCHAR", "EXECCICSTAG", + "EXECSQLTAG", "EXECSQLIMSTAG", "LESSTHANCHAR", "LESSTHANOREQUAL", + "LPARENCHAR", "MINUSCHAR", "MORETHANCHAR", "MORETHANOREQUAL", + "NOTEQUALCHAR", "PLUSCHAR", "SINGLEQUOTE", "RPARENCHAR", "SLASHCHAR", + "NONNUMERICLITERAL", "LEVEL_NUMBER_66", "LEVEL_NUMBER_77", "LEVEL_NUMBER_88", + "INTEGERLITERAL", "NUMERICLITERAL", "IDENTIFIER", "NEWLINE", + "EXECCICSLINE", "EXECSQLIMSLINE", "EXECSQLLINE", "COMMENTENTRYLINE", + "COMMENTLINE", "WS", "SEPARATOR" ] + + ruleNames = [ "ABORT", "ACCEPT", "ACCESS", "ADD", "ADDRESS", "ADVANCING", + "AFTER", "ALIGNED", "ALL", "ALPHABET", "ALPHABETIC", "ALPHABETIC_LOWER", + "ALPHABETIC_UPPER", "ALPHANUMERIC", "ALPHANUMERIC_EDITED", + "ALSO", "ALTER", "ALTERNATE", "AND", "ANY", "ARE", "AREA", + "AREAS", "AS", "ASCENDING", "ASCII", "ASSIGN", "ASSOCIATED_DATA", + "ASSOCIATED_DATA_LENGTH", "AT", "ATTRIBUTE", "AUTHOR", + "AUTO", "AUTO_SKIP", "BACKGROUND_COLOR", "BACKGROUND_COLOUR", + "BASIS", "BEEP", "BEFORE", "BEGINNING", "BELL", "BINARY", + "BIT", "BLANK", "BLINK", "BLOCK", "BOUNDS", "BOTTOM", + "BY", "BYFUNCTION", "BYTITLE", "CALL", "CANCEL", "CAPABLE", + "CCSVERSION", "CD", "CF", "CH", "CHAINING", "CHANGED", + "CHANNEL", "CHARACTER", "CHARACTERS", "CLASS", "CLASS_ID", + "CLOCK_UNITS", "CLOSE", "CLOSE_DISPOSITION", "COBOL", + "CODE", "CODE_SET", "COLLATING", "COL", "COLUMN", "COM_REG", + "COMMA", "COMMITMENT", "COMMON", "COMMUNICATION", "COMP", + "COMP_1", "COMP_2", "COMP_3", "COMP_4", "COMP_5", "COMPUTATIONAL", + "COMPUTATIONAL_1", "COMPUTATIONAL_2", "COMPUTATIONAL_3", + "COMPUTATIONAL_4", "COMPUTATIONAL_5", "COMPUTE", "CONFIGURATION", + "CONTAINS", "CONTENT", "CONTINUE", "CONTROL", "CONTROL_POINT", + "CONTROLS", "CONVENTION", "CONVERTING", "COPY", "CORR", + "CORRESPONDING", "COUNT", "CRUNCH", "CURRENCY", "CURSOR", + "DATA", "DATA_BASE", "DATE", "DATE_COMPILED", "DATE_WRITTEN", + "DAY", "DAY_OF_WEEK", "DBCS", "DE", "DEBUG_CONTENTS", + "DEBUG_ITEM", "DEBUG_LINE", "DEBUG_NAME", "DEBUG_SUB_1", + "DEBUG_SUB_2", "DEBUG_SUB_3", "DEBUGGING", "DECIMAL_POINT", + "DECLARATIVES", "DEFAULT", "DEFAULT_DISPLAY", "DEFINITION", + "DELETE", "DELIMITED", "DELIMITER", "DEPENDING", "DESCENDING", + "DESTINATION", "DETAIL", "DFHRESP", "DFHVALUE", "DISABLE", + "DISK", "DISPLAY", "DISPLAY_1", "DIVIDE", "DIVISION", + "DONTCARE", "DOUBLE", "DOWN", "DUPLICATES", "DYNAMIC", + "EBCDIC", "EGCS", "EGI", "ELSE", "EMI", "EMPTY_CHECK", + "ENABLE", "END", "END_ACCEPT", "END_ADD", "END_CALL", + "END_COMPUTE", "END_DELETE", "END_DIVIDE", "END_EVALUATE", + "END_IF", "END_MULTIPLY", "END_OF_PAGE", "END_PERFORM", + "END_READ", "END_RECEIVE", "END_RETURN", "END_REWRITE", + "END_SEARCH", "END_START", "END_STRING", "END_SUBTRACT", + "END_UNSTRING", "END_WRITE", "ENDING", "ENTER", "ENTRY", + "ENTRY_PROCEDURE", "ENVIRONMENT", "EOP", "EQUAL", "ERASE", + "ERROR", "EOL", "EOS", "ESCAPE", "ESI", "EVALUATE", "EVENT", + "EVERY", "EXCEPTION", "EXCLUSIVE", "EXHIBIT", "EXIT", + "EXPORT", "EXTEND", "EXTENDED", "EXTERNAL", "FALSE", "FD", + "FILE", "FILE_CONTROL", "FILLER", "FINAL", "FIRST", "FOOTING", + "FOR", "FOREGROUND_COLOR", "FOREGROUND_COLOUR", "FROM", + "FULL", "FUNCTION", "FUNCTIONNAME", "FUNCTION_POINTER", + "GENERATE", "GOBACK", "GIVING", "GLOBAL", "GO", "GREATER", + "GRID", "GROUP", "HEADING", "HIGHLIGHT", "HIGH_VALUE", + "HIGH_VALUES", "I_O", "I_O_CONTROL", "ID", "IDENTIFICATION", + "IF", "IMPLICIT", "IMPORT", "IN", "INDEX", "INDEXED", + "INDICATE", "INITIAL", "INITIALIZE", "INITIATE", "INPUT", + "INPUT_OUTPUT", "INSPECT", "INSTALLATION", "INTEGER", + "INTO", "INVALID", "INVOKE", "IS", "JUST", "JUSTIFIED", + "KANJI", "KEPT", "KEY", "KEYBOARD", "LABEL", "LANGUAGE", + "LAST", "LB", "LD", "LEADING", "LEFT", "LEFTLINE", "LENGTH", + "LENGTH_CHECK", "LESS", "LIBACCESS", "LIBPARAMETER", "LIBRARY", + "LIMIT", "LIMITS", "LINAGE", "LINAGE_COUNTER", "LINE", + "LINES", "LINE_COUNTER", "LINKAGE", "LIST", "LOCAL", "LOCAL_STORAGE", + "LOCK", "LONG_DATE", "LONG_TIME", "LOWER", "LOWLIGHT", + "LOW_VALUE", "LOW_VALUES", "MEMORY", "MERGE", "MESSAGE", + "MMDDYYYY", "MODE", "MODULES", "MORE_LABELS", "MOVE", + "MULTIPLE", "MULTIPLY", "NAMED", "NATIONAL", "NATIONAL_EDITED", + "NATIVE", "NEGATIVE", "NETWORK", "NEXT", "NO", "NO_ECHO", + "NOT", "NULL_", "NULLS", "NUMBER", "NUMERIC", "NUMERIC_DATE", + "NUMERIC_EDITED", "NUMERIC_TIME", "OBJECT_COMPUTER", "OCCURS", + "ODT", "OF", "OFF", "OMITTED", "ON", "OPEN", "OPTIONAL", + "OR", "ORDER", "ORDERLY", "ORGANIZATION", "OTHER", "OUTPUT", + "OVERFLOW", "OVERLINE", "OWN", "PACKED_DECIMAL", "PADDING", + "PAGE", "PAGE_COUNTER", "PASSWORD", "PERFORM", "PF", "PH", + "PIC", "PICTURE", "PLUS", "POINTER", "POSITION", "POSITIVE", + "PORT", "PRINTER", "PRINTING", "PRIVATE", "PROCEDURE", + "PROCEDURE_POINTER", "PROCEDURES", "PROCEED", "PROCESS", + "PROGRAM", "PROGRAM_ID", "PROGRAM_LIBRARY", "PROMPT", + "PURGE", "QUEUE", "QUOTE", "QUOTES", "RANDOM", "READER", + "REMOTE", "RD", "REAL", "READ", "RECEIVE", "RECEIVED", + "RECORD", "RECORDING", "RECORDS", "RECURSIVE", "REDEFINES", + "REEL", "REF", "REFERENCE", "REFERENCES", "RELATIVE", + "RELEASE", "REMAINDER", "REMARKS", "REMOVAL", "REMOVE", + "RENAMES", "REPLACE", "REPLACING", "REPORT", "REPORTING", + "REPORTS", "REQUIRED", "RERUN", "RESERVE", "REVERSE_VIDEO", + "RESET", "RETURN", "RETURN_CODE", "RETURNING", "REVERSED", + "REWIND", "REWRITE", "RF", "RH", "RIGHT", "ROUNDED", "RUN", + "SAME", "SAVE", "SCREEN", "SD", "SEARCH", "SECTION", "SECURE", + "SECURITY", "SEGMENT", "SEGMENT_LIMIT", "SELECT", "SEND", + "SENTENCE", "SEPARATE", "SEQUENCE", "SEQUENTIAL", "SET", + "SHARED", "SHAREDBYALL", "SHAREDBYRUNUNIT", "SHARING", + "SHIFT_IN", "SHIFT_OUT", "SHORT_DATE", "SIGN", "SIZE", + "SORT", "SORT_CONTROL", "SORT_CORE_SIZE", "SORT_FILE_SIZE", + "SORT_MERGE", "SORT_MESSAGE", "SORT_MODE_SIZE", "SORT_RETURN", + "SOURCE", "SOURCE_COMPUTER", "SPACE", "SPACES", "SPECIAL_NAMES", + "STANDARD", "STANDARD_1", "STANDARD_2", "START", "STATUS", + "STOP", "STRING", "SUB_QUEUE_1", "SUB_QUEUE_2", "SUB_QUEUE_3", + "SUBTRACT", "SUM", "SUPPRESS", "SYMBOL", "SYMBOLIC", "SYNC", + "SYNCHRONIZED", "TABLE", "TALLY", "TALLYING", "TASK", + "TAPE", "TERMINAL", "TERMINATE", "TEST", "TEXT", "THAN", + "THEN", "THREAD", "THREAD_LOCAL", "THROUGH", "THRU", "TIME", + "TIMER", "TIMES", "TITLE", "TO", "TODAYS_DATE", "TODAYS_NAME", + "TOP", "TRAILING", "TRUE", "TRUNCATED", "TYPE", "TYPEDEF", + "UNDERLINE", "UNIT", "UNSTRING", "UNTIL", "UP", "UPON", + "USAGE", "USE", "USING", "VALUE", "VALUES", "VARYING", + "VIRTUAL", "WAIT", "WHEN", "WHEN_COMPILED", "WITH", "WORDS", + "WORKING_STORAGE", "WRITE", "YEAR", "YYYYMMDD", "YYYYDDD", + "ZERO", "ZERO_FILL", "ZEROS", "ZEROES", "AMPCHAR", "ASTERISKCHAR", + "DOUBLEASTERISKCHAR", "COLONCHAR", "COMMACHAR", "COMMENTENTRYTAG", + "COMMENTTAG", "DOLLARCHAR", "DOUBLEQUOTE", "DOT_FS", "DOT", + "EQUALCHAR", "EXECCICSTAG", "EXECSQLTAG", "EXECSQLIMSTAG", + "LESSTHANCHAR", "LESSTHANOREQUAL", "LPARENCHAR", "MINUSCHAR", + "MORETHANCHAR", "MORETHANOREQUAL", "NOTEQUALCHAR", "PLUSCHAR", + "SINGLEQUOTE", "RPARENCHAR", "SLASHCHAR", "NONNUMERICLITERAL", + "HEXNUMBER", "NULLTERMINATED", "STRINGLITERAL", "DBCSLITERAL", + "LEVEL_NUMBER_66", "LEVEL_NUMBER_77", "LEVEL_NUMBER_88", + "INTEGERLITERAL", "NUMERICLITERAL", "IDENTIFIER", "NEWLINE", + "EXECCICSLINE", "EXECSQLIMSLINE", "EXECSQLLINE", "COMMENTENTRYLINE", + "COMMENTLINE", "WS", "SEPARATOR", "A", "B", "C", "D", + "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", + "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" ] + + grammarFileName = "Cobol85.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/src/Cobol85Lexer.tokens b/src/Cobol85Lexer.tokens new file mode 100644 index 0000000..e73851f --- /dev/null +++ b/src/Cobol85Lexer.tokens @@ -0,0 +1,594 @@ +ABORT=1 +ACCEPT=2 +ACCESS=3 +ADD=4 +ADDRESS=5 +ADVANCING=6 +AFTER=7 +ALIGNED=8 +ALL=9 +ALPHABET=10 +ALPHABETIC=11 +ALPHABETIC_LOWER=12 +ALPHABETIC_UPPER=13 +ALPHANUMERIC=14 +ALPHANUMERIC_EDITED=15 +ALSO=16 +ALTER=17 +ALTERNATE=18 +AND=19 +ANY=20 +ARE=21 +AREA=22 +AREAS=23 +AS=24 +ASCENDING=25 +ASCII=26 +ASSIGN=27 +ASSOCIATED_DATA=28 +ASSOCIATED_DATA_LENGTH=29 +AT=30 +ATTRIBUTE=31 +AUTHOR=32 +AUTO=33 +AUTO_SKIP=34 +BACKGROUND_COLOR=35 +BACKGROUND_COLOUR=36 +BASIS=37 +BEEP=38 +BEFORE=39 +BEGINNING=40 +BELL=41 +BINARY=42 +BIT=43 +BLANK=44 +BLINK=45 +BLOCK=46 +BOUNDS=47 +BOTTOM=48 +BY=49 +BYFUNCTION=50 +BYTITLE=51 +CALL=52 +CANCEL=53 +CAPABLE=54 +CCSVERSION=55 +CD=56 +CF=57 +CH=58 +CHAINING=59 +CHANGED=60 +CHANNEL=61 +CHARACTER=62 +CHARACTERS=63 +CLASS=64 +CLASS_ID=65 +CLOCK_UNITS=66 +CLOSE=67 +CLOSE_DISPOSITION=68 +COBOL=69 +CODE=70 +CODE_SET=71 +COLLATING=72 +COL=73 +COLUMN=74 +COM_REG=75 +COMMA=76 +COMMITMENT=77 +COMMON=78 +COMMUNICATION=79 +COMP=80 +COMP_1=81 +COMP_2=82 +COMP_3=83 +COMP_4=84 +COMP_5=85 +COMPUTATIONAL=86 +COMPUTATIONAL_1=87 +COMPUTATIONAL_2=88 +COMPUTATIONAL_3=89 +COMPUTATIONAL_4=90 +COMPUTATIONAL_5=91 +COMPUTE=92 +CONFIGURATION=93 +CONTAINS=94 +CONTENT=95 +CONTINUE=96 +CONTROL=97 +CONTROL_POINT=98 +CONTROLS=99 +CONVENTION=100 +CONVERTING=101 +COPY=102 +CORR=103 +CORRESPONDING=104 +COUNT=105 +CRUNCH=106 +CURRENCY=107 +CURSOR=108 +DATA=109 +DATA_BASE=110 +DATE=111 +DATE_COMPILED=112 +DATE_WRITTEN=113 +DAY=114 +DAY_OF_WEEK=115 +DBCS=116 +DE=117 +DEBUG_CONTENTS=118 +DEBUG_ITEM=119 +DEBUG_LINE=120 +DEBUG_NAME=121 +DEBUG_SUB_1=122 +DEBUG_SUB_2=123 +DEBUG_SUB_3=124 +DEBUGGING=125 +DECIMAL_POINT=126 +DECLARATIVES=127 +DEFAULT=128 +DEFAULT_DISPLAY=129 +DEFINITION=130 +DELETE=131 +DELIMITED=132 +DELIMITER=133 +DEPENDING=134 +DESCENDING=135 +DESTINATION=136 +DETAIL=137 +DFHRESP=138 +DFHVALUE=139 +DISABLE=140 +DISK=141 +DISPLAY=142 +DISPLAY_1=143 +DIVIDE=144 +DIVISION=145 +DONTCARE=146 +DOUBLE=147 +DOWN=148 +DUPLICATES=149 +DYNAMIC=150 +EBCDIC=151 +EGCS=152 +EGI=153 +ELSE=154 +EMI=155 +EMPTY_CHECK=156 +ENABLE=157 +END=158 +END_ACCEPT=159 +END_ADD=160 +END_CALL=161 +END_COMPUTE=162 +END_DELETE=163 +END_DIVIDE=164 +END_EVALUATE=165 +END_IF=166 +END_MULTIPLY=167 +END_OF_PAGE=168 +END_PERFORM=169 +END_READ=170 +END_RECEIVE=171 +END_RETURN=172 +END_REWRITE=173 +END_SEARCH=174 +END_START=175 +END_STRING=176 +END_SUBTRACT=177 +END_UNSTRING=178 +END_WRITE=179 +ENDING=180 +ENTER=181 +ENTRY=182 +ENTRY_PROCEDURE=183 +ENVIRONMENT=184 +EOP=185 +EQUAL=186 +ERASE=187 +ERROR=188 +EOL=189 +EOS=190 +ESCAPE=191 +ESI=192 +EVALUATE=193 +EVENT=194 +EVERY=195 +EXCEPTION=196 +EXCLUSIVE=197 +EXHIBIT=198 +EXIT=199 +EXPORT=200 +EXTEND=201 +EXTENDED=202 +EXTERNAL=203 +FALSE=204 +FD=205 +FILE=206 +FILE_CONTROL=207 +FILLER=208 +FINAL=209 +FIRST=210 +FOOTING=211 +FOR=212 +FOREGROUND_COLOR=213 +FOREGROUND_COLOUR=214 +FROM=215 +FULL=216 +FUNCTION=217 +FUNCTIONNAME=218 +FUNCTION_POINTER=219 +GENERATE=220 +GOBACK=221 +GIVING=222 +GLOBAL=223 +GO=224 +GREATER=225 +GRID=226 +GROUP=227 +HEADING=228 +HIGHLIGHT=229 +HIGH_VALUE=230 +HIGH_VALUES=231 +I_O=232 +I_O_CONTROL=233 +ID=234 +IDENTIFICATION=235 +IF=236 +IMPLICIT=237 +IMPORT=238 +IN=239 +INDEX=240 +INDEXED=241 +INDICATE=242 +INITIAL=243 +INITIALIZE=244 +INITIATE=245 +INPUT=246 +INPUT_OUTPUT=247 +INSPECT=248 +INSTALLATION=249 +INTEGER=250 +INTO=251 +INVALID=252 +INVOKE=253 +IS=254 +JUST=255 +JUSTIFIED=256 +KANJI=257 +KEPT=258 +KEY=259 +KEYBOARD=260 +LABEL=261 +LANGUAGE=262 +LAST=263 +LB=264 +LD=265 +LEADING=266 +LEFT=267 +LEFTLINE=268 +LENGTH=269 +LENGTH_CHECK=270 +LESS=271 +LIBACCESS=272 +LIBPARAMETER=273 +LIBRARY=274 +LIMIT=275 +LIMITS=276 +LINAGE=277 +LINAGE_COUNTER=278 +LINE=279 +LINES=280 +LINE_COUNTER=281 +LINKAGE=282 +LIST=283 +LOCAL=284 +LOCAL_STORAGE=285 +LOCK=286 +LONG_DATE=287 +LONG_TIME=288 +LOWER=289 +LOWLIGHT=290 +LOW_VALUE=291 +LOW_VALUES=292 +MEMORY=293 +MERGE=294 +MESSAGE=295 +MMDDYYYY=296 +MODE=297 +MODULES=298 +MORE_LABELS=299 +MOVE=300 +MULTIPLE=301 +MULTIPLY=302 +NAMED=303 +NATIONAL=304 +NATIONAL_EDITED=305 +NATIVE=306 +NEGATIVE=307 +NETWORK=308 +NEXT=309 +NO=310 +NO_ECHO=311 +NOT=312 +NULL_=313 +NULLS=314 +NUMBER=315 +NUMERIC=316 +NUMERIC_DATE=317 +NUMERIC_EDITED=318 +NUMERIC_TIME=319 +OBJECT_COMPUTER=320 +OCCURS=321 +ODT=322 +OF=323 +OFF=324 +OMITTED=325 +ON=326 +OPEN=327 +OPTIONAL=328 +OR=329 +ORDER=330 +ORDERLY=331 +ORGANIZATION=332 +OTHER=333 +OUTPUT=334 +OVERFLOW=335 +OVERLINE=336 +OWN=337 +PACKED_DECIMAL=338 +PADDING=339 +PAGE=340 +PAGE_COUNTER=341 +PASSWORD=342 +PERFORM=343 +PF=344 +PH=345 +PIC=346 +PICTURE=347 +PLUS=348 +POINTER=349 +POSITION=350 +POSITIVE=351 +PORT=352 +PRINTER=353 +PRINTING=354 +PRIVATE=355 +PROCEDURE=356 +PROCEDURE_POINTER=357 +PROCEDURES=358 +PROCEED=359 +PROCESS=360 +PROGRAM=361 +PROGRAM_ID=362 +PROGRAM_LIBRARY=363 +PROMPT=364 +PURGE=365 +QUEUE=366 +QUOTE=367 +QUOTES=368 +RANDOM=369 +READER=370 +REMOTE=371 +RD=372 +REAL=373 +READ=374 +RECEIVE=375 +RECEIVED=376 +RECORD=377 +RECORDING=378 +RECORDS=379 +RECURSIVE=380 +REDEFINES=381 +REEL=382 +REF=383 +REFERENCE=384 +REFERENCES=385 +RELATIVE=386 +RELEASE=387 +REMAINDER=388 +REMARKS=389 +REMOVAL=390 +REMOVE=391 +RENAMES=392 +REPLACE=393 +REPLACING=394 +REPORT=395 +REPORTING=396 +REPORTS=397 +REQUIRED=398 +RERUN=399 +RESERVE=400 +REVERSE_VIDEO=401 +RESET=402 +RETURN=403 +RETURN_CODE=404 +RETURNING=405 +REVERSED=406 +REWIND=407 +REWRITE=408 +RF=409 +RH=410 +RIGHT=411 +ROUNDED=412 +RUN=413 +SAME=414 +SAVE=415 +SCREEN=416 +SD=417 +SEARCH=418 +SECTION=419 +SECURE=420 +SECURITY=421 +SEGMENT=422 +SEGMENT_LIMIT=423 +SELECT=424 +SEND=425 +SENTENCE=426 +SEPARATE=427 +SEQUENCE=428 +SEQUENTIAL=429 +SET=430 +SHARED=431 +SHAREDBYALL=432 +SHAREDBYRUNUNIT=433 +SHARING=434 +SHIFT_IN=435 +SHIFT_OUT=436 +SHORT_DATE=437 +SIGN=438 +SIZE=439 +SORT=440 +SORT_CONTROL=441 +SORT_CORE_SIZE=442 +SORT_FILE_SIZE=443 +SORT_MERGE=444 +SORT_MESSAGE=445 +SORT_MODE_SIZE=446 +SORT_RETURN=447 +SOURCE=448 +SOURCE_COMPUTER=449 +SPACE=450 +SPACES=451 +SPECIAL_NAMES=452 +STANDARD=453 +STANDARD_1=454 +STANDARD_2=455 +START=456 +STATUS=457 +STOP=458 +STRING=459 +SUB_QUEUE_1=460 +SUB_QUEUE_2=461 +SUB_QUEUE_3=462 +SUBTRACT=463 +SUM=464 +SUPPRESS=465 +SYMBOL=466 +SYMBOLIC=467 +SYNC=468 +SYNCHRONIZED=469 +TABLE=470 +TALLY=471 +TALLYING=472 +TASK=473 +TAPE=474 +TERMINAL=475 +TERMINATE=476 +TEST=477 +TEXT=478 +THAN=479 +THEN=480 +THREAD=481 +THREAD_LOCAL=482 +THROUGH=483 +THRU=484 +TIME=485 +TIMER=486 +TIMES=487 +TITLE=488 +TO=489 +TODAYS_DATE=490 +TODAYS_NAME=491 +TOP=492 +TRAILING=493 +TRUE=494 +TRUNCATED=495 +TYPE=496 +TYPEDEF=497 +UNDERLINE=498 +UNIT=499 +UNSTRING=500 +UNTIL=501 +UP=502 +UPON=503 +USAGE=504 +USE=505 +USING=506 +VALUE=507 +VALUES=508 +VARYING=509 +VIRTUAL=510 +WAIT=511 +WHEN=512 +WHEN_COMPILED=513 +WITH=514 +WORDS=515 +WORKING_STORAGE=516 +WRITE=517 +YEAR=518 +YYYYMMDD=519 +YYYYDDD=520 +ZERO=521 +ZERO_FILL=522 +ZEROS=523 +ZEROES=524 +AMPCHAR=525 +ASTERISKCHAR=526 +DOUBLEASTERISKCHAR=527 +COLONCHAR=528 +COMMACHAR=529 +COMMENTENTRYTAG=530 +COMMENTTAG=531 +DOLLARCHAR=532 +DOUBLEQUOTE=533 +DOT_FS=534 +DOT=535 +EQUALCHAR=536 +EXECCICSTAG=537 +EXECSQLTAG=538 +EXECSQLIMSTAG=539 +LESSTHANCHAR=540 +LESSTHANOREQUAL=541 +LPARENCHAR=542 +MINUSCHAR=543 +MORETHANCHAR=544 +MORETHANOREQUAL=545 +NOTEQUALCHAR=546 +PLUSCHAR=547 +SINGLEQUOTE=548 +RPARENCHAR=549 +SLASHCHAR=550 +NONNUMERICLITERAL=551 +LEVEL_NUMBER_66=552 +LEVEL_NUMBER_77=553 +LEVEL_NUMBER_88=554 +INTEGERLITERAL=555 +NUMERICLITERAL=556 +IDENTIFIER=557 +NEWLINE=558 +EXECCICSLINE=559 +EXECSQLIMSLINE=560 +EXECSQLLINE=561 +COMMENTENTRYLINE=562 +COMMENTLINE=563 +WS=564 +SEPARATOR=565 +'&'=525 +'*'=526 +'**'=527 +':'=528 +','=529 +'*>CE'=530 +'*>'=531 +'$'=532 +'"'=533 +'.'=535 +'='=536 +'*>EXECCICS'=537 +'*>EXECSQL'=538 +'*>EXECSQLIMS'=539 +'<'=540 +'<='=541 +'('=542 +'-'=543 +'>'=544 +'>='=545 +'<>'=546 +'+'=547 +'\''=548 +')'=549 +'/'=550 +'66'=552 +'77'=553 +'88'=554 +', '=565 diff --git a/src/Cobol85Listener.py b/src/Cobol85Listener.py new file mode 100644 index 0000000..0462def --- /dev/null +++ b/src/Cobol85Listener.py @@ -0,0 +1,5367 @@ +# Generated from Cobol85.g4 by ANTLR 4.13.1 +from antlr4 import * +if "." in __name__: + from .Cobol85Parser import Cobol85Parser +else: + from Cobol85Parser import Cobol85Parser + +# This class defines a complete listener for a parse tree produced by Cobol85Parser. +class Cobol85Listener(ParseTreeListener): + + # Enter a parse tree produced by Cobol85Parser#startRule. + def enterStartRule(self, ctx:Cobol85Parser.StartRuleContext): + pass + + # Exit a parse tree produced by Cobol85Parser#startRule. + def exitStartRule(self, ctx:Cobol85Parser.StartRuleContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#compilationUnit. + def enterCompilationUnit(self, ctx:Cobol85Parser.CompilationUnitContext): + pass + + # Exit a parse tree produced by Cobol85Parser#compilationUnit. + def exitCompilationUnit(self, ctx:Cobol85Parser.CompilationUnitContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#programUnit. + def enterProgramUnit(self, ctx:Cobol85Parser.ProgramUnitContext): + pass + + # Exit a parse tree produced by Cobol85Parser#programUnit. + def exitProgramUnit(self, ctx:Cobol85Parser.ProgramUnitContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#endProgramStatement. + def enterEndProgramStatement(self, ctx:Cobol85Parser.EndProgramStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#endProgramStatement. + def exitEndProgramStatement(self, ctx:Cobol85Parser.EndProgramStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#identificationDivision. + def enterIdentificationDivision(self, ctx:Cobol85Parser.IdentificationDivisionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#identificationDivision. + def exitIdentificationDivision(self, ctx:Cobol85Parser.IdentificationDivisionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#identificationDivisionBody. + def enterIdentificationDivisionBody(self, ctx:Cobol85Parser.IdentificationDivisionBodyContext): + pass + + # Exit a parse tree produced by Cobol85Parser#identificationDivisionBody. + def exitIdentificationDivisionBody(self, ctx:Cobol85Parser.IdentificationDivisionBodyContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#programIdParagraph. + def enterProgramIdParagraph(self, ctx:Cobol85Parser.ProgramIdParagraphContext): + pass + + # Exit a parse tree produced by Cobol85Parser#programIdParagraph. + def exitProgramIdParagraph(self, ctx:Cobol85Parser.ProgramIdParagraphContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#authorParagraph. + def enterAuthorParagraph(self, ctx:Cobol85Parser.AuthorParagraphContext): + pass + + # Exit a parse tree produced by Cobol85Parser#authorParagraph. + def exitAuthorParagraph(self, ctx:Cobol85Parser.AuthorParagraphContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#installationParagraph. + def enterInstallationParagraph(self, ctx:Cobol85Parser.InstallationParagraphContext): + pass + + # Exit a parse tree produced by Cobol85Parser#installationParagraph. + def exitInstallationParagraph(self, ctx:Cobol85Parser.InstallationParagraphContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dateWrittenParagraph. + def enterDateWrittenParagraph(self, ctx:Cobol85Parser.DateWrittenParagraphContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dateWrittenParagraph. + def exitDateWrittenParagraph(self, ctx:Cobol85Parser.DateWrittenParagraphContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dateCompiledParagraph. + def enterDateCompiledParagraph(self, ctx:Cobol85Parser.DateCompiledParagraphContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dateCompiledParagraph. + def exitDateCompiledParagraph(self, ctx:Cobol85Parser.DateCompiledParagraphContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#securityParagraph. + def enterSecurityParagraph(self, ctx:Cobol85Parser.SecurityParagraphContext): + pass + + # Exit a parse tree produced by Cobol85Parser#securityParagraph. + def exitSecurityParagraph(self, ctx:Cobol85Parser.SecurityParagraphContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#remarksParagraph. + def enterRemarksParagraph(self, ctx:Cobol85Parser.RemarksParagraphContext): + pass + + # Exit a parse tree produced by Cobol85Parser#remarksParagraph. + def exitRemarksParagraph(self, ctx:Cobol85Parser.RemarksParagraphContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#environmentDivision. + def enterEnvironmentDivision(self, ctx:Cobol85Parser.EnvironmentDivisionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#environmentDivision. + def exitEnvironmentDivision(self, ctx:Cobol85Parser.EnvironmentDivisionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#environmentDivisionBody. + def enterEnvironmentDivisionBody(self, ctx:Cobol85Parser.EnvironmentDivisionBodyContext): + pass + + # Exit a parse tree produced by Cobol85Parser#environmentDivisionBody. + def exitEnvironmentDivisionBody(self, ctx:Cobol85Parser.EnvironmentDivisionBodyContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#configurationSection. + def enterConfigurationSection(self, ctx:Cobol85Parser.ConfigurationSectionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#configurationSection. + def exitConfigurationSection(self, ctx:Cobol85Parser.ConfigurationSectionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#configurationSectionParagraph. + def enterConfigurationSectionParagraph(self, ctx:Cobol85Parser.ConfigurationSectionParagraphContext): + pass + + # Exit a parse tree produced by Cobol85Parser#configurationSectionParagraph. + def exitConfigurationSectionParagraph(self, ctx:Cobol85Parser.ConfigurationSectionParagraphContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sourceComputerParagraph. + def enterSourceComputerParagraph(self, ctx:Cobol85Parser.SourceComputerParagraphContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sourceComputerParagraph. + def exitSourceComputerParagraph(self, ctx:Cobol85Parser.SourceComputerParagraphContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#objectComputerParagraph. + def enterObjectComputerParagraph(self, ctx:Cobol85Parser.ObjectComputerParagraphContext): + pass + + # Exit a parse tree produced by Cobol85Parser#objectComputerParagraph. + def exitObjectComputerParagraph(self, ctx:Cobol85Parser.ObjectComputerParagraphContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#objectComputerClause. + def enterObjectComputerClause(self, ctx:Cobol85Parser.ObjectComputerClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#objectComputerClause. + def exitObjectComputerClause(self, ctx:Cobol85Parser.ObjectComputerClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#memorySizeClause. + def enterMemorySizeClause(self, ctx:Cobol85Parser.MemorySizeClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#memorySizeClause. + def exitMemorySizeClause(self, ctx:Cobol85Parser.MemorySizeClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#diskSizeClause. + def enterDiskSizeClause(self, ctx:Cobol85Parser.DiskSizeClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#diskSizeClause. + def exitDiskSizeClause(self, ctx:Cobol85Parser.DiskSizeClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#collatingSequenceClause. + def enterCollatingSequenceClause(self, ctx:Cobol85Parser.CollatingSequenceClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#collatingSequenceClause. + def exitCollatingSequenceClause(self, ctx:Cobol85Parser.CollatingSequenceClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#collatingSequenceClauseAlphanumeric. + def enterCollatingSequenceClauseAlphanumeric(self, ctx:Cobol85Parser.CollatingSequenceClauseAlphanumericContext): + pass + + # Exit a parse tree produced by Cobol85Parser#collatingSequenceClauseAlphanumeric. + def exitCollatingSequenceClauseAlphanumeric(self, ctx:Cobol85Parser.CollatingSequenceClauseAlphanumericContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#collatingSequenceClauseNational. + def enterCollatingSequenceClauseNational(self, ctx:Cobol85Parser.CollatingSequenceClauseNationalContext): + pass + + # Exit a parse tree produced by Cobol85Parser#collatingSequenceClauseNational. + def exitCollatingSequenceClauseNational(self, ctx:Cobol85Parser.CollatingSequenceClauseNationalContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#segmentLimitClause. + def enterSegmentLimitClause(self, ctx:Cobol85Parser.SegmentLimitClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#segmentLimitClause. + def exitSegmentLimitClause(self, ctx:Cobol85Parser.SegmentLimitClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#characterSetClause. + def enterCharacterSetClause(self, ctx:Cobol85Parser.CharacterSetClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#characterSetClause. + def exitCharacterSetClause(self, ctx:Cobol85Parser.CharacterSetClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#specialNamesParagraph. + def enterSpecialNamesParagraph(self, ctx:Cobol85Parser.SpecialNamesParagraphContext): + pass + + # Exit a parse tree produced by Cobol85Parser#specialNamesParagraph. + def exitSpecialNamesParagraph(self, ctx:Cobol85Parser.SpecialNamesParagraphContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#specialNameClause. + def enterSpecialNameClause(self, ctx:Cobol85Parser.SpecialNameClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#specialNameClause. + def exitSpecialNameClause(self, ctx:Cobol85Parser.SpecialNameClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#alphabetClause. + def enterAlphabetClause(self, ctx:Cobol85Parser.AlphabetClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#alphabetClause. + def exitAlphabetClause(self, ctx:Cobol85Parser.AlphabetClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#alphabetClauseFormat1. + def enterAlphabetClauseFormat1(self, ctx:Cobol85Parser.AlphabetClauseFormat1Context): + pass + + # Exit a parse tree produced by Cobol85Parser#alphabetClauseFormat1. + def exitAlphabetClauseFormat1(self, ctx:Cobol85Parser.AlphabetClauseFormat1Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#alphabetLiterals. + def enterAlphabetLiterals(self, ctx:Cobol85Parser.AlphabetLiteralsContext): + pass + + # Exit a parse tree produced by Cobol85Parser#alphabetLiterals. + def exitAlphabetLiterals(self, ctx:Cobol85Parser.AlphabetLiteralsContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#alphabetThrough. + def enterAlphabetThrough(self, ctx:Cobol85Parser.AlphabetThroughContext): + pass + + # Exit a parse tree produced by Cobol85Parser#alphabetThrough. + def exitAlphabetThrough(self, ctx:Cobol85Parser.AlphabetThroughContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#alphabetAlso. + def enterAlphabetAlso(self, ctx:Cobol85Parser.AlphabetAlsoContext): + pass + + # Exit a parse tree produced by Cobol85Parser#alphabetAlso. + def exitAlphabetAlso(self, ctx:Cobol85Parser.AlphabetAlsoContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#alphabetClauseFormat2. + def enterAlphabetClauseFormat2(self, ctx:Cobol85Parser.AlphabetClauseFormat2Context): + pass + + # Exit a parse tree produced by Cobol85Parser#alphabetClauseFormat2. + def exitAlphabetClauseFormat2(self, ctx:Cobol85Parser.AlphabetClauseFormat2Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#channelClause. + def enterChannelClause(self, ctx:Cobol85Parser.ChannelClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#channelClause. + def exitChannelClause(self, ctx:Cobol85Parser.ChannelClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#classClause. + def enterClassClause(self, ctx:Cobol85Parser.ClassClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#classClause. + def exitClassClause(self, ctx:Cobol85Parser.ClassClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#classClauseThrough. + def enterClassClauseThrough(self, ctx:Cobol85Parser.ClassClauseThroughContext): + pass + + # Exit a parse tree produced by Cobol85Parser#classClauseThrough. + def exitClassClauseThrough(self, ctx:Cobol85Parser.ClassClauseThroughContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#classClauseFrom. + def enterClassClauseFrom(self, ctx:Cobol85Parser.ClassClauseFromContext): + pass + + # Exit a parse tree produced by Cobol85Parser#classClauseFrom. + def exitClassClauseFrom(self, ctx:Cobol85Parser.ClassClauseFromContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#classClauseTo. + def enterClassClauseTo(self, ctx:Cobol85Parser.ClassClauseToContext): + pass + + # Exit a parse tree produced by Cobol85Parser#classClauseTo. + def exitClassClauseTo(self, ctx:Cobol85Parser.ClassClauseToContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#currencySignClause. + def enterCurrencySignClause(self, ctx:Cobol85Parser.CurrencySignClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#currencySignClause. + def exitCurrencySignClause(self, ctx:Cobol85Parser.CurrencySignClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#decimalPointClause. + def enterDecimalPointClause(self, ctx:Cobol85Parser.DecimalPointClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#decimalPointClause. + def exitDecimalPointClause(self, ctx:Cobol85Parser.DecimalPointClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#defaultComputationalSignClause. + def enterDefaultComputationalSignClause(self, ctx:Cobol85Parser.DefaultComputationalSignClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#defaultComputationalSignClause. + def exitDefaultComputationalSignClause(self, ctx:Cobol85Parser.DefaultComputationalSignClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#defaultDisplaySignClause. + def enterDefaultDisplaySignClause(self, ctx:Cobol85Parser.DefaultDisplaySignClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#defaultDisplaySignClause. + def exitDefaultDisplaySignClause(self, ctx:Cobol85Parser.DefaultDisplaySignClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#environmentSwitchNameClause. + def enterEnvironmentSwitchNameClause(self, ctx:Cobol85Parser.EnvironmentSwitchNameClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#environmentSwitchNameClause. + def exitEnvironmentSwitchNameClause(self, ctx:Cobol85Parser.EnvironmentSwitchNameClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#environmentSwitchNameSpecialNamesStatusPhrase. + def enterEnvironmentSwitchNameSpecialNamesStatusPhrase(self, ctx:Cobol85Parser.EnvironmentSwitchNameSpecialNamesStatusPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#environmentSwitchNameSpecialNamesStatusPhrase. + def exitEnvironmentSwitchNameSpecialNamesStatusPhrase(self, ctx:Cobol85Parser.EnvironmentSwitchNameSpecialNamesStatusPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#odtClause. + def enterOdtClause(self, ctx:Cobol85Parser.OdtClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#odtClause. + def exitOdtClause(self, ctx:Cobol85Parser.OdtClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reserveNetworkClause. + def enterReserveNetworkClause(self, ctx:Cobol85Parser.ReserveNetworkClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reserveNetworkClause. + def exitReserveNetworkClause(self, ctx:Cobol85Parser.ReserveNetworkClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#symbolicCharactersClause. + def enterSymbolicCharactersClause(self, ctx:Cobol85Parser.SymbolicCharactersClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#symbolicCharactersClause. + def exitSymbolicCharactersClause(self, ctx:Cobol85Parser.SymbolicCharactersClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#symbolicCharacters. + def enterSymbolicCharacters(self, ctx:Cobol85Parser.SymbolicCharactersContext): + pass + + # Exit a parse tree produced by Cobol85Parser#symbolicCharacters. + def exitSymbolicCharacters(self, ctx:Cobol85Parser.SymbolicCharactersContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inputOutputSection. + def enterInputOutputSection(self, ctx:Cobol85Parser.InputOutputSectionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inputOutputSection. + def exitInputOutputSection(self, ctx:Cobol85Parser.InputOutputSectionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inputOutputSectionParagraph. + def enterInputOutputSectionParagraph(self, ctx:Cobol85Parser.InputOutputSectionParagraphContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inputOutputSectionParagraph. + def exitInputOutputSectionParagraph(self, ctx:Cobol85Parser.InputOutputSectionParagraphContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#fileControlParagraph. + def enterFileControlParagraph(self, ctx:Cobol85Parser.FileControlParagraphContext): + pass + + # Exit a parse tree produced by Cobol85Parser#fileControlParagraph. + def exitFileControlParagraph(self, ctx:Cobol85Parser.FileControlParagraphContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#fileControlEntry. + def enterFileControlEntry(self, ctx:Cobol85Parser.FileControlEntryContext): + pass + + # Exit a parse tree produced by Cobol85Parser#fileControlEntry. + def exitFileControlEntry(self, ctx:Cobol85Parser.FileControlEntryContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#selectClause. + def enterSelectClause(self, ctx:Cobol85Parser.SelectClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#selectClause. + def exitSelectClause(self, ctx:Cobol85Parser.SelectClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#fileControlClause. + def enterFileControlClause(self, ctx:Cobol85Parser.FileControlClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#fileControlClause. + def exitFileControlClause(self, ctx:Cobol85Parser.FileControlClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#assignClause. + def enterAssignClause(self, ctx:Cobol85Parser.AssignClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#assignClause. + def exitAssignClause(self, ctx:Cobol85Parser.AssignClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reserveClause. + def enterReserveClause(self, ctx:Cobol85Parser.ReserveClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reserveClause. + def exitReserveClause(self, ctx:Cobol85Parser.ReserveClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#organizationClause. + def enterOrganizationClause(self, ctx:Cobol85Parser.OrganizationClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#organizationClause. + def exitOrganizationClause(self, ctx:Cobol85Parser.OrganizationClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#paddingCharacterClause. + def enterPaddingCharacterClause(self, ctx:Cobol85Parser.PaddingCharacterClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#paddingCharacterClause. + def exitPaddingCharacterClause(self, ctx:Cobol85Parser.PaddingCharacterClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#recordDelimiterClause. + def enterRecordDelimiterClause(self, ctx:Cobol85Parser.RecordDelimiterClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#recordDelimiterClause. + def exitRecordDelimiterClause(self, ctx:Cobol85Parser.RecordDelimiterClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#accessModeClause. + def enterAccessModeClause(self, ctx:Cobol85Parser.AccessModeClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#accessModeClause. + def exitAccessModeClause(self, ctx:Cobol85Parser.AccessModeClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#recordKeyClause. + def enterRecordKeyClause(self, ctx:Cobol85Parser.RecordKeyClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#recordKeyClause. + def exitRecordKeyClause(self, ctx:Cobol85Parser.RecordKeyClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#alternateRecordKeyClause. + def enterAlternateRecordKeyClause(self, ctx:Cobol85Parser.AlternateRecordKeyClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#alternateRecordKeyClause. + def exitAlternateRecordKeyClause(self, ctx:Cobol85Parser.AlternateRecordKeyClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#passwordClause. + def enterPasswordClause(self, ctx:Cobol85Parser.PasswordClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#passwordClause. + def exitPasswordClause(self, ctx:Cobol85Parser.PasswordClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#fileStatusClause. + def enterFileStatusClause(self, ctx:Cobol85Parser.FileStatusClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#fileStatusClause. + def exitFileStatusClause(self, ctx:Cobol85Parser.FileStatusClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#relativeKeyClause. + def enterRelativeKeyClause(self, ctx:Cobol85Parser.RelativeKeyClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#relativeKeyClause. + def exitRelativeKeyClause(self, ctx:Cobol85Parser.RelativeKeyClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#ioControlParagraph. + def enterIoControlParagraph(self, ctx:Cobol85Parser.IoControlParagraphContext): + pass + + # Exit a parse tree produced by Cobol85Parser#ioControlParagraph. + def exitIoControlParagraph(self, ctx:Cobol85Parser.IoControlParagraphContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#ioControlClause. + def enterIoControlClause(self, ctx:Cobol85Parser.IoControlClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#ioControlClause. + def exitIoControlClause(self, ctx:Cobol85Parser.IoControlClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#rerunClause. + def enterRerunClause(self, ctx:Cobol85Parser.RerunClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#rerunClause. + def exitRerunClause(self, ctx:Cobol85Parser.RerunClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#rerunEveryRecords. + def enterRerunEveryRecords(self, ctx:Cobol85Parser.RerunEveryRecordsContext): + pass + + # Exit a parse tree produced by Cobol85Parser#rerunEveryRecords. + def exitRerunEveryRecords(self, ctx:Cobol85Parser.RerunEveryRecordsContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#rerunEveryOf. + def enterRerunEveryOf(self, ctx:Cobol85Parser.RerunEveryOfContext): + pass + + # Exit a parse tree produced by Cobol85Parser#rerunEveryOf. + def exitRerunEveryOf(self, ctx:Cobol85Parser.RerunEveryOfContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#rerunEveryClock. + def enterRerunEveryClock(self, ctx:Cobol85Parser.RerunEveryClockContext): + pass + + # Exit a parse tree produced by Cobol85Parser#rerunEveryClock. + def exitRerunEveryClock(self, ctx:Cobol85Parser.RerunEveryClockContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sameClause. + def enterSameClause(self, ctx:Cobol85Parser.SameClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sameClause. + def exitSameClause(self, ctx:Cobol85Parser.SameClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#multipleFileClause. + def enterMultipleFileClause(self, ctx:Cobol85Parser.MultipleFileClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#multipleFileClause. + def exitMultipleFileClause(self, ctx:Cobol85Parser.MultipleFileClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#multipleFilePosition. + def enterMultipleFilePosition(self, ctx:Cobol85Parser.MultipleFilePositionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#multipleFilePosition. + def exitMultipleFilePosition(self, ctx:Cobol85Parser.MultipleFilePositionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#commitmentControlClause. + def enterCommitmentControlClause(self, ctx:Cobol85Parser.CommitmentControlClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#commitmentControlClause. + def exitCommitmentControlClause(self, ctx:Cobol85Parser.CommitmentControlClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataDivision. + def enterDataDivision(self, ctx:Cobol85Parser.DataDivisionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataDivision. + def exitDataDivision(self, ctx:Cobol85Parser.DataDivisionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataDivisionSection. + def enterDataDivisionSection(self, ctx:Cobol85Parser.DataDivisionSectionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataDivisionSection. + def exitDataDivisionSection(self, ctx:Cobol85Parser.DataDivisionSectionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#fileSection. + def enterFileSection(self, ctx:Cobol85Parser.FileSectionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#fileSection. + def exitFileSection(self, ctx:Cobol85Parser.FileSectionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#fileDescriptionEntry. + def enterFileDescriptionEntry(self, ctx:Cobol85Parser.FileDescriptionEntryContext): + pass + + # Exit a parse tree produced by Cobol85Parser#fileDescriptionEntry. + def exitFileDescriptionEntry(self, ctx:Cobol85Parser.FileDescriptionEntryContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#fileDescriptionEntryClause. + def enterFileDescriptionEntryClause(self, ctx:Cobol85Parser.FileDescriptionEntryClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#fileDescriptionEntryClause. + def exitFileDescriptionEntryClause(self, ctx:Cobol85Parser.FileDescriptionEntryClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#externalClause. + def enterExternalClause(self, ctx:Cobol85Parser.ExternalClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#externalClause. + def exitExternalClause(self, ctx:Cobol85Parser.ExternalClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#globalClause. + def enterGlobalClause(self, ctx:Cobol85Parser.GlobalClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#globalClause. + def exitGlobalClause(self, ctx:Cobol85Parser.GlobalClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#blockContainsClause. + def enterBlockContainsClause(self, ctx:Cobol85Parser.BlockContainsClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#blockContainsClause. + def exitBlockContainsClause(self, ctx:Cobol85Parser.BlockContainsClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#blockContainsTo. + def enterBlockContainsTo(self, ctx:Cobol85Parser.BlockContainsToContext): + pass + + # Exit a parse tree produced by Cobol85Parser#blockContainsTo. + def exitBlockContainsTo(self, ctx:Cobol85Parser.BlockContainsToContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#recordContainsClause. + def enterRecordContainsClause(self, ctx:Cobol85Parser.RecordContainsClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#recordContainsClause. + def exitRecordContainsClause(self, ctx:Cobol85Parser.RecordContainsClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#recordContainsClauseFormat1. + def enterRecordContainsClauseFormat1(self, ctx:Cobol85Parser.RecordContainsClauseFormat1Context): + pass + + # Exit a parse tree produced by Cobol85Parser#recordContainsClauseFormat1. + def exitRecordContainsClauseFormat1(self, ctx:Cobol85Parser.RecordContainsClauseFormat1Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#recordContainsClauseFormat2. + def enterRecordContainsClauseFormat2(self, ctx:Cobol85Parser.RecordContainsClauseFormat2Context): + pass + + # Exit a parse tree produced by Cobol85Parser#recordContainsClauseFormat2. + def exitRecordContainsClauseFormat2(self, ctx:Cobol85Parser.RecordContainsClauseFormat2Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#recordContainsClauseFormat3. + def enterRecordContainsClauseFormat3(self, ctx:Cobol85Parser.RecordContainsClauseFormat3Context): + pass + + # Exit a parse tree produced by Cobol85Parser#recordContainsClauseFormat3. + def exitRecordContainsClauseFormat3(self, ctx:Cobol85Parser.RecordContainsClauseFormat3Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#recordContainsTo. + def enterRecordContainsTo(self, ctx:Cobol85Parser.RecordContainsToContext): + pass + + # Exit a parse tree produced by Cobol85Parser#recordContainsTo. + def exitRecordContainsTo(self, ctx:Cobol85Parser.RecordContainsToContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#labelRecordsClause. + def enterLabelRecordsClause(self, ctx:Cobol85Parser.LabelRecordsClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#labelRecordsClause. + def exitLabelRecordsClause(self, ctx:Cobol85Parser.LabelRecordsClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#valueOfClause. + def enterValueOfClause(self, ctx:Cobol85Parser.ValueOfClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#valueOfClause. + def exitValueOfClause(self, ctx:Cobol85Parser.ValueOfClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#valuePair. + def enterValuePair(self, ctx:Cobol85Parser.ValuePairContext): + pass + + # Exit a parse tree produced by Cobol85Parser#valuePair. + def exitValuePair(self, ctx:Cobol85Parser.ValuePairContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataRecordsClause. + def enterDataRecordsClause(self, ctx:Cobol85Parser.DataRecordsClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataRecordsClause. + def exitDataRecordsClause(self, ctx:Cobol85Parser.DataRecordsClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#linageClause. + def enterLinageClause(self, ctx:Cobol85Parser.LinageClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#linageClause. + def exitLinageClause(self, ctx:Cobol85Parser.LinageClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#linageAt. + def enterLinageAt(self, ctx:Cobol85Parser.LinageAtContext): + pass + + # Exit a parse tree produced by Cobol85Parser#linageAt. + def exitLinageAt(self, ctx:Cobol85Parser.LinageAtContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#linageFootingAt. + def enterLinageFootingAt(self, ctx:Cobol85Parser.LinageFootingAtContext): + pass + + # Exit a parse tree produced by Cobol85Parser#linageFootingAt. + def exitLinageFootingAt(self, ctx:Cobol85Parser.LinageFootingAtContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#linageLinesAtTop. + def enterLinageLinesAtTop(self, ctx:Cobol85Parser.LinageLinesAtTopContext): + pass + + # Exit a parse tree produced by Cobol85Parser#linageLinesAtTop. + def exitLinageLinesAtTop(self, ctx:Cobol85Parser.LinageLinesAtTopContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#linageLinesAtBottom. + def enterLinageLinesAtBottom(self, ctx:Cobol85Parser.LinageLinesAtBottomContext): + pass + + # Exit a parse tree produced by Cobol85Parser#linageLinesAtBottom. + def exitLinageLinesAtBottom(self, ctx:Cobol85Parser.LinageLinesAtBottomContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#recordingModeClause. + def enterRecordingModeClause(self, ctx:Cobol85Parser.RecordingModeClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#recordingModeClause. + def exitRecordingModeClause(self, ctx:Cobol85Parser.RecordingModeClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#modeStatement. + def enterModeStatement(self, ctx:Cobol85Parser.ModeStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#modeStatement. + def exitModeStatement(self, ctx:Cobol85Parser.ModeStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#codeSetClause. + def enterCodeSetClause(self, ctx:Cobol85Parser.CodeSetClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#codeSetClause. + def exitCodeSetClause(self, ctx:Cobol85Parser.CodeSetClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportClause. + def enterReportClause(self, ctx:Cobol85Parser.ReportClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportClause. + def exitReportClause(self, ctx:Cobol85Parser.ReportClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataBaseSection. + def enterDataBaseSection(self, ctx:Cobol85Parser.DataBaseSectionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataBaseSection. + def exitDataBaseSection(self, ctx:Cobol85Parser.DataBaseSectionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataBaseSectionEntry. + def enterDataBaseSectionEntry(self, ctx:Cobol85Parser.DataBaseSectionEntryContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataBaseSectionEntry. + def exitDataBaseSectionEntry(self, ctx:Cobol85Parser.DataBaseSectionEntryContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#workingStorageSection. + def enterWorkingStorageSection(self, ctx:Cobol85Parser.WorkingStorageSectionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#workingStorageSection. + def exitWorkingStorageSection(self, ctx:Cobol85Parser.WorkingStorageSectionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#linkageSection. + def enterLinkageSection(self, ctx:Cobol85Parser.LinkageSectionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#linkageSection. + def exitLinkageSection(self, ctx:Cobol85Parser.LinkageSectionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#communicationSection. + def enterCommunicationSection(self, ctx:Cobol85Parser.CommunicationSectionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#communicationSection. + def exitCommunicationSection(self, ctx:Cobol85Parser.CommunicationSectionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#communicationDescriptionEntry. + def enterCommunicationDescriptionEntry(self, ctx:Cobol85Parser.CommunicationDescriptionEntryContext): + pass + + # Exit a parse tree produced by Cobol85Parser#communicationDescriptionEntry. + def exitCommunicationDescriptionEntry(self, ctx:Cobol85Parser.CommunicationDescriptionEntryContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#communicationDescriptionEntryFormat1. + def enterCommunicationDescriptionEntryFormat1(self, ctx:Cobol85Parser.CommunicationDescriptionEntryFormat1Context): + pass + + # Exit a parse tree produced by Cobol85Parser#communicationDescriptionEntryFormat1. + def exitCommunicationDescriptionEntryFormat1(self, ctx:Cobol85Parser.CommunicationDescriptionEntryFormat1Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#communicationDescriptionEntryFormat2. + def enterCommunicationDescriptionEntryFormat2(self, ctx:Cobol85Parser.CommunicationDescriptionEntryFormat2Context): + pass + + # Exit a parse tree produced by Cobol85Parser#communicationDescriptionEntryFormat2. + def exitCommunicationDescriptionEntryFormat2(self, ctx:Cobol85Parser.CommunicationDescriptionEntryFormat2Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#communicationDescriptionEntryFormat3. + def enterCommunicationDescriptionEntryFormat3(self, ctx:Cobol85Parser.CommunicationDescriptionEntryFormat3Context): + pass + + # Exit a parse tree produced by Cobol85Parser#communicationDescriptionEntryFormat3. + def exitCommunicationDescriptionEntryFormat3(self, ctx:Cobol85Parser.CommunicationDescriptionEntryFormat3Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#destinationCountClause. + def enterDestinationCountClause(self, ctx:Cobol85Parser.DestinationCountClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#destinationCountClause. + def exitDestinationCountClause(self, ctx:Cobol85Parser.DestinationCountClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#destinationTableClause. + def enterDestinationTableClause(self, ctx:Cobol85Parser.DestinationTableClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#destinationTableClause. + def exitDestinationTableClause(self, ctx:Cobol85Parser.DestinationTableClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#endKeyClause. + def enterEndKeyClause(self, ctx:Cobol85Parser.EndKeyClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#endKeyClause. + def exitEndKeyClause(self, ctx:Cobol85Parser.EndKeyClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#errorKeyClause. + def enterErrorKeyClause(self, ctx:Cobol85Parser.ErrorKeyClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#errorKeyClause. + def exitErrorKeyClause(self, ctx:Cobol85Parser.ErrorKeyClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#messageCountClause. + def enterMessageCountClause(self, ctx:Cobol85Parser.MessageCountClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#messageCountClause. + def exitMessageCountClause(self, ctx:Cobol85Parser.MessageCountClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#messageDateClause. + def enterMessageDateClause(self, ctx:Cobol85Parser.MessageDateClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#messageDateClause. + def exitMessageDateClause(self, ctx:Cobol85Parser.MessageDateClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#messageTimeClause. + def enterMessageTimeClause(self, ctx:Cobol85Parser.MessageTimeClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#messageTimeClause. + def exitMessageTimeClause(self, ctx:Cobol85Parser.MessageTimeClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#statusKeyClause. + def enterStatusKeyClause(self, ctx:Cobol85Parser.StatusKeyClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#statusKeyClause. + def exitStatusKeyClause(self, ctx:Cobol85Parser.StatusKeyClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#symbolicDestinationClause. + def enterSymbolicDestinationClause(self, ctx:Cobol85Parser.SymbolicDestinationClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#symbolicDestinationClause. + def exitSymbolicDestinationClause(self, ctx:Cobol85Parser.SymbolicDestinationClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#symbolicQueueClause. + def enterSymbolicQueueClause(self, ctx:Cobol85Parser.SymbolicQueueClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#symbolicQueueClause. + def exitSymbolicQueueClause(self, ctx:Cobol85Parser.SymbolicQueueClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#symbolicSourceClause. + def enterSymbolicSourceClause(self, ctx:Cobol85Parser.SymbolicSourceClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#symbolicSourceClause. + def exitSymbolicSourceClause(self, ctx:Cobol85Parser.SymbolicSourceClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#symbolicTerminalClause. + def enterSymbolicTerminalClause(self, ctx:Cobol85Parser.SymbolicTerminalClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#symbolicTerminalClause. + def exitSymbolicTerminalClause(self, ctx:Cobol85Parser.SymbolicTerminalClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#symbolicSubQueueClause. + def enterSymbolicSubQueueClause(self, ctx:Cobol85Parser.SymbolicSubQueueClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#symbolicSubQueueClause. + def exitSymbolicSubQueueClause(self, ctx:Cobol85Parser.SymbolicSubQueueClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#textLengthClause. + def enterTextLengthClause(self, ctx:Cobol85Parser.TextLengthClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#textLengthClause. + def exitTextLengthClause(self, ctx:Cobol85Parser.TextLengthClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#localStorageSection. + def enterLocalStorageSection(self, ctx:Cobol85Parser.LocalStorageSectionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#localStorageSection. + def exitLocalStorageSection(self, ctx:Cobol85Parser.LocalStorageSectionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenSection. + def enterScreenSection(self, ctx:Cobol85Parser.ScreenSectionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenSection. + def exitScreenSection(self, ctx:Cobol85Parser.ScreenSectionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionEntry. + def enterScreenDescriptionEntry(self, ctx:Cobol85Parser.ScreenDescriptionEntryContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionEntry. + def exitScreenDescriptionEntry(self, ctx:Cobol85Parser.ScreenDescriptionEntryContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionBlankClause. + def enterScreenDescriptionBlankClause(self, ctx:Cobol85Parser.ScreenDescriptionBlankClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionBlankClause. + def exitScreenDescriptionBlankClause(self, ctx:Cobol85Parser.ScreenDescriptionBlankClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionBellClause. + def enterScreenDescriptionBellClause(self, ctx:Cobol85Parser.ScreenDescriptionBellClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionBellClause. + def exitScreenDescriptionBellClause(self, ctx:Cobol85Parser.ScreenDescriptionBellClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionBlinkClause. + def enterScreenDescriptionBlinkClause(self, ctx:Cobol85Parser.ScreenDescriptionBlinkClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionBlinkClause. + def exitScreenDescriptionBlinkClause(self, ctx:Cobol85Parser.ScreenDescriptionBlinkClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionEraseClause. + def enterScreenDescriptionEraseClause(self, ctx:Cobol85Parser.ScreenDescriptionEraseClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionEraseClause. + def exitScreenDescriptionEraseClause(self, ctx:Cobol85Parser.ScreenDescriptionEraseClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionLightClause. + def enterScreenDescriptionLightClause(self, ctx:Cobol85Parser.ScreenDescriptionLightClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionLightClause. + def exitScreenDescriptionLightClause(self, ctx:Cobol85Parser.ScreenDescriptionLightClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionGridClause. + def enterScreenDescriptionGridClause(self, ctx:Cobol85Parser.ScreenDescriptionGridClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionGridClause. + def exitScreenDescriptionGridClause(self, ctx:Cobol85Parser.ScreenDescriptionGridClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionReverseVideoClause. + def enterScreenDescriptionReverseVideoClause(self, ctx:Cobol85Parser.ScreenDescriptionReverseVideoClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionReverseVideoClause. + def exitScreenDescriptionReverseVideoClause(self, ctx:Cobol85Parser.ScreenDescriptionReverseVideoClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionUnderlineClause. + def enterScreenDescriptionUnderlineClause(self, ctx:Cobol85Parser.ScreenDescriptionUnderlineClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionUnderlineClause. + def exitScreenDescriptionUnderlineClause(self, ctx:Cobol85Parser.ScreenDescriptionUnderlineClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionSizeClause. + def enterScreenDescriptionSizeClause(self, ctx:Cobol85Parser.ScreenDescriptionSizeClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionSizeClause. + def exitScreenDescriptionSizeClause(self, ctx:Cobol85Parser.ScreenDescriptionSizeClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionLineClause. + def enterScreenDescriptionLineClause(self, ctx:Cobol85Parser.ScreenDescriptionLineClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionLineClause. + def exitScreenDescriptionLineClause(self, ctx:Cobol85Parser.ScreenDescriptionLineClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionColumnClause. + def enterScreenDescriptionColumnClause(self, ctx:Cobol85Parser.ScreenDescriptionColumnClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionColumnClause. + def exitScreenDescriptionColumnClause(self, ctx:Cobol85Parser.ScreenDescriptionColumnClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionForegroundColorClause. + def enterScreenDescriptionForegroundColorClause(self, ctx:Cobol85Parser.ScreenDescriptionForegroundColorClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionForegroundColorClause. + def exitScreenDescriptionForegroundColorClause(self, ctx:Cobol85Parser.ScreenDescriptionForegroundColorClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionBackgroundColorClause. + def enterScreenDescriptionBackgroundColorClause(self, ctx:Cobol85Parser.ScreenDescriptionBackgroundColorClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionBackgroundColorClause. + def exitScreenDescriptionBackgroundColorClause(self, ctx:Cobol85Parser.ScreenDescriptionBackgroundColorClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionControlClause. + def enterScreenDescriptionControlClause(self, ctx:Cobol85Parser.ScreenDescriptionControlClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionControlClause. + def exitScreenDescriptionControlClause(self, ctx:Cobol85Parser.ScreenDescriptionControlClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionValueClause. + def enterScreenDescriptionValueClause(self, ctx:Cobol85Parser.ScreenDescriptionValueClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionValueClause. + def exitScreenDescriptionValueClause(self, ctx:Cobol85Parser.ScreenDescriptionValueClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionPictureClause. + def enterScreenDescriptionPictureClause(self, ctx:Cobol85Parser.ScreenDescriptionPictureClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionPictureClause. + def exitScreenDescriptionPictureClause(self, ctx:Cobol85Parser.ScreenDescriptionPictureClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionFromClause. + def enterScreenDescriptionFromClause(self, ctx:Cobol85Parser.ScreenDescriptionFromClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionFromClause. + def exitScreenDescriptionFromClause(self, ctx:Cobol85Parser.ScreenDescriptionFromClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionToClause. + def enterScreenDescriptionToClause(self, ctx:Cobol85Parser.ScreenDescriptionToClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionToClause. + def exitScreenDescriptionToClause(self, ctx:Cobol85Parser.ScreenDescriptionToClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionUsingClause. + def enterScreenDescriptionUsingClause(self, ctx:Cobol85Parser.ScreenDescriptionUsingClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionUsingClause. + def exitScreenDescriptionUsingClause(self, ctx:Cobol85Parser.ScreenDescriptionUsingClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionUsageClause. + def enterScreenDescriptionUsageClause(self, ctx:Cobol85Parser.ScreenDescriptionUsageClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionUsageClause. + def exitScreenDescriptionUsageClause(self, ctx:Cobol85Parser.ScreenDescriptionUsageClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionBlankWhenZeroClause. + def enterScreenDescriptionBlankWhenZeroClause(self, ctx:Cobol85Parser.ScreenDescriptionBlankWhenZeroClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionBlankWhenZeroClause. + def exitScreenDescriptionBlankWhenZeroClause(self, ctx:Cobol85Parser.ScreenDescriptionBlankWhenZeroClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionJustifiedClause. + def enterScreenDescriptionJustifiedClause(self, ctx:Cobol85Parser.ScreenDescriptionJustifiedClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionJustifiedClause. + def exitScreenDescriptionJustifiedClause(self, ctx:Cobol85Parser.ScreenDescriptionJustifiedClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionSignClause. + def enterScreenDescriptionSignClause(self, ctx:Cobol85Parser.ScreenDescriptionSignClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionSignClause. + def exitScreenDescriptionSignClause(self, ctx:Cobol85Parser.ScreenDescriptionSignClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionAutoClause. + def enterScreenDescriptionAutoClause(self, ctx:Cobol85Parser.ScreenDescriptionAutoClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionAutoClause. + def exitScreenDescriptionAutoClause(self, ctx:Cobol85Parser.ScreenDescriptionAutoClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionSecureClause. + def enterScreenDescriptionSecureClause(self, ctx:Cobol85Parser.ScreenDescriptionSecureClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionSecureClause. + def exitScreenDescriptionSecureClause(self, ctx:Cobol85Parser.ScreenDescriptionSecureClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionRequiredClause. + def enterScreenDescriptionRequiredClause(self, ctx:Cobol85Parser.ScreenDescriptionRequiredClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionRequiredClause. + def exitScreenDescriptionRequiredClause(self, ctx:Cobol85Parser.ScreenDescriptionRequiredClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionPromptClause. + def enterScreenDescriptionPromptClause(self, ctx:Cobol85Parser.ScreenDescriptionPromptClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionPromptClause. + def exitScreenDescriptionPromptClause(self, ctx:Cobol85Parser.ScreenDescriptionPromptClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionPromptOccursClause. + def enterScreenDescriptionPromptOccursClause(self, ctx:Cobol85Parser.ScreenDescriptionPromptOccursClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionPromptOccursClause. + def exitScreenDescriptionPromptOccursClause(self, ctx:Cobol85Parser.ScreenDescriptionPromptOccursClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionFullClause. + def enterScreenDescriptionFullClause(self, ctx:Cobol85Parser.ScreenDescriptionFullClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionFullClause. + def exitScreenDescriptionFullClause(self, ctx:Cobol85Parser.ScreenDescriptionFullClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenDescriptionZeroFillClause. + def enterScreenDescriptionZeroFillClause(self, ctx:Cobol85Parser.ScreenDescriptionZeroFillClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenDescriptionZeroFillClause. + def exitScreenDescriptionZeroFillClause(self, ctx:Cobol85Parser.ScreenDescriptionZeroFillClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportSection. + def enterReportSection(self, ctx:Cobol85Parser.ReportSectionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportSection. + def exitReportSection(self, ctx:Cobol85Parser.ReportSectionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportDescription. + def enterReportDescription(self, ctx:Cobol85Parser.ReportDescriptionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportDescription. + def exitReportDescription(self, ctx:Cobol85Parser.ReportDescriptionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportDescriptionEntry. + def enterReportDescriptionEntry(self, ctx:Cobol85Parser.ReportDescriptionEntryContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportDescriptionEntry. + def exitReportDescriptionEntry(self, ctx:Cobol85Parser.ReportDescriptionEntryContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportDescriptionGlobalClause. + def enterReportDescriptionGlobalClause(self, ctx:Cobol85Parser.ReportDescriptionGlobalClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportDescriptionGlobalClause. + def exitReportDescriptionGlobalClause(self, ctx:Cobol85Parser.ReportDescriptionGlobalClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportDescriptionPageLimitClause. + def enterReportDescriptionPageLimitClause(self, ctx:Cobol85Parser.ReportDescriptionPageLimitClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportDescriptionPageLimitClause. + def exitReportDescriptionPageLimitClause(self, ctx:Cobol85Parser.ReportDescriptionPageLimitClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportDescriptionHeadingClause. + def enterReportDescriptionHeadingClause(self, ctx:Cobol85Parser.ReportDescriptionHeadingClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportDescriptionHeadingClause. + def exitReportDescriptionHeadingClause(self, ctx:Cobol85Parser.ReportDescriptionHeadingClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportDescriptionFirstDetailClause. + def enterReportDescriptionFirstDetailClause(self, ctx:Cobol85Parser.ReportDescriptionFirstDetailClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportDescriptionFirstDetailClause. + def exitReportDescriptionFirstDetailClause(self, ctx:Cobol85Parser.ReportDescriptionFirstDetailClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportDescriptionLastDetailClause. + def enterReportDescriptionLastDetailClause(self, ctx:Cobol85Parser.ReportDescriptionLastDetailClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportDescriptionLastDetailClause. + def exitReportDescriptionLastDetailClause(self, ctx:Cobol85Parser.ReportDescriptionLastDetailClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportDescriptionFootingClause. + def enterReportDescriptionFootingClause(self, ctx:Cobol85Parser.ReportDescriptionFootingClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportDescriptionFootingClause. + def exitReportDescriptionFootingClause(self, ctx:Cobol85Parser.ReportDescriptionFootingClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupDescriptionEntry. + def enterReportGroupDescriptionEntry(self, ctx:Cobol85Parser.ReportGroupDescriptionEntryContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupDescriptionEntry. + def exitReportGroupDescriptionEntry(self, ctx:Cobol85Parser.ReportGroupDescriptionEntryContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupDescriptionEntryFormat1. + def enterReportGroupDescriptionEntryFormat1(self, ctx:Cobol85Parser.ReportGroupDescriptionEntryFormat1Context): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupDescriptionEntryFormat1. + def exitReportGroupDescriptionEntryFormat1(self, ctx:Cobol85Parser.ReportGroupDescriptionEntryFormat1Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupDescriptionEntryFormat2. + def enterReportGroupDescriptionEntryFormat2(self, ctx:Cobol85Parser.ReportGroupDescriptionEntryFormat2Context): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupDescriptionEntryFormat2. + def exitReportGroupDescriptionEntryFormat2(self, ctx:Cobol85Parser.ReportGroupDescriptionEntryFormat2Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupDescriptionEntryFormat3. + def enterReportGroupDescriptionEntryFormat3(self, ctx:Cobol85Parser.ReportGroupDescriptionEntryFormat3Context): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupDescriptionEntryFormat3. + def exitReportGroupDescriptionEntryFormat3(self, ctx:Cobol85Parser.ReportGroupDescriptionEntryFormat3Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupBlankWhenZeroClause. + def enterReportGroupBlankWhenZeroClause(self, ctx:Cobol85Parser.ReportGroupBlankWhenZeroClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupBlankWhenZeroClause. + def exitReportGroupBlankWhenZeroClause(self, ctx:Cobol85Parser.ReportGroupBlankWhenZeroClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupColumnNumberClause. + def enterReportGroupColumnNumberClause(self, ctx:Cobol85Parser.ReportGroupColumnNumberClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupColumnNumberClause. + def exitReportGroupColumnNumberClause(self, ctx:Cobol85Parser.ReportGroupColumnNumberClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupIndicateClause. + def enterReportGroupIndicateClause(self, ctx:Cobol85Parser.ReportGroupIndicateClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupIndicateClause. + def exitReportGroupIndicateClause(self, ctx:Cobol85Parser.ReportGroupIndicateClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupJustifiedClause. + def enterReportGroupJustifiedClause(self, ctx:Cobol85Parser.ReportGroupJustifiedClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupJustifiedClause. + def exitReportGroupJustifiedClause(self, ctx:Cobol85Parser.ReportGroupJustifiedClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupLineNumberClause. + def enterReportGroupLineNumberClause(self, ctx:Cobol85Parser.ReportGroupLineNumberClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupLineNumberClause. + def exitReportGroupLineNumberClause(self, ctx:Cobol85Parser.ReportGroupLineNumberClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupLineNumberNextPage. + def enterReportGroupLineNumberNextPage(self, ctx:Cobol85Parser.ReportGroupLineNumberNextPageContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupLineNumberNextPage. + def exitReportGroupLineNumberNextPage(self, ctx:Cobol85Parser.ReportGroupLineNumberNextPageContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupLineNumberPlus. + def enterReportGroupLineNumberPlus(self, ctx:Cobol85Parser.ReportGroupLineNumberPlusContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupLineNumberPlus. + def exitReportGroupLineNumberPlus(self, ctx:Cobol85Parser.ReportGroupLineNumberPlusContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupNextGroupClause. + def enterReportGroupNextGroupClause(self, ctx:Cobol85Parser.ReportGroupNextGroupClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupNextGroupClause. + def exitReportGroupNextGroupClause(self, ctx:Cobol85Parser.ReportGroupNextGroupClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupNextGroupPlus. + def enterReportGroupNextGroupPlus(self, ctx:Cobol85Parser.ReportGroupNextGroupPlusContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupNextGroupPlus. + def exitReportGroupNextGroupPlus(self, ctx:Cobol85Parser.ReportGroupNextGroupPlusContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupNextGroupNextPage. + def enterReportGroupNextGroupNextPage(self, ctx:Cobol85Parser.ReportGroupNextGroupNextPageContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupNextGroupNextPage. + def exitReportGroupNextGroupNextPage(self, ctx:Cobol85Parser.ReportGroupNextGroupNextPageContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupPictureClause. + def enterReportGroupPictureClause(self, ctx:Cobol85Parser.ReportGroupPictureClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupPictureClause. + def exitReportGroupPictureClause(self, ctx:Cobol85Parser.ReportGroupPictureClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupResetClause. + def enterReportGroupResetClause(self, ctx:Cobol85Parser.ReportGroupResetClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupResetClause. + def exitReportGroupResetClause(self, ctx:Cobol85Parser.ReportGroupResetClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupSignClause. + def enterReportGroupSignClause(self, ctx:Cobol85Parser.ReportGroupSignClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupSignClause. + def exitReportGroupSignClause(self, ctx:Cobol85Parser.ReportGroupSignClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupSourceClause. + def enterReportGroupSourceClause(self, ctx:Cobol85Parser.ReportGroupSourceClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupSourceClause. + def exitReportGroupSourceClause(self, ctx:Cobol85Parser.ReportGroupSourceClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupSumClause. + def enterReportGroupSumClause(self, ctx:Cobol85Parser.ReportGroupSumClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupSumClause. + def exitReportGroupSumClause(self, ctx:Cobol85Parser.ReportGroupSumClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupTypeClause. + def enterReportGroupTypeClause(self, ctx:Cobol85Parser.ReportGroupTypeClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupTypeClause. + def exitReportGroupTypeClause(self, ctx:Cobol85Parser.ReportGroupTypeClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupTypeReportHeading. + def enterReportGroupTypeReportHeading(self, ctx:Cobol85Parser.ReportGroupTypeReportHeadingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupTypeReportHeading. + def exitReportGroupTypeReportHeading(self, ctx:Cobol85Parser.ReportGroupTypeReportHeadingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupTypePageHeading. + def enterReportGroupTypePageHeading(self, ctx:Cobol85Parser.ReportGroupTypePageHeadingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupTypePageHeading. + def exitReportGroupTypePageHeading(self, ctx:Cobol85Parser.ReportGroupTypePageHeadingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupTypeControlHeading. + def enterReportGroupTypeControlHeading(self, ctx:Cobol85Parser.ReportGroupTypeControlHeadingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupTypeControlHeading. + def exitReportGroupTypeControlHeading(self, ctx:Cobol85Parser.ReportGroupTypeControlHeadingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupTypeDetail. + def enterReportGroupTypeDetail(self, ctx:Cobol85Parser.ReportGroupTypeDetailContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupTypeDetail. + def exitReportGroupTypeDetail(self, ctx:Cobol85Parser.ReportGroupTypeDetailContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupTypeControlFooting. + def enterReportGroupTypeControlFooting(self, ctx:Cobol85Parser.ReportGroupTypeControlFootingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupTypeControlFooting. + def exitReportGroupTypeControlFooting(self, ctx:Cobol85Parser.ReportGroupTypeControlFootingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupUsageClause. + def enterReportGroupUsageClause(self, ctx:Cobol85Parser.ReportGroupUsageClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupUsageClause. + def exitReportGroupUsageClause(self, ctx:Cobol85Parser.ReportGroupUsageClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupTypePageFooting. + def enterReportGroupTypePageFooting(self, ctx:Cobol85Parser.ReportGroupTypePageFootingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupTypePageFooting. + def exitReportGroupTypePageFooting(self, ctx:Cobol85Parser.ReportGroupTypePageFootingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupTypeReportFooting. + def enterReportGroupTypeReportFooting(self, ctx:Cobol85Parser.ReportGroupTypeReportFootingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupTypeReportFooting. + def exitReportGroupTypeReportFooting(self, ctx:Cobol85Parser.ReportGroupTypeReportFootingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportGroupValueClause. + def enterReportGroupValueClause(self, ctx:Cobol85Parser.ReportGroupValueClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportGroupValueClause. + def exitReportGroupValueClause(self, ctx:Cobol85Parser.ReportGroupValueClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#programLibrarySection. + def enterProgramLibrarySection(self, ctx:Cobol85Parser.ProgramLibrarySectionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#programLibrarySection. + def exitProgramLibrarySection(self, ctx:Cobol85Parser.ProgramLibrarySectionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryDescriptionEntry. + def enterLibraryDescriptionEntry(self, ctx:Cobol85Parser.LibraryDescriptionEntryContext): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryDescriptionEntry. + def exitLibraryDescriptionEntry(self, ctx:Cobol85Parser.LibraryDescriptionEntryContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryDescriptionEntryFormat1. + def enterLibraryDescriptionEntryFormat1(self, ctx:Cobol85Parser.LibraryDescriptionEntryFormat1Context): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryDescriptionEntryFormat1. + def exitLibraryDescriptionEntryFormat1(self, ctx:Cobol85Parser.LibraryDescriptionEntryFormat1Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryDescriptionEntryFormat2. + def enterLibraryDescriptionEntryFormat2(self, ctx:Cobol85Parser.LibraryDescriptionEntryFormat2Context): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryDescriptionEntryFormat2. + def exitLibraryDescriptionEntryFormat2(self, ctx:Cobol85Parser.LibraryDescriptionEntryFormat2Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryAttributeClauseFormat1. + def enterLibraryAttributeClauseFormat1(self, ctx:Cobol85Parser.LibraryAttributeClauseFormat1Context): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryAttributeClauseFormat1. + def exitLibraryAttributeClauseFormat1(self, ctx:Cobol85Parser.LibraryAttributeClauseFormat1Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryAttributeClauseFormat2. + def enterLibraryAttributeClauseFormat2(self, ctx:Cobol85Parser.LibraryAttributeClauseFormat2Context): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryAttributeClauseFormat2. + def exitLibraryAttributeClauseFormat2(self, ctx:Cobol85Parser.LibraryAttributeClauseFormat2Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryAttributeFunction. + def enterLibraryAttributeFunction(self, ctx:Cobol85Parser.LibraryAttributeFunctionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryAttributeFunction. + def exitLibraryAttributeFunction(self, ctx:Cobol85Parser.LibraryAttributeFunctionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryAttributeParameter. + def enterLibraryAttributeParameter(self, ctx:Cobol85Parser.LibraryAttributeParameterContext): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryAttributeParameter. + def exitLibraryAttributeParameter(self, ctx:Cobol85Parser.LibraryAttributeParameterContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryAttributeTitle. + def enterLibraryAttributeTitle(self, ctx:Cobol85Parser.LibraryAttributeTitleContext): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryAttributeTitle. + def exitLibraryAttributeTitle(self, ctx:Cobol85Parser.LibraryAttributeTitleContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryEntryProcedureClauseFormat1. + def enterLibraryEntryProcedureClauseFormat1(self, ctx:Cobol85Parser.LibraryEntryProcedureClauseFormat1Context): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryEntryProcedureClauseFormat1. + def exitLibraryEntryProcedureClauseFormat1(self, ctx:Cobol85Parser.LibraryEntryProcedureClauseFormat1Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryEntryProcedureClauseFormat2. + def enterLibraryEntryProcedureClauseFormat2(self, ctx:Cobol85Parser.LibraryEntryProcedureClauseFormat2Context): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryEntryProcedureClauseFormat2. + def exitLibraryEntryProcedureClauseFormat2(self, ctx:Cobol85Parser.LibraryEntryProcedureClauseFormat2Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryEntryProcedureForClause. + def enterLibraryEntryProcedureForClause(self, ctx:Cobol85Parser.LibraryEntryProcedureForClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryEntryProcedureForClause. + def exitLibraryEntryProcedureForClause(self, ctx:Cobol85Parser.LibraryEntryProcedureForClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryEntryProcedureGivingClause. + def enterLibraryEntryProcedureGivingClause(self, ctx:Cobol85Parser.LibraryEntryProcedureGivingClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryEntryProcedureGivingClause. + def exitLibraryEntryProcedureGivingClause(self, ctx:Cobol85Parser.LibraryEntryProcedureGivingClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryEntryProcedureUsingClause. + def enterLibraryEntryProcedureUsingClause(self, ctx:Cobol85Parser.LibraryEntryProcedureUsingClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryEntryProcedureUsingClause. + def exitLibraryEntryProcedureUsingClause(self, ctx:Cobol85Parser.LibraryEntryProcedureUsingClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryEntryProcedureUsingName. + def enterLibraryEntryProcedureUsingName(self, ctx:Cobol85Parser.LibraryEntryProcedureUsingNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryEntryProcedureUsingName. + def exitLibraryEntryProcedureUsingName(self, ctx:Cobol85Parser.LibraryEntryProcedureUsingNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryEntryProcedureWithClause. + def enterLibraryEntryProcedureWithClause(self, ctx:Cobol85Parser.LibraryEntryProcedureWithClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryEntryProcedureWithClause. + def exitLibraryEntryProcedureWithClause(self, ctx:Cobol85Parser.LibraryEntryProcedureWithClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryEntryProcedureWithName. + def enterLibraryEntryProcedureWithName(self, ctx:Cobol85Parser.LibraryEntryProcedureWithNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryEntryProcedureWithName. + def exitLibraryEntryProcedureWithName(self, ctx:Cobol85Parser.LibraryEntryProcedureWithNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryIsCommonClause. + def enterLibraryIsCommonClause(self, ctx:Cobol85Parser.LibraryIsCommonClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryIsCommonClause. + def exitLibraryIsCommonClause(self, ctx:Cobol85Parser.LibraryIsCommonClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryIsGlobalClause. + def enterLibraryIsGlobalClause(self, ctx:Cobol85Parser.LibraryIsGlobalClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryIsGlobalClause. + def exitLibraryIsGlobalClause(self, ctx:Cobol85Parser.LibraryIsGlobalClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataDescriptionEntry. + def enterDataDescriptionEntry(self, ctx:Cobol85Parser.DataDescriptionEntryContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataDescriptionEntry. + def exitDataDescriptionEntry(self, ctx:Cobol85Parser.DataDescriptionEntryContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataDescriptionEntryFormat1. + def enterDataDescriptionEntryFormat1(self, ctx:Cobol85Parser.DataDescriptionEntryFormat1Context): + pass + + # Exit a parse tree produced by Cobol85Parser#dataDescriptionEntryFormat1. + def exitDataDescriptionEntryFormat1(self, ctx:Cobol85Parser.DataDescriptionEntryFormat1Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataDescriptionEntryFormat2. + def enterDataDescriptionEntryFormat2(self, ctx:Cobol85Parser.DataDescriptionEntryFormat2Context): + pass + + # Exit a parse tree produced by Cobol85Parser#dataDescriptionEntryFormat2. + def exitDataDescriptionEntryFormat2(self, ctx:Cobol85Parser.DataDescriptionEntryFormat2Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataDescriptionEntryFormat3. + def enterDataDescriptionEntryFormat3(self, ctx:Cobol85Parser.DataDescriptionEntryFormat3Context): + pass + + # Exit a parse tree produced by Cobol85Parser#dataDescriptionEntryFormat3. + def exitDataDescriptionEntryFormat3(self, ctx:Cobol85Parser.DataDescriptionEntryFormat3Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataDescriptionEntryExecSql. + def enterDataDescriptionEntryExecSql(self, ctx:Cobol85Parser.DataDescriptionEntryExecSqlContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataDescriptionEntryExecSql. + def exitDataDescriptionEntryExecSql(self, ctx:Cobol85Parser.DataDescriptionEntryExecSqlContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataAlignedClause. + def enterDataAlignedClause(self, ctx:Cobol85Parser.DataAlignedClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataAlignedClause. + def exitDataAlignedClause(self, ctx:Cobol85Parser.DataAlignedClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataBlankWhenZeroClause. + def enterDataBlankWhenZeroClause(self, ctx:Cobol85Parser.DataBlankWhenZeroClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataBlankWhenZeroClause. + def exitDataBlankWhenZeroClause(self, ctx:Cobol85Parser.DataBlankWhenZeroClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataCommonOwnLocalClause. + def enterDataCommonOwnLocalClause(self, ctx:Cobol85Parser.DataCommonOwnLocalClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataCommonOwnLocalClause. + def exitDataCommonOwnLocalClause(self, ctx:Cobol85Parser.DataCommonOwnLocalClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataExternalClause. + def enterDataExternalClause(self, ctx:Cobol85Parser.DataExternalClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataExternalClause. + def exitDataExternalClause(self, ctx:Cobol85Parser.DataExternalClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataGlobalClause. + def enterDataGlobalClause(self, ctx:Cobol85Parser.DataGlobalClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataGlobalClause. + def exitDataGlobalClause(self, ctx:Cobol85Parser.DataGlobalClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataIntegerStringClause. + def enterDataIntegerStringClause(self, ctx:Cobol85Parser.DataIntegerStringClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataIntegerStringClause. + def exitDataIntegerStringClause(self, ctx:Cobol85Parser.DataIntegerStringClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataJustifiedClause. + def enterDataJustifiedClause(self, ctx:Cobol85Parser.DataJustifiedClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataJustifiedClause. + def exitDataJustifiedClause(self, ctx:Cobol85Parser.DataJustifiedClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataOccursClause. + def enterDataOccursClause(self, ctx:Cobol85Parser.DataOccursClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataOccursClause. + def exitDataOccursClause(self, ctx:Cobol85Parser.DataOccursClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataOccursTo. + def enterDataOccursTo(self, ctx:Cobol85Parser.DataOccursToContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataOccursTo. + def exitDataOccursTo(self, ctx:Cobol85Parser.DataOccursToContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataOccursSort. + def enterDataOccursSort(self, ctx:Cobol85Parser.DataOccursSortContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataOccursSort. + def exitDataOccursSort(self, ctx:Cobol85Parser.DataOccursSortContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataPictureClause. + def enterDataPictureClause(self, ctx:Cobol85Parser.DataPictureClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataPictureClause. + def exitDataPictureClause(self, ctx:Cobol85Parser.DataPictureClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#pictureString. + def enterPictureString(self, ctx:Cobol85Parser.PictureStringContext): + pass + + # Exit a parse tree produced by Cobol85Parser#pictureString. + def exitPictureString(self, ctx:Cobol85Parser.PictureStringContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#pictureChars. + def enterPictureChars(self, ctx:Cobol85Parser.PictureCharsContext): + pass + + # Exit a parse tree produced by Cobol85Parser#pictureChars. + def exitPictureChars(self, ctx:Cobol85Parser.PictureCharsContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#pictureCardinality. + def enterPictureCardinality(self, ctx:Cobol85Parser.PictureCardinalityContext): + pass + + # Exit a parse tree produced by Cobol85Parser#pictureCardinality. + def exitPictureCardinality(self, ctx:Cobol85Parser.PictureCardinalityContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataReceivedByClause. + def enterDataReceivedByClause(self, ctx:Cobol85Parser.DataReceivedByClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataReceivedByClause. + def exitDataReceivedByClause(self, ctx:Cobol85Parser.DataReceivedByClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataRecordAreaClause. + def enterDataRecordAreaClause(self, ctx:Cobol85Parser.DataRecordAreaClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataRecordAreaClause. + def exitDataRecordAreaClause(self, ctx:Cobol85Parser.DataRecordAreaClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataRedefinesClause. + def enterDataRedefinesClause(self, ctx:Cobol85Parser.DataRedefinesClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataRedefinesClause. + def exitDataRedefinesClause(self, ctx:Cobol85Parser.DataRedefinesClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataRenamesClause. + def enterDataRenamesClause(self, ctx:Cobol85Parser.DataRenamesClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataRenamesClause. + def exitDataRenamesClause(self, ctx:Cobol85Parser.DataRenamesClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataSignClause. + def enterDataSignClause(self, ctx:Cobol85Parser.DataSignClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataSignClause. + def exitDataSignClause(self, ctx:Cobol85Parser.DataSignClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataSynchronizedClause. + def enterDataSynchronizedClause(self, ctx:Cobol85Parser.DataSynchronizedClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataSynchronizedClause. + def exitDataSynchronizedClause(self, ctx:Cobol85Parser.DataSynchronizedClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataThreadLocalClause. + def enterDataThreadLocalClause(self, ctx:Cobol85Parser.DataThreadLocalClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataThreadLocalClause. + def exitDataThreadLocalClause(self, ctx:Cobol85Parser.DataThreadLocalClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataTypeClause. + def enterDataTypeClause(self, ctx:Cobol85Parser.DataTypeClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataTypeClause. + def exitDataTypeClause(self, ctx:Cobol85Parser.DataTypeClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataTypeDefClause. + def enterDataTypeDefClause(self, ctx:Cobol85Parser.DataTypeDefClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataTypeDefClause. + def exitDataTypeDefClause(self, ctx:Cobol85Parser.DataTypeDefClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataUsageClause. + def enterDataUsageClause(self, ctx:Cobol85Parser.DataUsageClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataUsageClause. + def exitDataUsageClause(self, ctx:Cobol85Parser.DataUsageClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataUsingClause. + def enterDataUsingClause(self, ctx:Cobol85Parser.DataUsingClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataUsingClause. + def exitDataUsingClause(self, ctx:Cobol85Parser.DataUsingClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataValueClause. + def enterDataValueClause(self, ctx:Cobol85Parser.DataValueClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataValueClause. + def exitDataValueClause(self, ctx:Cobol85Parser.DataValueClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataValueInterval. + def enterDataValueInterval(self, ctx:Cobol85Parser.DataValueIntervalContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataValueInterval. + def exitDataValueInterval(self, ctx:Cobol85Parser.DataValueIntervalContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataValueIntervalFrom. + def enterDataValueIntervalFrom(self, ctx:Cobol85Parser.DataValueIntervalFromContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataValueIntervalFrom. + def exitDataValueIntervalFrom(self, ctx:Cobol85Parser.DataValueIntervalFromContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataValueIntervalTo. + def enterDataValueIntervalTo(self, ctx:Cobol85Parser.DataValueIntervalToContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataValueIntervalTo. + def exitDataValueIntervalTo(self, ctx:Cobol85Parser.DataValueIntervalToContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataWithLowerBoundsClause. + def enterDataWithLowerBoundsClause(self, ctx:Cobol85Parser.DataWithLowerBoundsClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataWithLowerBoundsClause. + def exitDataWithLowerBoundsClause(self, ctx:Cobol85Parser.DataWithLowerBoundsClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#procedureDivision. + def enterProcedureDivision(self, ctx:Cobol85Parser.ProcedureDivisionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#procedureDivision. + def exitProcedureDivision(self, ctx:Cobol85Parser.ProcedureDivisionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#procedureDivisionUsingClause. + def enterProcedureDivisionUsingClause(self, ctx:Cobol85Parser.ProcedureDivisionUsingClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#procedureDivisionUsingClause. + def exitProcedureDivisionUsingClause(self, ctx:Cobol85Parser.ProcedureDivisionUsingClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#procedureDivisionGivingClause. + def enterProcedureDivisionGivingClause(self, ctx:Cobol85Parser.ProcedureDivisionGivingClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#procedureDivisionGivingClause. + def exitProcedureDivisionGivingClause(self, ctx:Cobol85Parser.ProcedureDivisionGivingClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#procedureDivisionUsingParameter. + def enterProcedureDivisionUsingParameter(self, ctx:Cobol85Parser.ProcedureDivisionUsingParameterContext): + pass + + # Exit a parse tree produced by Cobol85Parser#procedureDivisionUsingParameter. + def exitProcedureDivisionUsingParameter(self, ctx:Cobol85Parser.ProcedureDivisionUsingParameterContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#procedureDivisionByReferencePhrase. + def enterProcedureDivisionByReferencePhrase(self, ctx:Cobol85Parser.ProcedureDivisionByReferencePhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#procedureDivisionByReferencePhrase. + def exitProcedureDivisionByReferencePhrase(self, ctx:Cobol85Parser.ProcedureDivisionByReferencePhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#procedureDivisionByReference. + def enterProcedureDivisionByReference(self, ctx:Cobol85Parser.ProcedureDivisionByReferenceContext): + pass + + # Exit a parse tree produced by Cobol85Parser#procedureDivisionByReference. + def exitProcedureDivisionByReference(self, ctx:Cobol85Parser.ProcedureDivisionByReferenceContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#procedureDivisionByValuePhrase. + def enterProcedureDivisionByValuePhrase(self, ctx:Cobol85Parser.ProcedureDivisionByValuePhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#procedureDivisionByValuePhrase. + def exitProcedureDivisionByValuePhrase(self, ctx:Cobol85Parser.ProcedureDivisionByValuePhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#procedureDivisionByValue. + def enterProcedureDivisionByValue(self, ctx:Cobol85Parser.ProcedureDivisionByValueContext): + pass + + # Exit a parse tree produced by Cobol85Parser#procedureDivisionByValue. + def exitProcedureDivisionByValue(self, ctx:Cobol85Parser.ProcedureDivisionByValueContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#procedureDeclaratives. + def enterProcedureDeclaratives(self, ctx:Cobol85Parser.ProcedureDeclarativesContext): + pass + + # Exit a parse tree produced by Cobol85Parser#procedureDeclaratives. + def exitProcedureDeclaratives(self, ctx:Cobol85Parser.ProcedureDeclarativesContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#procedureDeclarative. + def enterProcedureDeclarative(self, ctx:Cobol85Parser.ProcedureDeclarativeContext): + pass + + # Exit a parse tree produced by Cobol85Parser#procedureDeclarative. + def exitProcedureDeclarative(self, ctx:Cobol85Parser.ProcedureDeclarativeContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#procedureSectionHeader. + def enterProcedureSectionHeader(self, ctx:Cobol85Parser.ProcedureSectionHeaderContext): + pass + + # Exit a parse tree produced by Cobol85Parser#procedureSectionHeader. + def exitProcedureSectionHeader(self, ctx:Cobol85Parser.ProcedureSectionHeaderContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#procedureDivisionBody. + def enterProcedureDivisionBody(self, ctx:Cobol85Parser.ProcedureDivisionBodyContext): + pass + + # Exit a parse tree produced by Cobol85Parser#procedureDivisionBody. + def exitProcedureDivisionBody(self, ctx:Cobol85Parser.ProcedureDivisionBodyContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#procedureSection. + def enterProcedureSection(self, ctx:Cobol85Parser.ProcedureSectionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#procedureSection. + def exitProcedureSection(self, ctx:Cobol85Parser.ProcedureSectionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#paragraphs. + def enterParagraphs(self, ctx:Cobol85Parser.ParagraphsContext): + pass + + # Exit a parse tree produced by Cobol85Parser#paragraphs. + def exitParagraphs(self, ctx:Cobol85Parser.ParagraphsContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#paragraph. + def enterParagraph(self, ctx:Cobol85Parser.ParagraphContext): + pass + + # Exit a parse tree produced by Cobol85Parser#paragraph. + def exitParagraph(self, ctx:Cobol85Parser.ParagraphContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sentence. + def enterSentence(self, ctx:Cobol85Parser.SentenceContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sentence. + def exitSentence(self, ctx:Cobol85Parser.SentenceContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#statement. + def enterStatement(self, ctx:Cobol85Parser.StatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#statement. + def exitStatement(self, ctx:Cobol85Parser.StatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#acceptStatement. + def enterAcceptStatement(self, ctx:Cobol85Parser.AcceptStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#acceptStatement. + def exitAcceptStatement(self, ctx:Cobol85Parser.AcceptStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#acceptFromDateStatement. + def enterAcceptFromDateStatement(self, ctx:Cobol85Parser.AcceptFromDateStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#acceptFromDateStatement. + def exitAcceptFromDateStatement(self, ctx:Cobol85Parser.AcceptFromDateStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#acceptFromMnemonicStatement. + def enterAcceptFromMnemonicStatement(self, ctx:Cobol85Parser.AcceptFromMnemonicStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#acceptFromMnemonicStatement. + def exitAcceptFromMnemonicStatement(self, ctx:Cobol85Parser.AcceptFromMnemonicStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#acceptFromEscapeKeyStatement. + def enterAcceptFromEscapeKeyStatement(self, ctx:Cobol85Parser.AcceptFromEscapeKeyStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#acceptFromEscapeKeyStatement. + def exitAcceptFromEscapeKeyStatement(self, ctx:Cobol85Parser.AcceptFromEscapeKeyStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#acceptMessageCountStatement. + def enterAcceptMessageCountStatement(self, ctx:Cobol85Parser.AcceptMessageCountStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#acceptMessageCountStatement. + def exitAcceptMessageCountStatement(self, ctx:Cobol85Parser.AcceptMessageCountStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#addStatement. + def enterAddStatement(self, ctx:Cobol85Parser.AddStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#addStatement. + def exitAddStatement(self, ctx:Cobol85Parser.AddStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#addToStatement. + def enterAddToStatement(self, ctx:Cobol85Parser.AddToStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#addToStatement. + def exitAddToStatement(self, ctx:Cobol85Parser.AddToStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#addToGivingStatement. + def enterAddToGivingStatement(self, ctx:Cobol85Parser.AddToGivingStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#addToGivingStatement. + def exitAddToGivingStatement(self, ctx:Cobol85Parser.AddToGivingStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#addCorrespondingStatement. + def enterAddCorrespondingStatement(self, ctx:Cobol85Parser.AddCorrespondingStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#addCorrespondingStatement. + def exitAddCorrespondingStatement(self, ctx:Cobol85Parser.AddCorrespondingStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#addFrom. + def enterAddFrom(self, ctx:Cobol85Parser.AddFromContext): + pass + + # Exit a parse tree produced by Cobol85Parser#addFrom. + def exitAddFrom(self, ctx:Cobol85Parser.AddFromContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#addTo. + def enterAddTo(self, ctx:Cobol85Parser.AddToContext): + pass + + # Exit a parse tree produced by Cobol85Parser#addTo. + def exitAddTo(self, ctx:Cobol85Parser.AddToContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#addToGiving. + def enterAddToGiving(self, ctx:Cobol85Parser.AddToGivingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#addToGiving. + def exitAddToGiving(self, ctx:Cobol85Parser.AddToGivingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#addGiving. + def enterAddGiving(self, ctx:Cobol85Parser.AddGivingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#addGiving. + def exitAddGiving(self, ctx:Cobol85Parser.AddGivingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#alteredGoTo. + def enterAlteredGoTo(self, ctx:Cobol85Parser.AlteredGoToContext): + pass + + # Exit a parse tree produced by Cobol85Parser#alteredGoTo. + def exitAlteredGoTo(self, ctx:Cobol85Parser.AlteredGoToContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#alterStatement. + def enterAlterStatement(self, ctx:Cobol85Parser.AlterStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#alterStatement. + def exitAlterStatement(self, ctx:Cobol85Parser.AlterStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#alterProceedTo. + def enterAlterProceedTo(self, ctx:Cobol85Parser.AlterProceedToContext): + pass + + # Exit a parse tree produced by Cobol85Parser#alterProceedTo. + def exitAlterProceedTo(self, ctx:Cobol85Parser.AlterProceedToContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#callStatement. + def enterCallStatement(self, ctx:Cobol85Parser.CallStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#callStatement. + def exitCallStatement(self, ctx:Cobol85Parser.CallStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#callUsingPhrase. + def enterCallUsingPhrase(self, ctx:Cobol85Parser.CallUsingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#callUsingPhrase. + def exitCallUsingPhrase(self, ctx:Cobol85Parser.CallUsingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#callUsingParameter. + def enterCallUsingParameter(self, ctx:Cobol85Parser.CallUsingParameterContext): + pass + + # Exit a parse tree produced by Cobol85Parser#callUsingParameter. + def exitCallUsingParameter(self, ctx:Cobol85Parser.CallUsingParameterContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#callByReferencePhrase. + def enterCallByReferencePhrase(self, ctx:Cobol85Parser.CallByReferencePhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#callByReferencePhrase. + def exitCallByReferencePhrase(self, ctx:Cobol85Parser.CallByReferencePhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#callByReference. + def enterCallByReference(self, ctx:Cobol85Parser.CallByReferenceContext): + pass + + # Exit a parse tree produced by Cobol85Parser#callByReference. + def exitCallByReference(self, ctx:Cobol85Parser.CallByReferenceContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#callByValuePhrase. + def enterCallByValuePhrase(self, ctx:Cobol85Parser.CallByValuePhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#callByValuePhrase. + def exitCallByValuePhrase(self, ctx:Cobol85Parser.CallByValuePhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#callByValue. + def enterCallByValue(self, ctx:Cobol85Parser.CallByValueContext): + pass + + # Exit a parse tree produced by Cobol85Parser#callByValue. + def exitCallByValue(self, ctx:Cobol85Parser.CallByValueContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#callByContentPhrase. + def enterCallByContentPhrase(self, ctx:Cobol85Parser.CallByContentPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#callByContentPhrase. + def exitCallByContentPhrase(self, ctx:Cobol85Parser.CallByContentPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#callByContent. + def enterCallByContent(self, ctx:Cobol85Parser.CallByContentContext): + pass + + # Exit a parse tree produced by Cobol85Parser#callByContent. + def exitCallByContent(self, ctx:Cobol85Parser.CallByContentContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#callGivingPhrase. + def enterCallGivingPhrase(self, ctx:Cobol85Parser.CallGivingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#callGivingPhrase. + def exitCallGivingPhrase(self, ctx:Cobol85Parser.CallGivingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#cancelStatement. + def enterCancelStatement(self, ctx:Cobol85Parser.CancelStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#cancelStatement. + def exitCancelStatement(self, ctx:Cobol85Parser.CancelStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#cancelCall. + def enterCancelCall(self, ctx:Cobol85Parser.CancelCallContext): + pass + + # Exit a parse tree produced by Cobol85Parser#cancelCall. + def exitCancelCall(self, ctx:Cobol85Parser.CancelCallContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#closeStatement. + def enterCloseStatement(self, ctx:Cobol85Parser.CloseStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#closeStatement. + def exitCloseStatement(self, ctx:Cobol85Parser.CloseStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#closeFile. + def enterCloseFile(self, ctx:Cobol85Parser.CloseFileContext): + pass + + # Exit a parse tree produced by Cobol85Parser#closeFile. + def exitCloseFile(self, ctx:Cobol85Parser.CloseFileContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#closeReelUnitStatement. + def enterCloseReelUnitStatement(self, ctx:Cobol85Parser.CloseReelUnitStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#closeReelUnitStatement. + def exitCloseReelUnitStatement(self, ctx:Cobol85Parser.CloseReelUnitStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#closeRelativeStatement. + def enterCloseRelativeStatement(self, ctx:Cobol85Parser.CloseRelativeStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#closeRelativeStatement. + def exitCloseRelativeStatement(self, ctx:Cobol85Parser.CloseRelativeStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#closePortFileIOStatement. + def enterClosePortFileIOStatement(self, ctx:Cobol85Parser.ClosePortFileIOStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#closePortFileIOStatement. + def exitClosePortFileIOStatement(self, ctx:Cobol85Parser.ClosePortFileIOStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#closePortFileIOUsing. + def enterClosePortFileIOUsing(self, ctx:Cobol85Parser.ClosePortFileIOUsingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#closePortFileIOUsing. + def exitClosePortFileIOUsing(self, ctx:Cobol85Parser.ClosePortFileIOUsingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#closePortFileIOUsingCloseDisposition. + def enterClosePortFileIOUsingCloseDisposition(self, ctx:Cobol85Parser.ClosePortFileIOUsingCloseDispositionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#closePortFileIOUsingCloseDisposition. + def exitClosePortFileIOUsingCloseDisposition(self, ctx:Cobol85Parser.ClosePortFileIOUsingCloseDispositionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#closePortFileIOUsingAssociatedData. + def enterClosePortFileIOUsingAssociatedData(self, ctx:Cobol85Parser.ClosePortFileIOUsingAssociatedDataContext): + pass + + # Exit a parse tree produced by Cobol85Parser#closePortFileIOUsingAssociatedData. + def exitClosePortFileIOUsingAssociatedData(self, ctx:Cobol85Parser.ClosePortFileIOUsingAssociatedDataContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#closePortFileIOUsingAssociatedDataLength. + def enterClosePortFileIOUsingAssociatedDataLength(self, ctx:Cobol85Parser.ClosePortFileIOUsingAssociatedDataLengthContext): + pass + + # Exit a parse tree produced by Cobol85Parser#closePortFileIOUsingAssociatedDataLength. + def exitClosePortFileIOUsingAssociatedDataLength(self, ctx:Cobol85Parser.ClosePortFileIOUsingAssociatedDataLengthContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#computeStatement. + def enterComputeStatement(self, ctx:Cobol85Parser.ComputeStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#computeStatement. + def exitComputeStatement(self, ctx:Cobol85Parser.ComputeStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#computeStore. + def enterComputeStore(self, ctx:Cobol85Parser.ComputeStoreContext): + pass + + # Exit a parse tree produced by Cobol85Parser#computeStore. + def exitComputeStore(self, ctx:Cobol85Parser.ComputeStoreContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#continueStatement. + def enterContinueStatement(self, ctx:Cobol85Parser.ContinueStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#continueStatement. + def exitContinueStatement(self, ctx:Cobol85Parser.ContinueStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#deleteStatement. + def enterDeleteStatement(self, ctx:Cobol85Parser.DeleteStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#deleteStatement. + def exitDeleteStatement(self, ctx:Cobol85Parser.DeleteStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#disableStatement. + def enterDisableStatement(self, ctx:Cobol85Parser.DisableStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#disableStatement. + def exitDisableStatement(self, ctx:Cobol85Parser.DisableStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#displayStatement. + def enterDisplayStatement(self, ctx:Cobol85Parser.DisplayStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#displayStatement. + def exitDisplayStatement(self, ctx:Cobol85Parser.DisplayStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#displayOperand. + def enterDisplayOperand(self, ctx:Cobol85Parser.DisplayOperandContext): + pass + + # Exit a parse tree produced by Cobol85Parser#displayOperand. + def exitDisplayOperand(self, ctx:Cobol85Parser.DisplayOperandContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#displayAt. + def enterDisplayAt(self, ctx:Cobol85Parser.DisplayAtContext): + pass + + # Exit a parse tree produced by Cobol85Parser#displayAt. + def exitDisplayAt(self, ctx:Cobol85Parser.DisplayAtContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#displayUpon. + def enterDisplayUpon(self, ctx:Cobol85Parser.DisplayUponContext): + pass + + # Exit a parse tree produced by Cobol85Parser#displayUpon. + def exitDisplayUpon(self, ctx:Cobol85Parser.DisplayUponContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#displayWith. + def enterDisplayWith(self, ctx:Cobol85Parser.DisplayWithContext): + pass + + # Exit a parse tree produced by Cobol85Parser#displayWith. + def exitDisplayWith(self, ctx:Cobol85Parser.DisplayWithContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#divideStatement. + def enterDivideStatement(self, ctx:Cobol85Parser.DivideStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#divideStatement. + def exitDivideStatement(self, ctx:Cobol85Parser.DivideStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#divideIntoStatement. + def enterDivideIntoStatement(self, ctx:Cobol85Parser.DivideIntoStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#divideIntoStatement. + def exitDivideIntoStatement(self, ctx:Cobol85Parser.DivideIntoStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#divideIntoGivingStatement. + def enterDivideIntoGivingStatement(self, ctx:Cobol85Parser.DivideIntoGivingStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#divideIntoGivingStatement. + def exitDivideIntoGivingStatement(self, ctx:Cobol85Parser.DivideIntoGivingStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#divideByGivingStatement. + def enterDivideByGivingStatement(self, ctx:Cobol85Parser.DivideByGivingStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#divideByGivingStatement. + def exitDivideByGivingStatement(self, ctx:Cobol85Parser.DivideByGivingStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#divideGivingPhrase. + def enterDivideGivingPhrase(self, ctx:Cobol85Parser.DivideGivingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#divideGivingPhrase. + def exitDivideGivingPhrase(self, ctx:Cobol85Parser.DivideGivingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#divideInto. + def enterDivideInto(self, ctx:Cobol85Parser.DivideIntoContext): + pass + + # Exit a parse tree produced by Cobol85Parser#divideInto. + def exitDivideInto(self, ctx:Cobol85Parser.DivideIntoContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#divideGiving. + def enterDivideGiving(self, ctx:Cobol85Parser.DivideGivingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#divideGiving. + def exitDivideGiving(self, ctx:Cobol85Parser.DivideGivingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#divideRemainder. + def enterDivideRemainder(self, ctx:Cobol85Parser.DivideRemainderContext): + pass + + # Exit a parse tree produced by Cobol85Parser#divideRemainder. + def exitDivideRemainder(self, ctx:Cobol85Parser.DivideRemainderContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#enableStatement. + def enterEnableStatement(self, ctx:Cobol85Parser.EnableStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#enableStatement. + def exitEnableStatement(self, ctx:Cobol85Parser.EnableStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#entryStatement. + def enterEntryStatement(self, ctx:Cobol85Parser.EntryStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#entryStatement. + def exitEntryStatement(self, ctx:Cobol85Parser.EntryStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#evaluateStatement. + def enterEvaluateStatement(self, ctx:Cobol85Parser.EvaluateStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#evaluateStatement. + def exitEvaluateStatement(self, ctx:Cobol85Parser.EvaluateStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#evaluateSelect. + def enterEvaluateSelect(self, ctx:Cobol85Parser.EvaluateSelectContext): + pass + + # Exit a parse tree produced by Cobol85Parser#evaluateSelect. + def exitEvaluateSelect(self, ctx:Cobol85Parser.EvaluateSelectContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#evaluateAlsoSelect. + def enterEvaluateAlsoSelect(self, ctx:Cobol85Parser.EvaluateAlsoSelectContext): + pass + + # Exit a parse tree produced by Cobol85Parser#evaluateAlsoSelect. + def exitEvaluateAlsoSelect(self, ctx:Cobol85Parser.EvaluateAlsoSelectContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#evaluateWhenPhrase. + def enterEvaluateWhenPhrase(self, ctx:Cobol85Parser.EvaluateWhenPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#evaluateWhenPhrase. + def exitEvaluateWhenPhrase(self, ctx:Cobol85Parser.EvaluateWhenPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#evaluateWhen. + def enterEvaluateWhen(self, ctx:Cobol85Parser.EvaluateWhenContext): + pass + + # Exit a parse tree produced by Cobol85Parser#evaluateWhen. + def exitEvaluateWhen(self, ctx:Cobol85Parser.EvaluateWhenContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#evaluateCondition. + def enterEvaluateCondition(self, ctx:Cobol85Parser.EvaluateConditionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#evaluateCondition. + def exitEvaluateCondition(self, ctx:Cobol85Parser.EvaluateConditionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#evaluateThrough. + def enterEvaluateThrough(self, ctx:Cobol85Parser.EvaluateThroughContext): + pass + + # Exit a parse tree produced by Cobol85Parser#evaluateThrough. + def exitEvaluateThrough(self, ctx:Cobol85Parser.EvaluateThroughContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#evaluateAlsoCondition. + def enterEvaluateAlsoCondition(self, ctx:Cobol85Parser.EvaluateAlsoConditionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#evaluateAlsoCondition. + def exitEvaluateAlsoCondition(self, ctx:Cobol85Parser.EvaluateAlsoConditionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#evaluateWhenOther. + def enterEvaluateWhenOther(self, ctx:Cobol85Parser.EvaluateWhenOtherContext): + pass + + # Exit a parse tree produced by Cobol85Parser#evaluateWhenOther. + def exitEvaluateWhenOther(self, ctx:Cobol85Parser.EvaluateWhenOtherContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#evaluateValue. + def enterEvaluateValue(self, ctx:Cobol85Parser.EvaluateValueContext): + pass + + # Exit a parse tree produced by Cobol85Parser#evaluateValue. + def exitEvaluateValue(self, ctx:Cobol85Parser.EvaluateValueContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#execCicsStatement. + def enterExecCicsStatement(self, ctx:Cobol85Parser.ExecCicsStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#execCicsStatement. + def exitExecCicsStatement(self, ctx:Cobol85Parser.ExecCicsStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#execSqlStatement. + def enterExecSqlStatement(self, ctx:Cobol85Parser.ExecSqlStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#execSqlStatement. + def exitExecSqlStatement(self, ctx:Cobol85Parser.ExecSqlStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#execSqlImsStatement. + def enterExecSqlImsStatement(self, ctx:Cobol85Parser.ExecSqlImsStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#execSqlImsStatement. + def exitExecSqlImsStatement(self, ctx:Cobol85Parser.ExecSqlImsStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#exhibitStatement. + def enterExhibitStatement(self, ctx:Cobol85Parser.ExhibitStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#exhibitStatement. + def exitExhibitStatement(self, ctx:Cobol85Parser.ExhibitStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#exhibitOperand. + def enterExhibitOperand(self, ctx:Cobol85Parser.ExhibitOperandContext): + pass + + # Exit a parse tree produced by Cobol85Parser#exhibitOperand. + def exitExhibitOperand(self, ctx:Cobol85Parser.ExhibitOperandContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#exitStatement. + def enterExitStatement(self, ctx:Cobol85Parser.ExitStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#exitStatement. + def exitExitStatement(self, ctx:Cobol85Parser.ExitStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#generateStatement. + def enterGenerateStatement(self, ctx:Cobol85Parser.GenerateStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#generateStatement. + def exitGenerateStatement(self, ctx:Cobol85Parser.GenerateStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#gobackStatement. + def enterGobackStatement(self, ctx:Cobol85Parser.GobackStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#gobackStatement. + def exitGobackStatement(self, ctx:Cobol85Parser.GobackStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#goToStatement. + def enterGoToStatement(self, ctx:Cobol85Parser.GoToStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#goToStatement. + def exitGoToStatement(self, ctx:Cobol85Parser.GoToStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#goToStatementSimple. + def enterGoToStatementSimple(self, ctx:Cobol85Parser.GoToStatementSimpleContext): + pass + + # Exit a parse tree produced by Cobol85Parser#goToStatementSimple. + def exitGoToStatementSimple(self, ctx:Cobol85Parser.GoToStatementSimpleContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#goToDependingOnStatement. + def enterGoToDependingOnStatement(self, ctx:Cobol85Parser.GoToDependingOnStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#goToDependingOnStatement. + def exitGoToDependingOnStatement(self, ctx:Cobol85Parser.GoToDependingOnStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#ifStatement. + def enterIfStatement(self, ctx:Cobol85Parser.IfStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#ifStatement. + def exitIfStatement(self, ctx:Cobol85Parser.IfStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#ifThen. + def enterIfThen(self, ctx:Cobol85Parser.IfThenContext): + pass + + # Exit a parse tree produced by Cobol85Parser#ifThen. + def exitIfThen(self, ctx:Cobol85Parser.IfThenContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#ifElse. + def enterIfElse(self, ctx:Cobol85Parser.IfElseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#ifElse. + def exitIfElse(self, ctx:Cobol85Parser.IfElseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#initializeStatement. + def enterInitializeStatement(self, ctx:Cobol85Parser.InitializeStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#initializeStatement. + def exitInitializeStatement(self, ctx:Cobol85Parser.InitializeStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#initializeReplacingPhrase. + def enterInitializeReplacingPhrase(self, ctx:Cobol85Parser.InitializeReplacingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#initializeReplacingPhrase. + def exitInitializeReplacingPhrase(self, ctx:Cobol85Parser.InitializeReplacingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#initializeReplacingBy. + def enterInitializeReplacingBy(self, ctx:Cobol85Parser.InitializeReplacingByContext): + pass + + # Exit a parse tree produced by Cobol85Parser#initializeReplacingBy. + def exitInitializeReplacingBy(self, ctx:Cobol85Parser.InitializeReplacingByContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#initiateStatement. + def enterInitiateStatement(self, ctx:Cobol85Parser.InitiateStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#initiateStatement. + def exitInitiateStatement(self, ctx:Cobol85Parser.InitiateStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inspectStatement. + def enterInspectStatement(self, ctx:Cobol85Parser.InspectStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inspectStatement. + def exitInspectStatement(self, ctx:Cobol85Parser.InspectStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inspectTallyingPhrase. + def enterInspectTallyingPhrase(self, ctx:Cobol85Parser.InspectTallyingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inspectTallyingPhrase. + def exitInspectTallyingPhrase(self, ctx:Cobol85Parser.InspectTallyingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inspectReplacingPhrase. + def enterInspectReplacingPhrase(self, ctx:Cobol85Parser.InspectReplacingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inspectReplacingPhrase. + def exitInspectReplacingPhrase(self, ctx:Cobol85Parser.InspectReplacingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inspectTallyingReplacingPhrase. + def enterInspectTallyingReplacingPhrase(self, ctx:Cobol85Parser.InspectTallyingReplacingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inspectTallyingReplacingPhrase. + def exitInspectTallyingReplacingPhrase(self, ctx:Cobol85Parser.InspectTallyingReplacingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inspectConvertingPhrase. + def enterInspectConvertingPhrase(self, ctx:Cobol85Parser.InspectConvertingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inspectConvertingPhrase. + def exitInspectConvertingPhrase(self, ctx:Cobol85Parser.InspectConvertingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inspectFor. + def enterInspectFor(self, ctx:Cobol85Parser.InspectForContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inspectFor. + def exitInspectFor(self, ctx:Cobol85Parser.InspectForContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inspectCharacters. + def enterInspectCharacters(self, ctx:Cobol85Parser.InspectCharactersContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inspectCharacters. + def exitInspectCharacters(self, ctx:Cobol85Parser.InspectCharactersContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inspectReplacingCharacters. + def enterInspectReplacingCharacters(self, ctx:Cobol85Parser.InspectReplacingCharactersContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inspectReplacingCharacters. + def exitInspectReplacingCharacters(self, ctx:Cobol85Parser.InspectReplacingCharactersContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inspectAllLeadings. + def enterInspectAllLeadings(self, ctx:Cobol85Parser.InspectAllLeadingsContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inspectAllLeadings. + def exitInspectAllLeadings(self, ctx:Cobol85Parser.InspectAllLeadingsContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inspectReplacingAllLeadings. + def enterInspectReplacingAllLeadings(self, ctx:Cobol85Parser.InspectReplacingAllLeadingsContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inspectReplacingAllLeadings. + def exitInspectReplacingAllLeadings(self, ctx:Cobol85Parser.InspectReplacingAllLeadingsContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inspectAllLeading. + def enterInspectAllLeading(self, ctx:Cobol85Parser.InspectAllLeadingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inspectAllLeading. + def exitInspectAllLeading(self, ctx:Cobol85Parser.InspectAllLeadingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inspectReplacingAllLeading. + def enterInspectReplacingAllLeading(self, ctx:Cobol85Parser.InspectReplacingAllLeadingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inspectReplacingAllLeading. + def exitInspectReplacingAllLeading(self, ctx:Cobol85Parser.InspectReplacingAllLeadingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inspectBy. + def enterInspectBy(self, ctx:Cobol85Parser.InspectByContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inspectBy. + def exitInspectBy(self, ctx:Cobol85Parser.InspectByContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inspectTo. + def enterInspectTo(self, ctx:Cobol85Parser.InspectToContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inspectTo. + def exitInspectTo(self, ctx:Cobol85Parser.InspectToContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inspectBeforeAfter. + def enterInspectBeforeAfter(self, ctx:Cobol85Parser.InspectBeforeAfterContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inspectBeforeAfter. + def exitInspectBeforeAfter(self, ctx:Cobol85Parser.InspectBeforeAfterContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#mergeStatement. + def enterMergeStatement(self, ctx:Cobol85Parser.MergeStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#mergeStatement. + def exitMergeStatement(self, ctx:Cobol85Parser.MergeStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#mergeOnKeyClause. + def enterMergeOnKeyClause(self, ctx:Cobol85Parser.MergeOnKeyClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#mergeOnKeyClause. + def exitMergeOnKeyClause(self, ctx:Cobol85Parser.MergeOnKeyClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#mergeCollatingSequencePhrase. + def enterMergeCollatingSequencePhrase(self, ctx:Cobol85Parser.MergeCollatingSequencePhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#mergeCollatingSequencePhrase. + def exitMergeCollatingSequencePhrase(self, ctx:Cobol85Parser.MergeCollatingSequencePhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#mergeCollatingAlphanumeric. + def enterMergeCollatingAlphanumeric(self, ctx:Cobol85Parser.MergeCollatingAlphanumericContext): + pass + + # Exit a parse tree produced by Cobol85Parser#mergeCollatingAlphanumeric. + def exitMergeCollatingAlphanumeric(self, ctx:Cobol85Parser.MergeCollatingAlphanumericContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#mergeCollatingNational. + def enterMergeCollatingNational(self, ctx:Cobol85Parser.MergeCollatingNationalContext): + pass + + # Exit a parse tree produced by Cobol85Parser#mergeCollatingNational. + def exitMergeCollatingNational(self, ctx:Cobol85Parser.MergeCollatingNationalContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#mergeUsing. + def enterMergeUsing(self, ctx:Cobol85Parser.MergeUsingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#mergeUsing. + def exitMergeUsing(self, ctx:Cobol85Parser.MergeUsingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#mergeOutputProcedurePhrase. + def enterMergeOutputProcedurePhrase(self, ctx:Cobol85Parser.MergeOutputProcedurePhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#mergeOutputProcedurePhrase. + def exitMergeOutputProcedurePhrase(self, ctx:Cobol85Parser.MergeOutputProcedurePhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#mergeOutputThrough. + def enterMergeOutputThrough(self, ctx:Cobol85Parser.MergeOutputThroughContext): + pass + + # Exit a parse tree produced by Cobol85Parser#mergeOutputThrough. + def exitMergeOutputThrough(self, ctx:Cobol85Parser.MergeOutputThroughContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#mergeGivingPhrase. + def enterMergeGivingPhrase(self, ctx:Cobol85Parser.MergeGivingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#mergeGivingPhrase. + def exitMergeGivingPhrase(self, ctx:Cobol85Parser.MergeGivingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#mergeGiving. + def enterMergeGiving(self, ctx:Cobol85Parser.MergeGivingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#mergeGiving. + def exitMergeGiving(self, ctx:Cobol85Parser.MergeGivingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#moveStatement. + def enterMoveStatement(self, ctx:Cobol85Parser.MoveStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#moveStatement. + def exitMoveStatement(self, ctx:Cobol85Parser.MoveStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#moveToStatement. + def enterMoveToStatement(self, ctx:Cobol85Parser.MoveToStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#moveToStatement. + def exitMoveToStatement(self, ctx:Cobol85Parser.MoveToStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#moveToSendingArea. + def enterMoveToSendingArea(self, ctx:Cobol85Parser.MoveToSendingAreaContext): + pass + + # Exit a parse tree produced by Cobol85Parser#moveToSendingArea. + def exitMoveToSendingArea(self, ctx:Cobol85Parser.MoveToSendingAreaContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#moveCorrespondingToStatement. + def enterMoveCorrespondingToStatement(self, ctx:Cobol85Parser.MoveCorrespondingToStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#moveCorrespondingToStatement. + def exitMoveCorrespondingToStatement(self, ctx:Cobol85Parser.MoveCorrespondingToStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#moveCorrespondingToSendingArea. + def enterMoveCorrespondingToSendingArea(self, ctx:Cobol85Parser.MoveCorrespondingToSendingAreaContext): + pass + + # Exit a parse tree produced by Cobol85Parser#moveCorrespondingToSendingArea. + def exitMoveCorrespondingToSendingArea(self, ctx:Cobol85Parser.MoveCorrespondingToSendingAreaContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#multiplyStatement. + def enterMultiplyStatement(self, ctx:Cobol85Parser.MultiplyStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#multiplyStatement. + def exitMultiplyStatement(self, ctx:Cobol85Parser.MultiplyStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#multiplyRegular. + def enterMultiplyRegular(self, ctx:Cobol85Parser.MultiplyRegularContext): + pass + + # Exit a parse tree produced by Cobol85Parser#multiplyRegular. + def exitMultiplyRegular(self, ctx:Cobol85Parser.MultiplyRegularContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#multiplyRegularOperand. + def enterMultiplyRegularOperand(self, ctx:Cobol85Parser.MultiplyRegularOperandContext): + pass + + # Exit a parse tree produced by Cobol85Parser#multiplyRegularOperand. + def exitMultiplyRegularOperand(self, ctx:Cobol85Parser.MultiplyRegularOperandContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#multiplyGiving. + def enterMultiplyGiving(self, ctx:Cobol85Parser.MultiplyGivingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#multiplyGiving. + def exitMultiplyGiving(self, ctx:Cobol85Parser.MultiplyGivingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#multiplyGivingOperand. + def enterMultiplyGivingOperand(self, ctx:Cobol85Parser.MultiplyGivingOperandContext): + pass + + # Exit a parse tree produced by Cobol85Parser#multiplyGivingOperand. + def exitMultiplyGivingOperand(self, ctx:Cobol85Parser.MultiplyGivingOperandContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#multiplyGivingResult. + def enterMultiplyGivingResult(self, ctx:Cobol85Parser.MultiplyGivingResultContext): + pass + + # Exit a parse tree produced by Cobol85Parser#multiplyGivingResult. + def exitMultiplyGivingResult(self, ctx:Cobol85Parser.MultiplyGivingResultContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#openStatement. + def enterOpenStatement(self, ctx:Cobol85Parser.OpenStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#openStatement. + def exitOpenStatement(self, ctx:Cobol85Parser.OpenStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#openInputStatement. + def enterOpenInputStatement(self, ctx:Cobol85Parser.OpenInputStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#openInputStatement. + def exitOpenInputStatement(self, ctx:Cobol85Parser.OpenInputStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#openInput. + def enterOpenInput(self, ctx:Cobol85Parser.OpenInputContext): + pass + + # Exit a parse tree produced by Cobol85Parser#openInput. + def exitOpenInput(self, ctx:Cobol85Parser.OpenInputContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#openOutputStatement. + def enterOpenOutputStatement(self, ctx:Cobol85Parser.OpenOutputStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#openOutputStatement. + def exitOpenOutputStatement(self, ctx:Cobol85Parser.OpenOutputStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#openOutput. + def enterOpenOutput(self, ctx:Cobol85Parser.OpenOutputContext): + pass + + # Exit a parse tree produced by Cobol85Parser#openOutput. + def exitOpenOutput(self, ctx:Cobol85Parser.OpenOutputContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#openIOStatement. + def enterOpenIOStatement(self, ctx:Cobol85Parser.OpenIOStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#openIOStatement. + def exitOpenIOStatement(self, ctx:Cobol85Parser.OpenIOStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#openExtendStatement. + def enterOpenExtendStatement(self, ctx:Cobol85Parser.OpenExtendStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#openExtendStatement. + def exitOpenExtendStatement(self, ctx:Cobol85Parser.OpenExtendStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#performStatement. + def enterPerformStatement(self, ctx:Cobol85Parser.PerformStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#performStatement. + def exitPerformStatement(self, ctx:Cobol85Parser.PerformStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#performInlineStatement. + def enterPerformInlineStatement(self, ctx:Cobol85Parser.PerformInlineStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#performInlineStatement. + def exitPerformInlineStatement(self, ctx:Cobol85Parser.PerformInlineStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#performProcedureStatement. + def enterPerformProcedureStatement(self, ctx:Cobol85Parser.PerformProcedureStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#performProcedureStatement. + def exitPerformProcedureStatement(self, ctx:Cobol85Parser.PerformProcedureStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#performType. + def enterPerformType(self, ctx:Cobol85Parser.PerformTypeContext): + pass + + # Exit a parse tree produced by Cobol85Parser#performType. + def exitPerformType(self, ctx:Cobol85Parser.PerformTypeContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#performTimes. + def enterPerformTimes(self, ctx:Cobol85Parser.PerformTimesContext): + pass + + # Exit a parse tree produced by Cobol85Parser#performTimes. + def exitPerformTimes(self, ctx:Cobol85Parser.PerformTimesContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#performUntil. + def enterPerformUntil(self, ctx:Cobol85Parser.PerformUntilContext): + pass + + # Exit a parse tree produced by Cobol85Parser#performUntil. + def exitPerformUntil(self, ctx:Cobol85Parser.PerformUntilContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#performVarying. + def enterPerformVarying(self, ctx:Cobol85Parser.PerformVaryingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#performVarying. + def exitPerformVarying(self, ctx:Cobol85Parser.PerformVaryingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#performVaryingClause. + def enterPerformVaryingClause(self, ctx:Cobol85Parser.PerformVaryingClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#performVaryingClause. + def exitPerformVaryingClause(self, ctx:Cobol85Parser.PerformVaryingClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#performVaryingPhrase. + def enterPerformVaryingPhrase(self, ctx:Cobol85Parser.PerformVaryingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#performVaryingPhrase. + def exitPerformVaryingPhrase(self, ctx:Cobol85Parser.PerformVaryingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#performAfter. + def enterPerformAfter(self, ctx:Cobol85Parser.PerformAfterContext): + pass + + # Exit a parse tree produced by Cobol85Parser#performAfter. + def exitPerformAfter(self, ctx:Cobol85Parser.PerformAfterContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#performFrom. + def enterPerformFrom(self, ctx:Cobol85Parser.PerformFromContext): + pass + + # Exit a parse tree produced by Cobol85Parser#performFrom. + def exitPerformFrom(self, ctx:Cobol85Parser.PerformFromContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#performBy. + def enterPerformBy(self, ctx:Cobol85Parser.PerformByContext): + pass + + # Exit a parse tree produced by Cobol85Parser#performBy. + def exitPerformBy(self, ctx:Cobol85Parser.PerformByContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#performTestClause. + def enterPerformTestClause(self, ctx:Cobol85Parser.PerformTestClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#performTestClause. + def exitPerformTestClause(self, ctx:Cobol85Parser.PerformTestClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#purgeStatement. + def enterPurgeStatement(self, ctx:Cobol85Parser.PurgeStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#purgeStatement. + def exitPurgeStatement(self, ctx:Cobol85Parser.PurgeStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#readStatement. + def enterReadStatement(self, ctx:Cobol85Parser.ReadStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#readStatement. + def exitReadStatement(self, ctx:Cobol85Parser.ReadStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#readInto. + def enterReadInto(self, ctx:Cobol85Parser.ReadIntoContext): + pass + + # Exit a parse tree produced by Cobol85Parser#readInto. + def exitReadInto(self, ctx:Cobol85Parser.ReadIntoContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#readWith. + def enterReadWith(self, ctx:Cobol85Parser.ReadWithContext): + pass + + # Exit a parse tree produced by Cobol85Parser#readWith. + def exitReadWith(self, ctx:Cobol85Parser.ReadWithContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#readKey. + def enterReadKey(self, ctx:Cobol85Parser.ReadKeyContext): + pass + + # Exit a parse tree produced by Cobol85Parser#readKey. + def exitReadKey(self, ctx:Cobol85Parser.ReadKeyContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#receiveStatement. + def enterReceiveStatement(self, ctx:Cobol85Parser.ReceiveStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#receiveStatement. + def exitReceiveStatement(self, ctx:Cobol85Parser.ReceiveStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#receiveFromStatement. + def enterReceiveFromStatement(self, ctx:Cobol85Parser.ReceiveFromStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#receiveFromStatement. + def exitReceiveFromStatement(self, ctx:Cobol85Parser.ReceiveFromStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#receiveFrom. + def enterReceiveFrom(self, ctx:Cobol85Parser.ReceiveFromContext): + pass + + # Exit a parse tree produced by Cobol85Parser#receiveFrom. + def exitReceiveFrom(self, ctx:Cobol85Parser.ReceiveFromContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#receiveIntoStatement. + def enterReceiveIntoStatement(self, ctx:Cobol85Parser.ReceiveIntoStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#receiveIntoStatement. + def exitReceiveIntoStatement(self, ctx:Cobol85Parser.ReceiveIntoStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#receiveNoData. + def enterReceiveNoData(self, ctx:Cobol85Parser.ReceiveNoDataContext): + pass + + # Exit a parse tree produced by Cobol85Parser#receiveNoData. + def exitReceiveNoData(self, ctx:Cobol85Parser.ReceiveNoDataContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#receiveWithData. + def enterReceiveWithData(self, ctx:Cobol85Parser.ReceiveWithDataContext): + pass + + # Exit a parse tree produced by Cobol85Parser#receiveWithData. + def exitReceiveWithData(self, ctx:Cobol85Parser.ReceiveWithDataContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#receiveBefore. + def enterReceiveBefore(self, ctx:Cobol85Parser.ReceiveBeforeContext): + pass + + # Exit a parse tree produced by Cobol85Parser#receiveBefore. + def exitReceiveBefore(self, ctx:Cobol85Parser.ReceiveBeforeContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#receiveWith. + def enterReceiveWith(self, ctx:Cobol85Parser.ReceiveWithContext): + pass + + # Exit a parse tree produced by Cobol85Parser#receiveWith. + def exitReceiveWith(self, ctx:Cobol85Parser.ReceiveWithContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#receiveThread. + def enterReceiveThread(self, ctx:Cobol85Parser.ReceiveThreadContext): + pass + + # Exit a parse tree produced by Cobol85Parser#receiveThread. + def exitReceiveThread(self, ctx:Cobol85Parser.ReceiveThreadContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#receiveSize. + def enterReceiveSize(self, ctx:Cobol85Parser.ReceiveSizeContext): + pass + + # Exit a parse tree produced by Cobol85Parser#receiveSize. + def exitReceiveSize(self, ctx:Cobol85Parser.ReceiveSizeContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#receiveStatus. + def enterReceiveStatus(self, ctx:Cobol85Parser.ReceiveStatusContext): + pass + + # Exit a parse tree produced by Cobol85Parser#receiveStatus. + def exitReceiveStatus(self, ctx:Cobol85Parser.ReceiveStatusContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#releaseStatement. + def enterReleaseStatement(self, ctx:Cobol85Parser.ReleaseStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#releaseStatement. + def exitReleaseStatement(self, ctx:Cobol85Parser.ReleaseStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#returnStatement. + def enterReturnStatement(self, ctx:Cobol85Parser.ReturnStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#returnStatement. + def exitReturnStatement(self, ctx:Cobol85Parser.ReturnStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#returnInto. + def enterReturnInto(self, ctx:Cobol85Parser.ReturnIntoContext): + pass + + # Exit a parse tree produced by Cobol85Parser#returnInto. + def exitReturnInto(self, ctx:Cobol85Parser.ReturnIntoContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#rewriteStatement. + def enterRewriteStatement(self, ctx:Cobol85Parser.RewriteStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#rewriteStatement. + def exitRewriteStatement(self, ctx:Cobol85Parser.RewriteStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#rewriteFrom. + def enterRewriteFrom(self, ctx:Cobol85Parser.RewriteFromContext): + pass + + # Exit a parse tree produced by Cobol85Parser#rewriteFrom. + def exitRewriteFrom(self, ctx:Cobol85Parser.RewriteFromContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#searchStatement. + def enterSearchStatement(self, ctx:Cobol85Parser.SearchStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#searchStatement. + def exitSearchStatement(self, ctx:Cobol85Parser.SearchStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#searchVarying. + def enterSearchVarying(self, ctx:Cobol85Parser.SearchVaryingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#searchVarying. + def exitSearchVarying(self, ctx:Cobol85Parser.SearchVaryingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#searchWhen. + def enterSearchWhen(self, ctx:Cobol85Parser.SearchWhenContext): + pass + + # Exit a parse tree produced by Cobol85Parser#searchWhen. + def exitSearchWhen(self, ctx:Cobol85Parser.SearchWhenContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sendStatement. + def enterSendStatement(self, ctx:Cobol85Parser.SendStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sendStatement. + def exitSendStatement(self, ctx:Cobol85Parser.SendStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sendStatementSync. + def enterSendStatementSync(self, ctx:Cobol85Parser.SendStatementSyncContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sendStatementSync. + def exitSendStatementSync(self, ctx:Cobol85Parser.SendStatementSyncContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sendStatementAsync. + def enterSendStatementAsync(self, ctx:Cobol85Parser.SendStatementAsyncContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sendStatementAsync. + def exitSendStatementAsync(self, ctx:Cobol85Parser.SendStatementAsyncContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sendFromPhrase. + def enterSendFromPhrase(self, ctx:Cobol85Parser.SendFromPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sendFromPhrase. + def exitSendFromPhrase(self, ctx:Cobol85Parser.SendFromPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sendWithPhrase. + def enterSendWithPhrase(self, ctx:Cobol85Parser.SendWithPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sendWithPhrase. + def exitSendWithPhrase(self, ctx:Cobol85Parser.SendWithPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sendReplacingPhrase. + def enterSendReplacingPhrase(self, ctx:Cobol85Parser.SendReplacingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sendReplacingPhrase. + def exitSendReplacingPhrase(self, ctx:Cobol85Parser.SendReplacingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sendAdvancingPhrase. + def enterSendAdvancingPhrase(self, ctx:Cobol85Parser.SendAdvancingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sendAdvancingPhrase. + def exitSendAdvancingPhrase(self, ctx:Cobol85Parser.SendAdvancingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sendAdvancingPage. + def enterSendAdvancingPage(self, ctx:Cobol85Parser.SendAdvancingPageContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sendAdvancingPage. + def exitSendAdvancingPage(self, ctx:Cobol85Parser.SendAdvancingPageContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sendAdvancingLines. + def enterSendAdvancingLines(self, ctx:Cobol85Parser.SendAdvancingLinesContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sendAdvancingLines. + def exitSendAdvancingLines(self, ctx:Cobol85Parser.SendAdvancingLinesContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sendAdvancingMnemonic. + def enterSendAdvancingMnemonic(self, ctx:Cobol85Parser.SendAdvancingMnemonicContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sendAdvancingMnemonic. + def exitSendAdvancingMnemonic(self, ctx:Cobol85Parser.SendAdvancingMnemonicContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#setStatement. + def enterSetStatement(self, ctx:Cobol85Parser.SetStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#setStatement. + def exitSetStatement(self, ctx:Cobol85Parser.SetStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#setToStatement. + def enterSetToStatement(self, ctx:Cobol85Parser.SetToStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#setToStatement. + def exitSetToStatement(self, ctx:Cobol85Parser.SetToStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#setUpDownByStatement. + def enterSetUpDownByStatement(self, ctx:Cobol85Parser.SetUpDownByStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#setUpDownByStatement. + def exitSetUpDownByStatement(self, ctx:Cobol85Parser.SetUpDownByStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#setTo. + def enterSetTo(self, ctx:Cobol85Parser.SetToContext): + pass + + # Exit a parse tree produced by Cobol85Parser#setTo. + def exitSetTo(self, ctx:Cobol85Parser.SetToContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#setToValue. + def enterSetToValue(self, ctx:Cobol85Parser.SetToValueContext): + pass + + # Exit a parse tree produced by Cobol85Parser#setToValue. + def exitSetToValue(self, ctx:Cobol85Parser.SetToValueContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#setByValue. + def enterSetByValue(self, ctx:Cobol85Parser.SetByValueContext): + pass + + # Exit a parse tree produced by Cobol85Parser#setByValue. + def exitSetByValue(self, ctx:Cobol85Parser.SetByValueContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sortStatement. + def enterSortStatement(self, ctx:Cobol85Parser.SortStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sortStatement. + def exitSortStatement(self, ctx:Cobol85Parser.SortStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sortOnKeyClause. + def enterSortOnKeyClause(self, ctx:Cobol85Parser.SortOnKeyClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sortOnKeyClause. + def exitSortOnKeyClause(self, ctx:Cobol85Parser.SortOnKeyClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sortDuplicatesPhrase. + def enterSortDuplicatesPhrase(self, ctx:Cobol85Parser.SortDuplicatesPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sortDuplicatesPhrase. + def exitSortDuplicatesPhrase(self, ctx:Cobol85Parser.SortDuplicatesPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sortCollatingSequencePhrase. + def enterSortCollatingSequencePhrase(self, ctx:Cobol85Parser.SortCollatingSequencePhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sortCollatingSequencePhrase. + def exitSortCollatingSequencePhrase(self, ctx:Cobol85Parser.SortCollatingSequencePhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sortCollatingAlphanumeric. + def enterSortCollatingAlphanumeric(self, ctx:Cobol85Parser.SortCollatingAlphanumericContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sortCollatingAlphanumeric. + def exitSortCollatingAlphanumeric(self, ctx:Cobol85Parser.SortCollatingAlphanumericContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sortCollatingNational. + def enterSortCollatingNational(self, ctx:Cobol85Parser.SortCollatingNationalContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sortCollatingNational. + def exitSortCollatingNational(self, ctx:Cobol85Parser.SortCollatingNationalContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sortInputProcedurePhrase. + def enterSortInputProcedurePhrase(self, ctx:Cobol85Parser.SortInputProcedurePhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sortInputProcedurePhrase. + def exitSortInputProcedurePhrase(self, ctx:Cobol85Parser.SortInputProcedurePhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sortInputThrough. + def enterSortInputThrough(self, ctx:Cobol85Parser.SortInputThroughContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sortInputThrough. + def exitSortInputThrough(self, ctx:Cobol85Parser.SortInputThroughContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sortUsing. + def enterSortUsing(self, ctx:Cobol85Parser.SortUsingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sortUsing. + def exitSortUsing(self, ctx:Cobol85Parser.SortUsingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sortOutputProcedurePhrase. + def enterSortOutputProcedurePhrase(self, ctx:Cobol85Parser.SortOutputProcedurePhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sortOutputProcedurePhrase. + def exitSortOutputProcedurePhrase(self, ctx:Cobol85Parser.SortOutputProcedurePhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sortOutputThrough. + def enterSortOutputThrough(self, ctx:Cobol85Parser.SortOutputThroughContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sortOutputThrough. + def exitSortOutputThrough(self, ctx:Cobol85Parser.SortOutputThroughContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sortGivingPhrase. + def enterSortGivingPhrase(self, ctx:Cobol85Parser.SortGivingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sortGivingPhrase. + def exitSortGivingPhrase(self, ctx:Cobol85Parser.SortGivingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sortGiving. + def enterSortGiving(self, ctx:Cobol85Parser.SortGivingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sortGiving. + def exitSortGiving(self, ctx:Cobol85Parser.SortGivingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#startStatement. + def enterStartStatement(self, ctx:Cobol85Parser.StartStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#startStatement. + def exitStartStatement(self, ctx:Cobol85Parser.StartStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#startKey. + def enterStartKey(self, ctx:Cobol85Parser.StartKeyContext): + pass + + # Exit a parse tree produced by Cobol85Parser#startKey. + def exitStartKey(self, ctx:Cobol85Parser.StartKeyContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#stopStatement. + def enterStopStatement(self, ctx:Cobol85Parser.StopStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#stopStatement. + def exitStopStatement(self, ctx:Cobol85Parser.StopStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#stringStatement. + def enterStringStatement(self, ctx:Cobol85Parser.StringStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#stringStatement. + def exitStringStatement(self, ctx:Cobol85Parser.StringStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#stringSendingPhrase. + def enterStringSendingPhrase(self, ctx:Cobol85Parser.StringSendingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#stringSendingPhrase. + def exitStringSendingPhrase(self, ctx:Cobol85Parser.StringSendingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#stringSending. + def enterStringSending(self, ctx:Cobol85Parser.StringSendingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#stringSending. + def exitStringSending(self, ctx:Cobol85Parser.StringSendingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#stringDelimitedByPhrase. + def enterStringDelimitedByPhrase(self, ctx:Cobol85Parser.StringDelimitedByPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#stringDelimitedByPhrase. + def exitStringDelimitedByPhrase(self, ctx:Cobol85Parser.StringDelimitedByPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#stringForPhrase. + def enterStringForPhrase(self, ctx:Cobol85Parser.StringForPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#stringForPhrase. + def exitStringForPhrase(self, ctx:Cobol85Parser.StringForPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#stringIntoPhrase. + def enterStringIntoPhrase(self, ctx:Cobol85Parser.StringIntoPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#stringIntoPhrase. + def exitStringIntoPhrase(self, ctx:Cobol85Parser.StringIntoPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#stringWithPointerPhrase. + def enterStringWithPointerPhrase(self, ctx:Cobol85Parser.StringWithPointerPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#stringWithPointerPhrase. + def exitStringWithPointerPhrase(self, ctx:Cobol85Parser.StringWithPointerPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#subtractStatement. + def enterSubtractStatement(self, ctx:Cobol85Parser.SubtractStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#subtractStatement. + def exitSubtractStatement(self, ctx:Cobol85Parser.SubtractStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#subtractFromStatement. + def enterSubtractFromStatement(self, ctx:Cobol85Parser.SubtractFromStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#subtractFromStatement. + def exitSubtractFromStatement(self, ctx:Cobol85Parser.SubtractFromStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#subtractFromGivingStatement. + def enterSubtractFromGivingStatement(self, ctx:Cobol85Parser.SubtractFromGivingStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#subtractFromGivingStatement. + def exitSubtractFromGivingStatement(self, ctx:Cobol85Parser.SubtractFromGivingStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#subtractCorrespondingStatement. + def enterSubtractCorrespondingStatement(self, ctx:Cobol85Parser.SubtractCorrespondingStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#subtractCorrespondingStatement. + def exitSubtractCorrespondingStatement(self, ctx:Cobol85Parser.SubtractCorrespondingStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#subtractSubtrahend. + def enterSubtractSubtrahend(self, ctx:Cobol85Parser.SubtractSubtrahendContext): + pass + + # Exit a parse tree produced by Cobol85Parser#subtractSubtrahend. + def exitSubtractSubtrahend(self, ctx:Cobol85Parser.SubtractSubtrahendContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#subtractMinuend. + def enterSubtractMinuend(self, ctx:Cobol85Parser.SubtractMinuendContext): + pass + + # Exit a parse tree produced by Cobol85Parser#subtractMinuend. + def exitSubtractMinuend(self, ctx:Cobol85Parser.SubtractMinuendContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#subtractMinuendGiving. + def enterSubtractMinuendGiving(self, ctx:Cobol85Parser.SubtractMinuendGivingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#subtractMinuendGiving. + def exitSubtractMinuendGiving(self, ctx:Cobol85Parser.SubtractMinuendGivingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#subtractGiving. + def enterSubtractGiving(self, ctx:Cobol85Parser.SubtractGivingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#subtractGiving. + def exitSubtractGiving(self, ctx:Cobol85Parser.SubtractGivingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#subtractMinuendCorresponding. + def enterSubtractMinuendCorresponding(self, ctx:Cobol85Parser.SubtractMinuendCorrespondingContext): + pass + + # Exit a parse tree produced by Cobol85Parser#subtractMinuendCorresponding. + def exitSubtractMinuendCorresponding(self, ctx:Cobol85Parser.SubtractMinuendCorrespondingContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#terminateStatement. + def enterTerminateStatement(self, ctx:Cobol85Parser.TerminateStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#terminateStatement. + def exitTerminateStatement(self, ctx:Cobol85Parser.TerminateStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#unstringStatement. + def enterUnstringStatement(self, ctx:Cobol85Parser.UnstringStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#unstringStatement. + def exitUnstringStatement(self, ctx:Cobol85Parser.UnstringStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#unstringSendingPhrase. + def enterUnstringSendingPhrase(self, ctx:Cobol85Parser.UnstringSendingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#unstringSendingPhrase. + def exitUnstringSendingPhrase(self, ctx:Cobol85Parser.UnstringSendingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#unstringDelimitedByPhrase. + def enterUnstringDelimitedByPhrase(self, ctx:Cobol85Parser.UnstringDelimitedByPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#unstringDelimitedByPhrase. + def exitUnstringDelimitedByPhrase(self, ctx:Cobol85Parser.UnstringDelimitedByPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#unstringOrAllPhrase. + def enterUnstringOrAllPhrase(self, ctx:Cobol85Parser.UnstringOrAllPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#unstringOrAllPhrase. + def exitUnstringOrAllPhrase(self, ctx:Cobol85Parser.UnstringOrAllPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#unstringIntoPhrase. + def enterUnstringIntoPhrase(self, ctx:Cobol85Parser.UnstringIntoPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#unstringIntoPhrase. + def exitUnstringIntoPhrase(self, ctx:Cobol85Parser.UnstringIntoPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#unstringInto. + def enterUnstringInto(self, ctx:Cobol85Parser.UnstringIntoContext): + pass + + # Exit a parse tree produced by Cobol85Parser#unstringInto. + def exitUnstringInto(self, ctx:Cobol85Parser.UnstringIntoContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#unstringDelimiterIn. + def enterUnstringDelimiterIn(self, ctx:Cobol85Parser.UnstringDelimiterInContext): + pass + + # Exit a parse tree produced by Cobol85Parser#unstringDelimiterIn. + def exitUnstringDelimiterIn(self, ctx:Cobol85Parser.UnstringDelimiterInContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#unstringCountIn. + def enterUnstringCountIn(self, ctx:Cobol85Parser.UnstringCountInContext): + pass + + # Exit a parse tree produced by Cobol85Parser#unstringCountIn. + def exitUnstringCountIn(self, ctx:Cobol85Parser.UnstringCountInContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#unstringWithPointerPhrase. + def enterUnstringWithPointerPhrase(self, ctx:Cobol85Parser.UnstringWithPointerPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#unstringWithPointerPhrase. + def exitUnstringWithPointerPhrase(self, ctx:Cobol85Parser.UnstringWithPointerPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#unstringTallyingPhrase. + def enterUnstringTallyingPhrase(self, ctx:Cobol85Parser.UnstringTallyingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#unstringTallyingPhrase. + def exitUnstringTallyingPhrase(self, ctx:Cobol85Parser.UnstringTallyingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#useStatement. + def enterUseStatement(self, ctx:Cobol85Parser.UseStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#useStatement. + def exitUseStatement(self, ctx:Cobol85Parser.UseStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#useAfterClause. + def enterUseAfterClause(self, ctx:Cobol85Parser.UseAfterClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#useAfterClause. + def exitUseAfterClause(self, ctx:Cobol85Parser.UseAfterClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#useAfterOn. + def enterUseAfterOn(self, ctx:Cobol85Parser.UseAfterOnContext): + pass + + # Exit a parse tree produced by Cobol85Parser#useAfterOn. + def exitUseAfterOn(self, ctx:Cobol85Parser.UseAfterOnContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#useDebugClause. + def enterUseDebugClause(self, ctx:Cobol85Parser.UseDebugClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#useDebugClause. + def exitUseDebugClause(self, ctx:Cobol85Parser.UseDebugClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#useDebugOn. + def enterUseDebugOn(self, ctx:Cobol85Parser.UseDebugOnContext): + pass + + # Exit a parse tree produced by Cobol85Parser#useDebugOn. + def exitUseDebugOn(self, ctx:Cobol85Parser.UseDebugOnContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#writeStatement. + def enterWriteStatement(self, ctx:Cobol85Parser.WriteStatementContext): + pass + + # Exit a parse tree produced by Cobol85Parser#writeStatement. + def exitWriteStatement(self, ctx:Cobol85Parser.WriteStatementContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#writeFromPhrase. + def enterWriteFromPhrase(self, ctx:Cobol85Parser.WriteFromPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#writeFromPhrase. + def exitWriteFromPhrase(self, ctx:Cobol85Parser.WriteFromPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#writeAdvancingPhrase. + def enterWriteAdvancingPhrase(self, ctx:Cobol85Parser.WriteAdvancingPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#writeAdvancingPhrase. + def exitWriteAdvancingPhrase(self, ctx:Cobol85Parser.WriteAdvancingPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#writeAdvancingPage. + def enterWriteAdvancingPage(self, ctx:Cobol85Parser.WriteAdvancingPageContext): + pass + + # Exit a parse tree produced by Cobol85Parser#writeAdvancingPage. + def exitWriteAdvancingPage(self, ctx:Cobol85Parser.WriteAdvancingPageContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#writeAdvancingLines. + def enterWriteAdvancingLines(self, ctx:Cobol85Parser.WriteAdvancingLinesContext): + pass + + # Exit a parse tree produced by Cobol85Parser#writeAdvancingLines. + def exitWriteAdvancingLines(self, ctx:Cobol85Parser.WriteAdvancingLinesContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#writeAdvancingMnemonic. + def enterWriteAdvancingMnemonic(self, ctx:Cobol85Parser.WriteAdvancingMnemonicContext): + pass + + # Exit a parse tree produced by Cobol85Parser#writeAdvancingMnemonic. + def exitWriteAdvancingMnemonic(self, ctx:Cobol85Parser.WriteAdvancingMnemonicContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#writeAtEndOfPagePhrase. + def enterWriteAtEndOfPagePhrase(self, ctx:Cobol85Parser.WriteAtEndOfPagePhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#writeAtEndOfPagePhrase. + def exitWriteAtEndOfPagePhrase(self, ctx:Cobol85Parser.WriteAtEndOfPagePhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#writeNotAtEndOfPagePhrase. + def enterWriteNotAtEndOfPagePhrase(self, ctx:Cobol85Parser.WriteNotAtEndOfPagePhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#writeNotAtEndOfPagePhrase. + def exitWriteNotAtEndOfPagePhrase(self, ctx:Cobol85Parser.WriteNotAtEndOfPagePhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#atEndPhrase. + def enterAtEndPhrase(self, ctx:Cobol85Parser.AtEndPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#atEndPhrase. + def exitAtEndPhrase(self, ctx:Cobol85Parser.AtEndPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#notAtEndPhrase. + def enterNotAtEndPhrase(self, ctx:Cobol85Parser.NotAtEndPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#notAtEndPhrase. + def exitNotAtEndPhrase(self, ctx:Cobol85Parser.NotAtEndPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#invalidKeyPhrase. + def enterInvalidKeyPhrase(self, ctx:Cobol85Parser.InvalidKeyPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#invalidKeyPhrase. + def exitInvalidKeyPhrase(self, ctx:Cobol85Parser.InvalidKeyPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#notInvalidKeyPhrase. + def enterNotInvalidKeyPhrase(self, ctx:Cobol85Parser.NotInvalidKeyPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#notInvalidKeyPhrase. + def exitNotInvalidKeyPhrase(self, ctx:Cobol85Parser.NotInvalidKeyPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#onOverflowPhrase. + def enterOnOverflowPhrase(self, ctx:Cobol85Parser.OnOverflowPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#onOverflowPhrase. + def exitOnOverflowPhrase(self, ctx:Cobol85Parser.OnOverflowPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#notOnOverflowPhrase. + def enterNotOnOverflowPhrase(self, ctx:Cobol85Parser.NotOnOverflowPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#notOnOverflowPhrase. + def exitNotOnOverflowPhrase(self, ctx:Cobol85Parser.NotOnOverflowPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#onSizeErrorPhrase. + def enterOnSizeErrorPhrase(self, ctx:Cobol85Parser.OnSizeErrorPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#onSizeErrorPhrase. + def exitOnSizeErrorPhrase(self, ctx:Cobol85Parser.OnSizeErrorPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#notOnSizeErrorPhrase. + def enterNotOnSizeErrorPhrase(self, ctx:Cobol85Parser.NotOnSizeErrorPhraseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#notOnSizeErrorPhrase. + def exitNotOnSizeErrorPhrase(self, ctx:Cobol85Parser.NotOnSizeErrorPhraseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#onExceptionClause. + def enterOnExceptionClause(self, ctx:Cobol85Parser.OnExceptionClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#onExceptionClause. + def exitOnExceptionClause(self, ctx:Cobol85Parser.OnExceptionClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#notOnExceptionClause. + def enterNotOnExceptionClause(self, ctx:Cobol85Parser.NotOnExceptionClauseContext): + pass + + # Exit a parse tree produced by Cobol85Parser#notOnExceptionClause. + def exitNotOnExceptionClause(self, ctx:Cobol85Parser.NotOnExceptionClauseContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#arithmeticExpression. + def enterArithmeticExpression(self, ctx:Cobol85Parser.ArithmeticExpressionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#arithmeticExpression. + def exitArithmeticExpression(self, ctx:Cobol85Parser.ArithmeticExpressionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#plusMinus. + def enterPlusMinus(self, ctx:Cobol85Parser.PlusMinusContext): + pass + + # Exit a parse tree produced by Cobol85Parser#plusMinus. + def exitPlusMinus(self, ctx:Cobol85Parser.PlusMinusContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#multDivs. + def enterMultDivs(self, ctx:Cobol85Parser.MultDivsContext): + pass + + # Exit a parse tree produced by Cobol85Parser#multDivs. + def exitMultDivs(self, ctx:Cobol85Parser.MultDivsContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#multDiv. + def enterMultDiv(self, ctx:Cobol85Parser.MultDivContext): + pass + + # Exit a parse tree produced by Cobol85Parser#multDiv. + def exitMultDiv(self, ctx:Cobol85Parser.MultDivContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#powers. + def enterPowers(self, ctx:Cobol85Parser.PowersContext): + pass + + # Exit a parse tree produced by Cobol85Parser#powers. + def exitPowers(self, ctx:Cobol85Parser.PowersContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#power. + def enterPower(self, ctx:Cobol85Parser.PowerContext): + pass + + # Exit a parse tree produced by Cobol85Parser#power. + def exitPower(self, ctx:Cobol85Parser.PowerContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#basis. + def enterBasis(self, ctx:Cobol85Parser.BasisContext): + pass + + # Exit a parse tree produced by Cobol85Parser#basis. + def exitBasis(self, ctx:Cobol85Parser.BasisContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#condition. + def enterCondition(self, ctx:Cobol85Parser.ConditionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#condition. + def exitCondition(self, ctx:Cobol85Parser.ConditionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#andOrCondition. + def enterAndOrCondition(self, ctx:Cobol85Parser.AndOrConditionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#andOrCondition. + def exitAndOrCondition(self, ctx:Cobol85Parser.AndOrConditionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#combinableCondition. + def enterCombinableCondition(self, ctx:Cobol85Parser.CombinableConditionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#combinableCondition. + def exitCombinableCondition(self, ctx:Cobol85Parser.CombinableConditionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#simpleCondition. + def enterSimpleCondition(self, ctx:Cobol85Parser.SimpleConditionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#simpleCondition. + def exitSimpleCondition(self, ctx:Cobol85Parser.SimpleConditionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#classCondition. + def enterClassCondition(self, ctx:Cobol85Parser.ClassConditionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#classCondition. + def exitClassCondition(self, ctx:Cobol85Parser.ClassConditionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#conditionNameReference. + def enterConditionNameReference(self, ctx:Cobol85Parser.ConditionNameReferenceContext): + pass + + # Exit a parse tree produced by Cobol85Parser#conditionNameReference. + def exitConditionNameReference(self, ctx:Cobol85Parser.ConditionNameReferenceContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#conditionNameSubscriptReference. + def enterConditionNameSubscriptReference(self, ctx:Cobol85Parser.ConditionNameSubscriptReferenceContext): + pass + + # Exit a parse tree produced by Cobol85Parser#conditionNameSubscriptReference. + def exitConditionNameSubscriptReference(self, ctx:Cobol85Parser.ConditionNameSubscriptReferenceContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#relationCondition. + def enterRelationCondition(self, ctx:Cobol85Parser.RelationConditionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#relationCondition. + def exitRelationCondition(self, ctx:Cobol85Parser.RelationConditionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#relationSignCondition. + def enterRelationSignCondition(self, ctx:Cobol85Parser.RelationSignConditionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#relationSignCondition. + def exitRelationSignCondition(self, ctx:Cobol85Parser.RelationSignConditionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#relationArithmeticComparison. + def enterRelationArithmeticComparison(self, ctx:Cobol85Parser.RelationArithmeticComparisonContext): + pass + + # Exit a parse tree produced by Cobol85Parser#relationArithmeticComparison. + def exitRelationArithmeticComparison(self, ctx:Cobol85Parser.RelationArithmeticComparisonContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#relationCombinedComparison. + def enterRelationCombinedComparison(self, ctx:Cobol85Parser.RelationCombinedComparisonContext): + pass + + # Exit a parse tree produced by Cobol85Parser#relationCombinedComparison. + def exitRelationCombinedComparison(self, ctx:Cobol85Parser.RelationCombinedComparisonContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#relationCombinedCondition. + def enterRelationCombinedCondition(self, ctx:Cobol85Parser.RelationCombinedConditionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#relationCombinedCondition. + def exitRelationCombinedCondition(self, ctx:Cobol85Parser.RelationCombinedConditionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#relationalOperator. + def enterRelationalOperator(self, ctx:Cobol85Parser.RelationalOperatorContext): + pass + + # Exit a parse tree produced by Cobol85Parser#relationalOperator. + def exitRelationalOperator(self, ctx:Cobol85Parser.RelationalOperatorContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#abbreviation. + def enterAbbreviation(self, ctx:Cobol85Parser.AbbreviationContext): + pass + + # Exit a parse tree produced by Cobol85Parser#abbreviation. + def exitAbbreviation(self, ctx:Cobol85Parser.AbbreviationContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#identifier. + def enterIdentifier(self, ctx:Cobol85Parser.IdentifierContext): + pass + + # Exit a parse tree produced by Cobol85Parser#identifier. + def exitIdentifier(self, ctx:Cobol85Parser.IdentifierContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#tableCall. + def enterTableCall(self, ctx:Cobol85Parser.TableCallContext): + pass + + # Exit a parse tree produced by Cobol85Parser#tableCall. + def exitTableCall(self, ctx:Cobol85Parser.TableCallContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#functionCall. + def enterFunctionCall(self, ctx:Cobol85Parser.FunctionCallContext): + pass + + # Exit a parse tree produced by Cobol85Parser#functionCall. + def exitFunctionCall(self, ctx:Cobol85Parser.FunctionCallContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#referenceModifier. + def enterReferenceModifier(self, ctx:Cobol85Parser.ReferenceModifierContext): + pass + + # Exit a parse tree produced by Cobol85Parser#referenceModifier. + def exitReferenceModifier(self, ctx:Cobol85Parser.ReferenceModifierContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#characterPosition. + def enterCharacterPosition(self, ctx:Cobol85Parser.CharacterPositionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#characterPosition. + def exitCharacterPosition(self, ctx:Cobol85Parser.CharacterPositionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#length. + def enterLength(self, ctx:Cobol85Parser.LengthContext): + pass + + # Exit a parse tree produced by Cobol85Parser#length. + def exitLength(self, ctx:Cobol85Parser.LengthContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#subscript_. + def enterSubscript_(self, ctx:Cobol85Parser.Subscript_Context): + pass + + # Exit a parse tree produced by Cobol85Parser#subscript_. + def exitSubscript_(self, ctx:Cobol85Parser.Subscript_Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#argument. + def enterArgument(self, ctx:Cobol85Parser.ArgumentContext): + pass + + # Exit a parse tree produced by Cobol85Parser#argument. + def exitArgument(self, ctx:Cobol85Parser.ArgumentContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#qualifiedDataName. + def enterQualifiedDataName(self, ctx:Cobol85Parser.QualifiedDataNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#qualifiedDataName. + def exitQualifiedDataName(self, ctx:Cobol85Parser.QualifiedDataNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#qualifiedDataNameFormat1. + def enterQualifiedDataNameFormat1(self, ctx:Cobol85Parser.QualifiedDataNameFormat1Context): + pass + + # Exit a parse tree produced by Cobol85Parser#qualifiedDataNameFormat1. + def exitQualifiedDataNameFormat1(self, ctx:Cobol85Parser.QualifiedDataNameFormat1Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#qualifiedDataNameFormat2. + def enterQualifiedDataNameFormat2(self, ctx:Cobol85Parser.QualifiedDataNameFormat2Context): + pass + + # Exit a parse tree produced by Cobol85Parser#qualifiedDataNameFormat2. + def exitQualifiedDataNameFormat2(self, ctx:Cobol85Parser.QualifiedDataNameFormat2Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#qualifiedDataNameFormat3. + def enterQualifiedDataNameFormat3(self, ctx:Cobol85Parser.QualifiedDataNameFormat3Context): + pass + + # Exit a parse tree produced by Cobol85Parser#qualifiedDataNameFormat3. + def exitQualifiedDataNameFormat3(self, ctx:Cobol85Parser.QualifiedDataNameFormat3Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#qualifiedDataNameFormat4. + def enterQualifiedDataNameFormat4(self, ctx:Cobol85Parser.QualifiedDataNameFormat4Context): + pass + + # Exit a parse tree produced by Cobol85Parser#qualifiedDataNameFormat4. + def exitQualifiedDataNameFormat4(self, ctx:Cobol85Parser.QualifiedDataNameFormat4Context): + pass + + + # Enter a parse tree produced by Cobol85Parser#qualifiedInData. + def enterQualifiedInData(self, ctx:Cobol85Parser.QualifiedInDataContext): + pass + + # Exit a parse tree produced by Cobol85Parser#qualifiedInData. + def exitQualifiedInData(self, ctx:Cobol85Parser.QualifiedInDataContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inData. + def enterInData(self, ctx:Cobol85Parser.InDataContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inData. + def exitInData(self, ctx:Cobol85Parser.InDataContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inFile. + def enterInFile(self, ctx:Cobol85Parser.InFileContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inFile. + def exitInFile(self, ctx:Cobol85Parser.InFileContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inMnemonic. + def enterInMnemonic(self, ctx:Cobol85Parser.InMnemonicContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inMnemonic. + def exitInMnemonic(self, ctx:Cobol85Parser.InMnemonicContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inSection. + def enterInSection(self, ctx:Cobol85Parser.InSectionContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inSection. + def exitInSection(self, ctx:Cobol85Parser.InSectionContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inLibrary. + def enterInLibrary(self, ctx:Cobol85Parser.InLibraryContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inLibrary. + def exitInLibrary(self, ctx:Cobol85Parser.InLibraryContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#inTable. + def enterInTable(self, ctx:Cobol85Parser.InTableContext): + pass + + # Exit a parse tree produced by Cobol85Parser#inTable. + def exitInTable(self, ctx:Cobol85Parser.InTableContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#alphabetName. + def enterAlphabetName(self, ctx:Cobol85Parser.AlphabetNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#alphabetName. + def exitAlphabetName(self, ctx:Cobol85Parser.AlphabetNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#assignmentName. + def enterAssignmentName(self, ctx:Cobol85Parser.AssignmentNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#assignmentName. + def exitAssignmentName(self, ctx:Cobol85Parser.AssignmentNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#basisName. + def enterBasisName(self, ctx:Cobol85Parser.BasisNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#basisName. + def exitBasisName(self, ctx:Cobol85Parser.BasisNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#cdName. + def enterCdName(self, ctx:Cobol85Parser.CdNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#cdName. + def exitCdName(self, ctx:Cobol85Parser.CdNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#className. + def enterClassName(self, ctx:Cobol85Parser.ClassNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#className. + def exitClassName(self, ctx:Cobol85Parser.ClassNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#computerName. + def enterComputerName(self, ctx:Cobol85Parser.ComputerNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#computerName. + def exitComputerName(self, ctx:Cobol85Parser.ComputerNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#conditionName. + def enterConditionName(self, ctx:Cobol85Parser.ConditionNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#conditionName. + def exitConditionName(self, ctx:Cobol85Parser.ConditionNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataName. + def enterDataName(self, ctx:Cobol85Parser.DataNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataName. + def exitDataName(self, ctx:Cobol85Parser.DataNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#dataDescName. + def enterDataDescName(self, ctx:Cobol85Parser.DataDescNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#dataDescName. + def exitDataDescName(self, ctx:Cobol85Parser.DataDescNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#environmentName. + def enterEnvironmentName(self, ctx:Cobol85Parser.EnvironmentNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#environmentName. + def exitEnvironmentName(self, ctx:Cobol85Parser.EnvironmentNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#fileName. + def enterFileName(self, ctx:Cobol85Parser.FileNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#fileName. + def exitFileName(self, ctx:Cobol85Parser.FileNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#functionName. + def enterFunctionName(self, ctx:Cobol85Parser.FunctionNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#functionName. + def exitFunctionName(self, ctx:Cobol85Parser.FunctionNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#indexName. + def enterIndexName(self, ctx:Cobol85Parser.IndexNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#indexName. + def exitIndexName(self, ctx:Cobol85Parser.IndexNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#languageName. + def enterLanguageName(self, ctx:Cobol85Parser.LanguageNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#languageName. + def exitLanguageName(self, ctx:Cobol85Parser.LanguageNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#libraryName. + def enterLibraryName(self, ctx:Cobol85Parser.LibraryNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#libraryName. + def exitLibraryName(self, ctx:Cobol85Parser.LibraryNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#localName. + def enterLocalName(self, ctx:Cobol85Parser.LocalNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#localName. + def exitLocalName(self, ctx:Cobol85Parser.LocalNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#mnemonicName. + def enterMnemonicName(self, ctx:Cobol85Parser.MnemonicNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#mnemonicName. + def exitMnemonicName(self, ctx:Cobol85Parser.MnemonicNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#paragraphName. + def enterParagraphName(self, ctx:Cobol85Parser.ParagraphNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#paragraphName. + def exitParagraphName(self, ctx:Cobol85Parser.ParagraphNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#procedureName. + def enterProcedureName(self, ctx:Cobol85Parser.ProcedureNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#procedureName. + def exitProcedureName(self, ctx:Cobol85Parser.ProcedureNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#programName. + def enterProgramName(self, ctx:Cobol85Parser.ProgramNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#programName. + def exitProgramName(self, ctx:Cobol85Parser.ProgramNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#recordName. + def enterRecordName(self, ctx:Cobol85Parser.RecordNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#recordName. + def exitRecordName(self, ctx:Cobol85Parser.RecordNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#reportName. + def enterReportName(self, ctx:Cobol85Parser.ReportNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#reportName. + def exitReportName(self, ctx:Cobol85Parser.ReportNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#routineName. + def enterRoutineName(self, ctx:Cobol85Parser.RoutineNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#routineName. + def exitRoutineName(self, ctx:Cobol85Parser.RoutineNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#screenName. + def enterScreenName(self, ctx:Cobol85Parser.ScreenNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#screenName. + def exitScreenName(self, ctx:Cobol85Parser.ScreenNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#sectionName. + def enterSectionName(self, ctx:Cobol85Parser.SectionNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#sectionName. + def exitSectionName(self, ctx:Cobol85Parser.SectionNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#systemName. + def enterSystemName(self, ctx:Cobol85Parser.SystemNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#systemName. + def exitSystemName(self, ctx:Cobol85Parser.SystemNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#symbolicCharacter. + def enterSymbolicCharacter(self, ctx:Cobol85Parser.SymbolicCharacterContext): + pass + + # Exit a parse tree produced by Cobol85Parser#symbolicCharacter. + def exitSymbolicCharacter(self, ctx:Cobol85Parser.SymbolicCharacterContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#textName. + def enterTextName(self, ctx:Cobol85Parser.TextNameContext): + pass + + # Exit a parse tree produced by Cobol85Parser#textName. + def exitTextName(self, ctx:Cobol85Parser.TextNameContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#cobolWord. + def enterCobolWord(self, ctx:Cobol85Parser.CobolWordContext): + pass + + # Exit a parse tree produced by Cobol85Parser#cobolWord. + def exitCobolWord(self, ctx:Cobol85Parser.CobolWordContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#literal. + def enterLiteral(self, ctx:Cobol85Parser.LiteralContext): + pass + + # Exit a parse tree produced by Cobol85Parser#literal. + def exitLiteral(self, ctx:Cobol85Parser.LiteralContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#booleanLiteral. + def enterBooleanLiteral(self, ctx:Cobol85Parser.BooleanLiteralContext): + pass + + # Exit a parse tree produced by Cobol85Parser#booleanLiteral. + def exitBooleanLiteral(self, ctx:Cobol85Parser.BooleanLiteralContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#numericLiteral. + def enterNumericLiteral(self, ctx:Cobol85Parser.NumericLiteralContext): + pass + + # Exit a parse tree produced by Cobol85Parser#numericLiteral. + def exitNumericLiteral(self, ctx:Cobol85Parser.NumericLiteralContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#integerLiteral. + def enterIntegerLiteral(self, ctx:Cobol85Parser.IntegerLiteralContext): + pass + + # Exit a parse tree produced by Cobol85Parser#integerLiteral. + def exitIntegerLiteral(self, ctx:Cobol85Parser.IntegerLiteralContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#cicsDfhRespLiteral. + def enterCicsDfhRespLiteral(self, ctx:Cobol85Parser.CicsDfhRespLiteralContext): + pass + + # Exit a parse tree produced by Cobol85Parser#cicsDfhRespLiteral. + def exitCicsDfhRespLiteral(self, ctx:Cobol85Parser.CicsDfhRespLiteralContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#cicsDfhValueLiteral. + def enterCicsDfhValueLiteral(self, ctx:Cobol85Parser.CicsDfhValueLiteralContext): + pass + + # Exit a parse tree produced by Cobol85Parser#cicsDfhValueLiteral. + def exitCicsDfhValueLiteral(self, ctx:Cobol85Parser.CicsDfhValueLiteralContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#figurativeConstant. + def enterFigurativeConstant(self, ctx:Cobol85Parser.FigurativeConstantContext): + pass + + # Exit a parse tree produced by Cobol85Parser#figurativeConstant. + def exitFigurativeConstant(self, ctx:Cobol85Parser.FigurativeConstantContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#specialRegister. + def enterSpecialRegister(self, ctx:Cobol85Parser.SpecialRegisterContext): + pass + + # Exit a parse tree produced by Cobol85Parser#specialRegister. + def exitSpecialRegister(self, ctx:Cobol85Parser.SpecialRegisterContext): + pass + + + # Enter a parse tree produced by Cobol85Parser#commentEntry. + def enterCommentEntry(self, ctx:Cobol85Parser.CommentEntryContext): + pass + + # Exit a parse tree produced by Cobol85Parser#commentEntry. + def exitCommentEntry(self, ctx:Cobol85Parser.CommentEntryContext): + pass + + + +del Cobol85Parser \ No newline at end of file diff --git a/src/Cobol85Parser.py b/src/Cobol85Parser.py new file mode 100644 index 0000000..9750228 --- /dev/null +++ b/src/Cobol85Parser.py @@ -0,0 +1,50437 @@ +# Generated from Cobol85.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,565,6288,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6, + 7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7, + 13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2, + 20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7, + 26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2, + 33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7, + 39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2, + 46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7, + 52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2, + 59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7, + 65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2, + 72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7, + 78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2, + 85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7, + 91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2, + 98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103, + 2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109, + 7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114, + 2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120, + 7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125,7,125, + 2,126,7,126,2,127,7,127,2,128,7,128,2,129,7,129,2,130,7,130,2,131, + 7,131,2,132,7,132,2,133,7,133,2,134,7,134,2,135,7,135,2,136,7,136, + 2,137,7,137,2,138,7,138,2,139,7,139,2,140,7,140,2,141,7,141,2,142, + 7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,7,146,2,147,7,147, + 2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,7,152,2,153, + 7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158,7,158, + 2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164, + 7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169, + 2,170,7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175, + 7,175,2,176,7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180,7,180, + 2,181,7,181,2,182,7,182,2,183,7,183,2,184,7,184,2,185,7,185,2,186, + 7,186,2,187,7,187,2,188,7,188,2,189,7,189,2,190,7,190,2,191,7,191, + 2,192,7,192,2,193,7,193,2,194,7,194,2,195,7,195,2,196,7,196,2,197, + 7,197,2,198,7,198,2,199,7,199,2,200,7,200,2,201,7,201,2,202,7,202, + 2,203,7,203,2,204,7,204,2,205,7,205,2,206,7,206,2,207,7,207,2,208, + 7,208,2,209,7,209,2,210,7,210,2,211,7,211,2,212,7,212,2,213,7,213, + 2,214,7,214,2,215,7,215,2,216,7,216,2,217,7,217,2,218,7,218,2,219, + 7,219,2,220,7,220,2,221,7,221,2,222,7,222,2,223,7,223,2,224,7,224, + 2,225,7,225,2,226,7,226,2,227,7,227,2,228,7,228,2,229,7,229,2,230, + 7,230,2,231,7,231,2,232,7,232,2,233,7,233,2,234,7,234,2,235,7,235, + 2,236,7,236,2,237,7,237,2,238,7,238,2,239,7,239,2,240,7,240,2,241, + 7,241,2,242,7,242,2,243,7,243,2,244,7,244,2,245,7,245,2,246,7,246, + 2,247,7,247,2,248,7,248,2,249,7,249,2,250,7,250,2,251,7,251,2,252, + 7,252,2,253,7,253,2,254,7,254,2,255,7,255,2,256,7,256,2,257,7,257, + 2,258,7,258,2,259,7,259,2,260,7,260,2,261,7,261,2,262,7,262,2,263, + 7,263,2,264,7,264,2,265,7,265,2,266,7,266,2,267,7,267,2,268,7,268, + 2,269,7,269,2,270,7,270,2,271,7,271,2,272,7,272,2,273,7,273,2,274, + 7,274,2,275,7,275,2,276,7,276,2,277,7,277,2,278,7,278,2,279,7,279, + 2,280,7,280,2,281,7,281,2,282,7,282,2,283,7,283,2,284,7,284,2,285, + 7,285,2,286,7,286,2,287,7,287,2,288,7,288,2,289,7,289,2,290,7,290, + 2,291,7,291,2,292,7,292,2,293,7,293,2,294,7,294,2,295,7,295,2,296, + 7,296,2,297,7,297,2,298,7,298,2,299,7,299,2,300,7,300,2,301,7,301, + 2,302,7,302,2,303,7,303,2,304,7,304,2,305,7,305,2,306,7,306,2,307, + 7,307,2,308,7,308,2,309,7,309,2,310,7,310,2,311,7,311,2,312,7,312, + 2,313,7,313,2,314,7,314,2,315,7,315,2,316,7,316,2,317,7,317,2,318, + 7,318,2,319,7,319,2,320,7,320,2,321,7,321,2,322,7,322,2,323,7,323, + 2,324,7,324,2,325,7,325,2,326,7,326,2,327,7,327,2,328,7,328,2,329, + 7,329,2,330,7,330,2,331,7,331,2,332,7,332,2,333,7,333,2,334,7,334, + 2,335,7,335,2,336,7,336,2,337,7,337,2,338,7,338,2,339,7,339,2,340, + 7,340,2,341,7,341,2,342,7,342,2,343,7,343,2,344,7,344,2,345,7,345, + 2,346,7,346,2,347,7,347,2,348,7,348,2,349,7,349,2,350,7,350,2,351, + 7,351,2,352,7,352,2,353,7,353,2,354,7,354,2,355,7,355,2,356,7,356, + 2,357,7,357,2,358,7,358,2,359,7,359,2,360,7,360,2,361,7,361,2,362, + 7,362,2,363,7,363,2,364,7,364,2,365,7,365,2,366,7,366,2,367,7,367, + 2,368,7,368,2,369,7,369,2,370,7,370,2,371,7,371,2,372,7,372,2,373, + 7,373,2,374,7,374,2,375,7,375,2,376,7,376,2,377,7,377,2,378,7,378, + 2,379,7,379,2,380,7,380,2,381,7,381,2,382,7,382,2,383,7,383,2,384, + 7,384,2,385,7,385,2,386,7,386,2,387,7,387,2,388,7,388,2,389,7,389, + 2,390,7,390,2,391,7,391,2,392,7,392,2,393,7,393,2,394,7,394,2,395, + 7,395,2,396,7,396,2,397,7,397,2,398,7,398,2,399,7,399,2,400,7,400, + 2,401,7,401,2,402,7,402,2,403,7,403,2,404,7,404,2,405,7,405,2,406, + 7,406,2,407,7,407,2,408,7,408,2,409,7,409,2,410,7,410,2,411,7,411, + 2,412,7,412,2,413,7,413,2,414,7,414,2,415,7,415,2,416,7,416,2,417, + 7,417,2,418,7,418,2,419,7,419,2,420,7,420,2,421,7,421,2,422,7,422, + 2,423,7,423,2,424,7,424,2,425,7,425,2,426,7,426,2,427,7,427,2,428, + 7,428,2,429,7,429,2,430,7,430,2,431,7,431,2,432,7,432,2,433,7,433, + 2,434,7,434,2,435,7,435,2,436,7,436,2,437,7,437,2,438,7,438,2,439, + 7,439,2,440,7,440,2,441,7,441,2,442,7,442,2,443,7,443,2,444,7,444, + 2,445,7,445,2,446,7,446,2,447,7,447,2,448,7,448,2,449,7,449,2,450, + 7,450,2,451,7,451,2,452,7,452,2,453,7,453,2,454,7,454,2,455,7,455, + 2,456,7,456,2,457,7,457,2,458,7,458,2,459,7,459,2,460,7,460,2,461, + 7,461,2,462,7,462,2,463,7,463,2,464,7,464,2,465,7,465,2,466,7,466, + 2,467,7,467,2,468,7,468,2,469,7,469,2,470,7,470,2,471,7,471,2,472, + 7,472,2,473,7,473,2,474,7,474,2,475,7,475,2,476,7,476,2,477,7,477, + 2,478,7,478,2,479,7,479,2,480,7,480,2,481,7,481,2,482,7,482,2,483, + 7,483,2,484,7,484,2,485,7,485,2,486,7,486,2,487,7,487,2,488,7,488, + 2,489,7,489,2,490,7,490,2,491,7,491,2,492,7,492,2,493,7,493,2,494, + 7,494,2,495,7,495,2,496,7,496,2,497,7,497,2,498,7,498,2,499,7,499, + 2,500,7,500,2,501,7,501,2,502,7,502,2,503,7,503,2,504,7,504,2,505, + 7,505,2,506,7,506,2,507,7,507,2,508,7,508,2,509,7,509,2,510,7,510, + 2,511,7,511,2,512,7,512,2,513,7,513,2,514,7,514,2,515,7,515,2,516, + 7,516,2,517,7,517,2,518,7,518,2,519,7,519,2,520,7,520,2,521,7,521, + 2,522,7,522,2,523,7,523,2,524,7,524,2,525,7,525,2,526,7,526,2,527, + 7,527,2,528,7,528,2,529,7,529,2,530,7,530,2,531,7,531,2,532,7,532, + 2,533,7,533,2,534,7,534,2,535,7,535,2,536,7,536,2,537,7,537,2,538, + 7,538,2,539,7,539,2,540,7,540,2,541,7,541,2,542,7,542,2,543,7,543, + 2,544,7,544,2,545,7,545,2,546,7,546,2,547,7,547,2,548,7,548,2,549, + 7,549,2,550,7,550,2,551,7,551,2,552,7,552,2,553,7,553,2,554,7,554, + 2,555,7,555,2,556,7,556,2,557,7,557,2,558,7,558,2,559,7,559,2,560, + 7,560,2,561,7,561,2,562,7,562,2,563,7,563,2,564,7,564,2,565,7,565, + 2,566,7,566,2,567,7,567,2,568,7,568,2,569,7,569,2,570,7,570,2,571, + 7,571,2,572,7,572,2,573,7,573,2,574,7,574,2,575,7,575,2,576,7,576, + 2,577,7,577,2,578,7,578,2,579,7,579,2,580,7,580,2,581,7,581,2,582, + 7,582,2,583,7,583,2,584,7,584,2,585,7,585,2,586,7,586,2,587,7,587, + 2,588,7,588,2,589,7,589,2,590,7,590,2,591,7,591,2,592,7,592,2,593, + 7,593,2,594,7,594,1,0,1,0,1,0,1,1,4,1,1195,8,1,11,1,12,1,1196,1, + 2,1,2,3,2,1201,8,2,1,2,3,2,1204,8,2,1,2,3,2,1207,8,2,1,2,5,2,1210, + 8,2,10,2,12,2,1213,9,2,1,2,3,2,1216,8,2,1,3,1,3,1,3,1,3,1,3,1,4, + 1,4,1,4,1,4,1,4,5,4,1228,8,4,10,4,12,4,1231,9,4,1,5,1,5,1,5,1,5, + 1,5,1,5,3,5,1239,8,5,1,6,1,6,1,6,1,6,3,6,1245,8,6,1,6,1,6,3,6,1249, + 8,6,3,6,1251,8,6,1,6,3,6,1254,8,6,1,6,3,6,1257,8,6,1,7,1,7,1,7,3, + 7,1262,8,7,1,8,1,8,1,8,3,8,1267,8,8,1,9,1,9,1,9,3,9,1272,8,9,1,10, + 1,10,1,10,3,10,1277,8,10,1,11,1,11,1,11,3,11,1282,8,11,1,12,1,12, + 1,12,3,12,1287,8,12,1,13,1,13,1,13,1,13,5,13,1293,8,13,10,13,12, + 13,1296,9,13,1,14,1,14,1,14,3,14,1301,8,14,1,15,1,15,1,15,1,15,5, + 15,1307,8,15,10,15,12,15,1310,9,15,1,16,1,16,1,16,3,16,1315,8,16, + 1,17,1,17,1,17,1,17,3,17,1321,8,17,1,17,1,17,3,17,1325,8,17,1,17, + 1,17,1,18,1,18,1,18,1,18,5,18,1333,8,18,10,18,12,18,1336,9,18,1, + 18,1,18,1,19,1,19,1,19,1,19,1,19,3,19,1345,8,19,1,20,1,20,3,20,1349, + 8,20,1,20,1,20,3,20,1353,8,20,1,20,3,20,1356,8,20,1,21,1,21,3,21, + 1360,8,21,1,21,3,21,1363,8,21,1,21,1,21,3,21,1367,8,21,1,21,3,21, + 1370,8,21,1,22,3,22,1373,8,22,1,22,3,22,1376,8,22,1,22,1,22,3,22, + 1380,8,22,1,22,4,22,1383,8,22,11,22,12,22,1384,1,22,3,22,1388,8, + 22,1,22,3,22,1391,8,22,1,23,3,23,1394,8,23,1,23,1,23,3,23,1398,8, + 23,1,23,1,23,1,24,3,24,1403,8,24,1,24,1,24,3,24,1407,8,24,1,24,1, + 24,1,25,1,25,3,25,1413,8,25,1,25,1,25,1,26,1,26,1,26,1,26,1,27,1, + 27,1,27,4,27,1424,8,27,11,27,12,27,1425,1,27,1,27,3,27,1430,8,27, + 1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,28,3,28,1443, + 8,28,1,29,1,29,3,29,1447,8,29,1,30,1,30,1,30,1,30,3,30,1453,8,30, + 1,30,3,30,1456,8,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,4,30,1465, + 8,30,11,30,12,30,1466,3,30,1469,8,30,1,31,1,31,1,31,4,31,1474,8, + 31,11,31,12,31,1475,3,31,1478,8,31,1,32,1,32,1,32,1,33,1,33,4,33, + 1485,8,33,11,33,12,33,1486,1,34,1,34,1,34,3,34,1492,8,34,1,34,1, + 34,3,34,1496,8,34,1,34,1,34,1,34,3,34,1501,8,34,1,35,1,35,1,35,3, + 35,1506,8,35,1,35,1,35,1,36,1,36,1,36,3,36,1513,8,36,1,36,3,36,1516, + 8,36,1,36,3,36,1519,8,36,1,36,4,36,1522,8,36,11,36,12,36,1523,1, + 37,1,37,1,37,3,37,1529,8,37,1,38,1,38,3,38,1533,8,38,1,39,1,39,3, + 39,1537,8,39,1,40,1,40,3,40,1541,8,40,1,40,3,40,1544,8,40,1,40,1, + 40,3,40,1548,8,40,1,40,1,40,1,40,3,40,1553,8,40,1,41,1,41,3,41,1557, + 8,41,1,41,1,41,1,42,1,42,3,42,1563,8,42,1,42,1,42,3,42,1567,8,42, + 3,42,1569,8,42,1,42,3,42,1572,8,42,1,42,1,42,3,42,1576,8,42,1,43, + 1,43,1,43,3,43,1581,8,43,3,43,1583,8,43,1,43,1,43,1,43,3,43,1588, + 8,43,3,43,1590,8,43,1,44,1,44,3,44,1594,8,44,1,44,1,44,3,44,1598, + 8,44,1,44,3,44,1601,8,44,1,45,1,45,3,45,1605,8,45,1,45,3,45,1608, + 8,45,1,45,1,45,1,45,3,45,1613,8,45,1,45,3,45,1616,8,45,1,45,3,45, + 1619,8,45,1,45,1,45,3,45,1623,8,45,1,45,3,45,1626,8,45,1,45,1,45, + 1,45,3,45,1631,8,45,1,45,3,45,1634,8,45,1,45,3,45,1637,8,45,3,45, + 1639,8,45,1,46,1,46,3,46,1643,8,46,1,46,1,46,1,47,1,47,3,47,1649, + 8,47,1,47,3,47,1652,8,47,1,47,3,47,1655,8,47,1,47,1,47,3,47,1659, + 8,47,1,48,1,48,3,48,1663,8,48,1,48,3,48,1666,8,48,1,48,3,48,1669, + 8,48,1,48,4,48,1672,8,48,11,48,12,48,1673,1,48,1,48,3,48,1678,8, + 48,1,49,4,49,1681,8,49,11,49,12,49,1682,1,49,3,49,1686,8,49,1,49, + 4,49,1689,8,49,11,49,12,49,1690,1,50,1,50,1,50,1,50,5,50,1697,8, + 50,10,50,12,50,1700,9,50,1,51,1,51,3,51,1704,8,51,1,52,1,52,3,52, + 1708,8,52,1,52,5,52,1711,8,52,10,52,12,52,1714,9,52,1,52,1,52,1, + 53,1,53,5,53,1720,8,53,10,53,12,53,1723,9,53,1,54,1,54,3,54,1727, + 8,54,1,54,1,54,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55, + 1,55,3,55,1742,8,55,1,56,1,56,3,56,1746,8,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,1759,8,56,1,57,1,57,1,57, + 3,57,1764,8,57,1,57,3,57,1767,8,57,1,57,3,57,1770,8,57,1,58,1,58, + 3,58,1774,8,58,3,58,1776,8,58,1,58,1,58,1,58,1,58,1,58,3,58,1783, + 8,58,1,58,1,58,1,59,1,59,3,59,1789,8,59,1,59,3,59,1792,8,59,1,59, + 1,59,3,59,1796,8,59,1,60,1,60,1,60,3,60,1801,8,60,1,60,1,60,1,60, + 3,60,1806,8,60,1,61,1,61,3,61,1810,8,61,1,61,3,61,1813,8,61,1,61, + 1,61,1,62,1,62,3,62,1819,8,62,1,62,3,62,1822,8,62,1,62,1,62,3,62, + 1826,8,62,1,62,3,62,1829,8,62,1,62,3,62,1832,8,62,1,63,1,63,1,63, + 3,63,1837,8,63,1,63,3,63,1840,8,63,1,63,1,63,3,63,1844,8,63,1,63, + 3,63,1847,8,63,1,63,3,63,1850,8,63,1,64,1,64,3,64,1854,8,64,1,64, + 1,64,1,65,3,65,1859,8,65,1,65,1,65,3,65,1863,8,65,1,65,1,65,3,65, + 1867,8,65,1,66,1,66,3,66,1871,8,66,1,66,3,66,1874,8,66,1,66,1,66, + 1,67,1,67,1,67,1,67,1,67,3,67,1883,8,67,1,67,5,67,1886,8,67,10,67, + 12,67,1889,9,67,1,67,3,67,1892,8,67,1,68,1,68,1,68,1,68,3,68,1898, + 8,68,1,69,1,69,1,69,1,69,3,69,1904,8,69,3,69,1906,8,69,1,69,1,69, + 1,69,1,69,3,69,1912,8,69,1,70,1,70,1,70,1,71,3,71,1918,8,71,1,71, + 3,71,1921,8,71,1,71,1,71,1,71,1,71,1,72,1,72,3,72,1929,8,72,1,73, + 1,73,3,73,1933,8,73,1,73,3,73,1936,8,73,1,73,3,73,1939,8,73,1,73, + 4,73,1942,8,73,11,73,12,73,1943,1,74,1,74,1,74,3,74,1949,8,74,1, + 74,3,74,1952,8,74,1,74,4,74,1955,8,74,11,74,12,74,1956,1,75,1,75, + 1,75,3,75,1962,8,75,1,76,1,76,1,76,3,76,1967,8,76,1,76,1,76,1,77, + 1,77,1,77,1,77,5,77,1975,8,77,10,77,12,77,1978,9,77,1,78,1,78,1, + 78,1,78,1,78,1,78,1,78,1,78,1,78,3,78,1989,8,78,1,79,1,79,1,79,1, + 79,5,79,1995,8,79,10,79,12,79,1998,9,79,1,80,1,80,1,80,3,80,2003, + 8,80,1,80,5,80,2006,8,80,10,80,12,80,2009,9,80,1,80,1,80,5,80,2013, + 8,80,10,80,12,80,2016,9,80,1,81,1,81,1,81,1,81,1,81,1,81,1,81,1, + 81,1,81,1,81,1,81,3,81,2029,8,81,1,82,3,82,2032,8,82,1,82,1,82,1, + 83,3,83,2037,8,83,1,83,1,83,1,84,1,84,3,84,2043,8,84,1,84,1,84,3, + 84,2047,8,84,1,84,3,84,2050,8,84,1,85,1,85,1,85,1,86,1,86,1,86,1, + 86,3,86,2059,8,86,1,87,3,87,2062,8,87,1,87,1,87,3,87,2066,8,87,1, + 88,3,88,2069,8,88,1,88,1,88,3,88,2073,8,88,1,88,3,88,2076,8,88,1, + 88,3,88,2079,8,88,1,88,1,88,3,88,2083,8,88,1,88,3,88,2086,8,88,3, + 88,2088,8,88,1,88,1,88,3,88,2092,8,88,1,88,3,88,2095,8,88,1,89,3, + 89,2098,8,89,1,89,1,89,1,89,3,89,2103,8,89,1,90,1,90,1,90,1,91,1, + 91,1,91,3,91,2111,8,91,1,91,1,91,3,91,2115,8,91,3,91,2117,8,91,1, + 91,1,91,1,91,4,91,2122,8,91,11,91,12,91,2123,3,91,2126,8,91,1,92, + 1,92,1,92,4,92,2131,8,92,11,92,12,92,2132,1,93,1,93,3,93,2137,8, + 93,1,93,1,93,3,93,2141,8,93,1,94,1,94,1,94,3,94,2146,8,94,1,94,1, + 94,3,94,2150,8,94,3,94,2152,8,94,1,94,4,94,2155,8,94,11,94,12,94, + 2156,1,95,1,95,3,95,2161,8,95,1,95,1,95,3,95,2165,8,95,1,95,3,95, + 2168,8,95,1,95,5,95,2171,8,95,10,95,12,95,2174,9,95,1,96,1,96,1, + 96,3,96,2179,8,96,1,97,3,97,2182,8,97,1,97,1,97,3,97,2186,8,97,1, + 97,1,97,3,97,2190,8,97,1,98,3,98,2193,8,98,1,98,3,98,2196,8,98,1, + 98,1,98,1,98,3,98,2201,8,98,1,99,3,99,2204,8,99,1,99,3,99,2207,8, + 99,1,99,1,99,1,99,3,99,2212,8,99,1,100,1,100,3,100,2216,8,100,1, + 100,3,100,2219,8,100,1,100,1,100,1,101,1,101,1,102,1,102,3,102,2227, + 8,102,1,102,1,102,1,103,1,103,3,103,2233,8,103,1,103,1,103,3,103, + 2237,8,103,3,103,2239,8,103,1,103,4,103,2242,8,103,11,103,12,103, + 2243,1,104,1,104,1,104,1,104,5,104,2250,8,104,10,104,12,104,2253, + 9,104,1,105,1,105,1,105,1,105,1,105,1,106,1,106,1,106,1,106,5,106, + 2264,8,106,10,106,12,106,2267,9,106,1,107,1,107,1,107,1,107,5,107, + 2273,8,107,10,107,12,107,2276,9,107,1,108,1,108,1,108,1,108,1,108, + 5,108,2283,8,108,10,108,12,108,2286,9,108,1,109,1,109,1,109,3,109, + 2291,8,109,1,110,1,110,1,110,3,110,2296,8,110,1,110,3,110,2299,8, + 110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110, + 3,110,2311,8,110,1,110,5,110,2314,8,110,10,110,12,110,2317,9,110, + 1,110,1,110,1,111,1,111,1,111,3,111,2324,8,111,1,111,1,111,1,111, + 1,111,1,111,1,111,1,111,5,111,2333,8,111,10,111,12,111,2336,9,111, + 1,111,1,111,1,112,1,112,1,112,3,112,2343,8,112,1,112,1,112,1,112, + 1,112,1,112,1,112,1,112,1,112,3,112,2353,8,112,1,112,5,112,2356, + 8,112,10,112,12,112,2359,9,112,1,112,1,112,1,113,1,113,1,113,3,113, + 2366,8,113,1,113,1,113,1,114,1,114,1,114,1,114,1,114,1,114,1,114, + 1,114,4,114,2378,8,114,11,114,12,114,2379,3,114,2382,8,114,1,115, + 1,115,1,115,3,115,2387,8,115,1,115,1,115,1,116,1,116,1,116,3,116, + 2394,8,116,1,116,1,116,1,117,3,117,2399,8,117,1,117,1,117,3,117, + 2403,8,117,1,117,1,117,1,118,1,118,1,118,3,118,2410,8,118,1,118, + 1,118,1,119,1,119,1,119,3,119,2417,8,119,1,119,1,119,1,120,1,120, + 1,120,3,120,2424,8,120,1,120,1,120,1,121,3,121,2429,8,121,1,121, + 1,121,3,121,2433,8,121,1,121,1,121,1,122,3,122,2438,8,122,1,122, + 1,122,3,122,2442,8,122,1,122,1,122,1,123,3,123,2447,8,123,1,123, + 1,123,3,123,2451,8,123,1,123,1,123,1,124,3,124,2456,8,124,1,124, + 1,124,3,124,2460,8,124,1,124,1,124,1,125,3,125,2465,8,125,1,125, + 1,125,3,125,2469,8,125,1,125,1,125,1,126,1,126,1,126,3,126,2476, + 8,126,1,126,1,126,1,127,1,127,1,127,1,127,1,127,1,127,1,127,3,127, + 2487,8,127,1,127,5,127,2490,8,127,10,127,12,127,2493,9,127,1,128, + 1,128,1,128,1,128,5,128,2499,8,128,10,128,12,128,2502,9,128,1,129, + 1,129,1,129,3,129,2507,8,129,1,129,1,129,1,129,1,129,1,129,1,129, + 1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129, + 1,129,3,129,2527,8,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129, + 1,129,1,129,1,129,5,129,2539,8,129,10,129,12,129,2542,9,129,1,129, + 1,129,1,130,1,130,1,130,1,131,1,131,1,132,1,132,1,133,1,133,1,133, + 1,134,1,134,1,135,1,135,1,136,1,136,1,137,1,137,1,138,1,138,3,138, + 2566,8,138,1,138,1,138,3,138,2570,8,138,1,139,1,139,3,139,2574,8, + 139,1,139,3,139,2577,8,139,1,139,3,139,2580,8,139,1,139,1,139,3, + 139,2584,8,139,1,140,1,140,3,140,2588,8,140,1,140,3,140,2591,8,140, + 1,140,3,140,2594,8,140,1,140,1,140,3,140,2598,8,140,1,141,1,141, + 3,141,2602,8,141,1,141,1,141,3,141,2606,8,141,1,142,1,142,3,142, + 2610,8,142,1,142,1,142,3,142,2614,8,142,1,143,1,143,3,143,2618,8, + 143,1,143,1,143,1,144,1,144,3,144,2624,8,144,1,144,1,144,1,145,1, + 145,3,145,2630,8,145,1,145,1,145,1,146,1,146,1,146,3,146,2637,8, + 146,1,146,3,146,2640,8,146,1,147,1,147,1,147,1,148,1,148,1,148,1, + 149,1,149,3,149,2650,8,149,1,149,1,149,1,150,1,150,3,150,2656,8, + 150,1,150,1,150,1,151,1,151,3,151,2662,8,151,1,152,1,152,3,152,2666, + 8,152,3,152,2668,8,152,1,152,1,152,1,152,3,152,2673,8,152,3,152, + 2675,8,152,1,153,1,153,1,154,1,154,1,155,1,155,1,156,1,156,3,156, + 2685,8,156,1,156,3,156,2688,8,156,1,156,1,156,3,156,2692,8,156,1, + 156,3,156,2695,8,156,1,157,1,157,1,157,3,157,2700,8,157,1,158,1, + 158,1,159,1,159,1,160,1,160,1,160,1,160,5,160,2710,8,160,10,160, + 12,160,2713,9,160,1,161,1,161,4,161,2717,8,161,11,161,12,161,2718, + 1,162,1,162,1,162,3,162,2724,8,162,1,162,1,162,3,162,2728,8,162, + 1,162,3,162,2731,8,162,1,162,3,162,2734,8,162,1,162,3,162,2737,8, + 162,3,162,2739,8,162,1,162,1,162,1,163,3,163,2744,8,163,1,163,1, + 163,1,164,1,164,1,164,3,164,2751,8,164,1,164,1,164,3,164,2755,8, + 164,3,164,2757,8,164,1,164,1,164,3,164,2761,8,164,1,165,1,165,1, + 165,1,166,1,166,1,166,1,166,1,167,1,167,1,167,1,167,1,168,1,168, + 1,168,1,169,1,169,1,169,3,169,2780,8,169,1,170,1,170,1,170,3,170, + 2785,8,170,1,170,3,170,2788,8,170,1,170,1,170,3,170,2792,8,170,1, + 170,1,170,1,171,1,171,3,171,2798,8,171,1,171,3,171,2801,8,171,1, + 171,1,171,1,171,1,172,1,172,3,172,2808,8,172,1,172,1,172,1,172,1, + 172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,3,172,2821,8,172,1, + 172,5,172,2824,8,172,10,172,12,172,2827,9,172,1,172,1,172,1,173, + 1,173,3,173,2833,8,173,1,173,1,173,1,174,1,174,3,174,2839,8,174, + 1,174,3,174,2842,8,174,1,174,1,174,1,175,1,175,3,175,2848,8,175, + 1,176,1,176,3,176,2852,8,176,1,177,3,177,2855,8,177,1,177,3,177, + 2858,8,177,1,177,3,177,2861,8,177,1,177,1,177,3,177,2865,8,177,1, + 178,1,178,3,178,2869,8,178,1,178,1,178,3,178,2873,8,178,1,179,1, + 179,1,179,1,180,1,180,1,180,3,180,2881,8,180,1,180,1,180,1,180,3, + 180,2886,8,180,1,181,1,181,1,181,1,182,1,182,1,182,1,183,1,183,3, + 183,2896,8,183,1,183,1,183,1,184,1,184,3,184,2902,8,184,1,184,1, + 184,3,184,2906,8,184,1,185,1,185,3,185,2910,8,185,1,185,1,185,1, + 185,3,185,2915,8,185,1,186,1,186,3,186,2919,8,186,1,186,1,186,1, + 187,1,187,1,187,3,187,2926,8,187,1,187,5,187,2929,8,187,10,187,12, + 187,2932,9,187,1,187,1,187,1,187,3,187,2937,8,187,1,187,5,187,2940, + 8,187,10,187,12,187,2943,9,187,3,187,2945,8,187,1,188,1,188,3,188, + 2949,8,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,3,188,2958, + 8,188,1,189,1,189,1,189,3,189,2963,8,189,1,190,1,190,1,190,3,190, + 2968,8,190,1,191,1,191,1,191,3,191,2973,8,191,1,191,1,191,3,191, + 2977,8,191,1,192,1,192,1,193,1,193,1,193,3,193,2984,8,193,1,193, + 1,193,3,193,2988,8,193,1,194,1,194,3,194,2992,8,194,3,194,2994,8, + 194,1,194,1,194,1,195,1,195,1,195,3,195,3001,8,195,1,196,1,196,1, + 196,3,196,3006,8,196,1,197,1,197,3,197,3010,8,197,1,197,1,197,1, + 198,1,198,1,198,1,198,5,198,3018,8,198,10,198,12,198,3021,9,198, + 1,199,1,199,3,199,3025,8,199,1,200,1,200,1,200,1,200,3,200,3031, + 8,200,1,200,3,200,3034,8,200,1,201,1,201,1,201,1,201,3,201,3040, + 8,201,1,201,3,201,3043,8,201,1,201,1,201,5,201,3047,8,201,10,201, + 12,201,3050,9,201,1,202,1,202,1,202,3,202,3055,8,202,1,202,3,202, + 3058,8,202,1,203,1,203,3,203,3062,8,203,1,203,1,203,3,203,3066,8, + 203,1,203,3,203,3069,8,203,1,203,3,203,3072,8,203,1,203,3,203,3075, + 8,203,1,204,1,204,1,204,1,204,1,205,1,205,3,205,3083,8,205,1,205, + 1,205,1,206,1,206,3,206,3089,8,206,1,206,1,206,1,207,1,207,1,207, + 3,207,3096,8,207,1,208,1,208,1,208,3,208,3101,8,208,1,208,3,208, + 3104,8,208,1,208,3,208,3107,8,208,1,208,3,208,3110,8,208,1,209,1, + 209,1,209,1,210,1,210,1,210,1,211,1,211,4,211,3120,8,211,11,211, + 12,211,3121,1,212,1,212,3,212,3126,8,212,1,213,1,213,4,213,3130, + 8,213,11,213,12,213,3131,1,214,1,214,3,214,3136,8,214,1,215,3,215, + 3139,8,215,1,215,1,215,1,216,3,216,3144,8,216,1,216,1,216,1,217, + 1,217,1,217,1,217,3,217,3152,8,217,1,218,1,218,1,218,3,218,3157, + 8,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218, + 1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218,1,218, + 5,218,3180,8,218,10,218,12,218,3183,9,218,1,218,1,218,1,219,1,219, + 1,219,1,219,1,219,1,220,1,220,1,220,1,220,1,220,1,221,4,221,3198, + 8,221,11,221,12,221,3199,1,221,3,221,3203,8,221,1,222,1,222,1,223, + 1,223,3,223,3209,8,223,1,223,1,223,1,224,1,224,1,225,3,225,3216, + 8,225,1,225,1,225,1,225,3,225,3221,8,225,1,226,3,226,3224,8,226, + 1,226,1,226,1,227,1,227,1,228,1,228,3,228,3232,8,228,1,229,1,229, + 1,229,3,229,3237,8,229,1,229,3,229,3240,8,229,1,229,1,229,3,229, + 3244,8,229,1,229,3,229,3247,8,229,1,229,5,229,3250,8,229,10,229, + 12,229,3253,9,229,1,229,1,229,3,229,3257,8,229,1,229,3,229,3260, + 8,229,1,229,4,229,3263,8,229,11,229,12,229,3264,3,229,3267,8,229, + 1,230,1,230,1,230,1,231,1,231,3,231,3274,8,231,1,231,3,231,3277, + 8,231,1,231,4,231,3280,8,231,11,231,12,231,3281,1,232,1,232,3,232, + 3286,8,232,1,232,1,232,1,233,4,233,3291,8,233,11,233,12,233,3292, + 1,233,3,233,3296,8,233,4,233,3298,8,233,11,233,12,233,3299,1,234, + 1,234,1,234,1,234,1,234,1,234,1,234,1,234,1,234,1,234,1,234,1,234, + 1,234,1,234,1,234,1,234,3,234,3318,8,234,1,235,1,235,1,235,1,235, + 1,236,3,236,3325,8,236,1,236,3,236,3328,8,236,1,236,1,236,1,237, + 1,237,1,237,1,238,1,238,1,238,1,239,1,239,1,239,1,239,3,239,3342, + 8,239,1,240,1,240,3,240,3346,8,240,3,240,3348,8,240,1,240,1,240, + 1,240,3,240,3353,8,240,3,240,3355,8,240,1,241,1,241,3,241,3359,8, + 241,1,242,3,242,3362,8,242,1,242,1,242,1,243,1,243,3,243,3368,8, + 243,1,243,1,243,1,244,3,244,3373,8,244,1,244,1,244,1,245,1,245,3, + 245,3379,8,245,3,245,3381,8,245,1,245,1,245,3,245,3385,8,245,1,245, + 1,245,1,245,1,245,1,245,1,245,1,245,1,245,1,245,1,245,1,245,1,245, + 1,245,1,245,1,245,1,245,1,245,1,245,1,245,1,245,1,245,1,245,1,245, + 1,245,1,245,1,245,1,245,1,245,1,245,3,245,3416,8,245,1,246,1,246, + 1,246,3,246,3421,8,246,1,246,1,246,3,246,3425,8,246,1,247,1,247, + 3,247,3429,8,247,1,247,1,247,3,247,3433,8,247,3,247,3435,8,247,1, + 247,1,247,3,247,3439,8,247,1,247,5,247,3442,8,247,10,247,12,247, + 3445,9,247,1,248,1,248,3,248,3449,8,248,1,249,1,249,3,249,3453,8, + 249,1,250,1,250,1,250,1,251,3,251,3459,8,251,1,251,1,251,1,251,1, + 252,1,252,1,252,3,252,3467,8,252,1,252,3,252,3470,8,252,1,252,1, + 252,3,252,3474,8,252,1,252,1,252,1,253,1,253,4,253,3480,8,253,11, + 253,12,253,3481,1,254,1,254,1,254,1,255,1,255,3,255,3489,8,255,1, + 256,3,256,3492,8,256,1,256,3,256,3495,8,256,1,256,4,256,3498,8,256, + 11,256,12,256,3499,1,257,3,257,3503,8,257,1,257,1,257,3,257,3507, + 8,257,1,257,3,257,3510,8,257,1,258,3,258,3513,8,258,1,258,1,258, + 4,258,3517,8,258,11,258,12,258,3518,1,259,1,259,1,259,3,259,3524, + 8,259,1,260,1,260,1,260,4,260,3529,8,260,11,260,12,260,3530,1,260, + 1,260,1,260,1,260,1,261,1,261,1,261,1,261,1,261,1,261,1,262,1,262, + 1,262,3,262,3546,8,262,1,263,1,263,5,263,3550,8,263,10,263,12,263, + 3553,9,263,1,264,1,264,1,264,1,264,1,265,5,265,3560,8,265,10,265, + 12,265,3563,9,265,1,265,5,265,3566,8,265,10,265,12,265,3569,9,265, + 1,266,1,266,1,266,1,266,5,266,3575,8,266,10,266,12,266,3578,9,266, + 3,266,3580,8,266,1,267,5,267,3583,8,267,10,267,12,267,3586,9,267, + 1,267,1,267,1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268, + 1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268, + 1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268, + 1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268,1,268, + 1,268,1,268,1,268,1,268,1,268,1,268,1,268,3,268,3639,8,268,1,269, + 1,269,1,269,1,269,1,269,1,269,3,269,3647,8,269,1,269,3,269,3650, + 8,269,1,269,3,269,3653,8,269,1,269,3,269,3656,8,269,1,270,1,270, + 1,270,3,270,3661,8,270,1,270,1,270,3,270,3665,8,270,1,270,1,270, + 1,270,1,270,1,270,3,270,3672,8,270,1,270,1,270,1,270,1,270,3,270, + 3678,8,270,1,271,1,271,1,271,1,272,1,272,1,272,1,272,1,273,3,273, + 3688,8,273,1,273,1,273,1,274,1,274,1,274,1,274,3,274,3696,8,274, + 1,274,3,274,3699,8,274,1,274,3,274,3702,8,274,1,274,3,274,3705,8, + 274,1,275,4,275,3708,8,275,11,275,12,275,3709,1,275,1,275,4,275, + 3714,8,275,11,275,12,275,3715,1,276,4,276,3719,8,276,11,276,12,276, + 3720,1,276,1,276,4,276,3725,8,276,11,276,12,276,3726,3,276,3729, + 8,276,1,276,1,276,4,276,3733,8,276,11,276,12,276,3734,1,277,1,277, + 1,277,1,277,1,277,1,278,1,278,3,278,3744,8,278,1,279,1,279,3,279, + 3748,8,279,1,280,1,280,3,280,3752,8,280,1,281,1,281,3,281,3756,8, + 281,1,282,1,282,3,282,3760,8,282,1,282,1,282,1,283,1,283,4,283,3766, + 8,283,11,283,12,283,3767,1,284,1,284,1,284,1,284,3,284,3774,8,284, + 1,284,1,284,1,285,1,285,1,285,3,285,3781,8,285,1,285,3,285,3784, + 8,285,1,285,3,285,3787,8,285,1,285,3,285,3790,8,285,1,285,3,285, + 3793,8,285,1,285,3,285,3796,8,285,1,285,3,285,3799,8,285,1,286,1, + 286,4,286,3803,8,286,11,286,12,286,3804,1,287,1,287,1,287,3,287, + 3810,8,287,1,288,3,288,3813,8,288,1,288,3,288,3816,8,288,1,288,4, + 288,3819,8,288,11,288,12,288,3820,1,289,1,289,1,289,1,289,3,289, + 3827,8,289,1,289,1,289,1,289,3,289,3832,8,289,1,289,3,289,3835,8, + 289,1,290,3,290,3838,8,290,1,290,1,290,4,290,3842,8,290,11,290,12, + 290,3843,1,291,1,291,1,291,1,291,3,291,3850,8,291,3,291,3852,8,291, + 1,291,1,291,3,291,3856,8,291,1,292,3,292,3859,8,292,1,292,1,292, + 4,292,3863,8,292,11,292,12,292,3864,1,293,1,293,1,293,1,293,3,293, + 3871,8,293,3,293,3873,8,293,1,293,1,293,1,293,3,293,3878,8,293,1, + 294,1,294,1,294,1,295,1,295,4,295,3885,8,295,11,295,12,295,3886, + 1,296,1,296,1,296,1,296,1,296,3,296,3894,8,296,1,297,1,297,4,297, + 3898,8,297,11,297,12,297,3899,1,298,1,298,1,298,1,298,3,298,3906, + 8,298,1,299,1,299,3,299,3910,8,299,1,299,3,299,3913,8,299,1,299, + 3,299,3916,8,299,1,299,1,299,1,299,3,299,3921,8,299,3,299,3923,8, + 299,1,300,3,300,3926,8,300,1,300,1,300,1,300,3,300,3931,8,300,1, + 301,3,301,3934,8,301,1,301,1,301,1,301,1,301,3,301,3940,8,301,1, + 301,1,301,4,301,3944,8,301,11,301,12,301,3945,3,301,3948,8,301,1, + 302,1,302,1,302,3,302,3953,8,302,1,303,1,303,3,303,3957,8,303,1, + 303,1,303,1,304,1,304,1,304,3,304,3964,8,304,1,305,1,305,3,305,3968, + 8,305,1,305,1,305,3,305,3972,8,305,1,306,1,306,4,306,3976,8,306, + 11,306,12,306,3977,1,306,1,306,1,306,3,306,3983,8,306,1,306,3,306, + 3986,8,306,1,306,3,306,3989,8,306,1,307,1,307,3,307,3993,8,307,1, + 308,1,308,1,309,1,309,1,309,3,309,4000,8,309,1,309,3,309,4003,8, + 309,1,309,3,309,4006,8,309,1,309,3,309,4009,8,309,1,310,1,310,1, + 310,3,310,4014,8,310,1,310,1,310,1,310,3,310,4019,8,310,1,310,1, + 310,3,310,4023,8,310,1,310,1,310,1,310,3,310,4028,8,310,1,311,1, + 311,4,311,4032,8,311,11,311,12,311,4033,1,311,3,311,4037,8,311,1, + 311,3,311,4040,8,311,1,311,3,311,4043,8,311,1,312,1,312,3,312,4047, + 8,312,1,313,1,313,1,313,3,313,4052,8,313,1,314,1,314,1,314,3,314, + 4057,8,314,1,315,3,315,4060,8,315,1,315,1,315,1,315,1,316,1,316, + 1,316,3,316,4068,8,316,1,316,1,316,1,316,3,316,4073,8,316,1,316, + 3,316,4076,8,316,1,316,3,316,4079,8,316,1,316,3,316,4082,8,316,1, + 316,3,316,4085,8,316,1,317,1,317,4,317,4089,8,317,11,317,12,317, + 4090,1,318,1,318,1,318,3,318,4096,8,318,1,318,3,318,4099,8,318,1, + 319,1,319,1,319,3,319,4104,8,319,1,319,3,319,4107,8,319,1,320,1, + 320,4,320,4111,8,320,11,320,12,320,4112,1,321,1,321,3,321,4117,8, + 321,1,322,1,322,3,322,4121,8,322,1,323,1,323,1,323,1,324,1,324,1, + 324,3,324,4129,8,324,1,324,1,324,1,324,3,324,4134,8,324,1,324,1, + 324,3,324,4138,8,324,1,324,1,324,1,324,3,324,4143,8,324,1,325,1, + 325,1,325,1,325,4,325,4149,8,325,11,325,12,325,4150,3,325,4153,8, + 325,1,326,1,326,1,326,5,326,4158,8,326,10,326,12,326,4161,9,326, + 1,326,4,326,4164,8,326,11,326,12,326,4165,1,326,3,326,4169,8,326, + 1,326,3,326,4172,8,326,1,327,1,327,1,327,1,327,3,327,4178,8,327, + 1,328,1,328,1,328,1,329,4,329,4184,8,329,11,329,12,329,4185,1,329, + 5,329,4189,8,329,10,329,12,329,4192,9,329,1,330,1,330,1,330,5,330, + 4197,8,330,10,330,12,330,4200,9,330,1,331,1,331,3,331,4204,8,331, + 1,331,1,331,3,331,4208,8,331,1,331,1,331,3,331,4212,8,331,1,332, + 1,332,1,332,1,333,1,333,1,333,1,334,1,334,1,334,5,334,4223,8,334, + 10,334,12,334,4226,9,334,1,335,1,335,1,335,3,335,4231,8,335,1,336, + 4,336,4234,8,336,11,336,12,336,4235,1,337,4,337,4239,8,337,11,337, + 12,337,4240,1,338,4,338,4244,8,338,11,338,12,338,4245,1,339,1,339, + 3,339,4250,8,339,1,339,3,339,4253,8,339,1,339,4,339,4256,8,339,11, + 339,12,339,4257,1,340,1,340,3,340,4262,8,340,1,341,1,341,3,341,4266, + 8,341,1,342,1,342,1,342,1,343,1,343,1,344,1,344,3,344,4275,8,344, + 1,344,1,344,3,344,4279,8,344,1,345,1,345,1,346,1,346,4,346,4285, + 8,346,11,346,12,346,4286,1,346,1,346,3,346,4291,8,346,1,346,3,346, + 4294,8,346,3,346,4296,8,346,1,347,1,347,1,347,1,347,3,347,4302,8, + 347,1,347,3,347,4305,8,347,1,348,3,348,4308,8,348,1,348,1,348,1, + 348,5,348,4313,8,348,10,348,12,348,4316,9,348,3,348,4318,8,348,1, + 349,1,349,1,349,1,349,5,349,4324,8,349,10,349,12,349,4327,9,349, + 3,349,4329,8,349,1,350,1,350,4,350,4333,8,350,11,350,12,350,4334, + 1,350,3,350,4338,8,350,1,351,1,351,4,351,4342,8,351,11,351,12,351, + 4343,1,352,1,352,3,352,4348,8,352,1,352,1,352,1,352,3,352,4353,8, + 352,1,353,1,353,4,353,4357,8,353,11,353,12,353,4358,1,354,1,354, + 1,354,1,354,1,354,1,354,3,354,4367,8,354,1,355,1,355,4,355,4371, + 8,355,11,355,12,355,4372,1,356,1,356,1,356,4,356,4378,8,356,11,356, + 12,356,4379,1,357,1,357,4,357,4384,8,357,11,357,12,357,4385,1,357, + 4,357,4389,8,357,11,357,12,357,4390,1,358,1,358,1,358,3,358,4396, + 8,358,1,358,1,358,5,358,4400,8,358,10,358,12,358,4403,9,358,1,359, + 1,359,1,359,1,359,4,359,4409,8,359,11,359,12,359,4410,1,360,1,360, + 5,360,4415,8,360,10,360,12,360,4418,9,360,1,361,1,361,1,361,5,361, + 4423,8,361,10,361,12,361,4426,9,361,1,362,1,362,4,362,4430,8,362, + 11,362,12,362,4431,1,363,1,363,4,363,4436,8,363,11,363,12,363,4437, + 1,364,1,364,3,364,4442,8,364,1,364,5,364,4445,8,364,10,364,12,364, + 4448,9,364,1,365,1,365,3,365,4452,8,365,1,365,1,365,5,365,4456,8, + 365,10,365,12,365,4459,9,365,1,366,1,366,1,366,3,366,4464,8,366, + 1,367,1,367,1,367,3,367,4469,8,367,1,368,1,368,3,368,4473,8,368, + 1,368,1,368,3,368,4477,8,368,1,369,1,369,1,369,4,369,4482,8,369, + 11,369,12,369,4483,1,369,3,369,4487,8,369,1,369,5,369,4490,8,369, + 10,369,12,369,4493,9,369,1,369,3,369,4496,8,369,1,369,5,369,4499, + 8,369,10,369,12,369,4502,9,369,1,370,3,370,4505,8,370,1,370,1,370, + 3,370,4509,8,370,1,370,4,370,4512,8,370,11,370,12,370,4513,1,371, + 3,371,4517,8,371,1,371,1,371,3,371,4521,8,371,1,371,4,371,4524,8, + 371,11,371,12,371,4525,1,371,3,371,4529,8,371,1,371,3,371,4532,8, + 371,1,372,3,372,4535,8,372,1,372,1,372,1,372,1,372,1,373,3,373,4542, + 8,373,1,373,1,373,3,373,4546,8,373,1,373,1,373,1,374,1,374,4,374, + 4552,8,374,11,374,12,374,4553,1,375,1,375,1,375,3,375,4559,8,375, + 1,375,1,375,3,375,4563,8,375,1,376,1,376,1,376,1,377,1,377,4,377, + 4570,8,377,11,377,12,377,4571,1,378,1,378,1,378,1,378,1,378,1,378, + 1,378,1,378,1,378,1,378,3,378,4584,8,378,1,379,1,379,3,379,4588, + 8,379,1,379,1,379,3,379,4592,8,379,1,380,1,380,1,380,4,380,4597, + 8,380,11,380,12,380,4598,1,381,1,381,3,381,4603,8,381,1,382,1,382, + 1,382,1,382,4,382,4609,8,382,11,382,12,382,4610,1,383,1,383,1,384, + 1,384,1,384,3,384,4618,8,384,1,384,1,384,1,384,3,384,4623,8,384, + 1,384,3,384,4626,8,384,1,384,3,384,4629,8,384,1,384,3,384,4632,8, + 384,1,385,4,385,4635,8,385,11,385,12,385,4636,1,386,1,386,3,386, + 4641,8,386,1,387,1,387,1,387,4,387,4646,8,387,11,387,12,387,4647, + 1,388,1,388,3,388,4652,8,388,1,389,1,389,3,389,4656,8,389,1,390, + 1,390,1,390,1,390,1,390,4,390,4663,8,390,11,390,12,390,4664,1,391, + 1,391,4,391,4669,8,391,11,391,12,391,4670,1,392,1,392,1,392,3,392, + 4676,8,392,1,392,1,392,3,392,4680,8,392,1,393,1,393,4,393,4684,8, + 393,11,393,12,393,4685,1,394,1,394,3,394,4690,8,394,1,394,1,394, + 3,394,4694,8,394,1,395,1,395,4,395,4698,8,395,11,395,12,395,4699, + 1,396,1,396,4,396,4704,8,396,11,396,12,396,4705,1,397,1,397,1,397, + 3,397,4711,8,397,1,398,3,398,4714,8,398,1,398,5,398,4717,8,398,10, + 398,12,398,4720,9,398,1,398,1,398,1,399,1,399,1,399,3,399,4727,8, + 399,1,399,3,399,4730,8,399,1,400,1,400,1,400,3,400,4735,8,400,1, + 401,1,401,3,401,4739,8,401,1,401,1,401,1,402,3,402,4744,8,402,1, + 402,1,402,1,402,1,403,1,403,1,403,1,403,1,403,3,403,4754,8,403,3, + 403,4756,8,403,1,404,1,404,1,404,5,404,4761,8,404,10,404,12,404, + 4764,9,404,1,405,1,405,3,405,4768,8,405,1,405,1,405,1,405,1,405, + 1,406,1,406,1,406,1,407,1,407,1,407,1,407,3,407,4781,8,407,1,408, + 1,408,1,408,1,408,3,408,4787,8,408,1,409,3,409,4790,8,409,1,409, + 1,409,1,409,1,410,1,410,4,410,4797,8,410,11,410,12,410,4798,1,411, + 1,411,1,411,3,411,4804,8,411,1,411,3,411,4807,8,411,1,411,3,411, + 4810,8,411,1,411,3,411,4813,8,411,1,411,3,411,4816,8,411,1,411,3, + 411,4819,8,411,1,411,3,411,4822,8,411,1,411,3,411,4825,8,411,1,411, + 3,411,4828,8,411,1,411,3,411,4831,8,411,1,412,1,412,1,412,1,413, + 3,413,4837,8,413,1,413,1,413,1,413,3,413,4842,8,413,1,414,1,414, + 3,414,4846,8,414,1,414,1,414,1,415,1,415,1,415,3,415,4853,8,415, + 1,415,3,415,4856,8,415,1,415,3,415,4859,8,415,1,415,3,415,4862,8, + 415,1,416,1,416,1,416,1,416,1,416,1,416,1,416,1,416,5,416,4872,8, + 416,10,416,12,416,4875,9,416,1,417,1,417,1,417,1,417,1,417,1,417, + 3,417,4883,8,417,1,418,1,418,1,418,3,418,4888,8,418,1,418,1,418, + 3,418,4892,8,418,1,418,3,418,4895,8,418,1,419,1,419,1,419,5,419, + 4900,8,419,10,419,12,419,4903,9,419,1,420,1,420,1,420,5,420,4908, + 8,420,10,420,12,420,4911,9,420,1,421,1,421,3,421,4915,8,421,1,421, + 1,421,3,421,4919,8,421,1,422,3,422,4922,8,422,1,422,1,422,1,422, + 1,423,1,423,3,423,4929,8,423,1,423,1,423,1,424,1,424,3,424,4935, + 8,424,1,424,1,424,3,424,4939,8,424,1,425,1,425,3,425,4943,8,425, + 1,425,1,425,1,426,1,426,1,426,1,426,3,426,4951,8,426,1,427,1,427, + 1,427,3,427,4956,8,427,1,427,3,427,4959,8,427,1,427,1,427,3,427, + 4963,8,427,1,427,3,427,4966,8,427,1,428,1,428,1,428,1,429,1,429, + 1,429,3,429,4974,8,429,1,429,3,429,4977,8,429,1,429,3,429,4980,8, + 429,1,429,3,429,4983,8,429,1,430,1,430,1,430,1,431,1,431,3,431,4990, + 8,431,1,431,1,431,3,431,4994,8,431,1,431,3,431,4997,8,431,1,431, + 4,431,5000,8,431,11,431,12,431,5001,1,431,3,431,5005,8,431,1,432, + 1,432,1,432,1,433,1,433,1,433,1,433,1,433,5,433,5015,8,433,10,433, + 12,433,5018,9,433,3,433,5020,8,433,1,434,1,434,1,434,3,434,5025, + 8,434,1,434,3,434,5028,8,434,1,434,3,434,5031,8,434,1,435,1,435, + 3,435,5035,8,435,1,435,3,435,5038,8,435,1,435,3,435,5041,8,435,1, + 435,3,435,5044,8,435,1,435,3,435,5047,8,435,1,436,1,436,1,436,1, + 436,1,437,1,437,1,437,1,438,1,438,1,438,1,438,1,438,3,438,5061,8, + 438,1,439,1,439,3,439,5065,8,439,1,440,1,440,3,440,5069,8,440,1, + 440,1,440,1,440,3,440,5074,8,440,1,441,1,441,1,442,1,442,3,442,5080, + 8,442,1,442,3,442,5083,8,442,1,443,1,443,1,444,1,444,4,444,5089, + 8,444,11,444,12,444,5090,1,444,3,444,5094,8,444,1,445,4,445,5097, + 8,445,11,445,12,445,5098,1,445,1,445,4,445,5103,8,445,11,445,12, + 445,5104,1,446,4,446,5108,8,446,11,446,12,446,5109,1,446,1,446,1, + 446,1,446,3,446,5116,8,446,1,446,1,446,1,447,1,447,1,448,1,448,1, + 448,1,448,1,448,3,448,5127,8,448,1,448,1,448,3,448,5131,8,448,1, + 449,1,449,3,449,5135,8,449,1,450,1,450,1,450,4,450,5140,8,450,11, + 450,12,450,5141,1,450,3,450,5145,8,450,1,450,3,450,5148,8,450,1, + 450,3,450,5151,8,450,1,450,5,450,5154,8,450,10,450,12,450,5157,9, + 450,1,450,3,450,5160,8,450,1,450,5,450,5163,8,450,10,450,12,450, + 5166,9,450,1,451,3,451,5169,8,451,1,451,1,451,3,451,5173,8,451,1, + 451,4,451,5176,8,451,11,451,12,451,5177,1,452,3,452,5181,8,452,1, + 452,1,452,3,452,5185,8,452,1,452,3,452,5188,8,452,1,453,3,453,5191, + 8,453,1,453,1,453,3,453,5195,8,453,1,453,4,453,5198,8,453,11,453, + 12,453,5199,1,453,3,453,5203,8,453,1,453,3,453,5206,8,453,1,454, + 3,454,5209,8,454,1,454,1,454,1,454,1,454,1,455,3,455,5216,8,455, + 1,455,1,455,3,455,5220,8,455,1,455,1,455,1,456,1,456,1,456,3,456, + 5227,8,456,1,456,1,456,3,456,5231,8,456,1,457,1,457,1,457,1,458, + 1,458,4,458,5238,8,458,11,458,12,458,5239,1,459,1,459,1,459,3,459, + 5245,8,459,1,459,1,459,3,459,5249,8,459,1,460,1,460,1,460,1,461, + 1,461,4,461,5256,8,461,11,461,12,461,5257,1,462,1,462,1,462,1,462, + 1,462,1,462,1,462,1,462,1,462,1,462,3,462,5270,8,462,1,463,1,463, + 1,463,3,463,5275,8,463,1,463,3,463,5278,8,463,1,463,3,463,5281,8, + 463,1,463,3,463,5284,8,463,1,464,1,464,3,464,5288,8,464,1,464,1, + 464,3,464,5292,8,464,1,464,1,464,1,464,3,464,5297,8,464,1,464,1, + 464,1,464,1,464,3,464,5303,8,464,1,464,1,464,1,464,1,464,3,464,5309, + 8,464,1,464,1,464,1,464,3,464,5314,8,464,1,464,3,464,5317,8,464, + 1,464,1,464,1,465,1,465,1,465,3,465,5324,8,465,1,466,1,466,4,466, + 5328,8,466,11,466,12,466,5329,1,466,1,466,3,466,5334,8,466,1,466, + 3,466,5337,8,466,1,466,3,466,5340,8,466,1,466,3,466,5343,8,466,1, + 467,4,467,5346,8,467,11,467,12,467,5347,1,467,1,467,3,467,5352,8, + 467,1,468,1,468,3,468,5356,8,468,1,469,1,469,3,469,5360,8,469,1, + 469,1,469,1,469,3,469,5365,8,469,1,470,1,470,1,470,3,470,5370,8, + 470,1,471,1,471,1,471,1,472,3,472,5376,8,472,1,472,1,472,1,472,1, + 473,1,473,1,473,1,473,3,473,5385,8,473,1,473,3,473,5388,8,473,1, + 473,3,473,5391,8,473,1,473,3,473,5394,8,473,1,474,4,474,5397,8,474, + 11,474,12,474,5398,1,474,1,474,4,474,5403,8,474,11,474,12,474,5404, + 1,475,4,475,5408,8,475,11,475,12,475,5409,1,475,1,475,1,475,1,475, + 4,475,5416,8,475,11,475,12,475,5417,1,476,1,476,1,476,1,476,1,476, + 1,477,1,477,3,477,5427,8,477,1,478,1,478,3,478,5431,8,478,1,479, + 1,479,3,479,5435,8,479,1,480,1,480,3,480,5439,8,480,1,481,1,481, + 3,481,5443,8,481,1,482,1,482,1,482,1,483,1,483,1,483,1,483,3,483, + 5452,8,483,1,483,3,483,5455,8,483,1,483,3,483,5458,8,483,1,483,3, + 483,5461,8,483,1,483,3,483,5464,8,483,1,484,1,484,1,484,5,484,5469, + 8,484,10,484,12,484,5472,9,484,3,484,5474,8,484,1,485,1,485,3,485, + 5478,8,485,1,485,3,485,5481,8,485,1,485,1,485,3,485,5485,8,485,1, + 486,1,486,3,486,5489,8,486,1,486,1,486,3,486,5493,8,486,1,487,1, + 487,4,487,5497,8,487,11,487,12,487,5498,1,488,1,488,3,488,5503,8, + 488,1,488,3,488,5506,8,488,1,489,1,489,3,489,5510,8,489,1,489,1, + 489,1,490,1,490,3,490,5516,8,490,1,490,1,490,1,491,3,491,5521,8, + 491,1,491,1,491,1,491,1,492,1,492,3,492,5528,8,492,1,492,1,492,1, + 493,1,493,1,493,3,493,5535,8,493,1,494,3,494,5538,8,494,1,494,1, + 494,3,494,5542,8,494,1,494,1,494,1,494,3,494,5547,8,494,1,494,1, + 494,1,495,1,495,1,495,1,495,1,495,4,495,5556,8,495,11,495,12,495, + 5557,3,495,5560,8,495,1,496,3,496,5563,8,496,1,496,1,496,3,496,5567, + 8,496,1,496,4,496,5570,8,496,11,496,12,496,5571,1,497,1,497,1,497, + 1,497,3,497,5578,8,497,1,497,3,497,5581,8,497,1,497,1,497,1,497, + 3,497,5586,8,497,1,498,1,498,1,498,3,498,5591,8,498,1,498,3,498, + 5594,8,498,1,498,3,498,5597,8,498,1,498,3,498,5600,8,498,1,498,3, + 498,5603,8,498,1,498,3,498,5606,8,498,1,498,3,498,5609,8,498,1,499, + 1,499,1,499,3,499,5614,8,499,1,500,1,500,3,500,5618,8,500,1,500, + 1,500,1,500,3,500,5623,8,500,1,501,1,501,1,502,1,502,3,502,5629, + 8,502,1,502,3,502,5632,8,502,1,503,1,503,1,504,3,504,5637,8,504, + 1,504,1,504,5,504,5641,8,504,10,504,12,504,5644,9,504,1,505,1,505, + 3,505,5648,8,505,1,505,1,505,5,505,5652,8,505,10,505,12,505,5655, + 9,505,1,506,3,506,5658,8,506,1,506,1,506,5,506,5662,8,506,10,506, + 12,506,5665,9,506,1,507,1,507,3,507,5669,8,507,1,507,1,507,5,507, + 5673,8,507,10,507,12,507,5676,9,507,1,508,1,508,3,508,5680,8,508, + 1,508,5,508,5683,8,508,10,508,12,508,5686,9,508,1,509,1,509,1,509, + 3,509,5691,8,509,1,509,5,509,5694,8,509,10,509,12,509,5697,9,509, + 1,510,3,510,5700,8,510,1,510,1,510,5,510,5704,8,510,10,510,12,510, + 5707,9,510,1,511,1,511,3,511,5711,8,511,1,511,1,511,5,511,5715,8, + 511,10,511,12,511,5718,9,511,1,512,3,512,5721,8,512,1,512,1,512, + 1,512,5,512,5726,8,512,10,512,12,512,5729,9,512,1,513,1,513,3,513, + 5733,8,513,1,513,1,513,1,513,5,513,5738,8,513,10,513,12,513,5741, + 9,513,1,514,3,514,5744,8,514,1,514,1,514,5,514,5748,8,514,10,514, + 12,514,5751,9,514,1,515,1,515,3,515,5755,8,515,1,515,1,515,5,515, + 5759,8,515,10,515,12,515,5762,9,515,1,516,1,516,5,516,5766,8,516, + 10,516,12,516,5769,9,516,1,517,1,517,1,517,1,518,1,518,5,518,5776, + 8,518,10,518,12,518,5779,9,518,1,519,1,519,1,519,1,520,3,520,5785, + 8,520,1,520,1,520,5,520,5789,8,520,10,520,12,520,5792,9,520,1,521, + 1,521,1,521,1,522,1,522,1,522,1,522,1,522,1,522,3,522,5803,8,522, + 1,523,1,523,5,523,5807,8,523,10,523,12,523,5810,9,523,1,524,1,524, + 1,524,4,524,5815,8,524,11,524,12,524,5816,3,524,5819,8,524,1,525, + 3,525,5822,8,525,1,525,1,525,1,526,1,526,1,526,1,526,1,526,1,526, + 1,526,3,526,5833,8,526,1,527,1,527,3,527,5837,8,527,1,527,3,527, + 5840,8,527,1,527,1,527,1,527,1,527,1,527,1,527,1,527,3,527,5849, + 8,527,1,528,1,528,5,528,5853,8,528,10,528,12,528,5856,9,528,1,528, + 3,528,5859,8,528,1,528,5,528,5862,8,528,10,528,12,528,5865,9,528, + 1,528,5,528,5868,8,528,10,528,12,528,5871,9,528,3,528,5873,8,528, + 1,529,1,529,1,529,3,529,5878,8,529,1,529,5,529,5881,8,529,10,529, + 12,529,5884,9,529,1,529,1,529,1,530,1,530,1,530,3,530,5891,8,530, + 1,531,1,531,3,531,5895,8,531,1,531,3,531,5898,8,531,1,531,1,531, + 1,532,1,532,1,532,1,532,1,533,1,533,1,533,1,533,1,533,1,533,1,534, + 1,534,1,534,4,534,5915,8,534,11,534,12,534,5916,1,535,3,535,5920, + 8,535,1,535,3,535,5923,8,535,1,535,1,535,3,535,5927,8,535,1,535, + 1,535,1,535,3,535,5932,8,535,1,535,1,535,1,535,3,535,5937,8,535, + 1,535,3,535,5940,8,535,1,535,1,535,1,535,3,535,5945,8,535,1,535, + 1,535,1,535,3,535,5950,8,535,1,535,1,535,1,535,3,535,5955,8,535, + 1,535,1,535,1,535,3,535,5960,8,535,1,535,3,535,5963,8,535,1,536, + 3,536,5966,8,536,1,536,3,536,5969,8,536,1,536,1,536,1,536,1,536, + 1,536,1,536,3,536,5977,8,536,1,537,1,537,1,537,1,537,3,537,5983, + 8,537,1,538,1,538,1,538,1,538,3,538,5989,8,538,1,538,5,538,5992, + 8,538,10,538,12,538,5995,9,538,1,538,1,538,5,538,5999,8,538,10,538, + 12,538,6002,9,538,1,538,3,538,6005,8,538,1,539,1,539,1,539,1,539, + 1,539,3,539,6012,8,539,1,539,5,539,6015,8,539,10,539,12,539,6018, + 9,539,1,539,1,539,5,539,6022,8,539,10,539,12,539,6025,9,539,1,539, + 3,539,6028,8,539,1,540,1,540,1,540,1,540,3,540,6034,8,540,1,540, + 1,540,1,541,1,541,1,542,1,542,1,543,1,543,1,543,1,543,3,543,6046, + 8,543,1,543,1,543,3,543,6050,8,543,1,543,3,543,6053,8,543,1,544, + 1,544,1,544,1,544,3,544,6059,8,544,1,544,1,544,3,544,6063,8,544, + 1,544,3,544,6066,8,544,1,545,1,545,1,545,1,545,3,545,6072,8,545, + 1,546,1,546,3,546,6076,8,546,1,546,4,546,6079,8,546,11,546,12,546, + 6080,1,546,3,546,6084,8,546,1,546,3,546,6087,8,546,1,547,1,547,1, + 547,1,548,1,548,1,548,1,549,1,549,1,549,1,550,1,550,3,550,6100,8, + 550,1,551,1,551,1,551,1,552,1,552,1,552,1,553,1,553,1,553,1,554, + 1,554,1,554,1,555,1,555,1,555,1,556,1,556,1,556,1,557,1,557,1,558, + 1,558,1,559,1,559,1,560,1,560,1,561,1,561,1,562,1,562,1,563,1,563, + 1,564,1,564,1,565,1,565,1,565,3,565,6139,8,565,1,566,1,566,1,567, + 1,567,1,568,1,568,1,568,1,568,1,568,1,568,3,568,6151,8,568,1,569, + 1,569,1,570,1,570,1,571,1,571,1,572,1,572,1,573,1,573,1,574,1,574, + 3,574,6165,8,574,1,575,1,575,3,575,6169,8,575,1,575,3,575,6172,8, + 575,1,576,1,576,3,576,6176,8,576,1,577,1,577,1,578,1,578,1,579,1, + 579,1,580,1,580,1,581,1,581,3,581,6188,8,581,1,582,1,582,1,583,1, + 583,1,584,1,584,1,585,1,585,1,586,1,586,1,586,1,586,1,586,1,586, + 3,586,6204,8,586,1,587,1,587,1,588,1,588,1,588,3,588,6211,8,588, + 1,589,1,589,1,590,1,590,1,590,1,590,3,590,6219,8,590,1,590,1,590, + 1,591,1,591,1,591,1,591,3,591,6227,8,591,1,591,1,591,1,592,1,592, + 1,592,1,592,1,592,1,592,1,592,1,592,1,592,1,592,1,592,1,592,1,592, + 1,592,1,592,3,592,6246,8,592,1,593,1,593,1,593,1,593,1,593,1,593, + 1,593,1,593,1,593,1,593,1,593,1,593,1,593,1,593,1,593,3,593,6263, + 8,593,1,593,1,593,1,593,1,593,1,593,1,593,1,593,1,593,1,593,1,593, + 1,593,1,593,1,593,1,593,1,593,1,593,3,593,6281,8,593,1,594,4,594, + 6284,8,594,11,594,12,594,6285,1,594,0,0,595,0,2,4,6,8,10,12,14,16, + 18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60, + 62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102, + 104,106,108,110,112,114,116,118,120,122,124,126,128,130,132,134, + 136,138,140,142,144,146,148,150,152,154,156,158,160,162,164,166, + 168,170,172,174,176,178,180,182,184,186,188,190,192,194,196,198, + 200,202,204,206,208,210,212,214,216,218,220,222,224,226,228,230, + 232,234,236,238,240,242,244,246,248,250,252,254,256,258,260,262, + 264,266,268,270,272,274,276,278,280,282,284,286,288,290,292,294, + 296,298,300,302,304,306,308,310,312,314,316,318,320,322,324,326, + 328,330,332,334,336,338,340,342,344,346,348,350,352,354,356,358, + 360,362,364,366,368,370,372,374,376,378,380,382,384,386,388,390, + 392,394,396,398,400,402,404,406,408,410,412,414,416,418,420,422, + 424,426,428,430,432,434,436,438,440,442,444,446,448,450,452,454, + 456,458,460,462,464,466,468,470,472,474,476,478,480,482,484,486, + 488,490,492,494,496,498,500,502,504,506,508,510,512,514,516,518, + 520,522,524,526,528,530,532,534,536,538,540,542,544,546,548,550, + 552,554,556,558,560,562,564,566,568,570,572,574,576,578,580,582, + 584,586,588,590,592,594,596,598,600,602,604,606,608,610,612,614, + 616,618,620,622,624,626,628,630,632,634,636,638,640,642,644,646, + 648,650,652,654,656,658,660,662,664,666,668,670,672,674,676,678, + 680,682,684,686,688,690,692,694,696,698,700,702,704,706,708,710, + 712,714,716,718,720,722,724,726,728,730,732,734,736,738,740,742, + 744,746,748,750,752,754,756,758,760,762,764,766,768,770,772,774, + 776,778,780,782,784,786,788,790,792,794,796,798,800,802,804,806, + 808,810,812,814,816,818,820,822,824,826,828,830,832,834,836,838, + 840,842,844,846,848,850,852,854,856,858,860,862,864,866,868,870, + 872,874,876,878,880,882,884,886,888,890,892,894,896,898,900,902, + 904,906,908,910,912,914,916,918,920,922,924,926,928,930,932,934, + 936,938,940,942,944,946,948,950,952,954,956,958,960,962,964,966, + 968,970,972,974,976,978,980,982,984,986,988,990,992,994,996,998, + 1000,1002,1004,1006,1008,1010,1012,1014,1016,1018,1020,1022,1024, + 1026,1028,1030,1032,1034,1036,1038,1040,1042,1044,1046,1048,1050, + 1052,1054,1056,1058,1060,1062,1064,1066,1068,1070,1072,1074,1076, + 1078,1080,1082,1084,1086,1088,1090,1092,1094,1096,1098,1100,1102, + 1104,1106,1108,1110,1112,1114,1116,1118,1120,1122,1124,1126,1128, + 1130,1132,1134,1136,1138,1140,1142,1144,1146,1148,1150,1152,1154, + 1156,1158,1160,1162,1164,1166,1168,1170,1172,1174,1176,1178,1180, + 1182,1184,1186,1188,0,70,1,0,234,235,5,0,78,78,130,130,243,243,274, + 274,380,380,3,0,63,63,298,298,515,515,2,0,298,298,515,515,1,0,483, + 484,2,0,14,14,304,304,2,0,80,80,86,86,2,0,266,266,493,493,2,0,21, + 21,254,254,1,0,22,23,3,0,241,241,386,386,429,429,4,0,150,150,197, + 197,369,369,429,429,2,0,382,382,499,499,3,0,377,377,440,440,444, + 444,2,0,205,205,417,417,2,0,63,63,379,379,1,0,460,462,2,0,279,279, + 416,416,2,0,38,38,41,41,1,0,189,190,2,0,229,229,290,290,3,0,226, + 226,268,268,336,336,3,0,348,348,543,543,547,547,1,0,73,74,1,0,213, + 214,1,0,35,36,1,0,346,347,1,0,142,143,1,0,255,256,1,0,33,34,2,0, + 311,311,420,420,2,0,156,156,398,398,2,0,216,216,270,270,1,0,279, + 280,2,0,117,117,137,137,3,0,146,146,355,355,432,433,1,0,50,51,2, + 0,553,553,555,555,2,0,521,521,523,524,3,0,78,78,284,284,337,337, + 2,0,250,250,459,459,2,0,25,25,135,135,2,0,95,95,383,384,1,0,468, + 469,2,0,267,267,411,411,4,0,287,288,317,317,319,319,437,437,2,0, + 202,202,495,495,2,0,100,100,262,262,2,0,59,59,506,506,2,0,222,222, + 405,405,1,0,103,104,2,0,1,1,331,331,2,0,186,186,536,536,7,0,11,11, + 14,15,116,116,152,152,304,305,316,316,318,318,2,0,9,9,266,266,3, + 0,9,9,210,210,266,266,2,0,7,7,39,39,2,0,258,258,310,310,2,0,295, + 295,422,422,2,0,48,48,492,492,2,0,188,188,196,196,2,0,168,168,185, + 185,2,0,543,543,547,547,2,0,526,526,550,550,2,0,19,19,329,329,3, + 0,307,307,351,351,521,521,2,0,239,239,323,323,85,0,1,1,24,24,26, + 26,28,29,31,31,33,36,38,38,41,43,45,45,47,47,54,55,60,61,68,69,77, + 77,98,98,100,100,106,106,108,108,128,130,138,139,141,141,146,147, + 151,151,156,156,181,181,183,183,187,187,189,191,194,194,197,197, + 200,200,202,202,213,214,216,216,218,219,226,226,229,229,237,238, + 250,250,258,258,260,260,262,262,264,265,268,268,270,270,272,274, + 283,284,287,290,296,296,303,305,308,308,311,311,317,317,319,319, + 322,322,331,331,336,337,342,342,352,353,355,355,360,361,364,364, + 370,371,373,373,376,376,380,380,383,383,391,391,398,398,401,401, + 415,415,420,420,431,434,437,437,466,466,473,473,481,482,486,486, + 490,491,495,495,497,498,510,511,518,520,522,522,557,557,2,0,204, + 204,494,494,1,0,552,555,7059,0,1190,1,0,0,0,2,1194,1,0,0,0,4,1198, + 1,0,0,0,6,1217,1,0,0,0,8,1222,1,0,0,0,10,1238,1,0,0,0,12,1240,1, + 0,0,0,14,1258,1,0,0,0,16,1263,1,0,0,0,18,1268,1,0,0,0,20,1273,1, + 0,0,0,22,1278,1,0,0,0,24,1283,1,0,0,0,26,1288,1,0,0,0,28,1300,1, + 0,0,0,30,1302,1,0,0,0,32,1314,1,0,0,0,34,1316,1,0,0,0,36,1328,1, + 0,0,0,38,1344,1,0,0,0,40,1346,1,0,0,0,42,1357,1,0,0,0,44,1372,1, + 0,0,0,46,1393,1,0,0,0,48,1402,1,0,0,0,50,1410,1,0,0,0,52,1416,1, + 0,0,0,54,1420,1,0,0,0,56,1442,1,0,0,0,58,1446,1,0,0,0,60,1448,1, + 0,0,0,62,1470,1,0,0,0,64,1479,1,0,0,0,66,1482,1,0,0,0,68,1488,1, + 0,0,0,70,1502,1,0,0,0,72,1509,1,0,0,0,74,1525,1,0,0,0,76,1532,1, + 0,0,0,78,1536,1,0,0,0,80,1538,1,0,0,0,82,1554,1,0,0,0,84,1560,1, + 0,0,0,86,1577,1,0,0,0,88,1600,1,0,0,0,90,1638,1,0,0,0,92,1640,1, + 0,0,0,94,1646,1,0,0,0,96,1660,1,0,0,0,98,1680,1,0,0,0,100,1692,1, + 0,0,0,102,1703,1,0,0,0,104,1705,1,0,0,0,106,1717,1,0,0,0,108,1724, + 1,0,0,0,110,1741,1,0,0,0,112,1743,1,0,0,0,114,1760,1,0,0,0,116,1775, + 1,0,0,0,118,1786,1,0,0,0,120,1797,1,0,0,0,122,1807,1,0,0,0,124,1816, + 1,0,0,0,126,1833,1,0,0,0,128,1851,1,0,0,0,130,1858,1,0,0,0,132,1868, + 1,0,0,0,134,1877,1,0,0,0,136,1897,1,0,0,0,138,1899,1,0,0,0,140,1913, + 1,0,0,0,142,1917,1,0,0,0,144,1926,1,0,0,0,146,1930,1,0,0,0,148,1945, + 1,0,0,0,150,1958,1,0,0,0,152,1963,1,0,0,0,154,1970,1,0,0,0,156,1988, + 1,0,0,0,158,1990,1,0,0,0,160,1999,1,0,0,0,162,2028,1,0,0,0,164,2031, + 1,0,0,0,166,2036,1,0,0,0,168,2040,1,0,0,0,170,2051,1,0,0,0,172,2054, + 1,0,0,0,174,2061,1,0,0,0,176,2068,1,0,0,0,178,2097,1,0,0,0,180,2104, + 1,0,0,0,182,2107,1,0,0,0,184,2127,1,0,0,0,186,2134,1,0,0,0,188,2142, + 1,0,0,0,190,2158,1,0,0,0,192,2178,1,0,0,0,194,2181,1,0,0,0,196,2192, + 1,0,0,0,198,2203,1,0,0,0,200,2213,1,0,0,0,202,2222,1,0,0,0,204,2224, + 1,0,0,0,206,2238,1,0,0,0,208,2245,1,0,0,0,210,2254,1,0,0,0,212,2259, + 1,0,0,0,214,2268,1,0,0,0,216,2277,1,0,0,0,218,2290,1,0,0,0,220,2292, + 1,0,0,0,222,2320,1,0,0,0,224,2339,1,0,0,0,226,2362,1,0,0,0,228,2369, + 1,0,0,0,230,2383,1,0,0,0,232,2390,1,0,0,0,234,2398,1,0,0,0,236,2406, + 1,0,0,0,238,2413,1,0,0,0,240,2420,1,0,0,0,242,2428,1,0,0,0,244,2437, + 1,0,0,0,246,2446,1,0,0,0,248,2455,1,0,0,0,250,2464,1,0,0,0,252,2472, + 1,0,0,0,254,2479,1,0,0,0,256,2494,1,0,0,0,258,2503,1,0,0,0,260,2545, + 1,0,0,0,262,2548,1,0,0,0,264,2550,1,0,0,0,266,2552,1,0,0,0,268,2555, + 1,0,0,0,270,2557,1,0,0,0,272,2559,1,0,0,0,274,2561,1,0,0,0,276,2563, + 1,0,0,0,278,2571,1,0,0,0,280,2585,1,0,0,0,282,2599,1,0,0,0,284,2607, + 1,0,0,0,286,2615,1,0,0,0,288,2621,1,0,0,0,290,2627,1,0,0,0,292,2633, + 1,0,0,0,294,2641,1,0,0,0,296,2644,1,0,0,0,298,2647,1,0,0,0,300,2653, + 1,0,0,0,302,2659,1,0,0,0,304,2667,1,0,0,0,306,2676,1,0,0,0,308,2678, + 1,0,0,0,310,2680,1,0,0,0,312,2682,1,0,0,0,314,2696,1,0,0,0,316,2701, + 1,0,0,0,318,2703,1,0,0,0,320,2705,1,0,0,0,322,2714,1,0,0,0,324,2720, + 1,0,0,0,326,2743,1,0,0,0,328,2747,1,0,0,0,330,2762,1,0,0,0,332,2765, + 1,0,0,0,334,2769,1,0,0,0,336,2773,1,0,0,0,338,2779,1,0,0,0,340,2781, + 1,0,0,0,342,2795,1,0,0,0,344,2805,1,0,0,0,346,2830,1,0,0,0,348,2836, + 1,0,0,0,350,2845,1,0,0,0,352,2849,1,0,0,0,354,2854,1,0,0,0,356,2866, + 1,0,0,0,358,2874,1,0,0,0,360,2877,1,0,0,0,362,2887,1,0,0,0,364,2890, + 1,0,0,0,366,2893,1,0,0,0,368,2899,1,0,0,0,370,2907,1,0,0,0,372,2916, + 1,0,0,0,374,2922,1,0,0,0,376,2946,1,0,0,0,378,2962,1,0,0,0,380,2967, + 1,0,0,0,382,2972,1,0,0,0,384,2978,1,0,0,0,386,2983,1,0,0,0,388,2993, + 1,0,0,0,390,3000,1,0,0,0,392,3005,1,0,0,0,394,3007,1,0,0,0,396,3013, + 1,0,0,0,398,3024,1,0,0,0,400,3026,1,0,0,0,402,3035,1,0,0,0,404,3051, + 1,0,0,0,406,3059,1,0,0,0,408,3076,1,0,0,0,410,3080,1,0,0,0,412,3086, + 1,0,0,0,414,3092,1,0,0,0,416,3097,1,0,0,0,418,3111,1,0,0,0,420,3114, + 1,0,0,0,422,3117,1,0,0,0,424,3125,1,0,0,0,426,3127,1,0,0,0,428,3135, + 1,0,0,0,430,3138,1,0,0,0,432,3143,1,0,0,0,434,3151,1,0,0,0,436,3153, + 1,0,0,0,438,3186,1,0,0,0,440,3191,1,0,0,0,442,3197,1,0,0,0,444,3204, + 1,0,0,0,446,3206,1,0,0,0,448,3212,1,0,0,0,450,3215,1,0,0,0,452,3223, + 1,0,0,0,454,3227,1,0,0,0,456,3229,1,0,0,0,458,3233,1,0,0,0,460,3268, + 1,0,0,0,462,3271,1,0,0,0,464,3283,1,0,0,0,466,3297,1,0,0,0,468,3317, + 1,0,0,0,470,3319,1,0,0,0,472,3324,1,0,0,0,474,3331,1,0,0,0,476,3334, + 1,0,0,0,478,3337,1,0,0,0,480,3347,1,0,0,0,482,3356,1,0,0,0,484,3361, + 1,0,0,0,486,3365,1,0,0,0,488,3372,1,0,0,0,490,3380,1,0,0,0,492,3417, + 1,0,0,0,494,3434,1,0,0,0,496,3446,1,0,0,0,498,3452,1,0,0,0,500,3454, + 1,0,0,0,502,3458,1,0,0,0,504,3463,1,0,0,0,506,3477,1,0,0,0,508,3483, + 1,0,0,0,510,3488,1,0,0,0,512,3494,1,0,0,0,514,3509,1,0,0,0,516,3512, + 1,0,0,0,518,3523,1,0,0,0,520,3525,1,0,0,0,522,3536,1,0,0,0,524,3542, + 1,0,0,0,526,3547,1,0,0,0,528,3554,1,0,0,0,530,3561,1,0,0,0,532,3570, + 1,0,0,0,534,3584,1,0,0,0,536,3638,1,0,0,0,538,3640,1,0,0,0,540,3657, + 1,0,0,0,542,3679,1,0,0,0,544,3682,1,0,0,0,546,3687,1,0,0,0,548,3691, + 1,0,0,0,550,3707,1,0,0,0,552,3718,1,0,0,0,554,3736,1,0,0,0,556,3743, + 1,0,0,0,558,3745,1,0,0,0,560,3751,1,0,0,0,562,3753,1,0,0,0,564,3757, + 1,0,0,0,566,3763,1,0,0,0,568,3769,1,0,0,0,570,3777,1,0,0,0,572,3800, + 1,0,0,0,574,3809,1,0,0,0,576,3815,1,0,0,0,578,3834,1,0,0,0,580,3837, + 1,0,0,0,582,3851,1,0,0,0,584,3858,1,0,0,0,586,3877,1,0,0,0,588,3879, + 1,0,0,0,590,3882,1,0,0,0,592,3893,1,0,0,0,594,3895,1,0,0,0,596,3901, + 1,0,0,0,598,3907,1,0,0,0,600,3925,1,0,0,0,602,3939,1,0,0,0,604,3952, + 1,0,0,0,606,3954,1,0,0,0,608,3960,1,0,0,0,610,3965,1,0,0,0,612,3973, + 1,0,0,0,614,3990,1,0,0,0,616,3994,1,0,0,0,618,3996,1,0,0,0,620,4010, + 1,0,0,0,622,4029,1,0,0,0,624,4046,1,0,0,0,626,4048,1,0,0,0,628,4053, + 1,0,0,0,630,4059,1,0,0,0,632,4064,1,0,0,0,634,4086,1,0,0,0,636,4092, + 1,0,0,0,638,4100,1,0,0,0,640,4108,1,0,0,0,642,4114,1,0,0,0,644,4118, + 1,0,0,0,646,4122,1,0,0,0,648,4125,1,0,0,0,650,4144,1,0,0,0,652,4154, + 1,0,0,0,654,4177,1,0,0,0,656,4179,1,0,0,0,658,4183,1,0,0,0,660,4193, + 1,0,0,0,662,4211,1,0,0,0,664,4213,1,0,0,0,666,4216,1,0,0,0,668,4219, + 1,0,0,0,670,4230,1,0,0,0,672,4233,1,0,0,0,674,4238,1,0,0,0,676,4243, + 1,0,0,0,678,4247,1,0,0,0,680,4261,1,0,0,0,682,4263,1,0,0,0,684,4267, + 1,0,0,0,686,4270,1,0,0,0,688,4272,1,0,0,0,690,4280,1,0,0,0,692,4295, + 1,0,0,0,694,4297,1,0,0,0,696,4307,1,0,0,0,698,4319,1,0,0,0,700,4330, + 1,0,0,0,702,4339,1,0,0,0,704,4345,1,0,0,0,706,4354,1,0,0,0,708,4360, + 1,0,0,0,710,4368,1,0,0,0,712,4374,1,0,0,0,714,4381,1,0,0,0,716,4392, + 1,0,0,0,718,4404,1,0,0,0,720,4412,1,0,0,0,722,4419,1,0,0,0,724,4427, + 1,0,0,0,726,4433,1,0,0,0,728,4441,1,0,0,0,730,4451,1,0,0,0,732,4460, + 1,0,0,0,734,4465,1,0,0,0,736,4470,1,0,0,0,738,4478,1,0,0,0,740,4504, + 1,0,0,0,742,4516,1,0,0,0,744,4534,1,0,0,0,746,4541,1,0,0,0,748,4549, + 1,0,0,0,750,4555,1,0,0,0,752,4564,1,0,0,0,754,4567,1,0,0,0,756,4573, + 1,0,0,0,758,4585,1,0,0,0,760,4593,1,0,0,0,762,4602,1,0,0,0,764,4604, + 1,0,0,0,766,4612,1,0,0,0,768,4614,1,0,0,0,770,4634,1,0,0,0,772,4638, + 1,0,0,0,774,4642,1,0,0,0,776,4651,1,0,0,0,778,4653,1,0,0,0,780,4657, + 1,0,0,0,782,4666,1,0,0,0,784,4672,1,0,0,0,786,4681,1,0,0,0,788,4687, + 1,0,0,0,790,4695,1,0,0,0,792,4701,1,0,0,0,794,4707,1,0,0,0,796,4713, + 1,0,0,0,798,4723,1,0,0,0,800,4734,1,0,0,0,802,4738,1,0,0,0,804,4743, + 1,0,0,0,806,4755,1,0,0,0,808,4757,1,0,0,0,810,4767,1,0,0,0,812,4773, + 1,0,0,0,814,4776,1,0,0,0,816,4782,1,0,0,0,818,4789,1,0,0,0,820,4794, + 1,0,0,0,822,4800,1,0,0,0,824,4832,1,0,0,0,826,4836,1,0,0,0,828,4843, + 1,0,0,0,830,4849,1,0,0,0,832,4863,1,0,0,0,834,4882,1,0,0,0,836,4884, + 1,0,0,0,838,4896,1,0,0,0,840,4904,1,0,0,0,842,4912,1,0,0,0,844,4921, + 1,0,0,0,846,4926,1,0,0,0,848,4932,1,0,0,0,850,4940,1,0,0,0,852,4946, + 1,0,0,0,854,4952,1,0,0,0,856,4967,1,0,0,0,858,4970,1,0,0,0,860,4984, + 1,0,0,0,862,4987,1,0,0,0,864,5006,1,0,0,0,866,5009,1,0,0,0,868,5021, + 1,0,0,0,870,5034,1,0,0,0,872,5048,1,0,0,0,874,5052,1,0,0,0,876,5055, + 1,0,0,0,878,5062,1,0,0,0,880,5066,1,0,0,0,882,5075,1,0,0,0,884,5079, + 1,0,0,0,886,5084,1,0,0,0,888,5086,1,0,0,0,890,5096,1,0,0,0,892,5107, + 1,0,0,0,894,5119,1,0,0,0,896,5130,1,0,0,0,898,5134,1,0,0,0,900,5136, + 1,0,0,0,902,5168,1,0,0,0,904,5180,1,0,0,0,906,5190,1,0,0,0,908,5208, + 1,0,0,0,910,5215,1,0,0,0,912,5223,1,0,0,0,914,5232,1,0,0,0,916,5235, + 1,0,0,0,918,5241,1,0,0,0,920,5250,1,0,0,0,922,5253,1,0,0,0,924,5259, + 1,0,0,0,926,5271,1,0,0,0,928,5285,1,0,0,0,930,5320,1,0,0,0,932,5325, + 1,0,0,0,934,5345,1,0,0,0,936,5355,1,0,0,0,938,5357,1,0,0,0,940,5366, + 1,0,0,0,942,5371,1,0,0,0,944,5375,1,0,0,0,946,5380,1,0,0,0,948,5396, + 1,0,0,0,950,5407,1,0,0,0,952,5419,1,0,0,0,954,5426,1,0,0,0,956,5428, + 1,0,0,0,958,5434,1,0,0,0,960,5436,1,0,0,0,962,5440,1,0,0,0,964,5444, + 1,0,0,0,966,5447,1,0,0,0,968,5465,1,0,0,0,970,5475,1,0,0,0,972,5486, + 1,0,0,0,974,5494,1,0,0,0,976,5500,1,0,0,0,978,5507,1,0,0,0,980,5513, + 1,0,0,0,982,5520,1,0,0,0,984,5525,1,0,0,0,986,5531,1,0,0,0,988,5537, + 1,0,0,0,990,5559,1,0,0,0,992,5562,1,0,0,0,994,5585,1,0,0,0,996,5587, + 1,0,0,0,998,5610,1,0,0,0,1000,5615,1,0,0,0,1002,5624,1,0,0,0,1004, + 5628,1,0,0,0,1006,5633,1,0,0,0,1008,5636,1,0,0,0,1010,5645,1,0,0, + 0,1012,5657,1,0,0,0,1014,5666,1,0,0,0,1016,5677,1,0,0,0,1018,5687, + 1,0,0,0,1020,5699,1,0,0,0,1022,5708,1,0,0,0,1024,5720,1,0,0,0,1026, + 5730,1,0,0,0,1028,5743,1,0,0,0,1030,5752,1,0,0,0,1032,5763,1,0,0, + 0,1034,5770,1,0,0,0,1036,5773,1,0,0,0,1038,5780,1,0,0,0,1040,5784, + 1,0,0,0,1042,5793,1,0,0,0,1044,5802,1,0,0,0,1046,5804,1,0,0,0,1048, + 5811,1,0,0,0,1050,5821,1,0,0,0,1052,5832,1,0,0,0,1054,5834,1,0,0, + 0,1056,5850,1,0,0,0,1058,5874,1,0,0,0,1060,5890,1,0,0,0,1062,5892, + 1,0,0,0,1064,5901,1,0,0,0,1066,5905,1,0,0,0,1068,5911,1,0,0,0,1070, + 5919,1,0,0,0,1072,5965,1,0,0,0,1074,5982,1,0,0,0,1076,5984,1,0,0, + 0,1078,6006,1,0,0,0,1080,6029,1,0,0,0,1082,6037,1,0,0,0,1084,6039, + 1,0,0,0,1086,6052,1,0,0,0,1088,6065,1,0,0,0,1090,6071,1,0,0,0,1092, + 6075,1,0,0,0,1094,6088,1,0,0,0,1096,6091,1,0,0,0,1098,6094,1,0,0, + 0,1100,6099,1,0,0,0,1102,6101,1,0,0,0,1104,6104,1,0,0,0,1106,6107, + 1,0,0,0,1108,6110,1,0,0,0,1110,6113,1,0,0,0,1112,6116,1,0,0,0,1114, + 6119,1,0,0,0,1116,6121,1,0,0,0,1118,6123,1,0,0,0,1120,6125,1,0,0, + 0,1122,6127,1,0,0,0,1124,6129,1,0,0,0,1126,6131,1,0,0,0,1128,6133, + 1,0,0,0,1130,6138,1,0,0,0,1132,6140,1,0,0,0,1134,6142,1,0,0,0,1136, + 6150,1,0,0,0,1138,6152,1,0,0,0,1140,6154,1,0,0,0,1142,6156,1,0,0, + 0,1144,6158,1,0,0,0,1146,6160,1,0,0,0,1148,6164,1,0,0,0,1150,6171, + 1,0,0,0,1152,6175,1,0,0,0,1154,6177,1,0,0,0,1156,6179,1,0,0,0,1158, + 6181,1,0,0,0,1160,6183,1,0,0,0,1162,6187,1,0,0,0,1164,6189,1,0,0, + 0,1166,6191,1,0,0,0,1168,6193,1,0,0,0,1170,6195,1,0,0,0,1172,6203, + 1,0,0,0,1174,6205,1,0,0,0,1176,6210,1,0,0,0,1178,6212,1,0,0,0,1180, + 6214,1,0,0,0,1182,6222,1,0,0,0,1184,6245,1,0,0,0,1186,6280,1,0,0, + 0,1188,6283,1,0,0,0,1190,1191,3,2,1,0,1191,1192,5,0,0,1,1192,1,1, + 0,0,0,1193,1195,3,4,2,0,1194,1193,1,0,0,0,1195,1196,1,0,0,0,1196, + 1194,1,0,0,0,1196,1197,1,0,0,0,1197,3,1,0,0,0,1198,1200,3,8,4,0, + 1199,1201,3,26,13,0,1200,1199,1,0,0,0,1200,1201,1,0,0,0,1201,1203, + 1,0,0,0,1202,1204,3,154,77,0,1203,1202,1,0,0,0,1203,1204,1,0,0,0, + 1204,1206,1,0,0,0,1205,1207,3,504,252,0,1206,1205,1,0,0,0,1206,1207, + 1,0,0,0,1207,1211,1,0,0,0,1208,1210,3,4,2,0,1209,1208,1,0,0,0,1210, + 1213,1,0,0,0,1211,1209,1,0,0,0,1211,1212,1,0,0,0,1212,1215,1,0,0, + 0,1213,1211,1,0,0,0,1214,1216,3,6,3,0,1215,1214,1,0,0,0,1215,1216, + 1,0,0,0,1216,5,1,0,0,0,1217,1218,5,158,0,0,1218,1219,5,361,0,0,1219, + 1220,3,1152,576,0,1220,1221,5,534,0,0,1221,7,1,0,0,0,1222,1223,7, + 0,0,0,1223,1224,5,145,0,0,1224,1225,5,534,0,0,1225,1229,3,12,6,0, + 1226,1228,3,10,5,0,1227,1226,1,0,0,0,1228,1231,1,0,0,0,1229,1227, + 1,0,0,0,1229,1230,1,0,0,0,1230,9,1,0,0,0,1231,1229,1,0,0,0,1232, + 1239,3,14,7,0,1233,1239,3,16,8,0,1234,1239,3,18,9,0,1235,1239,3, + 20,10,0,1236,1239,3,22,11,0,1237,1239,3,24,12,0,1238,1232,1,0,0, + 0,1238,1233,1,0,0,0,1238,1234,1,0,0,0,1238,1235,1,0,0,0,1238,1236, + 1,0,0,0,1238,1237,1,0,0,0,1239,11,1,0,0,0,1240,1241,5,362,0,0,1241, + 1242,5,534,0,0,1242,1250,3,1152,576,0,1243,1245,5,254,0,0,1244,1243, + 1,0,0,0,1244,1245,1,0,0,0,1245,1246,1,0,0,0,1246,1248,7,1,0,0,1247, + 1249,5,361,0,0,1248,1247,1,0,0,0,1248,1249,1,0,0,0,1249,1251,1,0, + 0,0,1250,1244,1,0,0,0,1250,1251,1,0,0,0,1251,1253,1,0,0,0,1252,1254, + 5,534,0,0,1253,1252,1,0,0,0,1253,1254,1,0,0,0,1254,1256,1,0,0,0, + 1255,1257,3,1188,594,0,1256,1255,1,0,0,0,1256,1257,1,0,0,0,1257, + 13,1,0,0,0,1258,1259,5,32,0,0,1259,1261,5,534,0,0,1260,1262,3,1188, + 594,0,1261,1260,1,0,0,0,1261,1262,1,0,0,0,1262,15,1,0,0,0,1263,1264, + 5,249,0,0,1264,1266,5,534,0,0,1265,1267,3,1188,594,0,1266,1265,1, + 0,0,0,1266,1267,1,0,0,0,1267,17,1,0,0,0,1268,1269,5,113,0,0,1269, + 1271,5,534,0,0,1270,1272,3,1188,594,0,1271,1270,1,0,0,0,1271,1272, + 1,0,0,0,1272,19,1,0,0,0,1273,1274,5,112,0,0,1274,1276,5,534,0,0, + 1275,1277,3,1188,594,0,1276,1275,1,0,0,0,1276,1277,1,0,0,0,1277, + 21,1,0,0,0,1278,1279,5,421,0,0,1279,1281,5,534,0,0,1280,1282,3,1188, + 594,0,1281,1280,1,0,0,0,1281,1282,1,0,0,0,1282,23,1,0,0,0,1283,1284, + 5,389,0,0,1284,1286,5,534,0,0,1285,1287,3,1188,594,0,1286,1285,1, + 0,0,0,1286,1287,1,0,0,0,1287,25,1,0,0,0,1288,1289,5,184,0,0,1289, + 1290,5,145,0,0,1290,1294,5,534,0,0,1291,1293,3,28,14,0,1292,1291, + 1,0,0,0,1293,1296,1,0,0,0,1294,1292,1,0,0,0,1294,1295,1,0,0,0,1295, + 27,1,0,0,0,1296,1294,1,0,0,0,1297,1301,3,30,15,0,1298,1301,3,54, + 27,0,1299,1301,3,100,50,0,1300,1297,1,0,0,0,1300,1298,1,0,0,0,1300, + 1299,1,0,0,0,1301,29,1,0,0,0,1302,1303,5,93,0,0,1303,1304,5,419, + 0,0,1304,1308,5,534,0,0,1305,1307,3,32,16,0,1306,1305,1,0,0,0,1307, + 1310,1,0,0,0,1308,1306,1,0,0,0,1308,1309,1,0,0,0,1309,31,1,0,0,0, + 1310,1308,1,0,0,0,1311,1315,3,34,17,0,1312,1315,3,36,18,0,1313,1315, + 3,54,27,0,1314,1311,1,0,0,0,1314,1312,1,0,0,0,1314,1313,1,0,0,0, + 1315,33,1,0,0,0,1316,1317,5,449,0,0,1317,1318,5,534,0,0,1318,1324, + 3,1124,562,0,1319,1321,5,514,0,0,1320,1319,1,0,0,0,1320,1321,1,0, + 0,0,1321,1322,1,0,0,0,1322,1323,5,125,0,0,1323,1325,5,297,0,0,1324, + 1320,1,0,0,0,1324,1325,1,0,0,0,1325,1326,1,0,0,0,1326,1327,5,534, + 0,0,1327,35,1,0,0,0,1328,1329,5,320,0,0,1329,1330,5,534,0,0,1330, + 1334,3,1124,562,0,1331,1333,3,38,19,0,1332,1331,1,0,0,0,1333,1336, + 1,0,0,0,1334,1332,1,0,0,0,1334,1335,1,0,0,0,1335,1337,1,0,0,0,1336, + 1334,1,0,0,0,1337,1338,5,534,0,0,1338,37,1,0,0,0,1339,1345,3,40, + 20,0,1340,1345,3,42,21,0,1341,1345,3,44,22,0,1342,1345,3,50,25,0, + 1343,1345,3,52,26,0,1344,1339,1,0,0,0,1344,1340,1,0,0,0,1344,1341, + 1,0,0,0,1344,1342,1,0,0,0,1344,1343,1,0,0,0,1345,39,1,0,0,0,1346, + 1348,5,293,0,0,1347,1349,5,439,0,0,1348,1347,1,0,0,0,1348,1349,1, + 0,0,0,1349,1352,1,0,0,0,1350,1353,3,1178,589,0,1351,1353,3,1170, + 585,0,1352,1350,1,0,0,0,1352,1351,1,0,0,0,1353,1355,1,0,0,0,1354, + 1356,7,2,0,0,1355,1354,1,0,0,0,1355,1356,1,0,0,0,1356,41,1,0,0,0, + 1357,1359,5,141,0,0,1358,1360,5,439,0,0,1359,1358,1,0,0,0,1359,1360, + 1,0,0,0,1360,1362,1,0,0,0,1361,1363,5,254,0,0,1362,1361,1,0,0,0, + 1362,1363,1,0,0,0,1363,1366,1,0,0,0,1364,1367,3,1178,589,0,1365, + 1367,3,1170,585,0,1366,1364,1,0,0,0,1366,1365,1,0,0,0,1367,1369, + 1,0,0,0,1368,1370,7,3,0,0,1369,1368,1,0,0,0,1369,1370,1,0,0,0,1370, + 43,1,0,0,0,1371,1373,5,361,0,0,1372,1371,1,0,0,0,1372,1373,1,0,0, + 0,1373,1375,1,0,0,0,1374,1376,5,72,0,0,1375,1374,1,0,0,0,1375,1376, + 1,0,0,0,1376,1377,1,0,0,0,1377,1379,5,428,0,0,1378,1380,5,254,0, + 0,1379,1378,1,0,0,0,1379,1380,1,0,0,0,1380,1382,1,0,0,0,1381,1383, + 3,1114,557,0,1382,1381,1,0,0,0,1383,1384,1,0,0,0,1384,1382,1,0,0, + 0,1384,1385,1,0,0,0,1385,1387,1,0,0,0,1386,1388,3,46,23,0,1387,1386, + 1,0,0,0,1387,1388,1,0,0,0,1388,1390,1,0,0,0,1389,1391,3,48,24,0, + 1390,1389,1,0,0,0,1390,1391,1,0,0,0,1391,45,1,0,0,0,1392,1394,5, + 212,0,0,1393,1392,1,0,0,0,1393,1394,1,0,0,0,1394,1395,1,0,0,0,1395, + 1397,5,14,0,0,1396,1398,5,254,0,0,1397,1396,1,0,0,0,1397,1398,1, + 0,0,0,1398,1399,1,0,0,0,1399,1400,3,1114,557,0,1400,47,1,0,0,0,1401, + 1403,5,212,0,0,1402,1401,1,0,0,0,1402,1403,1,0,0,0,1403,1404,1,0, + 0,0,1404,1406,5,304,0,0,1405,1407,5,254,0,0,1406,1405,1,0,0,0,1406, + 1407,1,0,0,0,1407,1408,1,0,0,0,1408,1409,3,1114,557,0,1409,49,1, + 0,0,0,1410,1412,5,423,0,0,1411,1413,5,254,0,0,1412,1411,1,0,0,0, + 1412,1413,1,0,0,0,1413,1414,1,0,0,0,1414,1415,3,1178,589,0,1415, + 51,1,0,0,0,1416,1417,5,62,0,0,1417,1418,5,430,0,0,1418,1419,5,534, + 0,0,1419,53,1,0,0,0,1420,1421,5,452,0,0,1421,1429,5,534,0,0,1422, + 1424,3,56,28,0,1423,1422,1,0,0,0,1424,1425,1,0,0,0,1425,1423,1,0, + 0,0,1425,1426,1,0,0,0,1426,1427,1,0,0,0,1427,1428,5,534,0,0,1428, + 1430,1,0,0,0,1429,1423,1,0,0,0,1429,1430,1,0,0,0,1430,55,1,0,0,0, + 1431,1443,3,70,35,0,1432,1443,3,92,46,0,1433,1443,3,58,29,0,1434, + 1443,3,72,36,0,1435,1443,3,80,40,0,1436,1443,3,82,41,0,1437,1443, + 3,96,48,0,1438,1443,3,88,44,0,1439,1443,3,86,43,0,1440,1443,3,84, + 42,0,1441,1443,3,94,47,0,1442,1431,1,0,0,0,1442,1432,1,0,0,0,1442, + 1433,1,0,0,0,1442,1434,1,0,0,0,1442,1435,1,0,0,0,1442,1436,1,0,0, + 0,1442,1437,1,0,0,0,1442,1438,1,0,0,0,1442,1439,1,0,0,0,1442,1440, + 1,0,0,0,1442,1441,1,0,0,0,1443,57,1,0,0,0,1444,1447,3,60,30,0,1445, + 1447,3,68,34,0,1446,1444,1,0,0,0,1446,1445,1,0,0,0,1447,59,1,0,0, + 0,1448,1449,5,10,0,0,1449,1452,3,1114,557,0,1450,1451,5,212,0,0, + 1451,1453,5,14,0,0,1452,1450,1,0,0,0,1452,1453,1,0,0,0,1453,1455, + 1,0,0,0,1454,1456,5,254,0,0,1455,1454,1,0,0,0,1455,1456,1,0,0,0, + 1456,1468,1,0,0,0,1457,1469,5,151,0,0,1458,1469,5,26,0,0,1459,1469, + 5,454,0,0,1460,1469,5,455,0,0,1461,1469,5,306,0,0,1462,1469,3,1170, + 585,0,1463,1465,3,62,31,0,1464,1463,1,0,0,0,1465,1466,1,0,0,0,1466, + 1464,1,0,0,0,1466,1467,1,0,0,0,1467,1469,1,0,0,0,1468,1457,1,0,0, + 0,1468,1458,1,0,0,0,1468,1459,1,0,0,0,1468,1460,1,0,0,0,1468,1461, + 1,0,0,0,1468,1462,1,0,0,0,1468,1464,1,0,0,0,1469,61,1,0,0,0,1470, + 1477,3,1172,586,0,1471,1478,3,64,32,0,1472,1474,3,66,33,0,1473,1472, + 1,0,0,0,1474,1475,1,0,0,0,1475,1473,1,0,0,0,1475,1476,1,0,0,0,1476, + 1478,1,0,0,0,1477,1471,1,0,0,0,1477,1473,1,0,0,0,1477,1478,1,0,0, + 0,1478,63,1,0,0,0,1479,1480,7,4,0,0,1480,1481,3,1172,586,0,1481, + 65,1,0,0,0,1482,1484,5,16,0,0,1483,1485,3,1172,586,0,1484,1483,1, + 0,0,0,1485,1486,1,0,0,0,1486,1484,1,0,0,0,1486,1487,1,0,0,0,1487, + 67,1,0,0,0,1488,1489,5,10,0,0,1489,1491,3,1114,557,0,1490,1492,5, + 212,0,0,1491,1490,1,0,0,0,1491,1492,1,0,0,0,1492,1493,1,0,0,0,1493, + 1495,5,304,0,0,1494,1496,5,254,0,0,1495,1494,1,0,0,0,1495,1496,1, + 0,0,0,1496,1500,1,0,0,0,1497,1501,5,306,0,0,1498,1499,5,55,0,0,1499, + 1501,3,1172,586,0,1500,1497,1,0,0,0,1500,1498,1,0,0,0,1501,69,1, + 0,0,0,1502,1503,5,61,0,0,1503,1505,3,1178,589,0,1504,1506,5,254, + 0,0,1505,1504,1,0,0,0,1505,1506,1,0,0,0,1506,1507,1,0,0,0,1507,1508, + 3,1146,573,0,1508,71,1,0,0,0,1509,1510,5,64,0,0,1510,1515,3,1122, + 561,0,1511,1513,5,212,0,0,1512,1511,1,0,0,0,1512,1513,1,0,0,0,1513, + 1514,1,0,0,0,1514,1516,7,5,0,0,1515,1512,1,0,0,0,1515,1516,1,0,0, + 0,1516,1518,1,0,0,0,1517,1519,5,254,0,0,1518,1517,1,0,0,0,1518,1519, + 1,0,0,0,1519,1521,1,0,0,0,1520,1522,3,74,37,0,1521,1520,1,0,0,0, + 1522,1523,1,0,0,0,1523,1521,1,0,0,0,1523,1524,1,0,0,0,1524,73,1, + 0,0,0,1525,1528,3,76,38,0,1526,1527,7,4,0,0,1527,1529,3,78,39,0, + 1528,1526,1,0,0,0,1528,1529,1,0,0,0,1529,75,1,0,0,0,1530,1533,3, + 1074,537,0,1531,1533,3,1172,586,0,1532,1530,1,0,0,0,1532,1531,1, + 0,0,0,1533,77,1,0,0,0,1534,1537,3,1074,537,0,1535,1537,3,1172,586, + 0,1536,1534,1,0,0,0,1536,1535,1,0,0,0,1537,79,1,0,0,0,1538,1540, + 5,107,0,0,1539,1541,5,438,0,0,1540,1539,1,0,0,0,1540,1541,1,0,0, + 0,1541,1543,1,0,0,0,1542,1544,5,254,0,0,1543,1542,1,0,0,0,1543,1544, + 1,0,0,0,1544,1545,1,0,0,0,1545,1552,3,1172,586,0,1546,1548,5,514, + 0,0,1547,1546,1,0,0,0,1547,1548,1,0,0,0,1548,1549,1,0,0,0,1549,1550, + 5,347,0,0,1550,1551,5,466,0,0,1551,1553,3,1172,586,0,1552,1547,1, + 0,0,0,1552,1553,1,0,0,0,1553,81,1,0,0,0,1554,1556,5,126,0,0,1555, + 1557,5,254,0,0,1556,1555,1,0,0,0,1556,1557,1,0,0,0,1557,1558,1,0, + 0,0,1558,1559,5,76,0,0,1559,83,1,0,0,0,1560,1562,5,128,0,0,1561, + 1563,7,6,0,0,1562,1561,1,0,0,0,1562,1563,1,0,0,0,1563,1568,1,0,0, + 0,1564,1566,5,438,0,0,1565,1567,5,254,0,0,1566,1565,1,0,0,0,1566, + 1567,1,0,0,0,1567,1569,1,0,0,0,1568,1564,1,0,0,0,1568,1569,1,0,0, + 0,1569,1571,1,0,0,0,1570,1572,7,7,0,0,1571,1570,1,0,0,0,1571,1572, + 1,0,0,0,1572,1573,1,0,0,0,1573,1575,5,427,0,0,1574,1576,5,62,0,0, + 1575,1574,1,0,0,0,1575,1576,1,0,0,0,1576,85,1,0,0,0,1577,1582,5, + 129,0,0,1578,1580,5,438,0,0,1579,1581,5,254,0,0,1580,1579,1,0,0, + 0,1580,1581,1,0,0,0,1581,1583,1,0,0,0,1582,1578,1,0,0,0,1582,1583, + 1,0,0,0,1583,1584,1,0,0,0,1584,1589,7,7,0,0,1585,1587,5,427,0,0, + 1586,1588,5,62,0,0,1587,1586,1,0,0,0,1587,1588,1,0,0,0,1588,1590, + 1,0,0,0,1589,1585,1,0,0,0,1589,1590,1,0,0,0,1590,87,1,0,0,0,1591, + 1593,3,1132,566,0,1592,1594,5,254,0,0,1593,1592,1,0,0,0,1593,1594, + 1,0,0,0,1594,1595,1,0,0,0,1595,1597,3,1146,573,0,1596,1598,3,90, + 45,0,1597,1596,1,0,0,0,1597,1598,1,0,0,0,1598,1601,1,0,0,0,1599, + 1601,3,90,45,0,1600,1591,1,0,0,0,1600,1599,1,0,0,0,1601,89,1,0,0, + 0,1602,1604,5,326,0,0,1603,1605,5,457,0,0,1604,1603,1,0,0,0,1604, + 1605,1,0,0,0,1605,1607,1,0,0,0,1606,1608,5,254,0,0,1607,1606,1,0, + 0,0,1607,1608,1,0,0,0,1608,1609,1,0,0,0,1609,1618,3,1046,523,0,1610, + 1612,5,324,0,0,1611,1613,5,457,0,0,1612,1611,1,0,0,0,1612,1613,1, + 0,0,0,1613,1615,1,0,0,0,1614,1616,5,254,0,0,1615,1614,1,0,0,0,1615, + 1616,1,0,0,0,1616,1617,1,0,0,0,1617,1619,3,1046,523,0,1618,1610, + 1,0,0,0,1618,1619,1,0,0,0,1619,1639,1,0,0,0,1620,1622,5,324,0,0, + 1621,1623,5,457,0,0,1622,1621,1,0,0,0,1622,1623,1,0,0,0,1623,1625, + 1,0,0,0,1624,1626,5,254,0,0,1625,1624,1,0,0,0,1625,1626,1,0,0,0, + 1626,1627,1,0,0,0,1627,1636,3,1046,523,0,1628,1630,5,326,0,0,1629, + 1631,5,457,0,0,1630,1629,1,0,0,0,1630,1631,1,0,0,0,1631,1633,1,0, + 0,0,1632,1634,5,254,0,0,1633,1632,1,0,0,0,1633,1634,1,0,0,0,1634, + 1635,1,0,0,0,1635,1637,3,1046,523,0,1636,1628,1,0,0,0,1636,1637, + 1,0,0,0,1637,1639,1,0,0,0,1638,1602,1,0,0,0,1638,1620,1,0,0,0,1639, + 91,1,0,0,0,1640,1642,5,322,0,0,1641,1643,5,254,0,0,1642,1641,1,0, + 0,0,1642,1643,1,0,0,0,1643,1644,1,0,0,0,1644,1645,3,1146,573,0,1645, + 93,1,0,0,0,1646,1648,5,400,0,0,1647,1649,5,515,0,0,1648,1647,1,0, + 0,0,1648,1649,1,0,0,0,1649,1651,1,0,0,0,1650,1652,5,283,0,0,1651, + 1650,1,0,0,0,1651,1652,1,0,0,0,1652,1654,1,0,0,0,1653,1655,5,254, + 0,0,1654,1653,1,0,0,0,1654,1655,1,0,0,0,1655,1656,1,0,0,0,1656,1658, + 5,308,0,0,1657,1659,5,54,0,0,1658,1657,1,0,0,0,1658,1659,1,0,0,0, + 1659,95,1,0,0,0,1660,1662,5,467,0,0,1661,1663,5,63,0,0,1662,1661, + 1,0,0,0,1662,1663,1,0,0,0,1663,1668,1,0,0,0,1664,1666,5,212,0,0, + 1665,1664,1,0,0,0,1665,1666,1,0,0,0,1666,1667,1,0,0,0,1667,1669, + 7,5,0,0,1668,1665,1,0,0,0,1668,1669,1,0,0,0,1669,1671,1,0,0,0,1670, + 1672,3,98,49,0,1671,1670,1,0,0,0,1672,1673,1,0,0,0,1673,1671,1,0, + 0,0,1673,1674,1,0,0,0,1674,1677,1,0,0,0,1675,1676,5,239,0,0,1676, + 1678,3,1114,557,0,1677,1675,1,0,0,0,1677,1678,1,0,0,0,1678,97,1, + 0,0,0,1679,1681,3,1166,583,0,1680,1679,1,0,0,0,1681,1682,1,0,0,0, + 1682,1680,1,0,0,0,1682,1683,1,0,0,0,1683,1685,1,0,0,0,1684,1686, + 7,8,0,0,1685,1684,1,0,0,0,1685,1686,1,0,0,0,1686,1688,1,0,0,0,1687, + 1689,3,1178,589,0,1688,1687,1,0,0,0,1689,1690,1,0,0,0,1690,1688, + 1,0,0,0,1690,1691,1,0,0,0,1691,99,1,0,0,0,1692,1693,5,247,0,0,1693, + 1694,5,419,0,0,1694,1698,5,534,0,0,1695,1697,3,102,51,0,1696,1695, + 1,0,0,0,1697,1700,1,0,0,0,1698,1696,1,0,0,0,1698,1699,1,0,0,0,1699, + 101,1,0,0,0,1700,1698,1,0,0,0,1701,1704,3,104,52,0,1702,1704,3,134, + 67,0,1703,1701,1,0,0,0,1703,1702,1,0,0,0,1704,103,1,0,0,0,1705,1712, + 5,207,0,0,1706,1708,5,534,0,0,1707,1706,1,0,0,0,1707,1708,1,0,0, + 0,1708,1709,1,0,0,0,1709,1711,3,106,53,0,1710,1707,1,0,0,0,1711, + 1714,1,0,0,0,1712,1710,1,0,0,0,1712,1713,1,0,0,0,1713,1715,1,0,0, + 0,1714,1712,1,0,0,0,1715,1716,5,534,0,0,1716,105,1,0,0,0,1717,1721, + 3,108,54,0,1718,1720,3,110,55,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,107,1,0,0,0,1723,1721, + 1,0,0,0,1724,1726,5,424,0,0,1725,1727,5,328,0,0,1726,1725,1,0,0, + 0,1726,1727,1,0,0,0,1727,1728,1,0,0,0,1728,1729,3,1134,567,0,1729, + 109,1,0,0,0,1730,1742,3,112,56,0,1731,1742,3,114,57,0,1732,1742, + 3,116,58,0,1733,1742,3,118,59,0,1734,1742,3,120,60,0,1735,1742,3, + 122,61,0,1736,1742,3,124,62,0,1737,1742,3,126,63,0,1738,1742,3,130, + 65,0,1739,1742,3,128,64,0,1740,1742,3,132,66,0,1741,1730,1,0,0,0, + 1741,1731,1,0,0,0,1741,1732,1,0,0,0,1741,1733,1,0,0,0,1741,1734, + 1,0,0,0,1741,1735,1,0,0,0,1741,1736,1,0,0,0,1741,1737,1,0,0,0,1741, + 1738,1,0,0,0,1741,1739,1,0,0,0,1741,1740,1,0,0,0,1742,111,1,0,0, + 0,1743,1745,5,27,0,0,1744,1746,5,489,0,0,1745,1744,1,0,0,0,1745, + 1746,1,0,0,0,1746,1758,1,0,0,0,1747,1759,5,141,0,0,1748,1759,5,142, + 0,0,1749,1759,5,260,0,0,1750,1759,5,352,0,0,1751,1759,5,353,0,0, + 1752,1759,5,370,0,0,1753,1759,5,371,0,0,1754,1759,5,474,0,0,1755, + 1759,5,510,0,0,1756,1759,3,1116,558,0,1757,1759,3,1172,586,0,1758, + 1747,1,0,0,0,1758,1748,1,0,0,0,1758,1749,1,0,0,0,1758,1750,1,0,0, + 0,1758,1751,1,0,0,0,1758,1752,1,0,0,0,1758,1753,1,0,0,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, + 113,1,0,0,0,1760,1763,5,400,0,0,1761,1764,5,310,0,0,1762,1764,3, + 1178,589,0,1763,1761,1,0,0,0,1763,1762,1,0,0,0,1764,1766,1,0,0,0, + 1765,1767,5,18,0,0,1766,1765,1,0,0,0,1766,1767,1,0,0,0,1767,1769, + 1,0,0,0,1768,1770,7,9,0,0,1769,1768,1,0,0,0,1769,1770,1,0,0,0,1770, + 115,1,0,0,0,1771,1773,5,332,0,0,1772,1774,5,254,0,0,1773,1772,1, + 0,0,0,1773,1774,1,0,0,0,1774,1776,1,0,0,0,1775,1771,1,0,0,0,1775, + 1776,1,0,0,0,1776,1782,1,0,0,0,1777,1783,5,279,0,0,1778,1779,5,377, + 0,0,1779,1783,5,42,0,0,1780,1783,5,377,0,0,1781,1783,5,42,0,0,1782, + 1777,1,0,0,0,1782,1778,1,0,0,0,1782,1780,1,0,0,0,1782,1781,1,0,0, + 0,1782,1783,1,0,0,0,1783,1784,1,0,0,0,1784,1785,7,10,0,0,1785,117, + 1,0,0,0,1786,1788,5,339,0,0,1787,1789,5,62,0,0,1788,1787,1,0,0,0, + 1788,1789,1,0,0,0,1789,1791,1,0,0,0,1790,1792,5,254,0,0,1791,1790, + 1,0,0,0,1791,1792,1,0,0,0,1792,1795,1,0,0,0,1793,1796,3,1090,545, + 0,1794,1796,3,1172,586,0,1795,1793,1,0,0,0,1795,1794,1,0,0,0,1796, + 119,1,0,0,0,1797,1798,5,377,0,0,1798,1800,5,133,0,0,1799,1801,5, + 254,0,0,1800,1799,1,0,0,0,1800,1801,1,0,0,0,1801,1805,1,0,0,0,1802, + 1806,5,454,0,0,1803,1806,5,237,0,0,1804,1806,3,1116,558,0,1805,1802, + 1,0,0,0,1805,1803,1,0,0,0,1805,1804,1,0,0,0,1806,121,1,0,0,0,1807, + 1809,5,3,0,0,1808,1810,5,297,0,0,1809,1808,1,0,0,0,1809,1810,1,0, + 0,0,1810,1812,1,0,0,0,1811,1813,5,254,0,0,1812,1811,1,0,0,0,1812, + 1813,1,0,0,0,1813,1814,1,0,0,0,1814,1815,7,11,0,0,1815,123,1,0,0, + 0,1816,1818,5,377,0,0,1817,1819,5,259,0,0,1818,1817,1,0,0,0,1818, + 1819,1,0,0,0,1819,1821,1,0,0,0,1820,1822,5,254,0,0,1821,1820,1,0, + 0,0,1821,1822,1,0,0,0,1822,1823,1,0,0,0,1823,1825,3,1090,545,0,1824, + 1826,3,128,64,0,1825,1824,1,0,0,0,1825,1826,1,0,0,0,1826,1831,1, + 0,0,0,1827,1829,5,514,0,0,1828,1827,1,0,0,0,1828,1829,1,0,0,0,1829, + 1830,1,0,0,0,1830,1832,5,149,0,0,1831,1828,1,0,0,0,1831,1832,1,0, + 0,0,1832,125,1,0,0,0,1833,1834,5,18,0,0,1834,1836,5,377,0,0,1835, + 1837,5,259,0,0,1836,1835,1,0,0,0,1836,1837,1,0,0,0,1837,1839,1,0, + 0,0,1838,1840,5,254,0,0,1839,1838,1,0,0,0,1839,1840,1,0,0,0,1840, + 1841,1,0,0,0,1841,1843,3,1090,545,0,1842,1844,3,128,64,0,1843,1842, + 1,0,0,0,1843,1844,1,0,0,0,1844,1849,1,0,0,0,1845,1847,5,514,0,0, + 1846,1845,1,0,0,0,1846,1847,1,0,0,0,1847,1848,1,0,0,0,1848,1850, + 5,149,0,0,1849,1846,1,0,0,0,1849,1850,1,0,0,0,1850,127,1,0,0,0,1851, + 1853,5,342,0,0,1852,1854,5,254,0,0,1853,1852,1,0,0,0,1853,1854,1, + 0,0,0,1854,1855,1,0,0,0,1855,1856,3,1128,564,0,1856,129,1,0,0,0, + 1857,1859,5,206,0,0,1858,1857,1,0,0,0,1858,1859,1,0,0,0,1859,1860, + 1,0,0,0,1860,1862,5,457,0,0,1861,1863,5,254,0,0,1862,1861,1,0,0, + 0,1862,1863,1,0,0,0,1863,1864,1,0,0,0,1864,1866,3,1090,545,0,1865, + 1867,3,1090,545,0,1866,1865,1,0,0,0,1866,1867,1,0,0,0,1867,131,1, + 0,0,0,1868,1870,5,386,0,0,1869,1871,5,259,0,0,1870,1869,1,0,0,0, + 1870,1871,1,0,0,0,1871,1873,1,0,0,0,1872,1874,5,254,0,0,1873,1872, + 1,0,0,0,1873,1874,1,0,0,0,1874,1875,1,0,0,0,1875,1876,3,1090,545, + 0,1876,133,1,0,0,0,1877,1878,5,233,0,0,1878,1882,5,534,0,0,1879, + 1880,3,1134,567,0,1880,1881,5,534,0,0,1881,1883,1,0,0,0,1882,1879, + 1,0,0,0,1882,1883,1,0,0,0,1883,1891,1,0,0,0,1884,1886,3,136,68,0, + 1885,1884,1,0,0,0,1886,1889,1,0,0,0,1887,1885,1,0,0,0,1887,1888, + 1,0,0,0,1888,1890,1,0,0,0,1889,1887,1,0,0,0,1890,1892,5,534,0,0, + 1891,1887,1,0,0,0,1891,1892,1,0,0,0,1892,135,1,0,0,0,1893,1898,3, + 138,69,0,1894,1898,3,146,73,0,1895,1898,3,148,74,0,1896,1898,3,152, + 76,0,1897,1893,1,0,0,0,1897,1894,1,0,0,0,1897,1895,1,0,0,0,1897, + 1896,1,0,0,0,1898,137,1,0,0,0,1899,1905,5,399,0,0,1900,1903,5,326, + 0,0,1901,1904,3,1116,558,0,1902,1904,3,1134,567,0,1903,1901,1,0, + 0,0,1903,1902,1,0,0,0,1904,1906,1,0,0,0,1905,1900,1,0,0,0,1905,1906, + 1,0,0,0,1906,1907,1,0,0,0,1907,1911,5,195,0,0,1908,1912,3,140,70, + 0,1909,1912,3,142,71,0,1910,1912,3,144,72,0,1911,1908,1,0,0,0,1911, + 1909,1,0,0,0,1911,1910,1,0,0,0,1912,139,1,0,0,0,1913,1914,3,1178, + 589,0,1914,1915,5,379,0,0,1915,141,1,0,0,0,1916,1918,5,158,0,0,1917, + 1916,1,0,0,0,1917,1918,1,0,0,0,1918,1920,1,0,0,0,1919,1921,5,323, + 0,0,1920,1919,1,0,0,0,1920,1921,1,0,0,0,1921,1922,1,0,0,0,1922,1923, + 7,12,0,0,1923,1924,5,323,0,0,1924,1925,3,1134,567,0,1925,143,1,0, + 0,0,1926,1928,3,1178,589,0,1927,1929,5,66,0,0,1928,1927,1,0,0,0, + 1928,1929,1,0,0,0,1929,145,1,0,0,0,1930,1932,5,414,0,0,1931,1933, + 7,13,0,0,1932,1931,1,0,0,0,1932,1933,1,0,0,0,1933,1935,1,0,0,0,1934, + 1936,5,22,0,0,1935,1934,1,0,0,0,1935,1936,1,0,0,0,1936,1938,1,0, + 0,0,1937,1939,5,212,0,0,1938,1937,1,0,0,0,1938,1939,1,0,0,0,1939, + 1941,1,0,0,0,1940,1942,3,1134,567,0,1941,1940,1,0,0,0,1942,1943, + 1,0,0,0,1943,1941,1,0,0,0,1943,1944,1,0,0,0,1944,147,1,0,0,0,1945, + 1946,5,301,0,0,1946,1948,5,206,0,0,1947,1949,5,474,0,0,1948,1947, + 1,0,0,0,1948,1949,1,0,0,0,1949,1951,1,0,0,0,1950,1952,5,94,0,0,1951, + 1950,1,0,0,0,1951,1952,1,0,0,0,1952,1954,1,0,0,0,1953,1955,3,150, + 75,0,1954,1953,1,0,0,0,1955,1956,1,0,0,0,1956,1954,1,0,0,0,1956, + 1957,1,0,0,0,1957,149,1,0,0,0,1958,1961,3,1134,567,0,1959,1960,5, + 350,0,0,1960,1962,3,1178,589,0,1961,1959,1,0,0,0,1961,1962,1,0,0, + 0,1962,151,1,0,0,0,1963,1964,5,77,0,0,1964,1966,5,97,0,0,1965,1967, + 5,212,0,0,1966,1965,1,0,0,0,1966,1967,1,0,0,0,1967,1968,1,0,0,0, + 1968,1969,3,1134,567,0,1969,153,1,0,0,0,1970,1971,5,109,0,0,1971, + 1972,5,145,0,0,1972,1976,5,534,0,0,1973,1975,3,156,78,0,1974,1973, + 1,0,0,0,1975,1978,1,0,0,0,1976,1974,1,0,0,0,1976,1977,1,0,0,0,1977, + 155,1,0,0,0,1978,1976,1,0,0,0,1979,1989,3,158,79,0,1980,1989,3,208, + 104,0,1981,1989,3,212,106,0,1982,1989,3,214,107,0,1983,1989,3,216, + 108,0,1984,1989,3,254,127,0,1985,1989,3,256,128,0,1986,1989,3,320, + 160,0,1987,1989,3,396,198,0,1988,1979,1,0,0,0,1988,1980,1,0,0,0, + 1988,1981,1,0,0,0,1988,1982,1,0,0,0,1988,1983,1,0,0,0,1988,1984, + 1,0,0,0,1988,1985,1,0,0,0,1988,1986,1,0,0,0,1988,1987,1,0,0,0,1989, + 157,1,0,0,0,1990,1991,5,206,0,0,1991,1992,5,419,0,0,1992,1996,5, + 534,0,0,1993,1995,3,160,80,0,1994,1993,1,0,0,0,1995,1998,1,0,0,0, + 1996,1994,1,0,0,0,1996,1997,1,0,0,0,1997,159,1,0,0,0,1998,1996,1, + 0,0,0,1999,2000,7,14,0,0,2000,2007,3,1134,567,0,2001,2003,5,534, + 0,0,2002,2001,1,0,0,0,2002,2003,1,0,0,0,2003,2004,1,0,0,0,2004,2006, + 3,162,81,0,2005,2002,1,0,0,0,2006,2009,1,0,0,0,2007,2005,1,0,0,0, + 2007,2008,1,0,0,0,2008,2010,1,0,0,0,2009,2007,1,0,0,0,2010,2014, + 5,534,0,0,2011,2013,3,434,217,0,2012,2011,1,0,0,0,2013,2016,1,0, + 0,0,2014,2012,1,0,0,0,2014,2015,1,0,0,0,2015,161,1,0,0,0,2016,2014, + 1,0,0,0,2017,2029,3,164,82,0,2018,2029,3,166,83,0,2019,2029,3,168, + 84,0,2020,2029,3,172,86,0,2021,2029,3,182,91,0,2022,2029,3,184,92, + 0,2023,2029,3,188,94,0,2024,2029,3,190,95,0,2025,2029,3,204,102, + 0,2026,2029,3,206,103,0,2027,2029,3,200,100,0,2028,2017,1,0,0,0, + 2028,2018,1,0,0,0,2028,2019,1,0,0,0,2028,2020,1,0,0,0,2028,2021, + 1,0,0,0,2028,2022,1,0,0,0,2028,2023,1,0,0,0,2028,2024,1,0,0,0,2028, + 2025,1,0,0,0,2028,2026,1,0,0,0,2028,2027,1,0,0,0,2029,163,1,0,0, + 0,2030,2032,5,254,0,0,2031,2030,1,0,0,0,2031,2032,1,0,0,0,2032,2033, + 1,0,0,0,2033,2034,5,203,0,0,2034,165,1,0,0,0,2035,2037,5,254,0,0, + 2036,2035,1,0,0,0,2036,2037,1,0,0,0,2037,2038,1,0,0,0,2038,2039, + 5,223,0,0,2039,167,1,0,0,0,2040,2042,5,46,0,0,2041,2043,5,94,0,0, + 2042,2041,1,0,0,0,2042,2043,1,0,0,0,2043,2044,1,0,0,0,2044,2046, + 3,1178,589,0,2045,2047,3,170,85,0,2046,2045,1,0,0,0,2046,2047,1, + 0,0,0,2047,2049,1,0,0,0,2048,2050,7,15,0,0,2049,2048,1,0,0,0,2049, + 2050,1,0,0,0,2050,169,1,0,0,0,2051,2052,5,489,0,0,2052,2053,3,1178, + 589,0,2053,171,1,0,0,0,2054,2058,5,377,0,0,2055,2059,3,174,87,0, + 2056,2059,3,176,88,0,2057,2059,3,178,89,0,2058,2055,1,0,0,0,2058, + 2056,1,0,0,0,2058,2057,1,0,0,0,2059,173,1,0,0,0,2060,2062,5,94,0, + 0,2061,2060,1,0,0,0,2061,2062,1,0,0,0,2062,2063,1,0,0,0,2063,2065, + 3,1178,589,0,2064,2066,5,63,0,0,2065,2064,1,0,0,0,2065,2066,1,0, + 0,0,2066,175,1,0,0,0,2067,2069,5,254,0,0,2068,2067,1,0,0,0,2068, + 2069,1,0,0,0,2069,2070,1,0,0,0,2070,2072,5,509,0,0,2071,2073,5,239, + 0,0,2072,2071,1,0,0,0,2072,2073,1,0,0,0,2073,2075,1,0,0,0,2074,2076, + 5,439,0,0,2075,2074,1,0,0,0,2075,2076,1,0,0,0,2076,2087,1,0,0,0, + 2077,2079,5,215,0,0,2078,2077,1,0,0,0,2078,2079,1,0,0,0,2079,2080, + 1,0,0,0,2080,2082,3,1178,589,0,2081,2083,3,180,90,0,2082,2081,1, + 0,0,0,2082,2083,1,0,0,0,2083,2085,1,0,0,0,2084,2086,5,63,0,0,2085, + 2084,1,0,0,0,2085,2086,1,0,0,0,2086,2088,1,0,0,0,2087,2078,1,0,0, + 0,2087,2088,1,0,0,0,2088,2094,1,0,0,0,2089,2091,5,134,0,0,2090,2092, + 5,326,0,0,2091,2090,1,0,0,0,2091,2092,1,0,0,0,2092,2093,1,0,0,0, + 2093,2095,3,1090,545,0,2094,2089,1,0,0,0,2094,2095,1,0,0,0,2095, + 177,1,0,0,0,2096,2098,5,94,0,0,2097,2096,1,0,0,0,2097,2098,1,0,0, + 0,2098,2099,1,0,0,0,2099,2100,3,1178,589,0,2100,2102,3,180,90,0, + 2101,2103,5,63,0,0,2102,2101,1,0,0,0,2102,2103,1,0,0,0,2103,179, + 1,0,0,0,2104,2105,5,489,0,0,2105,2106,3,1178,589,0,2106,181,1,0, + 0,0,2107,2116,5,261,0,0,2108,2110,5,377,0,0,2109,2111,5,254,0,0, + 2110,2109,1,0,0,0,2110,2111,1,0,0,0,2111,2117,1,0,0,0,2112,2114, + 5,379,0,0,2113,2115,5,21,0,0,2114,2113,1,0,0,0,2114,2115,1,0,0,0, + 2115,2117,1,0,0,0,2116,2108,1,0,0,0,2116,2112,1,0,0,0,2117,2125, + 1,0,0,0,2118,2126,5,325,0,0,2119,2126,5,453,0,0,2120,2122,3,1128, + 564,0,2121,2120,1,0,0,0,2122,2123,1,0,0,0,2123,2121,1,0,0,0,2123, + 2124,1,0,0,0,2124,2126,1,0,0,0,2125,2118,1,0,0,0,2125,2119,1,0,0, + 0,2125,2121,1,0,0,0,2126,183,1,0,0,0,2127,2128,5,507,0,0,2128,2130, + 5,323,0,0,2129,2131,3,186,93,0,2130,2129,1,0,0,0,2131,2132,1,0,0, + 0,2132,2130,1,0,0,0,2132,2133,1,0,0,0,2133,185,1,0,0,0,2134,2136, + 3,1164,582,0,2135,2137,5,254,0,0,2136,2135,1,0,0,0,2136,2137,1,0, + 0,0,2137,2140,1,0,0,0,2138,2141,3,1090,545,0,2139,2141,3,1172,586, + 0,2140,2138,1,0,0,0,2140,2139,1,0,0,0,2141,187,1,0,0,0,2142,2151, + 5,109,0,0,2143,2145,5,377,0,0,2144,2146,5,254,0,0,2145,2144,1,0, + 0,0,2145,2146,1,0,0,0,2146,2152,1,0,0,0,2147,2149,5,379,0,0,2148, + 2150,5,21,0,0,2149,2148,1,0,0,0,2149,2150,1,0,0,0,2150,2152,1,0, + 0,0,2151,2143,1,0,0,0,2151,2147,1,0,0,0,2152,2154,1,0,0,0,2153,2155, + 3,1128,564,0,2154,2153,1,0,0,0,2155,2156,1,0,0,0,2156,2154,1,0,0, + 0,2156,2157,1,0,0,0,2157,189,1,0,0,0,2158,2160,5,277,0,0,2159,2161, + 5,254,0,0,2160,2159,1,0,0,0,2160,2161,1,0,0,0,2161,2164,1,0,0,0, + 2162,2165,3,1128,564,0,2163,2165,3,1178,589,0,2164,2162,1,0,0,0, + 2164,2163,1,0,0,0,2165,2167,1,0,0,0,2166,2168,5,280,0,0,2167,2166, + 1,0,0,0,2167,2168,1,0,0,0,2168,2172,1,0,0,0,2169,2171,3,192,96,0, + 2170,2169,1,0,0,0,2171,2174,1,0,0,0,2172,2170,1,0,0,0,2172,2173, + 1,0,0,0,2173,191,1,0,0,0,2174,2172,1,0,0,0,2175,2179,3,194,97,0, + 2176,2179,3,196,98,0,2177,2179,3,198,99,0,2178,2175,1,0,0,0,2178, + 2176,1,0,0,0,2178,2177,1,0,0,0,2179,193,1,0,0,0,2180,2182,5,514, + 0,0,2181,2180,1,0,0,0,2181,2182,1,0,0,0,2182,2183,1,0,0,0,2183,2185, + 5,211,0,0,2184,2186,5,30,0,0,2185,2184,1,0,0,0,2185,2186,1,0,0,0, + 2186,2189,1,0,0,0,2187,2190,3,1128,564,0,2188,2190,3,1178,589,0, + 2189,2187,1,0,0,0,2189,2188,1,0,0,0,2190,195,1,0,0,0,2191,2193,5, + 280,0,0,2192,2191,1,0,0,0,2192,2193,1,0,0,0,2193,2195,1,0,0,0,2194, + 2196,5,30,0,0,2195,2194,1,0,0,0,2195,2196,1,0,0,0,2196,2197,1,0, + 0,0,2197,2200,5,492,0,0,2198,2201,3,1128,564,0,2199,2201,3,1178, + 589,0,2200,2198,1,0,0,0,2200,2199,1,0,0,0,2201,197,1,0,0,0,2202, + 2204,5,280,0,0,2203,2202,1,0,0,0,2203,2204,1,0,0,0,2204,2206,1,0, + 0,0,2205,2207,5,30,0,0,2206,2205,1,0,0,0,2206,2207,1,0,0,0,2207, + 2208,1,0,0,0,2208,2211,5,48,0,0,2209,2212,3,1128,564,0,2210,2212, + 3,1178,589,0,2211,2209,1,0,0,0,2211,2210,1,0,0,0,2212,199,1,0,0, + 0,2213,2215,5,378,0,0,2214,2216,5,297,0,0,2215,2214,1,0,0,0,2215, + 2216,1,0,0,0,2216,2218,1,0,0,0,2217,2219,5,254,0,0,2218,2217,1,0, + 0,0,2218,2219,1,0,0,0,2219,2220,1,0,0,0,2220,2221,3,202,101,0,2221, + 201,1,0,0,0,2222,2223,3,1170,585,0,2223,203,1,0,0,0,2224,2226,5, + 71,0,0,2225,2227,5,254,0,0,2226,2225,1,0,0,0,2226,2227,1,0,0,0,2227, + 2228,1,0,0,0,2228,2229,3,1114,557,0,2229,205,1,0,0,0,2230,2232,5, + 395,0,0,2231,2233,5,254,0,0,2232,2231,1,0,0,0,2232,2233,1,0,0,0, + 2233,2239,1,0,0,0,2234,2236,5,397,0,0,2235,2237,5,21,0,0,2236,2235, + 1,0,0,0,2236,2237,1,0,0,0,2237,2239,1,0,0,0,2238,2230,1,0,0,0,2238, + 2234,1,0,0,0,2239,2241,1,0,0,0,2240,2242,3,1156,578,0,2241,2240, + 1,0,0,0,2242,2243,1,0,0,0,2243,2241,1,0,0,0,2243,2244,1,0,0,0,2244, + 207,1,0,0,0,2245,2246,5,110,0,0,2246,2247,5,419,0,0,2247,2251,5, + 534,0,0,2248,2250,3,210,105,0,2249,2248,1,0,0,0,2250,2253,1,0,0, + 0,2251,2249,1,0,0,0,2251,2252,1,0,0,0,2252,209,1,0,0,0,2253,2251, + 1,0,0,0,2254,2255,3,1178,589,0,2255,2256,3,1172,586,0,2256,2257, + 5,253,0,0,2257,2258,3,1172,586,0,2258,211,1,0,0,0,2259,2260,5,516, + 0,0,2260,2261,5,419,0,0,2261,2265,5,534,0,0,2262,2264,3,434,217, + 0,2263,2262,1,0,0,0,2264,2267,1,0,0,0,2265,2263,1,0,0,0,2265,2266, + 1,0,0,0,2266,213,1,0,0,0,2267,2265,1,0,0,0,2268,2269,5,282,0,0,2269, + 2270,5,419,0,0,2270,2274,5,534,0,0,2271,2273,3,434,217,0,2272,2271, + 1,0,0,0,2273,2276,1,0,0,0,2274,2272,1,0,0,0,2274,2275,1,0,0,0,2275, + 215,1,0,0,0,2276,2274,1,0,0,0,2277,2278,5,79,0,0,2278,2279,5,419, + 0,0,2279,2284,5,534,0,0,2280,2283,3,218,109,0,2281,2283,3,434,217, + 0,2282,2280,1,0,0,0,2282,2281,1,0,0,0,2283,2286,1,0,0,0,2284,2282, + 1,0,0,0,2284,2285,1,0,0,0,2285,217,1,0,0,0,2286,2284,1,0,0,0,2287, + 2291,3,220,110,0,2288,2291,3,222,111,0,2289,2291,3,224,112,0,2290, + 2287,1,0,0,0,2290,2288,1,0,0,0,2290,2289,1,0,0,0,2291,219,1,0,0, + 0,2292,2293,5,56,0,0,2293,2295,3,1120,560,0,2294,2296,5,212,0,0, + 2295,2294,1,0,0,0,2295,2296,1,0,0,0,2296,2298,1,0,0,0,2297,2299, + 5,243,0,0,2298,2297,1,0,0,0,2298,2299,1,0,0,0,2299,2300,1,0,0,0, + 2300,2315,5,246,0,0,2301,2311,3,244,122,0,2302,2311,3,250,125,0, + 2303,2311,3,236,118,0,2304,2311,3,238,119,0,2305,2311,3,246,123, + 0,2306,2311,3,252,126,0,2307,2311,3,230,115,0,2308,2311,3,240,120, + 0,2309,2311,3,234,117,0,2310,2301,1,0,0,0,2310,2302,1,0,0,0,2310, + 2303,1,0,0,0,2310,2304,1,0,0,0,2310,2305,1,0,0,0,2310,2306,1,0,0, + 0,2310,2307,1,0,0,0,2310,2308,1,0,0,0,2310,2309,1,0,0,0,2311,2314, + 1,0,0,0,2312,2314,3,1130,565,0,2313,2310,1,0,0,0,2313,2312,1,0,0, + 0,2314,2317,1,0,0,0,2315,2313,1,0,0,0,2315,2316,1,0,0,0,2316,2318, + 1,0,0,0,2317,2315,1,0,0,0,2318,2319,5,534,0,0,2319,221,1,0,0,0,2320, + 2321,5,56,0,0,2321,2323,3,1120,560,0,2322,2324,5,212,0,0,2323,2322, + 1,0,0,0,2323,2324,1,0,0,0,2324,2325,1,0,0,0,2325,2334,5,334,0,0, + 2326,2333,3,226,113,0,2327,2333,3,252,126,0,2328,2333,3,240,120, + 0,2329,2333,3,228,114,0,2330,2333,3,232,116,0,2331,2333,3,242,121, + 0,2332,2326,1,0,0,0,2332,2327,1,0,0,0,2332,2328,1,0,0,0,2332,2329, + 1,0,0,0,2332,2330,1,0,0,0,2332,2331,1,0,0,0,2333,2336,1,0,0,0,2334, + 2332,1,0,0,0,2334,2335,1,0,0,0,2335,2337,1,0,0,0,2336,2334,1,0,0, + 0,2337,2338,5,534,0,0,2338,223,1,0,0,0,2339,2340,5,56,0,0,2340,2342, + 3,1120,560,0,2341,2343,5,212,0,0,2342,2341,1,0,0,0,2342,2343,1,0, + 0,0,2343,2344,1,0,0,0,2344,2345,5,243,0,0,2345,2357,5,232,0,0,2346, + 2353,3,236,118,0,2347,2353,3,238,119,0,2348,2353,3,248,124,0,2349, + 2353,3,252,126,0,2350,2353,3,230,115,0,2351,2353,3,240,120,0,2352, + 2346,1,0,0,0,2352,2347,1,0,0,0,2352,2348,1,0,0,0,2352,2349,1,0,0, + 0,2352,2350,1,0,0,0,2352,2351,1,0,0,0,2353,2356,1,0,0,0,2354,2356, + 3,1130,565,0,2355,2352,1,0,0,0,2355,2354,1,0,0,0,2356,2359,1,0,0, + 0,2357,2355,1,0,0,0,2357,2358,1,0,0,0,2358,2360,1,0,0,0,2359,2357, + 1,0,0,0,2360,2361,5,534,0,0,2361,225,1,0,0,0,2362,2363,5,136,0,0, + 2363,2365,5,105,0,0,2364,2366,5,254,0,0,2365,2364,1,0,0,0,2365,2366, + 1,0,0,0,2366,2367,1,0,0,0,2367,2368,3,1130,565,0,2368,227,1,0,0, + 0,2369,2370,5,136,0,0,2370,2371,5,470,0,0,2371,2372,5,321,0,0,2372, + 2373,3,1178,589,0,2373,2381,5,487,0,0,2374,2375,5,241,0,0,2375,2377, + 5,49,0,0,2376,2378,3,1138,569,0,2377,2376,1,0,0,0,2378,2379,1,0, + 0,0,2379,2377,1,0,0,0,2379,2380,1,0,0,0,2380,2382,1,0,0,0,2381,2374, + 1,0,0,0,2381,2382,1,0,0,0,2382,229,1,0,0,0,2383,2384,5,158,0,0,2384, + 2386,5,259,0,0,2385,2387,5,254,0,0,2386,2385,1,0,0,0,2386,2387,1, + 0,0,0,2387,2388,1,0,0,0,2388,2389,3,1130,565,0,2389,231,1,0,0,0, + 2390,2391,5,188,0,0,2391,2393,5,259,0,0,2392,2394,5,254,0,0,2393, + 2392,1,0,0,0,2393,2394,1,0,0,0,2394,2395,1,0,0,0,2395,2396,3,1130, + 565,0,2396,233,1,0,0,0,2397,2399,5,295,0,0,2398,2397,1,0,0,0,2398, + 2399,1,0,0,0,2399,2400,1,0,0,0,2400,2402,5,105,0,0,2401,2403,5,254, + 0,0,2402,2401,1,0,0,0,2402,2403,1,0,0,0,2403,2404,1,0,0,0,2404,2405, + 3,1130,565,0,2405,235,1,0,0,0,2406,2407,5,295,0,0,2407,2409,5,111, + 0,0,2408,2410,5,254,0,0,2409,2408,1,0,0,0,2409,2410,1,0,0,0,2410, + 2411,1,0,0,0,2411,2412,3,1130,565,0,2412,237,1,0,0,0,2413,2414,5, + 295,0,0,2414,2416,5,485,0,0,2415,2417,5,254,0,0,2416,2415,1,0,0, + 0,2416,2417,1,0,0,0,2417,2418,1,0,0,0,2418,2419,3,1130,565,0,2419, + 239,1,0,0,0,2420,2421,5,457,0,0,2421,2423,5,259,0,0,2422,2424,5, + 254,0,0,2423,2422,1,0,0,0,2423,2424,1,0,0,0,2424,2425,1,0,0,0,2425, + 2426,3,1130,565,0,2426,241,1,0,0,0,2427,2429,5,467,0,0,2428,2427, + 1,0,0,0,2428,2429,1,0,0,0,2429,2430,1,0,0,0,2430,2432,5,136,0,0, + 2431,2433,5,254,0,0,2432,2431,1,0,0,0,2432,2433,1,0,0,0,2433,2434, + 1,0,0,0,2434,2435,3,1130,565,0,2435,243,1,0,0,0,2436,2438,5,467, + 0,0,2437,2436,1,0,0,0,2437,2438,1,0,0,0,2438,2439,1,0,0,0,2439,2441, + 5,366,0,0,2440,2442,5,254,0,0,2441,2440,1,0,0,0,2441,2442,1,0,0, + 0,2442,2443,1,0,0,0,2443,2444,3,1130,565,0,2444,245,1,0,0,0,2445, + 2447,5,467,0,0,2446,2445,1,0,0,0,2446,2447,1,0,0,0,2447,2448,1,0, + 0,0,2448,2450,5,448,0,0,2449,2451,5,254,0,0,2450,2449,1,0,0,0,2450, + 2451,1,0,0,0,2451,2452,1,0,0,0,2452,2453,3,1130,565,0,2453,247,1, + 0,0,0,2454,2456,5,467,0,0,2455,2454,1,0,0,0,2455,2456,1,0,0,0,2456, + 2457,1,0,0,0,2457,2459,5,475,0,0,2458,2460,5,254,0,0,2459,2458,1, + 0,0,0,2459,2460,1,0,0,0,2460,2461,1,0,0,0,2461,2462,3,1130,565,0, + 2462,249,1,0,0,0,2463,2465,5,467,0,0,2464,2463,1,0,0,0,2464,2465, + 1,0,0,0,2465,2466,1,0,0,0,2466,2468,7,16,0,0,2467,2469,5,254,0,0, + 2468,2467,1,0,0,0,2468,2469,1,0,0,0,2469,2470,1,0,0,0,2470,2471, + 3,1130,565,0,2471,251,1,0,0,0,2472,2473,5,478,0,0,2473,2475,5,269, + 0,0,2474,2476,5,254,0,0,2475,2474,1,0,0,0,2475,2476,1,0,0,0,2476, + 2477,1,0,0,0,2477,2478,3,1130,565,0,2478,253,1,0,0,0,2479,2480,5, + 285,0,0,2480,2481,5,419,0,0,2481,2486,5,534,0,0,2482,2483,5,265, + 0,0,2483,2484,3,1144,572,0,2484,2485,5,534,0,0,2485,2487,1,0,0,0, + 2486,2482,1,0,0,0,2486,2487,1,0,0,0,2487,2491,1,0,0,0,2488,2490, + 3,434,217,0,2489,2488,1,0,0,0,2490,2493,1,0,0,0,2491,2489,1,0,0, + 0,2491,2492,1,0,0,0,2492,255,1,0,0,0,2493,2491,1,0,0,0,2494,2495, + 5,416,0,0,2495,2496,5,419,0,0,2496,2500,5,534,0,0,2497,2499,3,258, + 129,0,2498,2497,1,0,0,0,2499,2502,1,0,0,0,2500,2498,1,0,0,0,2500, + 2501,1,0,0,0,2501,257,1,0,0,0,2502,2500,1,0,0,0,2503,2506,5,555, + 0,0,2504,2507,5,208,0,0,2505,2507,3,1160,580,0,2506,2504,1,0,0,0, + 2506,2505,1,0,0,0,2506,2507,1,0,0,0,2507,2540,1,0,0,0,2508,2539, + 3,260,130,0,2509,2539,3,262,131,0,2510,2539,3,264,132,0,2511,2539, + 3,266,133,0,2512,2539,3,268,134,0,2513,2539,3,270,135,0,2514,2539, + 3,272,136,0,2515,2539,3,274,137,0,2516,2539,3,276,138,0,2517,2539, + 3,278,139,0,2518,2539,3,280,140,0,2519,2539,3,282,141,0,2520,2539, + 3,284,142,0,2521,2539,3,286,143,0,2522,2539,3,288,144,0,2523,2539, + 3,290,145,0,2524,2527,3,292,146,0,2525,2527,3,296,148,0,2526,2524, + 1,0,0,0,2526,2525,1,0,0,0,2527,2539,1,0,0,0,2528,2539,3,298,149, + 0,2529,2539,3,300,150,0,2530,2539,3,302,151,0,2531,2539,3,304,152, + 0,2532,2539,3,306,153,0,2533,2539,3,308,154,0,2534,2539,3,310,155, + 0,2535,2539,3,312,156,0,2536,2539,3,316,158,0,2537,2539,3,318,159, + 0,2538,2508,1,0,0,0,2538,2509,1,0,0,0,2538,2510,1,0,0,0,2538,2511, + 1,0,0,0,2538,2512,1,0,0,0,2538,2513,1,0,0,0,2538,2514,1,0,0,0,2538, + 2515,1,0,0,0,2538,2516,1,0,0,0,2538,2517,1,0,0,0,2538,2518,1,0,0, + 0,2538,2519,1,0,0,0,2538,2520,1,0,0,0,2538,2521,1,0,0,0,2538,2522, + 1,0,0,0,2538,2523,1,0,0,0,2538,2526,1,0,0,0,2538,2528,1,0,0,0,2538, + 2529,1,0,0,0,2538,2530,1,0,0,0,2538,2531,1,0,0,0,2538,2532,1,0,0, + 0,2538,2533,1,0,0,0,2538,2534,1,0,0,0,2538,2535,1,0,0,0,2538,2536, + 1,0,0,0,2538,2537,1,0,0,0,2539,2542,1,0,0,0,2540,2538,1,0,0,0,2540, + 2541,1,0,0,0,2541,2543,1,0,0,0,2542,2540,1,0,0,0,2543,2544,5,534, + 0,0,2544,259,1,0,0,0,2545,2546,5,44,0,0,2546,2547,7,17,0,0,2547, + 261,1,0,0,0,2548,2549,7,18,0,0,2549,263,1,0,0,0,2550,2551,5,45,0, + 0,2551,265,1,0,0,0,2552,2553,5,187,0,0,2553,2554,7,19,0,0,2554,267, + 1,0,0,0,2555,2556,7,20,0,0,2556,269,1,0,0,0,2557,2558,7,21,0,0,2558, + 271,1,0,0,0,2559,2560,5,401,0,0,2560,273,1,0,0,0,2561,2562,5,498, + 0,0,2562,275,1,0,0,0,2563,2565,5,439,0,0,2564,2566,5,254,0,0,2565, + 2564,1,0,0,0,2565,2566,1,0,0,0,2566,2569,1,0,0,0,2567,2570,3,1074, + 537,0,2568,2570,3,1178,589,0,2569,2567,1,0,0,0,2569,2568,1,0,0,0, + 2570,277,1,0,0,0,2571,2579,5,279,0,0,2572,2574,5,315,0,0,2573,2572, + 1,0,0,0,2573,2574,1,0,0,0,2574,2576,1,0,0,0,2575,2577,5,254,0,0, + 2576,2575,1,0,0,0,2576,2577,1,0,0,0,2577,2578,1,0,0,0,2578,2580, + 7,22,0,0,2579,2573,1,0,0,0,2579,2580,1,0,0,0,2580,2583,1,0,0,0,2581, + 2584,3,1074,537,0,2582,2584,3,1178,589,0,2583,2581,1,0,0,0,2583, + 2582,1,0,0,0,2584,279,1,0,0,0,2585,2593,7,23,0,0,2586,2588,5,315, + 0,0,2587,2586,1,0,0,0,2587,2588,1,0,0,0,2588,2590,1,0,0,0,2589,2591, + 5,254,0,0,2590,2589,1,0,0,0,2590,2591,1,0,0,0,2591,2592,1,0,0,0, + 2592,2594,7,22,0,0,2593,2587,1,0,0,0,2593,2594,1,0,0,0,2594,2597, + 1,0,0,0,2595,2598,3,1074,537,0,2596,2598,3,1178,589,0,2597,2595, + 1,0,0,0,2597,2596,1,0,0,0,2598,281,1,0,0,0,2599,2601,7,24,0,0,2600, + 2602,5,254,0,0,2601,2600,1,0,0,0,2601,2602,1,0,0,0,2602,2605,1,0, + 0,0,2603,2606,3,1074,537,0,2604,2606,3,1178,589,0,2605,2603,1,0, + 0,0,2605,2604,1,0,0,0,2606,283,1,0,0,0,2607,2609,7,25,0,0,2608,2610, + 5,254,0,0,2609,2608,1,0,0,0,2609,2610,1,0,0,0,2610,2613,1,0,0,0, + 2611,2614,3,1074,537,0,2612,2614,3,1178,589,0,2613,2611,1,0,0,0, + 2613,2612,1,0,0,0,2614,285,1,0,0,0,2615,2617,5,97,0,0,2616,2618, + 5,254,0,0,2617,2616,1,0,0,0,2617,2618,1,0,0,0,2618,2619,1,0,0,0, + 2619,2620,3,1074,537,0,2620,287,1,0,0,0,2621,2623,5,507,0,0,2622, + 2624,5,254,0,0,2623,2622,1,0,0,0,2623,2624,1,0,0,0,2624,2625,1,0, + 0,0,2625,2626,3,1172,586,0,2626,289,1,0,0,0,2627,2629,7,26,0,0,2628, + 2630,5,254,0,0,2629,2628,1,0,0,0,2629,2630,1,0,0,0,2630,2631,1,0, + 0,0,2631,2632,3,466,233,0,2632,291,1,0,0,0,2633,2636,5,215,0,0,2634, + 2637,3,1074,537,0,2635,2637,3,1172,586,0,2636,2634,1,0,0,0,2636, + 2635,1,0,0,0,2637,2639,1,0,0,0,2638,2640,3,294,147,0,2639,2638,1, + 0,0,0,2639,2640,1,0,0,0,2640,293,1,0,0,0,2641,2642,5,489,0,0,2642, + 2643,3,1074,537,0,2643,295,1,0,0,0,2644,2645,5,506,0,0,2645,2646, + 3,1074,537,0,2646,297,1,0,0,0,2647,2649,5,504,0,0,2648,2650,5,254, + 0,0,2649,2648,1,0,0,0,2649,2650,1,0,0,0,2650,2651,1,0,0,0,2651,2652, + 7,27,0,0,2652,299,1,0,0,0,2653,2655,5,44,0,0,2654,2656,5,512,0,0, + 2655,2654,1,0,0,0,2655,2656,1,0,0,0,2656,2657,1,0,0,0,2657,2658, + 5,521,0,0,2658,301,1,0,0,0,2659,2661,7,28,0,0,2660,2662,5,411,0, + 0,2661,2660,1,0,0,0,2661,2662,1,0,0,0,2662,303,1,0,0,0,2663,2665, + 5,438,0,0,2664,2666,5,254,0,0,2665,2664,1,0,0,0,2665,2666,1,0,0, + 0,2666,2668,1,0,0,0,2667,2663,1,0,0,0,2667,2668,1,0,0,0,2668,2669, + 1,0,0,0,2669,2674,7,7,0,0,2670,2672,5,427,0,0,2671,2673,5,62,0,0, + 2672,2671,1,0,0,0,2672,2673,1,0,0,0,2673,2675,1,0,0,0,2674,2670, + 1,0,0,0,2674,2675,1,0,0,0,2675,305,1,0,0,0,2676,2677,7,29,0,0,2677, + 307,1,0,0,0,2678,2679,7,30,0,0,2679,309,1,0,0,0,2680,2681,7,31,0, + 0,2681,311,1,0,0,0,2682,2684,5,364,0,0,2683,2685,5,62,0,0,2684,2683, + 1,0,0,0,2684,2685,1,0,0,0,2685,2687,1,0,0,0,2686,2688,5,254,0,0, + 2687,2686,1,0,0,0,2687,2688,1,0,0,0,2688,2691,1,0,0,0,2689,2692, + 3,1074,537,0,2690,2692,3,1172,586,0,2691,2689,1,0,0,0,2691,2690, + 1,0,0,0,2692,2694,1,0,0,0,2693,2695,3,314,157,0,2694,2693,1,0,0, + 0,2694,2695,1,0,0,0,2695,313,1,0,0,0,2696,2697,5,321,0,0,2697,2699, + 3,1178,589,0,2698,2700,5,487,0,0,2699,2698,1,0,0,0,2699,2700,1,0, + 0,0,2700,315,1,0,0,0,2701,2702,7,32,0,0,2702,317,1,0,0,0,2703,2704, + 5,522,0,0,2704,319,1,0,0,0,2705,2706,5,395,0,0,2706,2707,5,419,0, + 0,2707,2711,5,534,0,0,2708,2710,3,322,161,0,2709,2708,1,0,0,0,2710, + 2713,1,0,0,0,2711,2709,1,0,0,0,2711,2712,1,0,0,0,2712,321,1,0,0, + 0,2713,2711,1,0,0,0,2714,2716,3,324,162,0,2715,2717,3,338,169,0, + 2716,2715,1,0,0,0,2717,2718,1,0,0,0,2718,2716,1,0,0,0,2718,2719, + 1,0,0,0,2719,323,1,0,0,0,2720,2721,5,372,0,0,2721,2723,3,1156,578, + 0,2722,2724,3,326,163,0,2723,2722,1,0,0,0,2723,2724,1,0,0,0,2724, + 2738,1,0,0,0,2725,2727,3,328,164,0,2726,2728,3,330,165,0,2727,2726, + 1,0,0,0,2727,2728,1,0,0,0,2728,2730,1,0,0,0,2729,2731,3,332,166, + 0,2730,2729,1,0,0,0,2730,2731,1,0,0,0,2731,2733,1,0,0,0,2732,2734, + 3,334,167,0,2733,2732,1,0,0,0,2733,2734,1,0,0,0,2734,2736,1,0,0, + 0,2735,2737,3,336,168,0,2736,2735,1,0,0,0,2736,2737,1,0,0,0,2737, + 2739,1,0,0,0,2738,2725,1,0,0,0,2738,2739,1,0,0,0,2739,2740,1,0,0, + 0,2740,2741,5,534,0,0,2741,325,1,0,0,0,2742,2744,5,254,0,0,2743, + 2742,1,0,0,0,2743,2744,1,0,0,0,2744,2745,1,0,0,0,2745,2746,5,223, + 0,0,2746,327,1,0,0,0,2747,2756,5,340,0,0,2748,2750,5,275,0,0,2749, + 2751,5,254,0,0,2750,2749,1,0,0,0,2750,2751,1,0,0,0,2751,2757,1,0, + 0,0,2752,2754,5,276,0,0,2753,2755,5,21,0,0,2754,2753,1,0,0,0,2754, + 2755,1,0,0,0,2755,2757,1,0,0,0,2756,2748,1,0,0,0,2756,2752,1,0,0, + 0,2756,2757,1,0,0,0,2757,2758,1,0,0,0,2758,2760,3,1178,589,0,2759, + 2761,7,33,0,0,2760,2759,1,0,0,0,2760,2761,1,0,0,0,2761,329,1,0,0, + 0,2762,2763,5,228,0,0,2763,2764,3,1178,589,0,2764,331,1,0,0,0,2765, + 2766,5,210,0,0,2766,2767,5,137,0,0,2767,2768,3,1178,589,0,2768,333, + 1,0,0,0,2769,2770,5,263,0,0,2770,2771,5,137,0,0,2771,2772,3,1178, + 589,0,2772,335,1,0,0,0,2773,2774,5,211,0,0,2774,2775,3,1178,589, + 0,2775,337,1,0,0,0,2776,2780,3,340,170,0,2777,2780,3,342,171,0,2778, + 2780,3,344,172,0,2779,2776,1,0,0,0,2779,2777,1,0,0,0,2779,2778,1, + 0,0,0,2780,339,1,0,0,0,2781,2782,3,1178,589,0,2782,2784,3,1128,564, + 0,2783,2785,3,354,177,0,2784,2783,1,0,0,0,2784,2785,1,0,0,0,2785, + 2787,1,0,0,0,2786,2788,3,360,180,0,2787,2786,1,0,0,0,2787,2788,1, + 0,0,0,2788,2789,1,0,0,0,2789,2791,3,376,188,0,2790,2792,3,388,194, + 0,2791,2790,1,0,0,0,2791,2792,1,0,0,0,2792,2793,1,0,0,0,2793,2794, + 5,534,0,0,2794,341,1,0,0,0,2795,2797,3,1178,589,0,2796,2798,3,1128, + 564,0,2797,2796,1,0,0,0,2797,2798,1,0,0,0,2798,2800,1,0,0,0,2799, + 2801,3,354,177,0,2800,2799,1,0,0,0,2800,2801,1,0,0,0,2801,2802,1, + 0,0,0,2802,2803,3,388,194,0,2803,2804,5,534,0,0,2804,343,1,0,0,0, + 2805,2807,3,1178,589,0,2806,2808,3,1128,564,0,2807,2806,1,0,0,0, + 2807,2808,1,0,0,0,2808,2825,1,0,0,0,2809,2824,3,366,183,0,2810,2824, + 3,388,194,0,2811,2824,3,370,185,0,2812,2824,3,352,176,0,2813,2824, + 3,346,173,0,2814,2824,3,354,177,0,2815,2824,3,348,174,0,2816,2821, + 3,372,186,0,2817,2821,3,394,197,0,2818,2821,3,374,187,0,2819,2821, + 3,368,184,0,2820,2816,1,0,0,0,2820,2817,1,0,0,0,2820,2818,1,0,0, + 0,2820,2819,1,0,0,0,2821,2824,1,0,0,0,2822,2824,3,350,175,0,2823, + 2809,1,0,0,0,2823,2810,1,0,0,0,2823,2811,1,0,0,0,2823,2812,1,0,0, + 0,2823,2813,1,0,0,0,2823,2814,1,0,0,0,2823,2815,1,0,0,0,2823,2820, + 1,0,0,0,2823,2822,1,0,0,0,2824,2827,1,0,0,0,2825,2823,1,0,0,0,2825, + 2826,1,0,0,0,2826,2828,1,0,0,0,2827,2825,1,0,0,0,2828,2829,5,534, + 0,0,2829,345,1,0,0,0,2830,2832,5,44,0,0,2831,2833,5,512,0,0,2832, + 2831,1,0,0,0,2832,2833,1,0,0,0,2833,2834,1,0,0,0,2834,2835,5,521, + 0,0,2835,347,1,0,0,0,2836,2838,5,74,0,0,2837,2839,5,315,0,0,2838, + 2837,1,0,0,0,2838,2839,1,0,0,0,2839,2841,1,0,0,0,2840,2842,5,254, + 0,0,2841,2840,1,0,0,0,2841,2842,1,0,0,0,2842,2843,1,0,0,0,2843,2844, + 3,1178,589,0,2844,349,1,0,0,0,2845,2847,5,227,0,0,2846,2848,5,242, + 0,0,2847,2846,1,0,0,0,2847,2848,1,0,0,0,2848,351,1,0,0,0,2849,2851, + 7,28,0,0,2850,2852,5,411,0,0,2851,2850,1,0,0,0,2851,2852,1,0,0,0, + 2852,353,1,0,0,0,2853,2855,5,279,0,0,2854,2853,1,0,0,0,2854,2855, + 1,0,0,0,2855,2857,1,0,0,0,2856,2858,5,315,0,0,2857,2856,1,0,0,0, + 2857,2858,1,0,0,0,2858,2860,1,0,0,0,2859,2861,5,254,0,0,2860,2859, + 1,0,0,0,2860,2861,1,0,0,0,2861,2864,1,0,0,0,2862,2865,3,356,178, + 0,2863,2865,3,358,179,0,2864,2862,1,0,0,0,2864,2863,1,0,0,0,2865, + 355,1,0,0,0,2866,2872,3,1178,589,0,2867,2869,5,326,0,0,2868,2867, + 1,0,0,0,2868,2869,1,0,0,0,2869,2870,1,0,0,0,2870,2871,5,309,0,0, + 2871,2873,5,340,0,0,2872,2868,1,0,0,0,2872,2873,1,0,0,0,2873,357, + 1,0,0,0,2874,2875,5,348,0,0,2875,2876,3,1178,589,0,2876,359,1,0, + 0,0,2877,2878,5,309,0,0,2878,2880,5,227,0,0,2879,2881,5,254,0,0, + 2880,2879,1,0,0,0,2880,2881,1,0,0,0,2881,2885,1,0,0,0,2882,2886, + 3,1178,589,0,2883,2886,3,364,182,0,2884,2886,3,362,181,0,2885,2882, + 1,0,0,0,2885,2883,1,0,0,0,2885,2884,1,0,0,0,2886,361,1,0,0,0,2887, + 2888,5,348,0,0,2888,2889,3,1178,589,0,2889,363,1,0,0,0,2890,2891, + 5,309,0,0,2891,2892,5,340,0,0,2892,365,1,0,0,0,2893,2895,7,26,0, + 0,2894,2896,5,254,0,0,2895,2894,1,0,0,0,2895,2896,1,0,0,0,2896,2897, + 1,0,0,0,2897,2898,3,466,233,0,2898,367,1,0,0,0,2899,2901,5,402,0, + 0,2900,2902,5,326,0,0,2901,2900,1,0,0,0,2901,2902,1,0,0,0,2902,2905, + 1,0,0,0,2903,2906,5,209,0,0,2904,2906,3,1128,564,0,2905,2903,1,0, + 0,0,2905,2904,1,0,0,0,2906,369,1,0,0,0,2907,2909,5,438,0,0,2908, + 2910,5,254,0,0,2909,2908,1,0,0,0,2909,2910,1,0,0,0,2910,2911,1,0, + 0,0,2911,2912,7,7,0,0,2912,2914,5,427,0,0,2913,2915,5,62,0,0,2914, + 2913,1,0,0,0,2914,2915,1,0,0,0,2915,371,1,0,0,0,2916,2918,5,448, + 0,0,2917,2919,5,254,0,0,2918,2917,1,0,0,0,2918,2919,1,0,0,0,2919, + 2920,1,0,0,0,2920,2921,3,1074,537,0,2921,373,1,0,0,0,2922,2923,5, + 464,0,0,2923,2930,3,1074,537,0,2924,2926,5,529,0,0,2925,2924,1,0, + 0,0,2925,2926,1,0,0,0,2926,2927,1,0,0,0,2927,2929,3,1074,537,0,2928, + 2925,1,0,0,0,2929,2932,1,0,0,0,2930,2928,1,0,0,0,2930,2931,1,0,0, + 0,2931,2944,1,0,0,0,2932,2930,1,0,0,0,2933,2934,5,503,0,0,2934,2941, + 3,1128,564,0,2935,2937,5,529,0,0,2936,2935,1,0,0,0,2936,2937,1,0, + 0,0,2937,2938,1,0,0,0,2938,2940,3,1128,564,0,2939,2936,1,0,0,0,2940, + 2943,1,0,0,0,2941,2939,1,0,0,0,2941,2942,1,0,0,0,2942,2945,1,0,0, + 0,2943,2941,1,0,0,0,2944,2933,1,0,0,0,2944,2945,1,0,0,0,2945,375, + 1,0,0,0,2946,2948,5,496,0,0,2947,2949,5,254,0,0,2948,2947,1,0,0, + 0,2948,2949,1,0,0,0,2949,2957,1,0,0,0,2950,2958,3,378,189,0,2951, + 2958,3,380,190,0,2952,2958,3,382,191,0,2953,2958,3,384,192,0,2954, + 2958,3,386,193,0,2955,2958,3,390,195,0,2956,2958,3,392,196,0,2957, + 2950,1,0,0,0,2957,2951,1,0,0,0,2957,2952,1,0,0,0,2957,2953,1,0,0, + 0,2957,2954,1,0,0,0,2957,2955,1,0,0,0,2957,2956,1,0,0,0,2958,377, + 1,0,0,0,2959,2960,5,395,0,0,2960,2963,5,228,0,0,2961,2963,5,410, + 0,0,2962,2959,1,0,0,0,2962,2961,1,0,0,0,2963,379,1,0,0,0,2964,2965, + 5,340,0,0,2965,2968,5,228,0,0,2966,2968,5,345,0,0,2967,2964,1,0, + 0,0,2967,2966,1,0,0,0,2968,381,1,0,0,0,2969,2970,5,97,0,0,2970,2973, + 5,228,0,0,2971,2973,5,58,0,0,2972,2969,1,0,0,0,2972,2971,1,0,0,0, + 2973,2976,1,0,0,0,2974,2977,5,209,0,0,2975,2977,3,1128,564,0,2976, + 2974,1,0,0,0,2976,2975,1,0,0,0,2977,383,1,0,0,0,2978,2979,7,34,0, + 0,2979,385,1,0,0,0,2980,2981,5,97,0,0,2981,2984,5,211,0,0,2982,2984, + 5,57,0,0,2983,2980,1,0,0,0,2983,2982,1,0,0,0,2984,2987,1,0,0,0,2985, + 2988,5,209,0,0,2986,2988,3,1128,564,0,2987,2985,1,0,0,0,2987,2986, + 1,0,0,0,2988,387,1,0,0,0,2989,2991,5,504,0,0,2990,2992,5,254,0,0, + 2991,2990,1,0,0,0,2991,2992,1,0,0,0,2992,2994,1,0,0,0,2993,2989, + 1,0,0,0,2993,2994,1,0,0,0,2994,2995,1,0,0,0,2995,2996,7,27,0,0,2996, + 389,1,0,0,0,2997,2998,5,340,0,0,2998,3001,5,211,0,0,2999,3001,5, + 344,0,0,3000,2997,1,0,0,0,3000,2999,1,0,0,0,3001,391,1,0,0,0,3002, + 3003,5,395,0,0,3003,3006,5,211,0,0,3004,3006,5,409,0,0,3005,3002, + 1,0,0,0,3005,3004,1,0,0,0,3006,393,1,0,0,0,3007,3009,5,507,0,0,3008, + 3010,5,254,0,0,3009,3008,1,0,0,0,3009,3010,1,0,0,0,3010,3011,1,0, + 0,0,3011,3012,3,1172,586,0,3012,395,1,0,0,0,3013,3014,5,363,0,0, + 3014,3015,5,419,0,0,3015,3019,5,534,0,0,3016,3018,3,398,199,0,3017, + 3016,1,0,0,0,3018,3021,1,0,0,0,3019,3017,1,0,0,0,3019,3020,1,0,0, + 0,3020,397,1,0,0,0,3021,3019,1,0,0,0,3022,3025,3,400,200,0,3023, + 3025,3,402,201,0,3024,3022,1,0,0,0,3024,3023,1,0,0,0,3025,399,1, + 0,0,0,3026,3027,5,265,0,0,3027,3028,3,1142,571,0,3028,3030,5,200, + 0,0,3029,3031,3,404,202,0,3030,3029,1,0,0,0,3030,3031,1,0,0,0,3031, + 3033,1,0,0,0,3032,3034,3,414,207,0,3033,3032,1,0,0,0,3033,3034,1, + 0,0,0,3034,401,1,0,0,0,3035,3036,5,264,0,0,3036,3037,3,1142,571, + 0,3037,3039,5,238,0,0,3038,3040,3,432,216,0,3039,3038,1,0,0,0,3039, + 3040,1,0,0,0,3040,3042,1,0,0,0,3041,3043,3,430,215,0,3042,3041,1, + 0,0,0,3042,3043,1,0,0,0,3043,3048,1,0,0,0,3044,3047,3,406,203,0, + 3045,3047,3,416,208,0,3046,3044,1,0,0,0,3046,3045,1,0,0,0,3047,3050, + 1,0,0,0,3048,3046,1,0,0,0,3048,3049,1,0,0,0,3049,403,1,0,0,0,3050, + 3048,1,0,0,0,3051,3057,5,31,0,0,3052,3054,5,434,0,0,3053,3055,5, + 254,0,0,3054,3053,1,0,0,0,3054,3055,1,0,0,0,3055,3056,1,0,0,0,3056, + 3058,7,35,0,0,3057,3052,1,0,0,0,3057,3058,1,0,0,0,3058,405,1,0,0, + 0,3059,3061,5,31,0,0,3060,3062,3,408,204,0,3061,3060,1,0,0,0,3061, + 3062,1,0,0,0,3062,3068,1,0,0,0,3063,3065,5,272,0,0,3064,3066,5,254, + 0,0,3065,3064,1,0,0,0,3065,3066,1,0,0,0,3066,3067,1,0,0,0,3067,3069, + 7,36,0,0,3068,3063,1,0,0,0,3068,3069,1,0,0,0,3069,3071,1,0,0,0,3070, + 3072,3,410,205,0,3071,3070,1,0,0,0,3071,3072,1,0,0,0,3072,3074,1, + 0,0,0,3073,3075,3,412,206,0,3074,3073,1,0,0,0,3074,3075,1,0,0,0, + 3075,407,1,0,0,0,3076,3077,5,218,0,0,3077,3078,5,254,0,0,3078,3079, + 3,1172,586,0,3079,409,1,0,0,0,3080,3082,5,273,0,0,3081,3083,5,254, + 0,0,3082,3081,1,0,0,0,3082,3083,1,0,0,0,3083,3084,1,0,0,0,3084,3085, + 3,1172,586,0,3085,411,1,0,0,0,3086,3088,5,488,0,0,3087,3089,5,254, + 0,0,3088,3087,1,0,0,0,3088,3089,1,0,0,0,3089,3090,1,0,0,0,3090,3091, + 3,1172,586,0,3091,413,1,0,0,0,3092,3093,5,183,0,0,3093,3095,3,1152, + 576,0,3094,3096,3,418,209,0,3095,3094,1,0,0,0,3095,3096,1,0,0,0, + 3096,415,1,0,0,0,3097,3098,5,183,0,0,3098,3100,3,1152,576,0,3099, + 3101,3,418,209,0,3100,3099,1,0,0,0,3100,3101,1,0,0,0,3101,3103,1, + 0,0,0,3102,3104,3,426,213,0,3103,3102,1,0,0,0,3103,3104,1,0,0,0, + 3104,3106,1,0,0,0,3105,3107,3,422,211,0,3106,3105,1,0,0,0,3106,3107, + 1,0,0,0,3107,3109,1,0,0,0,3108,3110,3,420,210,0,3109,3108,1,0,0, + 0,3109,3110,1,0,0,0,3110,417,1,0,0,0,3111,3112,5,212,0,0,3112,3113, + 3,1172,586,0,3113,419,1,0,0,0,3114,3115,5,222,0,0,3115,3116,3,1128, + 564,0,3116,421,1,0,0,0,3117,3119,5,506,0,0,3118,3120,3,424,212,0, + 3119,3118,1,0,0,0,3120,3121,1,0,0,0,3121,3119,1,0,0,0,3121,3122, + 1,0,0,0,3122,423,1,0,0,0,3123,3126,3,1128,564,0,3124,3126,3,1134, + 567,0,3125,3123,1,0,0,0,3125,3124,1,0,0,0,3126,425,1,0,0,0,3127, + 3129,5,514,0,0,3128,3130,3,428,214,0,3129,3128,1,0,0,0,3130,3131, + 1,0,0,0,3131,3129,1,0,0,0,3131,3132,1,0,0,0,3132,427,1,0,0,0,3133, + 3136,3,1144,572,0,3134,3136,3,1134,567,0,3135,3133,1,0,0,0,3135, + 3134,1,0,0,0,3136,429,1,0,0,0,3137,3139,5,254,0,0,3138,3137,1,0, + 0,0,3138,3139,1,0,0,0,3139,3140,1,0,0,0,3140,3141,5,78,0,0,3141, + 431,1,0,0,0,3142,3144,5,254,0,0,3143,3142,1,0,0,0,3143,3144,1,0, + 0,0,3144,3145,1,0,0,0,3145,3146,5,223,0,0,3146,433,1,0,0,0,3147, + 3152,3,436,218,0,3148,3152,3,438,219,0,3149,3152,3,440,220,0,3150, + 3152,3,442,221,0,3151,3147,1,0,0,0,3151,3148,1,0,0,0,3151,3149,1, + 0,0,0,3151,3150,1,0,0,0,3152,435,1,0,0,0,3153,3156,7,37,0,0,3154, + 3157,5,208,0,0,3155,3157,3,1128,564,0,3156,3154,1,0,0,0,3156,3155, + 1,0,0,0,3156,3157,1,0,0,0,3157,3181,1,0,0,0,3158,3180,3,476,238, + 0,3159,3180,3,454,227,0,3160,3180,3,450,225,0,3161,3180,3,452,226, + 0,3162,3180,3,488,244,0,3163,3180,3,484,242,0,3164,3180,3,464,232, + 0,3165,3180,3,448,224,0,3166,3180,3,486,243,0,3167,3180,3,492,246, + 0,3168,3180,3,490,245,0,3169,3180,3,494,247,0,3170,3180,3,472,236, + 0,3171,3180,3,458,229,0,3172,3180,3,480,240,0,3173,3180,3,482,241, + 0,3174,3180,3,456,228,0,3175,3180,3,446,223,0,3176,3180,3,502,251, + 0,3177,3180,3,444,222,0,3178,3180,3,474,237,0,3179,3158,1,0,0,0, + 3179,3159,1,0,0,0,3179,3160,1,0,0,0,3179,3161,1,0,0,0,3179,3162, + 1,0,0,0,3179,3163,1,0,0,0,3179,3164,1,0,0,0,3179,3165,1,0,0,0,3179, + 3166,1,0,0,0,3179,3167,1,0,0,0,3179,3168,1,0,0,0,3179,3169,1,0,0, + 0,3179,3170,1,0,0,0,3179,3171,1,0,0,0,3179,3172,1,0,0,0,3179,3173, + 1,0,0,0,3179,3174,1,0,0,0,3179,3175,1,0,0,0,3179,3176,1,0,0,0,3179, + 3177,1,0,0,0,3179,3178,1,0,0,0,3180,3183,1,0,0,0,3181,3179,1,0,0, + 0,3181,3182,1,0,0,0,3182,3184,1,0,0,0,3183,3181,1,0,0,0,3184,3185, + 5,534,0,0,3185,437,1,0,0,0,3186,3187,5,552,0,0,3187,3188,3,1128, + 564,0,3188,3189,3,478,239,0,3189,3190,5,534,0,0,3190,439,1,0,0,0, + 3191,3192,5,554,0,0,3192,3193,3,1126,563,0,3193,3194,3,494,247,0, + 3194,3195,5,534,0,0,3195,441,1,0,0,0,3196,3198,5,561,0,0,3197,3196, + 1,0,0,0,3198,3199,1,0,0,0,3199,3197,1,0,0,0,3199,3200,1,0,0,0,3200, + 3202,1,0,0,0,3201,3203,5,534,0,0,3202,3201,1,0,0,0,3202,3203,1,0, + 0,0,3203,443,1,0,0,0,3204,3205,5,8,0,0,3205,445,1,0,0,0,3206,3208, + 5,44,0,0,3207,3209,5,512,0,0,3208,3207,1,0,0,0,3208,3209,1,0,0,0, + 3209,3210,1,0,0,0,3210,3211,7,38,0,0,3211,447,1,0,0,0,3212,3213, + 7,39,0,0,3213,449,1,0,0,0,3214,3216,5,254,0,0,3215,3214,1,0,0,0, + 3215,3216,1,0,0,0,3216,3217,1,0,0,0,3217,3220,5,203,0,0,3218,3219, + 5,49,0,0,3219,3221,3,1172,586,0,3220,3218,1,0,0,0,3220,3221,1,0, + 0,0,3221,451,1,0,0,0,3222,3224,5,254,0,0,3223,3222,1,0,0,0,3223, + 3224,1,0,0,0,3224,3225,1,0,0,0,3225,3226,5,223,0,0,3226,453,1,0, + 0,0,3227,3228,7,40,0,0,3228,455,1,0,0,0,3229,3231,7,28,0,0,3230, + 3232,5,411,0,0,3231,3230,1,0,0,0,3231,3232,1,0,0,0,3232,457,1,0, + 0,0,3233,3234,5,321,0,0,3234,3236,3,1178,589,0,3235,3237,3,460,230, + 0,3236,3235,1,0,0,0,3236,3237,1,0,0,0,3237,3239,1,0,0,0,3238,3240, + 5,487,0,0,3239,3238,1,0,0,0,3239,3240,1,0,0,0,3240,3246,1,0,0,0, + 3241,3243,5,134,0,0,3242,3244,5,326,0,0,3243,3242,1,0,0,0,3243,3244, + 1,0,0,0,3244,3245,1,0,0,0,3245,3247,3,1090,545,0,3246,3241,1,0,0, + 0,3246,3247,1,0,0,0,3247,3251,1,0,0,0,3248,3250,3,462,231,0,3249, + 3248,1,0,0,0,3250,3253,1,0,0,0,3251,3249,1,0,0,0,3251,3252,1,0,0, + 0,3252,3266,1,0,0,0,3253,3251,1,0,0,0,3254,3256,5,241,0,0,3255,3257, + 5,49,0,0,3256,3255,1,0,0,0,3256,3257,1,0,0,0,3257,3259,1,0,0,0,3258, + 3260,5,284,0,0,3259,3258,1,0,0,0,3259,3260,1,0,0,0,3260,3262,1,0, + 0,0,3261,3263,3,1138,569,0,3262,3261,1,0,0,0,3263,3264,1,0,0,0,3264, + 3262,1,0,0,0,3264,3265,1,0,0,0,3265,3267,1,0,0,0,3266,3254,1,0,0, + 0,3266,3267,1,0,0,0,3267,459,1,0,0,0,3268,3269,5,489,0,0,3269,3270, + 3,1178,589,0,3270,461,1,0,0,0,3271,3273,7,41,0,0,3272,3274,5,259, + 0,0,3273,3272,1,0,0,0,3273,3274,1,0,0,0,3274,3276,1,0,0,0,3275,3277, + 5,254,0,0,3276,3275,1,0,0,0,3276,3277,1,0,0,0,3277,3279,1,0,0,0, + 3278,3280,3,1090,545,0,3279,3278,1,0,0,0,3280,3281,1,0,0,0,3281, + 3279,1,0,0,0,3281,3282,1,0,0,0,3282,463,1,0,0,0,3283,3285,7,26,0, + 0,3284,3286,5,254,0,0,3285,3284,1,0,0,0,3285,3286,1,0,0,0,3286,3287, + 1,0,0,0,3287,3288,3,466,233,0,3288,465,1,0,0,0,3289,3291,3,468,234, + 0,3290,3289,1,0,0,0,3291,3292,1,0,0,0,3292,3290,1,0,0,0,3292,3293, + 1,0,0,0,3293,3295,1,0,0,0,3294,3296,3,470,235,0,3295,3294,1,0,0, + 0,3295,3296,1,0,0,0,3296,3298,1,0,0,0,3297,3290,1,0,0,0,3298,3299, + 1,0,0,0,3299,3297,1,0,0,0,3299,3300,1,0,0,0,3300,467,1,0,0,0,3301, + 3318,5,532,0,0,3302,3318,5,557,0,0,3303,3318,5,556,0,0,3304,3318, + 5,550,0,0,3305,3318,5,529,0,0,3306,3318,5,535,0,0,3307,3318,5,528, + 0,0,3308,3318,5,526,0,0,3309,3318,5,527,0,0,3310,3318,5,542,0,0, + 3311,3318,5,549,0,0,3312,3318,5,547,0,0,3313,3318,5,543,0,0,3314, + 3318,5,540,0,0,3315,3318,5,544,0,0,3316,3318,3,1178,589,0,3317,3301, + 1,0,0,0,3317,3302,1,0,0,0,3317,3303,1,0,0,0,3317,3304,1,0,0,0,3317, + 3305,1,0,0,0,3317,3306,1,0,0,0,3317,3307,1,0,0,0,3317,3308,1,0,0, + 0,3317,3309,1,0,0,0,3317,3310,1,0,0,0,3317,3311,1,0,0,0,3317,3312, + 1,0,0,0,3317,3313,1,0,0,0,3317,3314,1,0,0,0,3317,3315,1,0,0,0,3317, + 3316,1,0,0,0,3318,469,1,0,0,0,3319,3320,5,542,0,0,3320,3321,3,1178, + 589,0,3321,3322,5,549,0,0,3322,471,1,0,0,0,3323,3325,5,376,0,0,3324, + 3323,1,0,0,0,3324,3325,1,0,0,0,3325,3327,1,0,0,0,3326,3328,5,49, + 0,0,3327,3326,1,0,0,0,3327,3328,1,0,0,0,3328,3329,1,0,0,0,3329,3330, + 7,42,0,0,3330,473,1,0,0,0,3331,3332,5,377,0,0,3332,3333,5,22,0,0, + 3333,475,1,0,0,0,3334,3335,5,381,0,0,3335,3336,3,1128,564,0,3336, + 477,1,0,0,0,3337,3338,5,392,0,0,3338,3341,3,1090,545,0,3339,3340, + 7,4,0,0,3340,3342,3,1090,545,0,3341,3339,1,0,0,0,3341,3342,1,0,0, + 0,3342,479,1,0,0,0,3343,3345,5,438,0,0,3344,3346,5,254,0,0,3345, + 3344,1,0,0,0,3345,3346,1,0,0,0,3346,3348,1,0,0,0,3347,3343,1,0,0, + 0,3347,3348,1,0,0,0,3348,3349,1,0,0,0,3349,3354,7,7,0,0,3350,3352, + 5,427,0,0,3351,3353,5,62,0,0,3352,3351,1,0,0,0,3352,3353,1,0,0,0, + 3353,3355,1,0,0,0,3354,3350,1,0,0,0,3354,3355,1,0,0,0,3355,481,1, + 0,0,0,3356,3358,7,43,0,0,3357,3359,7,44,0,0,3358,3357,1,0,0,0,3358, + 3359,1,0,0,0,3359,483,1,0,0,0,3360,3362,5,254,0,0,3361,3360,1,0, + 0,0,3361,3362,1,0,0,0,3362,3363,1,0,0,0,3363,3364,5,482,0,0,3364, + 485,1,0,0,0,3365,3367,5,496,0,0,3366,3368,5,254,0,0,3367,3366,1, + 0,0,0,3367,3368,1,0,0,0,3368,3369,1,0,0,0,3369,3370,7,45,0,0,3370, + 487,1,0,0,0,3371,3373,5,254,0,0,3372,3371,1,0,0,0,3372,3373,1,0, + 0,0,3373,3374,1,0,0,0,3374,3375,5,497,0,0,3375,489,1,0,0,0,3376, + 3378,5,504,0,0,3377,3379,5,254,0,0,3378,3377,1,0,0,0,3378,3379,1, + 0,0,0,3379,3381,1,0,0,0,3380,3376,1,0,0,0,3380,3381,1,0,0,0,3381, + 3415,1,0,0,0,3382,3384,5,42,0,0,3383,3385,7,46,0,0,3384,3383,1,0, + 0,0,3384,3385,1,0,0,0,3385,3416,1,0,0,0,3386,3416,5,43,0,0,3387, + 3416,5,80,0,0,3388,3416,5,81,0,0,3389,3416,5,82,0,0,3390,3416,5, + 83,0,0,3391,3416,5,84,0,0,3392,3416,5,85,0,0,3393,3416,5,86,0,0, + 3394,3416,5,87,0,0,3395,3416,5,88,0,0,3396,3416,5,89,0,0,3397,3416, + 5,90,0,0,3398,3416,5,91,0,0,3399,3416,5,98,0,0,3400,3416,5,111,0, + 0,3401,3416,5,142,0,0,3402,3416,5,143,0,0,3403,3416,5,147,0,0,3404, + 3416,5,194,0,0,3405,3416,5,219,0,0,3406,3416,5,240,0,0,3407,3416, + 5,257,0,0,3408,3416,5,286,0,0,3409,3416,5,304,0,0,3410,3416,5,338, + 0,0,3411,3416,5,349,0,0,3412,3416,5,357,0,0,3413,3416,5,373,0,0, + 3414,3416,5,473,0,0,3415,3382,1,0,0,0,3415,3386,1,0,0,0,3415,3387, + 1,0,0,0,3415,3388,1,0,0,0,3415,3389,1,0,0,0,3415,3390,1,0,0,0,3415, + 3391,1,0,0,0,3415,3392,1,0,0,0,3415,3393,1,0,0,0,3415,3394,1,0,0, + 0,3415,3395,1,0,0,0,3415,3396,1,0,0,0,3415,3397,1,0,0,0,3415,3398, + 1,0,0,0,3415,3399,1,0,0,0,3415,3400,1,0,0,0,3415,3401,1,0,0,0,3415, + 3402,1,0,0,0,3415,3403,1,0,0,0,3415,3404,1,0,0,0,3415,3405,1,0,0, + 0,3415,3406,1,0,0,0,3415,3407,1,0,0,0,3415,3408,1,0,0,0,3415,3409, + 1,0,0,0,3415,3410,1,0,0,0,3415,3411,1,0,0,0,3415,3412,1,0,0,0,3415, + 3413,1,0,0,0,3415,3414,1,0,0,0,3416,491,1,0,0,0,3417,3418,5,506, + 0,0,3418,3420,7,47,0,0,3419,3421,5,323,0,0,3420,3419,1,0,0,0,3420, + 3421,1,0,0,0,3421,3424,1,0,0,0,3422,3425,3,1170,585,0,3423,3425, + 3,1128,564,0,3424,3422,1,0,0,0,3424,3423,1,0,0,0,3425,493,1,0,0, + 0,3426,3428,5,507,0,0,3427,3429,5,254,0,0,3428,3427,1,0,0,0,3428, + 3429,1,0,0,0,3429,3435,1,0,0,0,3430,3432,5,508,0,0,3431,3433,5,21, + 0,0,3432,3431,1,0,0,0,3432,3433,1,0,0,0,3433,3435,1,0,0,0,3434,3426, + 1,0,0,0,3434,3430,1,0,0,0,3434,3435,1,0,0,0,3435,3436,1,0,0,0,3436, + 3443,3,496,248,0,3437,3439,5,529,0,0,3438,3437,1,0,0,0,3438,3439, + 1,0,0,0,3439,3440,1,0,0,0,3440,3442,3,496,248,0,3441,3438,1,0,0, + 0,3442,3445,1,0,0,0,3443,3441,1,0,0,0,3443,3444,1,0,0,0,3444,495, + 1,0,0,0,3445,3443,1,0,0,0,3446,3448,3,498,249,0,3447,3449,3,500, + 250,0,3448,3447,1,0,0,0,3448,3449,1,0,0,0,3449,497,1,0,0,0,3450, + 3453,3,1172,586,0,3451,3453,3,1170,585,0,3452,3450,1,0,0,0,3452, + 3451,1,0,0,0,3453,499,1,0,0,0,3454,3455,7,4,0,0,3455,3456,3,1172, + 586,0,3456,501,1,0,0,0,3457,3459,5,514,0,0,3458,3457,1,0,0,0,3458, + 3459,1,0,0,0,3459,3460,1,0,0,0,3460,3461,5,289,0,0,3461,3462,5,47, + 0,0,3462,503,1,0,0,0,3463,3464,5,356,0,0,3464,3466,5,145,0,0,3465, + 3467,3,506,253,0,3466,3465,1,0,0,0,3466,3467,1,0,0,0,3467,3469,1, + 0,0,0,3468,3470,3,508,254,0,3469,3468,1,0,0,0,3469,3470,1,0,0,0, + 3470,3471,1,0,0,0,3471,3473,5,534,0,0,3472,3474,3,520,260,0,3473, + 3472,1,0,0,0,3473,3474,1,0,0,0,3474,3475,1,0,0,0,3475,3476,3,526, + 263,0,3476,505,1,0,0,0,3477,3479,7,48,0,0,3478,3480,3,510,255,0, + 3479,3478,1,0,0,0,3480,3481,1,0,0,0,3481,3479,1,0,0,0,3481,3482, + 1,0,0,0,3482,507,1,0,0,0,3483,3484,7,49,0,0,3484,3485,3,1128,564, + 0,3485,509,1,0,0,0,3486,3489,3,512,256,0,3487,3489,3,516,258,0,3488, + 3486,1,0,0,0,3488,3487,1,0,0,0,3489,511,1,0,0,0,3490,3492,5,49,0, + 0,3491,3490,1,0,0,0,3491,3492,1,0,0,0,3492,3493,1,0,0,0,3493,3495, + 5,384,0,0,3494,3491,1,0,0,0,3494,3495,1,0,0,0,3495,3497,1,0,0,0, + 3496,3498,3,514,257,0,3497,3496,1,0,0,0,3498,3499,1,0,0,0,3499,3497, + 1,0,0,0,3499,3500,1,0,0,0,3500,513,1,0,0,0,3501,3503,5,328,0,0,3502, + 3501,1,0,0,0,3502,3503,1,0,0,0,3503,3506,1,0,0,0,3504,3507,3,1074, + 537,0,3505,3507,3,1134,567,0,3506,3504,1,0,0,0,3506,3505,1,0,0,0, + 3507,3510,1,0,0,0,3508,3510,5,20,0,0,3509,3502,1,0,0,0,3509,3508, + 1,0,0,0,3510,515,1,0,0,0,3511,3513,5,49,0,0,3512,3511,1,0,0,0,3512, + 3513,1,0,0,0,3513,3514,1,0,0,0,3514,3516,5,507,0,0,3515,3517,3,518, + 259,0,3516,3515,1,0,0,0,3517,3518,1,0,0,0,3518,3516,1,0,0,0,3518, + 3519,1,0,0,0,3519,517,1,0,0,0,3520,3524,3,1074,537,0,3521,3524,3, + 1172,586,0,3522,3524,5,20,0,0,3523,3520,1,0,0,0,3523,3521,1,0,0, + 0,3523,3522,1,0,0,0,3524,519,1,0,0,0,3525,3526,5,127,0,0,3526,3528, + 5,534,0,0,3527,3529,3,522,261,0,3528,3527,1,0,0,0,3529,3530,1,0, + 0,0,3530,3528,1,0,0,0,3530,3531,1,0,0,0,3531,3532,1,0,0,0,3532,3533, + 5,158,0,0,3533,3534,5,127,0,0,3534,3535,5,534,0,0,3535,521,1,0,0, + 0,3536,3537,3,524,262,0,3537,3538,5,534,0,0,3538,3539,3,986,493, + 0,3539,3540,5,534,0,0,3540,3541,3,530,265,0,3541,523,1,0,0,0,3542, + 3543,3,1162,581,0,3543,3545,5,419,0,0,3544,3546,3,1178,589,0,3545, + 3544,1,0,0,0,3545,3546,1,0,0,0,3546,525,1,0,0,0,3547,3551,3,530, + 265,0,3548,3550,3,528,264,0,3549,3548,1,0,0,0,3550,3553,1,0,0,0, + 3551,3549,1,0,0,0,3551,3552,1,0,0,0,3552,527,1,0,0,0,3553,3551,1, + 0,0,0,3554,3555,3,524,262,0,3555,3556,5,534,0,0,3556,3557,3,530, + 265,0,3557,529,1,0,0,0,3558,3560,3,534,267,0,3559,3558,1,0,0,0,3560, + 3563,1,0,0,0,3561,3559,1,0,0,0,3561,3562,1,0,0,0,3562,3567,1,0,0, + 0,3563,3561,1,0,0,0,3564,3566,3,532,266,0,3565,3564,1,0,0,0,3566, + 3569,1,0,0,0,3567,3565,1,0,0,0,3567,3568,1,0,0,0,3568,531,1,0,0, + 0,3569,3567,1,0,0,0,3570,3571,3,1148,574,0,3571,3579,5,534,0,0,3572, + 3580,3,564,282,0,3573,3575,3,534,267,0,3574,3573,1,0,0,0,3575,3578, + 1,0,0,0,3576,3574,1,0,0,0,3576,3577,1,0,0,0,3577,3580,1,0,0,0,3578, + 3576,1,0,0,0,3579,3572,1,0,0,0,3579,3576,1,0,0,0,3580,533,1,0,0, + 0,3581,3583,3,536,268,0,3582,3581,1,0,0,0,3583,3586,1,0,0,0,3584, + 3582,1,0,0,0,3584,3585,1,0,0,0,3585,3587,1,0,0,0,3586,3584,1,0,0, + 0,3587,3588,5,534,0,0,3588,535,1,0,0,0,3589,3639,3,538,269,0,3590, + 3639,3,548,274,0,3591,3639,3,566,283,0,3592,3639,3,570,285,0,3593, + 3639,3,590,295,0,3594,3639,3,594,297,0,3595,3639,3,612,306,0,3596, + 3639,3,616,308,0,3597,3639,3,618,309,0,3598,3639,3,620,310,0,3599, + 3639,3,622,311,0,3600,3639,3,632,316,0,3601,3639,3,648,324,0,3602, + 3639,3,650,325,0,3603,3639,3,652,326,0,3604,3639,3,678,339,0,3605, + 3639,3,672,336,0,3606,3639,3,674,337,0,3607,3639,3,676,338,0,3608, + 3639,3,682,341,0,3609,3639,3,684,342,0,3610,3639,3,686,343,0,3611, + 3639,3,688,344,0,3612,3639,3,694,347,0,3613,3639,3,700,350,0,3614, + 3639,3,706,353,0,3615,3639,3,708,354,0,3616,3639,3,738,369,0,3617, + 3639,3,758,379,0,3618,3639,3,768,384,0,3619,3639,3,780,390,0,3620, + 3639,3,794,397,0,3621,3639,3,820,410,0,3622,3639,3,822,411,0,3623, + 3639,3,830,415,0,3624,3639,3,852,426,0,3625,3639,3,854,427,0,3626, + 3639,3,858,429,0,3627,3639,3,862,431,0,3628,3639,3,868,434,0,3629, + 3639,3,888,444,0,3630,3639,3,900,450,0,3631,3639,3,926,463,0,3632, + 3639,3,930,465,0,3633,3639,3,932,466,0,3634,3639,3,946,473,0,3635, + 3639,3,964,482,0,3636,3639,3,966,483,0,3637,3639,3,996,498,0,3638, + 3589,1,0,0,0,3638,3590,1,0,0,0,3638,3591,1,0,0,0,3638,3592,1,0,0, + 0,3638,3593,1,0,0,0,3638,3594,1,0,0,0,3638,3595,1,0,0,0,3638,3596, + 1,0,0,0,3638,3597,1,0,0,0,3638,3598,1,0,0,0,3638,3599,1,0,0,0,3638, + 3600,1,0,0,0,3638,3601,1,0,0,0,3638,3602,1,0,0,0,3638,3603,1,0,0, + 0,3638,3604,1,0,0,0,3638,3605,1,0,0,0,3638,3606,1,0,0,0,3638,3607, + 1,0,0,0,3638,3608,1,0,0,0,3638,3609,1,0,0,0,3638,3610,1,0,0,0,3638, + 3611,1,0,0,0,3638,3612,1,0,0,0,3638,3613,1,0,0,0,3638,3614,1,0,0, + 0,3638,3615,1,0,0,0,3638,3616,1,0,0,0,3638,3617,1,0,0,0,3638,3618, + 1,0,0,0,3638,3619,1,0,0,0,3638,3620,1,0,0,0,3638,3621,1,0,0,0,3638, + 3622,1,0,0,0,3638,3623,1,0,0,0,3638,3624,1,0,0,0,3638,3625,1,0,0, + 0,3638,3626,1,0,0,0,3638,3627,1,0,0,0,3638,3628,1,0,0,0,3638,3629, + 1,0,0,0,3638,3630,1,0,0,0,3638,3631,1,0,0,0,3638,3632,1,0,0,0,3638, + 3633,1,0,0,0,3638,3634,1,0,0,0,3638,3635,1,0,0,0,3638,3636,1,0,0, + 0,3638,3637,1,0,0,0,3639,537,1,0,0,0,3640,3641,5,2,0,0,3641,3646, + 3,1074,537,0,3642,3647,3,540,270,0,3643,3647,3,544,272,0,3644,3647, + 3,542,271,0,3645,3647,3,546,273,0,3646,3642,1,0,0,0,3646,3643,1, + 0,0,0,3646,3644,1,0,0,0,3646,3645,1,0,0,0,3646,3647,1,0,0,0,3647, + 3649,1,0,0,0,3648,3650,3,1028,514,0,3649,3648,1,0,0,0,3649,3650, + 1,0,0,0,3650,3652,1,0,0,0,3651,3653,3,1030,515,0,3652,3651,1,0,0, + 0,3652,3653,1,0,0,0,3653,3655,1,0,0,0,3654,3656,5,159,0,0,3655,3654, + 1,0,0,0,3655,3656,1,0,0,0,3656,539,1,0,0,0,3657,3677,5,215,0,0,3658, + 3660,5,111,0,0,3659,3661,5,519,0,0,3660,3659,1,0,0,0,3660,3661,1, + 0,0,0,3661,3678,1,0,0,0,3662,3664,5,114,0,0,3663,3665,5,520,0,0, + 3664,3663,1,0,0,0,3664,3665,1,0,0,0,3665,3678,1,0,0,0,3666,3678, + 5,115,0,0,3667,3678,5,485,0,0,3668,3678,5,486,0,0,3669,3671,5,490, + 0,0,3670,3672,5,296,0,0,3671,3670,1,0,0,0,3671,3672,1,0,0,0,3672, + 3678,1,0,0,0,3673,3678,5,491,0,0,3674,3678,5,518,0,0,3675,3678,5, + 519,0,0,3676,3678,5,520,0,0,3677,3658,1,0,0,0,3677,3662,1,0,0,0, + 3677,3666,1,0,0,0,3677,3667,1,0,0,0,3677,3668,1,0,0,0,3677,3669, + 1,0,0,0,3677,3673,1,0,0,0,3677,3674,1,0,0,0,3677,3675,1,0,0,0,3677, + 3676,1,0,0,0,3678,541,1,0,0,0,3679,3680,5,215,0,0,3680,3681,3,1146, + 573,0,3681,543,1,0,0,0,3682,3683,5,215,0,0,3683,3684,5,191,0,0,3684, + 3685,5,259,0,0,3685,545,1,0,0,0,3686,3688,5,295,0,0,3687,3686,1, + 0,0,0,3687,3688,1,0,0,0,3688,3689,1,0,0,0,3689,3690,5,105,0,0,3690, + 547,1,0,0,0,3691,3695,5,4,0,0,3692,3696,3,550,275,0,3693,3696,3, + 552,276,0,3694,3696,3,554,277,0,3695,3692,1,0,0,0,3695,3693,1,0, + 0,0,3695,3694,1,0,0,0,3696,3698,1,0,0,0,3697,3699,3,1024,512,0,3698, + 3697,1,0,0,0,3698,3699,1,0,0,0,3699,3701,1,0,0,0,3700,3702,3,1026, + 513,0,3701,3700,1,0,0,0,3701,3702,1,0,0,0,3702,3704,1,0,0,0,3703, + 3705,5,160,0,0,3704,3703,1,0,0,0,3704,3705,1,0,0,0,3705,549,1,0, + 0,0,3706,3708,3,556,278,0,3707,3706,1,0,0,0,3708,3709,1,0,0,0,3709, + 3707,1,0,0,0,3709,3710,1,0,0,0,3710,3711,1,0,0,0,3711,3713,5,489, + 0,0,3712,3714,3,558,279,0,3713,3712,1,0,0,0,3714,3715,1,0,0,0,3715, + 3713,1,0,0,0,3715,3716,1,0,0,0,3716,551,1,0,0,0,3717,3719,3,556, + 278,0,3718,3717,1,0,0,0,3719,3720,1,0,0,0,3720,3718,1,0,0,0,3720, + 3721,1,0,0,0,3721,3728,1,0,0,0,3722,3724,5,489,0,0,3723,3725,3,560, + 280,0,3724,3723,1,0,0,0,3725,3726,1,0,0,0,3726,3724,1,0,0,0,3726, + 3727,1,0,0,0,3727,3729,1,0,0,0,3728,3722,1,0,0,0,3728,3729,1,0,0, + 0,3729,3730,1,0,0,0,3730,3732,5,222,0,0,3731,3733,3,562,281,0,3732, + 3731,1,0,0,0,3733,3734,1,0,0,0,3734,3732,1,0,0,0,3734,3735,1,0,0, + 0,3735,553,1,0,0,0,3736,3737,7,50,0,0,3737,3738,3,1074,537,0,3738, + 3739,5,489,0,0,3739,3740,3,558,279,0,3740,555,1,0,0,0,3741,3744, + 3,1074,537,0,3742,3744,3,1172,586,0,3743,3741,1,0,0,0,3743,3742, + 1,0,0,0,3744,557,1,0,0,0,3745,3747,3,1074,537,0,3746,3748,5,412, + 0,0,3747,3746,1,0,0,0,3747,3748,1,0,0,0,3748,559,1,0,0,0,3749,3752, + 3,1074,537,0,3750,3752,3,1172,586,0,3751,3749,1,0,0,0,3751,3750, + 1,0,0,0,3752,561,1,0,0,0,3753,3755,3,1074,537,0,3754,3756,5,412, + 0,0,3755,3754,1,0,0,0,3755,3756,1,0,0,0,3756,563,1,0,0,0,3757,3759, + 5,224,0,0,3758,3760,5,489,0,0,3759,3758,1,0,0,0,3759,3760,1,0,0, + 0,3760,3761,1,0,0,0,3761,3762,5,534,0,0,3762,565,1,0,0,0,3763,3765, + 5,17,0,0,3764,3766,3,568,284,0,3765,3764,1,0,0,0,3766,3767,1,0,0, + 0,3767,3765,1,0,0,0,3767,3768,1,0,0,0,3768,567,1,0,0,0,3769,3770, + 3,1150,575,0,3770,3773,5,489,0,0,3771,3772,5,359,0,0,3772,3774,5, + 489,0,0,3773,3771,1,0,0,0,3773,3774,1,0,0,0,3774,3775,1,0,0,0,3775, + 3776,3,1150,575,0,3776,569,1,0,0,0,3777,3780,5,52,0,0,3778,3781, + 3,1074,537,0,3779,3781,3,1172,586,0,3780,3778,1,0,0,0,3780,3779, + 1,0,0,0,3781,3783,1,0,0,0,3782,3784,3,572,286,0,3783,3782,1,0,0, + 0,3783,3784,1,0,0,0,3784,3786,1,0,0,0,3785,3787,3,588,294,0,3786, + 3785,1,0,0,0,3786,3787,1,0,0,0,3787,3789,1,0,0,0,3788,3790,3,1020, + 510,0,3789,3788,1,0,0,0,3789,3790,1,0,0,0,3790,3792,1,0,0,0,3791, + 3793,3,1028,514,0,3792,3791,1,0,0,0,3792,3793,1,0,0,0,3793,3795, + 1,0,0,0,3794,3796,3,1030,515,0,3795,3794,1,0,0,0,3795,3796,1,0,0, + 0,3796,3798,1,0,0,0,3797,3799,5,161,0,0,3798,3797,1,0,0,0,3798,3799, + 1,0,0,0,3799,571,1,0,0,0,3800,3802,5,506,0,0,3801,3803,3,574,287, + 0,3802,3801,1,0,0,0,3803,3804,1,0,0,0,3804,3802,1,0,0,0,3804,3805, + 1,0,0,0,3805,573,1,0,0,0,3806,3810,3,576,288,0,3807,3810,3,580,290, + 0,3808,3810,3,584,292,0,3809,3806,1,0,0,0,3809,3807,1,0,0,0,3809, + 3808,1,0,0,0,3810,575,1,0,0,0,3811,3813,5,49,0,0,3812,3811,1,0,0, + 0,3812,3813,1,0,0,0,3813,3814,1,0,0,0,3814,3816,5,384,0,0,3815,3812, + 1,0,0,0,3815,3816,1,0,0,0,3816,3818,1,0,0,0,3817,3819,3,578,289, + 0,3818,3817,1,0,0,0,3819,3820,1,0,0,0,3820,3818,1,0,0,0,3820,3821, + 1,0,0,0,3821,577,1,0,0,0,3822,3823,5,5,0,0,3823,3827,5,323,0,0,3824, + 3827,5,250,0,0,3825,3827,5,459,0,0,3826,3822,1,0,0,0,3826,3824,1, + 0,0,0,3826,3825,1,0,0,0,3826,3827,1,0,0,0,3827,3828,1,0,0,0,3828, + 3832,3,1074,537,0,3829,3832,3,1172,586,0,3830,3832,3,1134,567,0, + 3831,3826,1,0,0,0,3831,3829,1,0,0,0,3831,3830,1,0,0,0,3832,3835, + 1,0,0,0,3833,3835,5,325,0,0,3834,3831,1,0,0,0,3834,3833,1,0,0,0, + 3835,579,1,0,0,0,3836,3838,5,49,0,0,3837,3836,1,0,0,0,3837,3838, + 1,0,0,0,3838,3839,1,0,0,0,3839,3841,5,507,0,0,3840,3842,3,582,291, + 0,3841,3840,1,0,0,0,3842,3843,1,0,0,0,3843,3841,1,0,0,0,3843,3844, + 1,0,0,0,3844,581,1,0,0,0,3845,3846,5,5,0,0,3846,3852,5,323,0,0,3847, + 3849,5,269,0,0,3848,3850,5,323,0,0,3849,3848,1,0,0,0,3849,3850,1, + 0,0,0,3850,3852,1,0,0,0,3851,3845,1,0,0,0,3851,3847,1,0,0,0,3851, + 3852,1,0,0,0,3852,3855,1,0,0,0,3853,3856,3,1074,537,0,3854,3856, + 3,1172,586,0,3855,3853,1,0,0,0,3855,3854,1,0,0,0,3856,583,1,0,0, + 0,3857,3859,5,49,0,0,3858,3857,1,0,0,0,3858,3859,1,0,0,0,3859,3860, + 1,0,0,0,3860,3862,5,95,0,0,3861,3863,3,586,293,0,3862,3861,1,0,0, + 0,3863,3864,1,0,0,0,3864,3862,1,0,0,0,3864,3865,1,0,0,0,3865,585, + 1,0,0,0,3866,3867,5,5,0,0,3867,3873,5,323,0,0,3868,3870,5,269,0, + 0,3869,3871,5,323,0,0,3870,3869,1,0,0,0,3870,3871,1,0,0,0,3871,3873, + 1,0,0,0,3872,3866,1,0,0,0,3872,3868,1,0,0,0,3872,3873,1,0,0,0,3873, + 3874,1,0,0,0,3874,3878,3,1074,537,0,3875,3878,3,1172,586,0,3876, + 3878,5,325,0,0,3877,3872,1,0,0,0,3877,3875,1,0,0,0,3877,3876,1,0, + 0,0,3878,587,1,0,0,0,3879,3880,7,49,0,0,3880,3881,3,1074,537,0,3881, + 589,1,0,0,0,3882,3884,5,53,0,0,3883,3885,3,592,296,0,3884,3883,1, + 0,0,0,3885,3886,1,0,0,0,3886,3884,1,0,0,0,3886,3887,1,0,0,0,3887, + 591,1,0,0,0,3888,3889,3,1142,571,0,3889,3890,7,36,0,0,3890,3894, + 1,0,0,0,3891,3894,3,1074,537,0,3892,3894,3,1172,586,0,3893,3888, + 1,0,0,0,3893,3891,1,0,0,0,3893,3892,1,0,0,0,3894,593,1,0,0,0,3895, + 3897,5,67,0,0,3896,3898,3,596,298,0,3897,3896,1,0,0,0,3898,3899, + 1,0,0,0,3899,3897,1,0,0,0,3899,3900,1,0,0,0,3900,595,1,0,0,0,3901, + 3905,3,1134,567,0,3902,3906,3,598,299,0,3903,3906,3,600,300,0,3904, + 3906,3,602,301,0,3905,3902,1,0,0,0,3905,3903,1,0,0,0,3905,3904,1, + 0,0,0,3905,3906,1,0,0,0,3906,597,1,0,0,0,3907,3912,7,12,0,0,3908, + 3910,5,212,0,0,3909,3908,1,0,0,0,3909,3910,1,0,0,0,3910,3911,1,0, + 0,0,3911,3913,5,390,0,0,3912,3909,1,0,0,0,3912,3913,1,0,0,0,3913, + 3922,1,0,0,0,3914,3916,5,514,0,0,3915,3914,1,0,0,0,3915,3916,1,0, + 0,0,3916,3920,1,0,0,0,3917,3918,5,310,0,0,3918,3921,5,407,0,0,3919, + 3921,5,286,0,0,3920,3917,1,0,0,0,3920,3919,1,0,0,0,3921,3923,1,0, + 0,0,3922,3915,1,0,0,0,3922,3923,1,0,0,0,3923,599,1,0,0,0,3924,3926, + 5,514,0,0,3925,3924,1,0,0,0,3925,3926,1,0,0,0,3926,3930,1,0,0,0, + 3927,3928,5,310,0,0,3928,3931,5,407,0,0,3929,3931,5,286,0,0,3930, + 3927,1,0,0,0,3930,3929,1,0,0,0,3931,601,1,0,0,0,3932,3934,5,514, + 0,0,3933,3932,1,0,0,0,3933,3934,1,0,0,0,3934,3935,1,0,0,0,3935,3936, + 5,310,0,0,3936,3940,5,511,0,0,3937,3938,5,514,0,0,3938,3940,5,511, + 0,0,3939,3933,1,0,0,0,3939,3937,1,0,0,0,3940,3947,1,0,0,0,3941,3943, + 5,506,0,0,3942,3944,3,604,302,0,3943,3942,1,0,0,0,3944,3945,1,0, + 0,0,3945,3943,1,0,0,0,3945,3946,1,0,0,0,3946,3948,1,0,0,0,3947,3941, + 1,0,0,0,3947,3948,1,0,0,0,3948,603,1,0,0,0,3949,3953,3,606,303,0, + 3950,3953,3,608,304,0,3951,3953,3,610,305,0,3952,3949,1,0,0,0,3952, + 3950,1,0,0,0,3952,3951,1,0,0,0,3953,605,1,0,0,0,3954,3956,5,68,0, + 0,3955,3957,5,323,0,0,3956,3955,1,0,0,0,3956,3957,1,0,0,0,3957,3958, + 1,0,0,0,3958,3959,7,51,0,0,3959,607,1,0,0,0,3960,3963,5,28,0,0,3961, + 3964,3,1074,537,0,3962,3964,3,1178,589,0,3963,3961,1,0,0,0,3963, + 3962,1,0,0,0,3964,609,1,0,0,0,3965,3967,5,29,0,0,3966,3968,5,323, + 0,0,3967,3966,1,0,0,0,3967,3968,1,0,0,0,3968,3971,1,0,0,0,3969,3972, + 3,1074,537,0,3970,3972,3,1178,589,0,3971,3969,1,0,0,0,3971,3970, + 1,0,0,0,3972,611,1,0,0,0,3973,3975,5,92,0,0,3974,3976,3,614,307, + 0,3975,3974,1,0,0,0,3976,3977,1,0,0,0,3977,3975,1,0,0,0,3977,3978, + 1,0,0,0,3978,3979,1,0,0,0,3979,3980,7,52,0,0,3980,3982,3,1032,516, + 0,3981,3983,3,1024,512,0,3982,3981,1,0,0,0,3982,3983,1,0,0,0,3983, + 3985,1,0,0,0,3984,3986,3,1026,513,0,3985,3984,1,0,0,0,3985,3986, + 1,0,0,0,3986,3988,1,0,0,0,3987,3989,5,162,0,0,3988,3987,1,0,0,0, + 3988,3989,1,0,0,0,3989,613,1,0,0,0,3990,3992,3,1074,537,0,3991,3993, + 5,412,0,0,3992,3991,1,0,0,0,3992,3993,1,0,0,0,3993,615,1,0,0,0,3994, + 3995,5,96,0,0,3995,617,1,0,0,0,3996,3997,5,131,0,0,3997,3999,3,1134, + 567,0,3998,4000,5,377,0,0,3999,3998,1,0,0,0,3999,4000,1,0,0,0,4000, + 4002,1,0,0,0,4001,4003,3,1016,508,0,4002,4001,1,0,0,0,4002,4003, + 1,0,0,0,4003,4005,1,0,0,0,4004,4006,3,1018,509,0,4005,4004,1,0,0, + 0,4005,4006,1,0,0,0,4006,4008,1,0,0,0,4007,4009,5,163,0,0,4008,4007, + 1,0,0,0,4008,4009,1,0,0,0,4009,619,1,0,0,0,4010,4018,5,140,0,0,4011, + 4013,5,246,0,0,4012,4014,5,475,0,0,4013,4012,1,0,0,0,4013,4014,1, + 0,0,0,4014,4019,1,0,0,0,4015,4016,5,232,0,0,4016,4019,5,475,0,0, + 4017,4019,5,334,0,0,4018,4011,1,0,0,0,4018,4015,1,0,0,0,4018,4017, + 1,0,0,0,4019,4020,1,0,0,0,4020,4022,3,1120,560,0,4021,4023,5,514, + 0,0,4022,4021,1,0,0,0,4022,4023,1,0,0,0,4023,4024,1,0,0,0,4024,4027, + 5,259,0,0,4025,4028,3,1074,537,0,4026,4028,3,1172,586,0,4027,4025, + 1,0,0,0,4027,4026,1,0,0,0,4028,621,1,0,0,0,4029,4031,5,142,0,0,4030, + 4032,3,624,312,0,4031,4030,1,0,0,0,4032,4033,1,0,0,0,4033,4031,1, + 0,0,0,4033,4034,1,0,0,0,4034,4036,1,0,0,0,4035,4037,3,626,313,0, + 4036,4035,1,0,0,0,4036,4037,1,0,0,0,4037,4039,1,0,0,0,4038,4040, + 3,628,314,0,4039,4038,1,0,0,0,4039,4040,1,0,0,0,4040,4042,1,0,0, + 0,4041,4043,3,630,315,0,4042,4041,1,0,0,0,4042,4043,1,0,0,0,4043, + 623,1,0,0,0,4044,4047,3,1074,537,0,4045,4047,3,1172,586,0,4046,4044, + 1,0,0,0,4046,4045,1,0,0,0,4047,625,1,0,0,0,4048,4051,5,30,0,0,4049, + 4052,3,1074,537,0,4050,4052,3,1172,586,0,4051,4049,1,0,0,0,4051, + 4050,1,0,0,0,4052,627,1,0,0,0,4053,4056,5,503,0,0,4054,4057,3,1146, + 573,0,4055,4057,3,1132,566,0,4056,4054,1,0,0,0,4056,4055,1,0,0,0, + 4057,629,1,0,0,0,4058,4060,5,514,0,0,4059,4058,1,0,0,0,4059,4060, + 1,0,0,0,4060,4061,1,0,0,0,4061,4062,5,310,0,0,4062,4063,5,6,0,0, + 4063,631,1,0,0,0,4064,4067,5,144,0,0,4065,4068,3,1074,537,0,4066, + 4068,3,1172,586,0,4067,4065,1,0,0,0,4067,4066,1,0,0,0,4068,4072, + 1,0,0,0,4069,4073,3,634,317,0,4070,4073,3,636,318,0,4071,4073,3, + 638,319,0,4072,4069,1,0,0,0,4072,4070,1,0,0,0,4072,4071,1,0,0,0, + 4073,4075,1,0,0,0,4074,4076,3,646,323,0,4075,4074,1,0,0,0,4075,4076, + 1,0,0,0,4076,4078,1,0,0,0,4077,4079,3,1024,512,0,4078,4077,1,0,0, + 0,4078,4079,1,0,0,0,4079,4081,1,0,0,0,4080,4082,3,1026,513,0,4081, + 4080,1,0,0,0,4081,4082,1,0,0,0,4082,4084,1,0,0,0,4083,4085,5,164, + 0,0,4084,4083,1,0,0,0,4084,4085,1,0,0,0,4085,633,1,0,0,0,4086,4088, + 5,251,0,0,4087,4089,3,642,321,0,4088,4087,1,0,0,0,4089,4090,1,0, + 0,0,4090,4088,1,0,0,0,4090,4091,1,0,0,0,4091,635,1,0,0,0,4092,4095, + 5,251,0,0,4093,4096,3,1074,537,0,4094,4096,3,1172,586,0,4095,4093, + 1,0,0,0,4095,4094,1,0,0,0,4096,4098,1,0,0,0,4097,4099,3,640,320, + 0,4098,4097,1,0,0,0,4098,4099,1,0,0,0,4099,637,1,0,0,0,4100,4103, + 5,49,0,0,4101,4104,3,1074,537,0,4102,4104,3,1172,586,0,4103,4101, + 1,0,0,0,4103,4102,1,0,0,0,4104,4106,1,0,0,0,4105,4107,3,640,320, + 0,4106,4105,1,0,0,0,4106,4107,1,0,0,0,4107,639,1,0,0,0,4108,4110, + 5,222,0,0,4109,4111,3,644,322,0,4110,4109,1,0,0,0,4111,4112,1,0, + 0,0,4112,4110,1,0,0,0,4112,4113,1,0,0,0,4113,641,1,0,0,0,4114,4116, + 3,1074,537,0,4115,4117,5,412,0,0,4116,4115,1,0,0,0,4116,4117,1,0, + 0,0,4117,643,1,0,0,0,4118,4120,3,1074,537,0,4119,4121,5,412,0,0, + 4120,4119,1,0,0,0,4120,4121,1,0,0,0,4121,645,1,0,0,0,4122,4123,5, + 388,0,0,4123,4124,3,1074,537,0,4124,647,1,0,0,0,4125,4133,5,157, + 0,0,4126,4128,5,246,0,0,4127,4129,5,475,0,0,4128,4127,1,0,0,0,4128, + 4129,1,0,0,0,4129,4134,1,0,0,0,4130,4131,5,232,0,0,4131,4134,5,475, + 0,0,4132,4134,5,334,0,0,4133,4126,1,0,0,0,4133,4130,1,0,0,0,4133, + 4132,1,0,0,0,4134,4135,1,0,0,0,4135,4137,3,1120,560,0,4136,4138, + 5,514,0,0,4137,4136,1,0,0,0,4137,4138,1,0,0,0,4138,4139,1,0,0,0, + 4139,4142,5,259,0,0,4140,4143,3,1172,586,0,4141,4143,3,1074,537, + 0,4142,4140,1,0,0,0,4142,4141,1,0,0,0,4143,649,1,0,0,0,4144,4145, + 5,182,0,0,4145,4152,3,1172,586,0,4146,4148,5,506,0,0,4147,4149,3, + 1074,537,0,4148,4147,1,0,0,0,4149,4150,1,0,0,0,4150,4148,1,0,0,0, + 4150,4151,1,0,0,0,4151,4153,1,0,0,0,4152,4146,1,0,0,0,4152,4153, + 1,0,0,0,4153,651,1,0,0,0,4154,4155,5,193,0,0,4155,4159,3,654,327, + 0,4156,4158,3,656,328,0,4157,4156,1,0,0,0,4158,4161,1,0,0,0,4159, + 4157,1,0,0,0,4159,4160,1,0,0,0,4160,4163,1,0,0,0,4161,4159,1,0,0, + 0,4162,4164,3,658,329,0,4163,4162,1,0,0,0,4164,4165,1,0,0,0,4165, + 4163,1,0,0,0,4165,4166,1,0,0,0,4166,4168,1,0,0,0,4167,4169,3,668, + 334,0,4168,4167,1,0,0,0,4168,4169,1,0,0,0,4169,4171,1,0,0,0,4170, + 4172,5,165,0,0,4171,4170,1,0,0,0,4171,4172,1,0,0,0,4172,653,1,0, + 0,0,4173,4178,3,1074,537,0,4174,4178,3,1172,586,0,4175,4178,3,1032, + 516,0,4176,4178,3,1046,523,0,4177,4173,1,0,0,0,4177,4174,1,0,0,0, + 4177,4175,1,0,0,0,4177,4176,1,0,0,0,4178,655,1,0,0,0,4179,4180,5, + 16,0,0,4180,4181,3,654,327,0,4181,657,1,0,0,0,4182,4184,3,660,330, + 0,4183,4182,1,0,0,0,4184,4185,1,0,0,0,4185,4183,1,0,0,0,4185,4186, + 1,0,0,0,4186,4190,1,0,0,0,4187,4189,3,536,268,0,4188,4187,1,0,0, + 0,4189,4192,1,0,0,0,4190,4188,1,0,0,0,4190,4191,1,0,0,0,4191,659, + 1,0,0,0,4192,4190,1,0,0,0,4193,4194,5,512,0,0,4194,4198,3,662,331, + 0,4195,4197,3,666,333,0,4196,4195,1,0,0,0,4197,4200,1,0,0,0,4198, + 4196,1,0,0,0,4198,4199,1,0,0,0,4199,661,1,0,0,0,4200,4198,1,0,0, + 0,4201,4212,5,20,0,0,4202,4204,5,312,0,0,4203,4202,1,0,0,0,4203, + 4204,1,0,0,0,4204,4205,1,0,0,0,4205,4207,3,670,335,0,4206,4208,3, + 664,332,0,4207,4206,1,0,0,0,4207,4208,1,0,0,0,4208,4212,1,0,0,0, + 4209,4212,3,1046,523,0,4210,4212,3,1174,587,0,4211,4201,1,0,0,0, + 4211,4203,1,0,0,0,4211,4209,1,0,0,0,4211,4210,1,0,0,0,4212,663,1, + 0,0,0,4213,4214,7,4,0,0,4214,4215,3,670,335,0,4215,665,1,0,0,0,4216, + 4217,5,16,0,0,4217,4218,3,662,331,0,4218,667,1,0,0,0,4219,4220,5, + 512,0,0,4220,4224,5,333,0,0,4221,4223,3,536,268,0,4222,4221,1,0, + 0,0,4223,4226,1,0,0,0,4224,4222,1,0,0,0,4224,4225,1,0,0,0,4225,669, + 1,0,0,0,4226,4224,1,0,0,0,4227,4231,3,1074,537,0,4228,4231,3,1172, + 586,0,4229,4231,3,1032,516,0,4230,4227,1,0,0,0,4230,4228,1,0,0,0, + 4230,4229,1,0,0,0,4231,671,1,0,0,0,4232,4234,5,559,0,0,4233,4232, + 1,0,0,0,4234,4235,1,0,0,0,4235,4233,1,0,0,0,4235,4236,1,0,0,0,4236, + 673,1,0,0,0,4237,4239,5,561,0,0,4238,4237,1,0,0,0,4239,4240,1,0, + 0,0,4240,4238,1,0,0,0,4240,4241,1,0,0,0,4241,675,1,0,0,0,4242,4244, + 5,560,0,0,4243,4242,1,0,0,0,4244,4245,1,0,0,0,4245,4243,1,0,0,0, + 4245,4246,1,0,0,0,4246,677,1,0,0,0,4247,4249,5,198,0,0,4248,4250, + 5,303,0,0,4249,4248,1,0,0,0,4249,4250,1,0,0,0,4250,4252,1,0,0,0, + 4251,4253,5,60,0,0,4252,4251,1,0,0,0,4252,4253,1,0,0,0,4253,4255, + 1,0,0,0,4254,4256,3,680,340,0,4255,4254,1,0,0,0,4256,4257,1,0,0, + 0,4257,4255,1,0,0,0,4257,4258,1,0,0,0,4258,679,1,0,0,0,4259,4262, + 3,1074,537,0,4260,4262,3,1172,586,0,4261,4259,1,0,0,0,4261,4260, + 1,0,0,0,4262,681,1,0,0,0,4263,4265,5,199,0,0,4264,4266,5,361,0,0, + 4265,4264,1,0,0,0,4265,4266,1,0,0,0,4266,683,1,0,0,0,4267,4268,5, + 220,0,0,4268,4269,3,1156,578,0,4269,685,1,0,0,0,4270,4271,5,221, + 0,0,4271,687,1,0,0,0,4272,4274,5,224,0,0,4273,4275,5,489,0,0,4274, + 4273,1,0,0,0,4274,4275,1,0,0,0,4275,4278,1,0,0,0,4276,4279,3,690, + 345,0,4277,4279,3,692,346,0,4278,4276,1,0,0,0,4278,4277,1,0,0,0, + 4279,689,1,0,0,0,4280,4281,3,1150,575,0,4281,691,1,0,0,0,4282,4296, + 5,299,0,0,4283,4285,3,1150,575,0,4284,4283,1,0,0,0,4285,4286,1,0, + 0,0,4286,4284,1,0,0,0,4286,4287,1,0,0,0,4287,4293,1,0,0,0,4288,4290, + 5,134,0,0,4289,4291,5,326,0,0,4290,4289,1,0,0,0,4290,4291,1,0,0, + 0,4291,4292,1,0,0,0,4292,4294,3,1074,537,0,4293,4288,1,0,0,0,4293, + 4294,1,0,0,0,4294,4296,1,0,0,0,4295,4282,1,0,0,0,4295,4284,1,0,0, + 0,4296,693,1,0,0,0,4297,4298,5,236,0,0,4298,4299,3,1046,523,0,4299, + 4301,3,696,348,0,4300,4302,3,698,349,0,4301,4300,1,0,0,0,4301,4302, + 1,0,0,0,4302,4304,1,0,0,0,4303,4305,5,166,0,0,4304,4303,1,0,0,0, + 4304,4305,1,0,0,0,4305,695,1,0,0,0,4306,4308,5,480,0,0,4307,4306, + 1,0,0,0,4307,4308,1,0,0,0,4308,4317,1,0,0,0,4309,4310,5,309,0,0, + 4310,4318,5,426,0,0,4311,4313,3,536,268,0,4312,4311,1,0,0,0,4313, + 4316,1,0,0,0,4314,4312,1,0,0,0,4314,4315,1,0,0,0,4315,4318,1,0,0, + 0,4316,4314,1,0,0,0,4317,4309,1,0,0,0,4317,4314,1,0,0,0,4318,697, + 1,0,0,0,4319,4328,5,154,0,0,4320,4321,5,309,0,0,4321,4329,5,426, + 0,0,4322,4324,3,536,268,0,4323,4322,1,0,0,0,4324,4327,1,0,0,0,4325, + 4323,1,0,0,0,4325,4326,1,0,0,0,4326,4329,1,0,0,0,4327,4325,1,0,0, + 0,4328,4320,1,0,0,0,4328,4325,1,0,0,0,4329,699,1,0,0,0,4330,4332, + 5,244,0,0,4331,4333,3,1074,537,0,4332,4331,1,0,0,0,4333,4334,1,0, + 0,0,4334,4332,1,0,0,0,4334,4335,1,0,0,0,4335,4337,1,0,0,0,4336,4338, + 3,702,351,0,4337,4336,1,0,0,0,4337,4338,1,0,0,0,4338,701,1,0,0,0, + 4339,4341,5,394,0,0,4340,4342,3,704,352,0,4341,4340,1,0,0,0,4342, + 4343,1,0,0,0,4343,4341,1,0,0,0,4343,4344,1,0,0,0,4344,703,1,0,0, + 0,4345,4347,7,53,0,0,4346,4348,5,109,0,0,4347,4346,1,0,0,0,4347, + 4348,1,0,0,0,4348,4349,1,0,0,0,4349,4352,5,49,0,0,4350,4353,3,1074, + 537,0,4351,4353,3,1172,586,0,4352,4350,1,0,0,0,4352,4351,1,0,0,0, + 4353,705,1,0,0,0,4354,4356,5,245,0,0,4355,4357,3,1156,578,0,4356, + 4355,1,0,0,0,4357,4358,1,0,0,0,4358,4356,1,0,0,0,4358,4359,1,0,0, + 0,4359,707,1,0,0,0,4360,4361,5,248,0,0,4361,4366,3,1074,537,0,4362, + 4367,3,710,355,0,4363,4367,3,712,356,0,4364,4367,3,714,357,0,4365, + 4367,3,716,358,0,4366,4362,1,0,0,0,4366,4363,1,0,0,0,4366,4364,1, + 0,0,0,4366,4365,1,0,0,0,4367,709,1,0,0,0,4368,4370,5,472,0,0,4369, + 4371,3,718,359,0,4370,4369,1,0,0,0,4371,4372,1,0,0,0,4372,4370,1, + 0,0,0,4372,4373,1,0,0,0,4373,711,1,0,0,0,4374,4377,5,394,0,0,4375, + 4378,3,722,361,0,4376,4378,3,726,363,0,4377,4375,1,0,0,0,4377,4376, + 1,0,0,0,4378,4379,1,0,0,0,4379,4377,1,0,0,0,4379,4380,1,0,0,0,4380, + 713,1,0,0,0,4381,4383,5,472,0,0,4382,4384,3,718,359,0,4383,4382, + 1,0,0,0,4384,4385,1,0,0,0,4385,4383,1,0,0,0,4385,4386,1,0,0,0,4386, + 4388,1,0,0,0,4387,4389,3,712,356,0,4388,4387,1,0,0,0,4389,4390,1, + 0,0,0,4390,4388,1,0,0,0,4390,4391,1,0,0,0,4391,715,1,0,0,0,4392, + 4395,5,101,0,0,4393,4396,3,1074,537,0,4394,4396,3,1172,586,0,4395, + 4393,1,0,0,0,4395,4394,1,0,0,0,4396,4397,1,0,0,0,4397,4401,3,734, + 367,0,4398,4400,3,736,368,0,4399,4398,1,0,0,0,4400,4403,1,0,0,0, + 4401,4399,1,0,0,0,4401,4402,1,0,0,0,4402,717,1,0,0,0,4403,4401,1, + 0,0,0,4404,4405,3,1074,537,0,4405,4408,5,212,0,0,4406,4409,3,720, + 360,0,4407,4409,3,724,362,0,4408,4406,1,0,0,0,4408,4407,1,0,0,0, + 4409,4410,1,0,0,0,4410,4408,1,0,0,0,4410,4411,1,0,0,0,4411,719,1, + 0,0,0,4412,4416,5,63,0,0,4413,4415,3,736,368,0,4414,4413,1,0,0,0, + 4415,4418,1,0,0,0,4416,4414,1,0,0,0,4416,4417,1,0,0,0,4417,721,1, + 0,0,0,4418,4416,1,0,0,0,4419,4420,5,63,0,0,4420,4424,3,732,366,0, + 4421,4423,3,736,368,0,4422,4421,1,0,0,0,4423,4426,1,0,0,0,4424,4422, + 1,0,0,0,4424,4425,1,0,0,0,4425,723,1,0,0,0,4426,4424,1,0,0,0,4427, + 4429,7,54,0,0,4428,4430,3,728,364,0,4429,4428,1,0,0,0,4430,4431, + 1,0,0,0,4431,4429,1,0,0,0,4431,4432,1,0,0,0,4432,725,1,0,0,0,4433, + 4435,7,55,0,0,4434,4436,3,730,365,0,4435,4434,1,0,0,0,4436,4437, + 1,0,0,0,4437,4435,1,0,0,0,4437,4438,1,0,0,0,4438,727,1,0,0,0,4439, + 4442,3,1074,537,0,4440,4442,3,1172,586,0,4441,4439,1,0,0,0,4441, + 4440,1,0,0,0,4442,4446,1,0,0,0,4443,4445,3,736,368,0,4444,4443,1, + 0,0,0,4445,4448,1,0,0,0,4446,4444,1,0,0,0,4446,4447,1,0,0,0,4447, + 729,1,0,0,0,4448,4446,1,0,0,0,4449,4452,3,1074,537,0,4450,4452,3, + 1172,586,0,4451,4449,1,0,0,0,4451,4450,1,0,0,0,4452,4453,1,0,0,0, + 4453,4457,3,732,366,0,4454,4456,3,736,368,0,4455,4454,1,0,0,0,4456, + 4459,1,0,0,0,4457,4455,1,0,0,0,4457,4458,1,0,0,0,4458,731,1,0,0, + 0,4459,4457,1,0,0,0,4460,4463,5,49,0,0,4461,4464,3,1074,537,0,4462, + 4464,3,1172,586,0,4463,4461,1,0,0,0,4463,4462,1,0,0,0,4464,733,1, + 0,0,0,4465,4468,5,489,0,0,4466,4469,3,1074,537,0,4467,4469,3,1172, + 586,0,4468,4466,1,0,0,0,4468,4467,1,0,0,0,4469,735,1,0,0,0,4470, + 4472,7,56,0,0,4471,4473,5,243,0,0,4472,4471,1,0,0,0,4472,4473,1, + 0,0,0,4473,4476,1,0,0,0,4474,4477,3,1074,537,0,4475,4477,3,1172, + 586,0,4476,4474,1,0,0,0,4476,4475,1,0,0,0,4477,737,1,0,0,0,4478, + 4479,5,294,0,0,4479,4481,3,1134,567,0,4480,4482,3,740,370,0,4481, + 4480,1,0,0,0,4482,4483,1,0,0,0,4483,4481,1,0,0,0,4483,4484,1,0,0, + 0,4484,4486,1,0,0,0,4485,4487,3,742,371,0,4486,4485,1,0,0,0,4486, + 4487,1,0,0,0,4487,4491,1,0,0,0,4488,4490,3,748,374,0,4489,4488,1, + 0,0,0,4490,4493,1,0,0,0,4491,4489,1,0,0,0,4491,4492,1,0,0,0,4492, + 4495,1,0,0,0,4493,4491,1,0,0,0,4494,4496,3,750,375,0,4495,4494,1, + 0,0,0,4495,4496,1,0,0,0,4496,4500,1,0,0,0,4497,4499,3,754,377,0, + 4498,4497,1,0,0,0,4499,4502,1,0,0,0,4500,4498,1,0,0,0,4500,4501, + 1,0,0,0,4501,739,1,0,0,0,4502,4500,1,0,0,0,4503,4505,5,326,0,0,4504, + 4503,1,0,0,0,4504,4505,1,0,0,0,4505,4506,1,0,0,0,4506,4508,7,41, + 0,0,4507,4509,5,259,0,0,4508,4507,1,0,0,0,4508,4509,1,0,0,0,4509, + 4511,1,0,0,0,4510,4512,3,1090,545,0,4511,4510,1,0,0,0,4512,4513, + 1,0,0,0,4513,4511,1,0,0,0,4513,4514,1,0,0,0,4514,741,1,0,0,0,4515, + 4517,5,72,0,0,4516,4515,1,0,0,0,4516,4517,1,0,0,0,4517,4518,1,0, + 0,0,4518,4520,5,428,0,0,4519,4521,5,254,0,0,4520,4519,1,0,0,0,4520, + 4521,1,0,0,0,4521,4523,1,0,0,0,4522,4524,3,1114,557,0,4523,4522, + 1,0,0,0,4524,4525,1,0,0,0,4525,4523,1,0,0,0,4525,4526,1,0,0,0,4526, + 4528,1,0,0,0,4527,4529,3,744,372,0,4528,4527,1,0,0,0,4528,4529,1, + 0,0,0,4529,4531,1,0,0,0,4530,4532,3,746,373,0,4531,4530,1,0,0,0, + 4531,4532,1,0,0,0,4532,743,1,0,0,0,4533,4535,5,212,0,0,4534,4533, + 1,0,0,0,4534,4535,1,0,0,0,4535,4536,1,0,0,0,4536,4537,5,14,0,0,4537, + 4538,5,254,0,0,4538,4539,3,1114,557,0,4539,745,1,0,0,0,4540,4542, + 5,212,0,0,4541,4540,1,0,0,0,4541,4542,1,0,0,0,4542,4543,1,0,0,0, + 4543,4545,5,304,0,0,4544,4546,5,254,0,0,4545,4544,1,0,0,0,4545,4546, + 1,0,0,0,4546,4547,1,0,0,0,4547,4548,3,1114,557,0,4548,747,1,0,0, + 0,4549,4551,5,506,0,0,4550,4552,3,1134,567,0,4551,4550,1,0,0,0,4552, + 4553,1,0,0,0,4553,4551,1,0,0,0,4553,4554,1,0,0,0,4554,749,1,0,0, + 0,4555,4556,5,334,0,0,4556,4558,5,356,0,0,4557,4559,5,254,0,0,4558, + 4557,1,0,0,0,4558,4559,1,0,0,0,4559,4560,1,0,0,0,4560,4562,3,1150, + 575,0,4561,4563,3,752,376,0,4562,4561,1,0,0,0,4562,4563,1,0,0,0, + 4563,751,1,0,0,0,4564,4565,7,4,0,0,4565,4566,3,1150,575,0,4566,753, + 1,0,0,0,4567,4569,5,222,0,0,4568,4570,3,756,378,0,4569,4568,1,0, + 0,0,4570,4571,1,0,0,0,4571,4569,1,0,0,0,4571,4572,1,0,0,0,4572,755, + 1,0,0,0,4573,4583,3,1134,567,0,4574,4584,5,286,0,0,4575,4584,5,415, + 0,0,4576,4577,5,310,0,0,4577,4584,5,407,0,0,4578,4584,5,106,0,0, + 4579,4584,5,387,0,0,4580,4581,5,514,0,0,4581,4582,5,391,0,0,4582, + 4584,5,106,0,0,4583,4574,1,0,0,0,4583,4575,1,0,0,0,4583,4576,1,0, + 0,0,4583,4578,1,0,0,0,4583,4579,1,0,0,0,4583,4580,1,0,0,0,4583,4584, + 1,0,0,0,4584,757,1,0,0,0,4585,4587,5,300,0,0,4586,4588,5,9,0,0,4587, + 4586,1,0,0,0,4587,4588,1,0,0,0,4588,4591,1,0,0,0,4589,4592,3,760, + 380,0,4590,4592,3,764,382,0,4591,4589,1,0,0,0,4591,4590,1,0,0,0, + 4592,759,1,0,0,0,4593,4594,3,762,381,0,4594,4596,5,489,0,0,4595, + 4597,3,1074,537,0,4596,4595,1,0,0,0,4597,4598,1,0,0,0,4598,4596, + 1,0,0,0,4598,4599,1,0,0,0,4599,761,1,0,0,0,4600,4603,3,1074,537, + 0,4601,4603,3,1172,586,0,4602,4600,1,0,0,0,4602,4601,1,0,0,0,4603, + 763,1,0,0,0,4604,4605,7,50,0,0,4605,4606,3,766,383,0,4606,4608,5, + 489,0,0,4607,4609,3,1074,537,0,4608,4607,1,0,0,0,4609,4610,1,0,0, + 0,4610,4608,1,0,0,0,4610,4611,1,0,0,0,4611,765,1,0,0,0,4612,4613, + 3,1074,537,0,4613,767,1,0,0,0,4614,4617,5,302,0,0,4615,4618,3,1074, + 537,0,4616,4618,3,1172,586,0,4617,4615,1,0,0,0,4617,4616,1,0,0,0, + 4618,4619,1,0,0,0,4619,4622,5,49,0,0,4620,4623,3,770,385,0,4621, + 4623,3,774,387,0,4622,4620,1,0,0,0,4622,4621,1,0,0,0,4623,4625,1, + 0,0,0,4624,4626,3,1024,512,0,4625,4624,1,0,0,0,4625,4626,1,0,0,0, + 4626,4628,1,0,0,0,4627,4629,3,1026,513,0,4628,4627,1,0,0,0,4628, + 4629,1,0,0,0,4629,4631,1,0,0,0,4630,4632,5,167,0,0,4631,4630,1,0, + 0,0,4631,4632,1,0,0,0,4632,769,1,0,0,0,4633,4635,3,772,386,0,4634, + 4633,1,0,0,0,4635,4636,1,0,0,0,4636,4634,1,0,0,0,4636,4637,1,0,0, + 0,4637,771,1,0,0,0,4638,4640,3,1074,537,0,4639,4641,5,412,0,0,4640, + 4639,1,0,0,0,4640,4641,1,0,0,0,4641,773,1,0,0,0,4642,4643,3,776, + 388,0,4643,4645,5,222,0,0,4644,4646,3,778,389,0,4645,4644,1,0,0, + 0,4646,4647,1,0,0,0,4647,4645,1,0,0,0,4647,4648,1,0,0,0,4648,775, + 1,0,0,0,4649,4652,3,1074,537,0,4650,4652,3,1172,586,0,4651,4649, + 1,0,0,0,4651,4650,1,0,0,0,4652,777,1,0,0,0,4653,4655,3,1074,537, + 0,4654,4656,5,412,0,0,4655,4654,1,0,0,0,4655,4656,1,0,0,0,4656,779, + 1,0,0,0,4657,4662,5,327,0,0,4658,4663,3,782,391,0,4659,4663,3,786, + 393,0,4660,4663,3,790,395,0,4661,4663,3,792,396,0,4662,4658,1,0, + 0,0,4662,4659,1,0,0,0,4662,4660,1,0,0,0,4662,4661,1,0,0,0,4663,4664, + 1,0,0,0,4664,4662,1,0,0,0,4664,4665,1,0,0,0,4665,781,1,0,0,0,4666, + 4668,5,246,0,0,4667,4669,3,784,392,0,4668,4667,1,0,0,0,4669,4670, + 1,0,0,0,4670,4668,1,0,0,0,4670,4671,1,0,0,0,4671,783,1,0,0,0,4672, + 4679,3,1134,567,0,4673,4680,5,406,0,0,4674,4676,5,514,0,0,4675,4674, + 1,0,0,0,4675,4676,1,0,0,0,4676,4677,1,0,0,0,4677,4678,5,310,0,0, + 4678,4680,5,407,0,0,4679,4673,1,0,0,0,4679,4675,1,0,0,0,4679,4680, + 1,0,0,0,4680,785,1,0,0,0,4681,4683,5,334,0,0,4682,4684,3,788,394, + 0,4683,4682,1,0,0,0,4684,4685,1,0,0,0,4685,4683,1,0,0,0,4685,4686, + 1,0,0,0,4686,787,1,0,0,0,4687,4693,3,1134,567,0,4688,4690,5,514, + 0,0,4689,4688,1,0,0,0,4689,4690,1,0,0,0,4690,4691,1,0,0,0,4691,4692, + 5,310,0,0,4692,4694,5,407,0,0,4693,4689,1,0,0,0,4693,4694,1,0,0, + 0,4694,789,1,0,0,0,4695,4697,5,232,0,0,4696,4698,3,1134,567,0,4697, + 4696,1,0,0,0,4698,4699,1,0,0,0,4699,4697,1,0,0,0,4699,4700,1,0,0, + 0,4700,791,1,0,0,0,4701,4703,5,201,0,0,4702,4704,3,1134,567,0,4703, + 4702,1,0,0,0,4704,4705,1,0,0,0,4705,4703,1,0,0,0,4705,4706,1,0,0, + 0,4706,793,1,0,0,0,4707,4710,5,343,0,0,4708,4711,3,796,398,0,4709, + 4711,3,798,399,0,4710,4708,1,0,0,0,4710,4709,1,0,0,0,4711,795,1, + 0,0,0,4712,4714,3,800,400,0,4713,4712,1,0,0,0,4713,4714,1,0,0,0, + 4714,4718,1,0,0,0,4715,4717,3,536,268,0,4716,4715,1,0,0,0,4717,4720, + 1,0,0,0,4718,4716,1,0,0,0,4718,4719,1,0,0,0,4719,4721,1,0,0,0,4720, + 4718,1,0,0,0,4721,4722,5,169,0,0,4722,797,1,0,0,0,4723,4726,3,1150, + 575,0,4724,4725,7,4,0,0,4725,4727,3,1150,575,0,4726,4724,1,0,0,0, + 4726,4727,1,0,0,0,4727,4729,1,0,0,0,4728,4730,3,800,400,0,4729,4728, + 1,0,0,0,4729,4730,1,0,0,0,4730,799,1,0,0,0,4731,4735,3,802,401,0, + 4732,4735,3,804,402,0,4733,4735,3,806,403,0,4734,4731,1,0,0,0,4734, + 4732,1,0,0,0,4734,4733,1,0,0,0,4735,801,1,0,0,0,4736,4739,3,1074, + 537,0,4737,4739,3,1178,589,0,4738,4736,1,0,0,0,4738,4737,1,0,0,0, + 4739,4740,1,0,0,0,4740,4741,5,487,0,0,4741,803,1,0,0,0,4742,4744, + 3,818,409,0,4743,4742,1,0,0,0,4743,4744,1,0,0,0,4744,4745,1,0,0, + 0,4745,4746,5,501,0,0,4746,4747,3,1046,523,0,4747,805,1,0,0,0,4748, + 4749,3,818,409,0,4749,4750,3,808,404,0,4750,4756,1,0,0,0,4751,4753, + 3,808,404,0,4752,4754,3,818,409,0,4753,4752,1,0,0,0,4753,4754,1, + 0,0,0,4754,4756,1,0,0,0,4755,4748,1,0,0,0,4755,4751,1,0,0,0,4756, + 807,1,0,0,0,4757,4758,5,509,0,0,4758,4762,3,810,405,0,4759,4761, + 3,812,406,0,4760,4759,1,0,0,0,4761,4764,1,0,0,0,4762,4760,1,0,0, + 0,4762,4763,1,0,0,0,4763,809,1,0,0,0,4764,4762,1,0,0,0,4765,4768, + 3,1074,537,0,4766,4768,3,1172,586,0,4767,4765,1,0,0,0,4767,4766, + 1,0,0,0,4768,4769,1,0,0,0,4769,4770,3,814,407,0,4770,4771,3,816, + 408,0,4771,4772,3,804,402,0,4772,811,1,0,0,0,4773,4774,5,7,0,0,4774, + 4775,3,810,405,0,4775,813,1,0,0,0,4776,4780,5,215,0,0,4777,4781, + 3,1074,537,0,4778,4781,3,1172,586,0,4779,4781,3,1032,516,0,4780, + 4777,1,0,0,0,4780,4778,1,0,0,0,4780,4779,1,0,0,0,4781,815,1,0,0, + 0,4782,4786,5,49,0,0,4783,4787,3,1074,537,0,4784,4787,3,1172,586, + 0,4785,4787,3,1032,516,0,4786,4783,1,0,0,0,4786,4784,1,0,0,0,4786, + 4785,1,0,0,0,4787,817,1,0,0,0,4788,4790,5,514,0,0,4789,4788,1,0, + 0,0,4789,4790,1,0,0,0,4790,4791,1,0,0,0,4791,4792,5,477,0,0,4792, + 4793,7,56,0,0,4793,819,1,0,0,0,4794,4796,5,365,0,0,4795,4797,3,1120, + 560,0,4796,4795,1,0,0,0,4797,4798,1,0,0,0,4798,4796,1,0,0,0,4798, + 4799,1,0,0,0,4799,821,1,0,0,0,4800,4801,5,374,0,0,4801,4803,3,1134, + 567,0,4802,4804,5,309,0,0,4803,4802,1,0,0,0,4803,4804,1,0,0,0,4804, + 4806,1,0,0,0,4805,4807,5,377,0,0,4806,4805,1,0,0,0,4806,4807,1,0, + 0,0,4807,4809,1,0,0,0,4808,4810,3,824,412,0,4809,4808,1,0,0,0,4809, + 4810,1,0,0,0,4810,4812,1,0,0,0,4811,4813,3,826,413,0,4812,4811,1, + 0,0,0,4812,4813,1,0,0,0,4813,4815,1,0,0,0,4814,4816,3,828,414,0, + 4815,4814,1,0,0,0,4815,4816,1,0,0,0,4816,4818,1,0,0,0,4817,4819, + 3,1016,508,0,4818,4817,1,0,0,0,4818,4819,1,0,0,0,4819,4821,1,0,0, + 0,4820,4822,3,1018,509,0,4821,4820,1,0,0,0,4821,4822,1,0,0,0,4822, + 4824,1,0,0,0,4823,4825,3,1012,506,0,4824,4823,1,0,0,0,4824,4825, + 1,0,0,0,4825,4827,1,0,0,0,4826,4828,3,1014,507,0,4827,4826,1,0,0, + 0,4827,4828,1,0,0,0,4828,4830,1,0,0,0,4829,4831,5,170,0,0,4830,4829, + 1,0,0,0,4830,4831,1,0,0,0,4831,823,1,0,0,0,4832,4833,5,251,0,0,4833, + 4834,3,1074,537,0,4834,825,1,0,0,0,4835,4837,5,514,0,0,4836,4835, + 1,0,0,0,4836,4837,1,0,0,0,4837,4841,1,0,0,0,4838,4839,7,57,0,0,4839, + 4842,5,286,0,0,4840,4842,5,511,0,0,4841,4838,1,0,0,0,4841,4840,1, + 0,0,0,4842,827,1,0,0,0,4843,4845,5,259,0,0,4844,4846,5,254,0,0,4845, + 4844,1,0,0,0,4845,4846,1,0,0,0,4846,4847,1,0,0,0,4847,4848,3,1090, + 545,0,4848,829,1,0,0,0,4849,4852,5,375,0,0,4850,4853,3,832,416,0, + 4851,4853,3,836,418,0,4852,4850,1,0,0,0,4852,4851,1,0,0,0,4853,4855, + 1,0,0,0,4854,4856,3,1028,514,0,4855,4854,1,0,0,0,4855,4856,1,0,0, + 0,4856,4858,1,0,0,0,4857,4859,3,1030,515,0,4858,4857,1,0,0,0,4858, + 4859,1,0,0,0,4859,4861,1,0,0,0,4860,4862,5,171,0,0,4861,4860,1,0, + 0,0,4861,4862,1,0,0,0,4862,831,1,0,0,0,4863,4864,3,1128,564,0,4864, + 4865,5,215,0,0,4865,4873,3,834,417,0,4866,4872,3,842,421,0,4867, + 4872,3,844,422,0,4868,4872,3,846,423,0,4869,4872,3,848,424,0,4870, + 4872,3,850,425,0,4871,4866,1,0,0,0,4871,4867,1,0,0,0,4871,4868,1, + 0,0,0,4871,4869,1,0,0,0,4871,4870,1,0,0,0,4872,4875,1,0,0,0,4873, + 4871,1,0,0,0,4873,4874,1,0,0,0,4874,833,1,0,0,0,4875,4873,1,0,0, + 0,4876,4877,5,481,0,0,4877,4883,3,1128,564,0,4878,4879,5,263,0,0, + 4879,4883,5,481,0,0,4880,4881,5,20,0,0,4881,4883,5,481,0,0,4882, + 4876,1,0,0,0,4882,4878,1,0,0,0,4882,4880,1,0,0,0,4883,835,1,0,0, + 0,4884,4885,3,1120,560,0,4885,4887,7,58,0,0,4886,4888,5,251,0,0, + 4887,4886,1,0,0,0,4887,4888,1,0,0,0,4888,4889,1,0,0,0,4889,4891, + 3,1074,537,0,4890,4892,3,838,419,0,4891,4890,1,0,0,0,4891,4892,1, + 0,0,0,4892,4894,1,0,0,0,4893,4895,3,840,420,0,4894,4893,1,0,0,0, + 4894,4895,1,0,0,0,4895,837,1,0,0,0,4896,4897,5,310,0,0,4897,4901, + 5,109,0,0,4898,4900,3,536,268,0,4899,4898,1,0,0,0,4900,4903,1,0, + 0,0,4901,4899,1,0,0,0,4901,4902,1,0,0,0,4902,839,1,0,0,0,4903,4901, + 1,0,0,0,4904,4905,5,514,0,0,4905,4909,5,109,0,0,4906,4908,3,536, + 268,0,4907,4906,1,0,0,0,4908,4911,1,0,0,0,4909,4907,1,0,0,0,4909, + 4910,1,0,0,0,4910,841,1,0,0,0,4911,4909,1,0,0,0,4912,4914,5,39,0, + 0,4913,4915,5,485,0,0,4914,4913,1,0,0,0,4914,4915,1,0,0,0,4915,4918, + 1,0,0,0,4916,4919,3,1176,588,0,4917,4919,3,1074,537,0,4918,4916, + 1,0,0,0,4918,4917,1,0,0,0,4919,843,1,0,0,0,4920,4922,5,514,0,0,4921, + 4920,1,0,0,0,4921,4922,1,0,0,0,4922,4923,1,0,0,0,4923,4924,5,310, + 0,0,4924,4925,5,511,0,0,4925,845,1,0,0,0,4926,4928,5,481,0,0,4927, + 4929,5,239,0,0,4928,4927,1,0,0,0,4928,4929,1,0,0,0,4929,4930,1,0, + 0,0,4930,4931,3,1128,564,0,4931,847,1,0,0,0,4932,4934,5,439,0,0, + 4933,4935,5,239,0,0,4934,4933,1,0,0,0,4934,4935,1,0,0,0,4935,4938, + 1,0,0,0,4936,4939,3,1176,588,0,4937,4939,3,1074,537,0,4938,4936, + 1,0,0,0,4938,4937,1,0,0,0,4939,849,1,0,0,0,4940,4942,5,457,0,0,4941, + 4943,5,239,0,0,4942,4941,1,0,0,0,4942,4943,1,0,0,0,4943,4944,1,0, + 0,0,4944,4945,3,1074,537,0,4945,851,1,0,0,0,4946,4947,5,387,0,0, + 4947,4950,3,1154,577,0,4948,4949,5,215,0,0,4949,4951,3,1090,545, + 0,4950,4948,1,0,0,0,4950,4951,1,0,0,0,4951,853,1,0,0,0,4952,4953, + 5,403,0,0,4953,4955,3,1134,567,0,4954,4956,5,377,0,0,4955,4954,1, + 0,0,0,4955,4956,1,0,0,0,4956,4958,1,0,0,0,4957,4959,3,856,428,0, + 4958,4957,1,0,0,0,4958,4959,1,0,0,0,4959,4960,1,0,0,0,4960,4962, + 3,1012,506,0,4961,4963,3,1014,507,0,4962,4961,1,0,0,0,4962,4963, + 1,0,0,0,4963,4965,1,0,0,0,4964,4966,5,172,0,0,4965,4964,1,0,0,0, + 4965,4966,1,0,0,0,4966,855,1,0,0,0,4967,4968,5,251,0,0,4968,4969, + 3,1090,545,0,4969,857,1,0,0,0,4970,4971,5,408,0,0,4971,4973,3,1154, + 577,0,4972,4974,3,860,430,0,4973,4972,1,0,0,0,4973,4974,1,0,0,0, + 4974,4976,1,0,0,0,4975,4977,3,1016,508,0,4976,4975,1,0,0,0,4976, + 4977,1,0,0,0,4977,4979,1,0,0,0,4978,4980,3,1018,509,0,4979,4978, + 1,0,0,0,4979,4980,1,0,0,0,4980,4982,1,0,0,0,4981,4983,5,173,0,0, + 4982,4981,1,0,0,0,4982,4983,1,0,0,0,4983,859,1,0,0,0,4984,4985,5, + 215,0,0,4985,4986,3,1074,537,0,4986,861,1,0,0,0,4987,4989,5,418, + 0,0,4988,4990,5,9,0,0,4989,4988,1,0,0,0,4989,4990,1,0,0,0,4990,4991, + 1,0,0,0,4991,4993,3,1090,545,0,4992,4994,3,864,432,0,4993,4992,1, + 0,0,0,4993,4994,1,0,0,0,4994,4996,1,0,0,0,4995,4997,3,1012,506,0, + 4996,4995,1,0,0,0,4996,4997,1,0,0,0,4997,4999,1,0,0,0,4998,5000, + 3,866,433,0,4999,4998,1,0,0,0,5000,5001,1,0,0,0,5001,4999,1,0,0, + 0,5001,5002,1,0,0,0,5002,5004,1,0,0,0,5003,5005,5,174,0,0,5004,5003, + 1,0,0,0,5004,5005,1,0,0,0,5005,863,1,0,0,0,5006,5007,5,509,0,0,5007, + 5008,3,1090,545,0,5008,865,1,0,0,0,5009,5010,5,512,0,0,5010,5019, + 3,1046,523,0,5011,5012,5,309,0,0,5012,5020,5,426,0,0,5013,5015,3, + 536,268,0,5014,5013,1,0,0,0,5015,5018,1,0,0,0,5016,5014,1,0,0,0, + 5016,5017,1,0,0,0,5017,5020,1,0,0,0,5018,5016,1,0,0,0,5019,5011, + 1,0,0,0,5019,5016,1,0,0,0,5020,867,1,0,0,0,5021,5024,5,425,0,0,5022, + 5025,3,870,435,0,5023,5025,3,872,436,0,5024,5022,1,0,0,0,5024,5023, + 1,0,0,0,5025,5027,1,0,0,0,5026,5028,3,1028,514,0,5027,5026,1,0,0, + 0,5027,5028,1,0,0,0,5028,5030,1,0,0,0,5029,5031,3,1030,515,0,5030, + 5029,1,0,0,0,5030,5031,1,0,0,0,5031,869,1,0,0,0,5032,5035,3,1074, + 537,0,5033,5035,3,1172,586,0,5034,5032,1,0,0,0,5034,5033,1,0,0,0, + 5035,5037,1,0,0,0,5036,5038,3,874,437,0,5037,5036,1,0,0,0,5037,5038, + 1,0,0,0,5038,5040,1,0,0,0,5039,5041,3,876,438,0,5040,5039,1,0,0, + 0,5040,5041,1,0,0,0,5041,5043,1,0,0,0,5042,5044,3,878,439,0,5043, + 5042,1,0,0,0,5043,5044,1,0,0,0,5044,5046,1,0,0,0,5045,5047,3,880, + 440,0,5046,5045,1,0,0,0,5046,5047,1,0,0,0,5047,871,1,0,0,0,5048, + 5049,5,489,0,0,5049,5050,7,59,0,0,5050,5051,3,1074,537,0,5051,873, + 1,0,0,0,5052,5053,5,215,0,0,5053,5054,3,1074,537,0,5054,875,1,0, + 0,0,5055,5060,5,514,0,0,5056,5061,5,153,0,0,5057,5061,5,155,0,0, + 5058,5061,5,192,0,0,5059,5061,3,1074,537,0,5060,5056,1,0,0,0,5060, + 5057,1,0,0,0,5060,5058,1,0,0,0,5060,5059,1,0,0,0,5061,877,1,0,0, + 0,5062,5064,5,394,0,0,5063,5065,5,279,0,0,5064,5063,1,0,0,0,5064, + 5065,1,0,0,0,5065,879,1,0,0,0,5066,5068,7,56,0,0,5067,5069,5,6,0, + 0,5068,5067,1,0,0,0,5068,5069,1,0,0,0,5069,5073,1,0,0,0,5070,5074, + 3,882,441,0,5071,5074,3,884,442,0,5072,5074,3,886,443,0,5073,5070, + 1,0,0,0,5073,5071,1,0,0,0,5073,5072,1,0,0,0,5074,881,1,0,0,0,5075, + 5076,5,340,0,0,5076,883,1,0,0,0,5077,5080,3,1074,537,0,5078,5080, + 3,1172,586,0,5079,5077,1,0,0,0,5079,5078,1,0,0,0,5080,5082,1,0,0, + 0,5081,5083,7,33,0,0,5082,5081,1,0,0,0,5082,5083,1,0,0,0,5083,885, + 1,0,0,0,5084,5085,3,1146,573,0,5085,887,1,0,0,0,5086,5093,5,430, + 0,0,5087,5089,3,890,445,0,5088,5087,1,0,0,0,5089,5090,1,0,0,0,5090, + 5088,1,0,0,0,5090,5091,1,0,0,0,5091,5094,1,0,0,0,5092,5094,3,892, + 446,0,5093,5088,1,0,0,0,5093,5092,1,0,0,0,5094,889,1,0,0,0,5095, + 5097,3,894,447,0,5096,5095,1,0,0,0,5097,5098,1,0,0,0,5098,5096,1, + 0,0,0,5098,5099,1,0,0,0,5099,5100,1,0,0,0,5100,5102,5,489,0,0,5101, + 5103,3,896,448,0,5102,5101,1,0,0,0,5103,5104,1,0,0,0,5104,5102,1, + 0,0,0,5104,5105,1,0,0,0,5105,891,1,0,0,0,5106,5108,3,894,447,0,5107, + 5106,1,0,0,0,5108,5109,1,0,0,0,5109,5107,1,0,0,0,5109,5110,1,0,0, + 0,5110,5115,1,0,0,0,5111,5112,5,502,0,0,5112,5116,5,49,0,0,5113, + 5114,5,148,0,0,5114,5116,5,49,0,0,5115,5111,1,0,0,0,5115,5113,1, + 0,0,0,5116,5117,1,0,0,0,5117,5118,3,898,449,0,5118,893,1,0,0,0,5119, + 5120,3,1074,537,0,5120,895,1,0,0,0,5121,5131,5,326,0,0,5122,5131, + 5,324,0,0,5123,5126,5,182,0,0,5124,5127,3,1074,537,0,5125,5127,3, + 1172,586,0,5126,5124,1,0,0,0,5126,5125,1,0,0,0,5127,5131,1,0,0,0, + 5128,5131,3,1074,537,0,5129,5131,3,1172,586,0,5130,5121,1,0,0,0, + 5130,5122,1,0,0,0,5130,5123,1,0,0,0,5130,5128,1,0,0,0,5130,5129, + 1,0,0,0,5131,897,1,0,0,0,5132,5135,3,1074,537,0,5133,5135,3,1172, + 586,0,5134,5132,1,0,0,0,5134,5133,1,0,0,0,5135,899,1,0,0,0,5136, + 5137,5,440,0,0,5137,5139,3,1134,567,0,5138,5140,3,902,451,0,5139, + 5138,1,0,0,0,5140,5141,1,0,0,0,5141,5139,1,0,0,0,5141,5142,1,0,0, + 0,5142,5144,1,0,0,0,5143,5145,3,904,452,0,5144,5143,1,0,0,0,5144, + 5145,1,0,0,0,5145,5147,1,0,0,0,5146,5148,3,906,453,0,5147,5146,1, + 0,0,0,5147,5148,1,0,0,0,5148,5150,1,0,0,0,5149,5151,3,912,456,0, + 5150,5149,1,0,0,0,5150,5151,1,0,0,0,5151,5155,1,0,0,0,5152,5154, + 3,916,458,0,5153,5152,1,0,0,0,5154,5157,1,0,0,0,5155,5153,1,0,0, + 0,5155,5156,1,0,0,0,5156,5159,1,0,0,0,5157,5155,1,0,0,0,5158,5160, + 3,918,459,0,5159,5158,1,0,0,0,5159,5160,1,0,0,0,5160,5164,1,0,0, + 0,5161,5163,3,922,461,0,5162,5161,1,0,0,0,5163,5166,1,0,0,0,5164, + 5162,1,0,0,0,5164,5165,1,0,0,0,5165,901,1,0,0,0,5166,5164,1,0,0, + 0,5167,5169,5,326,0,0,5168,5167,1,0,0,0,5168,5169,1,0,0,0,5169,5170, + 1,0,0,0,5170,5172,7,41,0,0,5171,5173,5,259,0,0,5172,5171,1,0,0,0, + 5172,5173,1,0,0,0,5173,5175,1,0,0,0,5174,5176,3,1090,545,0,5175, + 5174,1,0,0,0,5176,5177,1,0,0,0,5177,5175,1,0,0,0,5177,5178,1,0,0, + 0,5178,903,1,0,0,0,5179,5181,5,514,0,0,5180,5179,1,0,0,0,5180,5181, + 1,0,0,0,5181,5182,1,0,0,0,5182,5184,5,149,0,0,5183,5185,5,239,0, + 0,5184,5183,1,0,0,0,5184,5185,1,0,0,0,5185,5187,1,0,0,0,5186,5188, + 5,330,0,0,5187,5186,1,0,0,0,5187,5188,1,0,0,0,5188,905,1,0,0,0,5189, + 5191,5,72,0,0,5190,5189,1,0,0,0,5190,5191,1,0,0,0,5191,5192,1,0, + 0,0,5192,5194,5,428,0,0,5193,5195,5,254,0,0,5194,5193,1,0,0,0,5194, + 5195,1,0,0,0,5195,5197,1,0,0,0,5196,5198,3,1114,557,0,5197,5196, + 1,0,0,0,5198,5199,1,0,0,0,5199,5197,1,0,0,0,5199,5200,1,0,0,0,5200, + 5202,1,0,0,0,5201,5203,3,908,454,0,5202,5201,1,0,0,0,5202,5203,1, + 0,0,0,5203,5205,1,0,0,0,5204,5206,3,910,455,0,5205,5204,1,0,0,0, + 5205,5206,1,0,0,0,5206,907,1,0,0,0,5207,5209,5,212,0,0,5208,5207, + 1,0,0,0,5208,5209,1,0,0,0,5209,5210,1,0,0,0,5210,5211,5,14,0,0,5211, + 5212,5,254,0,0,5212,5213,3,1114,557,0,5213,909,1,0,0,0,5214,5216, + 5,212,0,0,5215,5214,1,0,0,0,5215,5216,1,0,0,0,5216,5217,1,0,0,0, + 5217,5219,5,304,0,0,5218,5220,5,254,0,0,5219,5218,1,0,0,0,5219,5220, + 1,0,0,0,5220,5221,1,0,0,0,5221,5222,3,1114,557,0,5222,911,1,0,0, + 0,5223,5224,5,246,0,0,5224,5226,5,356,0,0,5225,5227,5,254,0,0,5226, + 5225,1,0,0,0,5226,5227,1,0,0,0,5227,5228,1,0,0,0,5228,5230,3,1150, + 575,0,5229,5231,3,914,457,0,5230,5229,1,0,0,0,5230,5231,1,0,0,0, + 5231,913,1,0,0,0,5232,5233,7,4,0,0,5233,5234,3,1150,575,0,5234,915, + 1,0,0,0,5235,5237,5,506,0,0,5236,5238,3,1134,567,0,5237,5236,1,0, + 0,0,5238,5239,1,0,0,0,5239,5237,1,0,0,0,5239,5240,1,0,0,0,5240,917, + 1,0,0,0,5241,5242,5,334,0,0,5242,5244,5,356,0,0,5243,5245,5,254, + 0,0,5244,5243,1,0,0,0,5244,5245,1,0,0,0,5245,5246,1,0,0,0,5246,5248, + 3,1150,575,0,5247,5249,3,920,460,0,5248,5247,1,0,0,0,5248,5249,1, + 0,0,0,5249,919,1,0,0,0,5250,5251,7,4,0,0,5251,5252,3,1150,575,0, + 5252,921,1,0,0,0,5253,5255,5,222,0,0,5254,5256,3,924,462,0,5255, + 5254,1,0,0,0,5256,5257,1,0,0,0,5257,5255,1,0,0,0,5257,5258,1,0,0, + 0,5258,923,1,0,0,0,5259,5269,3,1134,567,0,5260,5270,5,286,0,0,5261, + 5270,5,415,0,0,5262,5263,5,310,0,0,5263,5270,5,407,0,0,5264,5270, + 5,106,0,0,5265,5270,5,387,0,0,5266,5267,5,514,0,0,5267,5268,5,391, + 0,0,5268,5270,5,106,0,0,5269,5260,1,0,0,0,5269,5261,1,0,0,0,5269, + 5262,1,0,0,0,5269,5264,1,0,0,0,5269,5265,1,0,0,0,5269,5266,1,0,0, + 0,5269,5270,1,0,0,0,5270,925,1,0,0,0,5271,5272,5,456,0,0,5272,5274, + 3,1134,567,0,5273,5275,3,928,464,0,5274,5273,1,0,0,0,5274,5275,1, + 0,0,0,5275,5277,1,0,0,0,5276,5278,3,1016,508,0,5277,5276,1,0,0,0, + 5277,5278,1,0,0,0,5278,5280,1,0,0,0,5279,5281,3,1018,509,0,5280, + 5279,1,0,0,0,5280,5281,1,0,0,0,5281,5283,1,0,0,0,5282,5284,5,175, + 0,0,5283,5282,1,0,0,0,5283,5284,1,0,0,0,5284,927,1,0,0,0,5285,5287, + 5,259,0,0,5286,5288,5,254,0,0,5287,5286,1,0,0,0,5287,5288,1,0,0, + 0,5288,5316,1,0,0,0,5289,5291,5,186,0,0,5290,5292,5,489,0,0,5291, + 5290,1,0,0,0,5291,5292,1,0,0,0,5292,5317,1,0,0,0,5293,5317,5,536, + 0,0,5294,5296,5,225,0,0,5295,5297,5,479,0,0,5296,5295,1,0,0,0,5296, + 5297,1,0,0,0,5297,5317,1,0,0,0,5298,5317,5,544,0,0,5299,5300,5,312, + 0,0,5300,5302,5,271,0,0,5301,5303,5,479,0,0,5302,5301,1,0,0,0,5302, + 5303,1,0,0,0,5303,5317,1,0,0,0,5304,5305,5,312,0,0,5305,5317,5,540, + 0,0,5306,5308,5,225,0,0,5307,5309,5,479,0,0,5308,5307,1,0,0,0,5308, + 5309,1,0,0,0,5309,5310,1,0,0,0,5310,5311,5,329,0,0,5311,5313,5,186, + 0,0,5312,5314,5,489,0,0,5313,5312,1,0,0,0,5313,5314,1,0,0,0,5314, + 5317,1,0,0,0,5315,5317,5,545,0,0,5316,5289,1,0,0,0,5316,5293,1,0, + 0,0,5316,5294,1,0,0,0,5316,5298,1,0,0,0,5316,5299,1,0,0,0,5316,5304, + 1,0,0,0,5316,5306,1,0,0,0,5316,5315,1,0,0,0,5317,5318,1,0,0,0,5318, + 5319,3,1090,545,0,5319,929,1,0,0,0,5320,5323,5,458,0,0,5321,5324, + 5,413,0,0,5322,5324,3,1172,586,0,5323,5321,1,0,0,0,5323,5322,1,0, + 0,0,5324,931,1,0,0,0,5325,5327,5,459,0,0,5326,5328,3,934,467,0,5327, + 5326,1,0,0,0,5328,5329,1,0,0,0,5329,5327,1,0,0,0,5329,5330,1,0,0, + 0,5330,5331,1,0,0,0,5331,5333,3,942,471,0,5332,5334,3,944,472,0, + 5333,5332,1,0,0,0,5333,5334,1,0,0,0,5334,5336,1,0,0,0,5335,5337, + 3,1020,510,0,5336,5335,1,0,0,0,5336,5337,1,0,0,0,5337,5339,1,0,0, + 0,5338,5340,3,1022,511,0,5339,5338,1,0,0,0,5339,5340,1,0,0,0,5340, + 5342,1,0,0,0,5341,5343,5,176,0,0,5342,5341,1,0,0,0,5342,5343,1,0, + 0,0,5343,933,1,0,0,0,5344,5346,3,936,468,0,5345,5344,1,0,0,0,5346, + 5347,1,0,0,0,5347,5345,1,0,0,0,5347,5348,1,0,0,0,5348,5351,1,0,0, + 0,5349,5352,3,938,469,0,5350,5352,3,940,470,0,5351,5349,1,0,0,0, + 5351,5350,1,0,0,0,5352,935,1,0,0,0,5353,5356,3,1074,537,0,5354,5356, + 3,1172,586,0,5355,5353,1,0,0,0,5355,5354,1,0,0,0,5356,937,1,0,0, + 0,5357,5359,5,132,0,0,5358,5360,5,49,0,0,5359,5358,1,0,0,0,5359, + 5360,1,0,0,0,5360,5364,1,0,0,0,5361,5365,5,439,0,0,5362,5365,3,1074, + 537,0,5363,5365,3,1172,586,0,5364,5361,1,0,0,0,5364,5362,1,0,0,0, + 5364,5363,1,0,0,0,5365,939,1,0,0,0,5366,5369,5,212,0,0,5367,5370, + 3,1074,537,0,5368,5370,3,1172,586,0,5369,5367,1,0,0,0,5369,5368, + 1,0,0,0,5370,941,1,0,0,0,5371,5372,5,251,0,0,5372,5373,3,1074,537, + 0,5373,943,1,0,0,0,5374,5376,5,514,0,0,5375,5374,1,0,0,0,5375,5376, + 1,0,0,0,5376,5377,1,0,0,0,5377,5378,5,349,0,0,5378,5379,3,1090,545, + 0,5379,945,1,0,0,0,5380,5384,5,463,0,0,5381,5385,3,948,474,0,5382, + 5385,3,950,475,0,5383,5385,3,952,476,0,5384,5381,1,0,0,0,5384,5382, + 1,0,0,0,5384,5383,1,0,0,0,5385,5387,1,0,0,0,5386,5388,3,1024,512, + 0,5387,5386,1,0,0,0,5387,5388,1,0,0,0,5388,5390,1,0,0,0,5389,5391, + 3,1026,513,0,5390,5389,1,0,0,0,5390,5391,1,0,0,0,5391,5393,1,0,0, + 0,5392,5394,5,177,0,0,5393,5392,1,0,0,0,5393,5394,1,0,0,0,5394,947, + 1,0,0,0,5395,5397,3,954,477,0,5396,5395,1,0,0,0,5397,5398,1,0,0, + 0,5398,5396,1,0,0,0,5398,5399,1,0,0,0,5399,5400,1,0,0,0,5400,5402, + 5,215,0,0,5401,5403,3,956,478,0,5402,5401,1,0,0,0,5403,5404,1,0, + 0,0,5404,5402,1,0,0,0,5404,5405,1,0,0,0,5405,949,1,0,0,0,5406,5408, + 3,954,477,0,5407,5406,1,0,0,0,5408,5409,1,0,0,0,5409,5407,1,0,0, + 0,5409,5410,1,0,0,0,5410,5411,1,0,0,0,5411,5412,5,215,0,0,5412,5413, + 3,958,479,0,5413,5415,5,222,0,0,5414,5416,3,960,480,0,5415,5414, + 1,0,0,0,5416,5417,1,0,0,0,5417,5415,1,0,0,0,5417,5418,1,0,0,0,5418, + 951,1,0,0,0,5419,5420,7,50,0,0,5420,5421,3,1090,545,0,5421,5422, + 5,215,0,0,5422,5423,3,962,481,0,5423,953,1,0,0,0,5424,5427,3,1074, + 537,0,5425,5427,3,1172,586,0,5426,5424,1,0,0,0,5426,5425,1,0,0,0, + 5427,955,1,0,0,0,5428,5430,3,1074,537,0,5429,5431,5,412,0,0,5430, + 5429,1,0,0,0,5430,5431,1,0,0,0,5431,957,1,0,0,0,5432,5435,3,1074, + 537,0,5433,5435,3,1172,586,0,5434,5432,1,0,0,0,5434,5433,1,0,0,0, + 5435,959,1,0,0,0,5436,5438,3,1074,537,0,5437,5439,5,412,0,0,5438, + 5437,1,0,0,0,5438,5439,1,0,0,0,5439,961,1,0,0,0,5440,5442,3,1090, + 545,0,5441,5443,5,412,0,0,5442,5441,1,0,0,0,5442,5443,1,0,0,0,5443, + 963,1,0,0,0,5444,5445,5,476,0,0,5445,5446,3,1156,578,0,5446,965, + 1,0,0,0,5447,5448,5,500,0,0,5448,5449,3,968,484,0,5449,5451,3,974, + 487,0,5450,5452,3,982,491,0,5451,5450,1,0,0,0,5451,5452,1,0,0,0, + 5452,5454,1,0,0,0,5453,5455,3,984,492,0,5454,5453,1,0,0,0,5454,5455, + 1,0,0,0,5455,5457,1,0,0,0,5456,5458,3,1020,510,0,5457,5456,1,0,0, + 0,5457,5458,1,0,0,0,5458,5460,1,0,0,0,5459,5461,3,1022,511,0,5460, + 5459,1,0,0,0,5460,5461,1,0,0,0,5461,5463,1,0,0,0,5462,5464,5,178, + 0,0,5463,5462,1,0,0,0,5463,5464,1,0,0,0,5464,967,1,0,0,0,5465,5473, + 3,1074,537,0,5466,5470,3,970,485,0,5467,5469,3,972,486,0,5468,5467, + 1,0,0,0,5469,5472,1,0,0,0,5470,5468,1,0,0,0,5470,5471,1,0,0,0,5471, + 5474,1,0,0,0,5472,5470,1,0,0,0,5473,5466,1,0,0,0,5473,5474,1,0,0, + 0,5474,969,1,0,0,0,5475,5477,5,132,0,0,5476,5478,5,49,0,0,5477,5476, + 1,0,0,0,5477,5478,1,0,0,0,5478,5480,1,0,0,0,5479,5481,5,9,0,0,5480, + 5479,1,0,0,0,5480,5481,1,0,0,0,5481,5484,1,0,0,0,5482,5485,3,1074, + 537,0,5483,5485,3,1172,586,0,5484,5482,1,0,0,0,5484,5483,1,0,0,0, + 5485,971,1,0,0,0,5486,5488,5,329,0,0,5487,5489,5,9,0,0,5488,5487, + 1,0,0,0,5488,5489,1,0,0,0,5489,5492,1,0,0,0,5490,5493,3,1074,537, + 0,5491,5493,3,1172,586,0,5492,5490,1,0,0,0,5492,5491,1,0,0,0,5493, + 973,1,0,0,0,5494,5496,5,251,0,0,5495,5497,3,976,488,0,5496,5495, + 1,0,0,0,5497,5498,1,0,0,0,5498,5496,1,0,0,0,5498,5499,1,0,0,0,5499, + 975,1,0,0,0,5500,5502,3,1074,537,0,5501,5503,3,978,489,0,5502,5501, + 1,0,0,0,5502,5503,1,0,0,0,5503,5505,1,0,0,0,5504,5506,3,980,490, + 0,5505,5504,1,0,0,0,5505,5506,1,0,0,0,5506,977,1,0,0,0,5507,5509, + 5,133,0,0,5508,5510,5,239,0,0,5509,5508,1,0,0,0,5509,5510,1,0,0, + 0,5510,5511,1,0,0,0,5511,5512,3,1074,537,0,5512,979,1,0,0,0,5513, + 5515,5,105,0,0,5514,5516,5,239,0,0,5515,5514,1,0,0,0,5515,5516,1, + 0,0,0,5516,5517,1,0,0,0,5517,5518,3,1074,537,0,5518,981,1,0,0,0, + 5519,5521,5,514,0,0,5520,5519,1,0,0,0,5520,5521,1,0,0,0,5521,5522, + 1,0,0,0,5522,5523,5,349,0,0,5523,5524,3,1090,545,0,5524,983,1,0, + 0,0,5525,5527,5,472,0,0,5526,5528,5,239,0,0,5527,5526,1,0,0,0,5527, + 5528,1,0,0,0,5528,5529,1,0,0,0,5529,5530,3,1090,545,0,5530,985,1, + 0,0,0,5531,5534,5,505,0,0,5532,5535,3,988,494,0,5533,5535,3,992, + 496,0,5534,5532,1,0,0,0,5534,5533,1,0,0,0,5535,987,1,0,0,0,5536, + 5538,5,223,0,0,5537,5536,1,0,0,0,5537,5538,1,0,0,0,5538,5539,1,0, + 0,0,5539,5541,5,7,0,0,5540,5542,5,453,0,0,5541,5540,1,0,0,0,5541, + 5542,1,0,0,0,5542,5543,1,0,0,0,5543,5544,7,60,0,0,5544,5546,5,356, + 0,0,5545,5547,5,326,0,0,5546,5545,1,0,0,0,5546,5547,1,0,0,0,5547, + 5548,1,0,0,0,5548,5549,3,990,495,0,5549,989,1,0,0,0,5550,5560,5, + 246,0,0,5551,5560,5,334,0,0,5552,5560,5,232,0,0,5553,5560,5,201, + 0,0,5554,5556,3,1134,567,0,5555,5554,1,0,0,0,5556,5557,1,0,0,0,5557, + 5555,1,0,0,0,5557,5558,1,0,0,0,5558,5560,1,0,0,0,5559,5550,1,0,0, + 0,5559,5551,1,0,0,0,5559,5552,1,0,0,0,5559,5553,1,0,0,0,5559,5555, + 1,0,0,0,5560,991,1,0,0,0,5561,5563,5,212,0,0,5562,5561,1,0,0,0,5562, + 5563,1,0,0,0,5563,5564,1,0,0,0,5564,5566,5,125,0,0,5565,5567,5,326, + 0,0,5566,5565,1,0,0,0,5566,5567,1,0,0,0,5567,5569,1,0,0,0,5568,5570, + 3,994,497,0,5569,5568,1,0,0,0,5570,5571,1,0,0,0,5571,5569,1,0,0, + 0,5571,5572,1,0,0,0,5572,993,1,0,0,0,5573,5574,5,9,0,0,5574,5586, + 5,358,0,0,5575,5577,5,9,0,0,5576,5578,5,385,0,0,5577,5576,1,0,0, + 0,5577,5578,1,0,0,0,5578,5580,1,0,0,0,5579,5581,5,323,0,0,5580,5579, + 1,0,0,0,5580,5581,1,0,0,0,5581,5582,1,0,0,0,5582,5586,3,1074,537, + 0,5583,5586,3,1150,575,0,5584,5586,3,1134,567,0,5585,5573,1,0,0, + 0,5585,5575,1,0,0,0,5585,5583,1,0,0,0,5585,5584,1,0,0,0,5586,995, + 1,0,0,0,5587,5588,5,517,0,0,5588,5590,3,1154,577,0,5589,5591,3,998, + 499,0,5590,5589,1,0,0,0,5590,5591,1,0,0,0,5591,5593,1,0,0,0,5592, + 5594,3,1000,500,0,5593,5592,1,0,0,0,5593,5594,1,0,0,0,5594,5596, + 1,0,0,0,5595,5597,3,1008,504,0,5596,5595,1,0,0,0,5596,5597,1,0,0, + 0,5597,5599,1,0,0,0,5598,5600,3,1010,505,0,5599,5598,1,0,0,0,5599, + 5600,1,0,0,0,5600,5602,1,0,0,0,5601,5603,3,1016,508,0,5602,5601, + 1,0,0,0,5602,5603,1,0,0,0,5603,5605,1,0,0,0,5604,5606,3,1018,509, + 0,5605,5604,1,0,0,0,5605,5606,1,0,0,0,5606,5608,1,0,0,0,5607,5609, + 5,179,0,0,5608,5607,1,0,0,0,5608,5609,1,0,0,0,5609,997,1,0,0,0,5610, + 5613,5,215,0,0,5611,5614,3,1074,537,0,5612,5614,3,1172,586,0,5613, + 5611,1,0,0,0,5613,5612,1,0,0,0,5614,999,1,0,0,0,5615,5617,7,56,0, + 0,5616,5618,5,6,0,0,5617,5616,1,0,0,0,5617,5618,1,0,0,0,5618,5622, + 1,0,0,0,5619,5623,3,1002,501,0,5620,5623,3,1004,502,0,5621,5623, + 3,1006,503,0,5622,5619,1,0,0,0,5622,5620,1,0,0,0,5622,5621,1,0,0, + 0,5623,1001,1,0,0,0,5624,5625,5,340,0,0,5625,1003,1,0,0,0,5626,5629, + 3,1074,537,0,5627,5629,3,1172,586,0,5628,5626,1,0,0,0,5628,5627, + 1,0,0,0,5629,5631,1,0,0,0,5630,5632,7,33,0,0,5631,5630,1,0,0,0,5631, + 5632,1,0,0,0,5632,1005,1,0,0,0,5633,5634,3,1146,573,0,5634,1007, + 1,0,0,0,5635,5637,5,30,0,0,5636,5635,1,0,0,0,5636,5637,1,0,0,0,5637, + 5638,1,0,0,0,5638,5642,7,61,0,0,5639,5641,3,536,268,0,5640,5639, + 1,0,0,0,5641,5644,1,0,0,0,5642,5640,1,0,0,0,5642,5643,1,0,0,0,5643, + 1009,1,0,0,0,5644,5642,1,0,0,0,5645,5647,5,312,0,0,5646,5648,5,30, + 0,0,5647,5646,1,0,0,0,5647,5648,1,0,0,0,5648,5649,1,0,0,0,5649,5653, + 7,61,0,0,5650,5652,3,536,268,0,5651,5650,1,0,0,0,5652,5655,1,0,0, + 0,5653,5651,1,0,0,0,5653,5654,1,0,0,0,5654,1011,1,0,0,0,5655,5653, + 1,0,0,0,5656,5658,5,30,0,0,5657,5656,1,0,0,0,5657,5658,1,0,0,0,5658, + 5659,1,0,0,0,5659,5663,5,158,0,0,5660,5662,3,536,268,0,5661,5660, + 1,0,0,0,5662,5665,1,0,0,0,5663,5661,1,0,0,0,5663,5664,1,0,0,0,5664, + 1013,1,0,0,0,5665,5663,1,0,0,0,5666,5668,5,312,0,0,5667,5669,5,30, + 0,0,5668,5667,1,0,0,0,5668,5669,1,0,0,0,5669,5670,1,0,0,0,5670,5674, + 5,158,0,0,5671,5673,3,536,268,0,5672,5671,1,0,0,0,5673,5676,1,0, + 0,0,5674,5672,1,0,0,0,5674,5675,1,0,0,0,5675,1015,1,0,0,0,5676,5674, + 1,0,0,0,5677,5679,5,252,0,0,5678,5680,5,259,0,0,5679,5678,1,0,0, + 0,5679,5680,1,0,0,0,5680,5684,1,0,0,0,5681,5683,3,536,268,0,5682, + 5681,1,0,0,0,5683,5686,1,0,0,0,5684,5682,1,0,0,0,5684,5685,1,0,0, + 0,5685,1017,1,0,0,0,5686,5684,1,0,0,0,5687,5688,5,312,0,0,5688,5690, + 5,252,0,0,5689,5691,5,259,0,0,5690,5689,1,0,0,0,5690,5691,1,0,0, + 0,5691,5695,1,0,0,0,5692,5694,3,536,268,0,5693,5692,1,0,0,0,5694, + 5697,1,0,0,0,5695,5693,1,0,0,0,5695,5696,1,0,0,0,5696,1019,1,0,0, + 0,5697,5695,1,0,0,0,5698,5700,5,326,0,0,5699,5698,1,0,0,0,5699,5700, + 1,0,0,0,5700,5701,1,0,0,0,5701,5705,5,335,0,0,5702,5704,3,536,268, + 0,5703,5702,1,0,0,0,5704,5707,1,0,0,0,5705,5703,1,0,0,0,5705,5706, + 1,0,0,0,5706,1021,1,0,0,0,5707,5705,1,0,0,0,5708,5710,5,312,0,0, + 5709,5711,5,326,0,0,5710,5709,1,0,0,0,5710,5711,1,0,0,0,5711,5712, + 1,0,0,0,5712,5716,5,335,0,0,5713,5715,3,536,268,0,5714,5713,1,0, + 0,0,5715,5718,1,0,0,0,5716,5714,1,0,0,0,5716,5717,1,0,0,0,5717,1023, + 1,0,0,0,5718,5716,1,0,0,0,5719,5721,5,326,0,0,5720,5719,1,0,0,0, + 5720,5721,1,0,0,0,5721,5722,1,0,0,0,5722,5723,5,439,0,0,5723,5727, + 5,188,0,0,5724,5726,3,536,268,0,5725,5724,1,0,0,0,5726,5729,1,0, + 0,0,5727,5725,1,0,0,0,5727,5728,1,0,0,0,5728,1025,1,0,0,0,5729,5727, + 1,0,0,0,5730,5732,5,312,0,0,5731,5733,5,326,0,0,5732,5731,1,0,0, + 0,5732,5733,1,0,0,0,5733,5734,1,0,0,0,5734,5735,5,439,0,0,5735,5739, + 5,188,0,0,5736,5738,3,536,268,0,5737,5736,1,0,0,0,5738,5741,1,0, + 0,0,5739,5737,1,0,0,0,5739,5740,1,0,0,0,5740,1027,1,0,0,0,5741,5739, + 1,0,0,0,5742,5744,5,326,0,0,5743,5742,1,0,0,0,5743,5744,1,0,0,0, + 5744,5745,1,0,0,0,5745,5749,5,196,0,0,5746,5748,3,536,268,0,5747, + 5746,1,0,0,0,5748,5751,1,0,0,0,5749,5747,1,0,0,0,5749,5750,1,0,0, + 0,5750,1029,1,0,0,0,5751,5749,1,0,0,0,5752,5754,5,312,0,0,5753,5755, + 5,326,0,0,5754,5753,1,0,0,0,5754,5755,1,0,0,0,5755,5756,1,0,0,0, + 5756,5760,5,196,0,0,5757,5759,3,536,268,0,5758,5757,1,0,0,0,5759, + 5762,1,0,0,0,5760,5758,1,0,0,0,5760,5761,1,0,0,0,5761,1031,1,0,0, + 0,5762,5760,1,0,0,0,5763,5767,3,1036,518,0,5764,5766,3,1034,517, + 0,5765,5764,1,0,0,0,5766,5769,1,0,0,0,5767,5765,1,0,0,0,5767,5768, + 1,0,0,0,5768,1033,1,0,0,0,5769,5767,1,0,0,0,5770,5771,7,62,0,0,5771, + 5772,3,1036,518,0,5772,1035,1,0,0,0,5773,5777,3,1040,520,0,5774, + 5776,3,1038,519,0,5775,5774,1,0,0,0,5776,5779,1,0,0,0,5777,5775, + 1,0,0,0,5777,5778,1,0,0,0,5778,1037,1,0,0,0,5779,5777,1,0,0,0,5780, + 5781,7,63,0,0,5781,5782,3,1040,520,0,5782,1039,1,0,0,0,5783,5785, + 7,62,0,0,5784,5783,1,0,0,0,5784,5785,1,0,0,0,5785,5786,1,0,0,0,5786, + 5790,3,1044,522,0,5787,5789,3,1042,521,0,5788,5787,1,0,0,0,5789, + 5792,1,0,0,0,5790,5788,1,0,0,0,5790,5791,1,0,0,0,5791,1041,1,0,0, + 0,5792,5790,1,0,0,0,5793,5794,5,527,0,0,5794,5795,3,1044,522,0,5795, + 1043,1,0,0,0,5796,5797,5,542,0,0,5797,5798,3,1032,516,0,5798,5799, + 5,549,0,0,5799,5803,1,0,0,0,5800,5803,3,1074,537,0,5801,5803,3,1172, + 586,0,5802,5796,1,0,0,0,5802,5800,1,0,0,0,5802,5801,1,0,0,0,5803, + 1045,1,0,0,0,5804,5808,3,1050,525,0,5805,5807,3,1048,524,0,5806, + 5805,1,0,0,0,5807,5810,1,0,0,0,5808,5806,1,0,0,0,5808,5809,1,0,0, + 0,5809,1047,1,0,0,0,5810,5808,1,0,0,0,5811,5818,7,64,0,0,5812,5819, + 3,1050,525,0,5813,5815,3,1072,536,0,5814,5813,1,0,0,0,5815,5816, + 1,0,0,0,5816,5814,1,0,0,0,5816,5817,1,0,0,0,5817,5819,1,0,0,0,5818, + 5812,1,0,0,0,5818,5814,1,0,0,0,5819,1049,1,0,0,0,5820,5822,5,312, + 0,0,5821,5820,1,0,0,0,5821,5822,1,0,0,0,5822,5823,1,0,0,0,5823,5824, + 3,1052,526,0,5824,1051,1,0,0,0,5825,5826,5,542,0,0,5826,5827,3,1046, + 523,0,5827,5828,5,549,0,0,5828,5833,1,0,0,0,5829,5833,3,1060,530, + 0,5830,5833,3,1054,527,0,5831,5833,3,1056,528,0,5832,5825,1,0,0, + 0,5832,5829,1,0,0,0,5832,5830,1,0,0,0,5832,5831,1,0,0,0,5833,1053, + 1,0,0,0,5834,5836,3,1074,537,0,5835,5837,5,254,0,0,5836,5835,1,0, + 0,0,5836,5837,1,0,0,0,5837,5839,1,0,0,0,5838,5840,5,312,0,0,5839, + 5838,1,0,0,0,5839,5840,1,0,0,0,5840,5848,1,0,0,0,5841,5849,5,316, + 0,0,5842,5849,5,11,0,0,5843,5849,5,12,0,0,5844,5849,5,13,0,0,5845, + 5849,5,116,0,0,5846,5849,5,257,0,0,5847,5849,3,1122,561,0,5848,5841, + 1,0,0,0,5848,5842,1,0,0,0,5848,5843,1,0,0,0,5848,5844,1,0,0,0,5848, + 5845,1,0,0,0,5848,5846,1,0,0,0,5848,5847,1,0,0,0,5849,1055,1,0,0, + 0,5850,5872,3,1126,563,0,5851,5853,3,1102,551,0,5852,5851,1,0,0, + 0,5853,5856,1,0,0,0,5854,5852,1,0,0,0,5854,5855,1,0,0,0,5855,5858, + 1,0,0,0,5856,5854,1,0,0,0,5857,5859,3,1104,552,0,5858,5857,1,0,0, + 0,5858,5859,1,0,0,0,5859,5863,1,0,0,0,5860,5862,3,1058,529,0,5861, + 5860,1,0,0,0,5862,5865,1,0,0,0,5863,5861,1,0,0,0,5863,5864,1,0,0, + 0,5864,5873,1,0,0,0,5865,5863,1,0,0,0,5866,5868,3,1106,553,0,5867, + 5866,1,0,0,0,5868,5871,1,0,0,0,5869,5867,1,0,0,0,5869,5870,1,0,0, + 0,5870,5873,1,0,0,0,5871,5869,1,0,0,0,5872,5854,1,0,0,0,5872,5869, + 1,0,0,0,5873,1057,1,0,0,0,5874,5875,5,542,0,0,5875,5882,3,1086,543, + 0,5876,5878,5,529,0,0,5877,5876,1,0,0,0,5877,5878,1,0,0,0,5878,5879, + 1,0,0,0,5879,5881,3,1086,543,0,5880,5877,1,0,0,0,5881,5884,1,0,0, + 0,5882,5880,1,0,0,0,5882,5883,1,0,0,0,5883,5885,1,0,0,0,5884,5882, + 1,0,0,0,5885,5886,5,549,0,0,5886,1059,1,0,0,0,5887,5891,3,1062,531, + 0,5888,5891,3,1064,532,0,5889,5891,3,1066,533,0,5890,5887,1,0,0, + 0,5890,5888,1,0,0,0,5890,5889,1,0,0,0,5891,1061,1,0,0,0,5892,5894, + 3,1032,516,0,5893,5895,5,254,0,0,5894,5893,1,0,0,0,5894,5895,1,0, + 0,0,5895,5897,1,0,0,0,5896,5898,5,312,0,0,5897,5896,1,0,0,0,5897, + 5898,1,0,0,0,5898,5899,1,0,0,0,5899,5900,7,65,0,0,5900,1063,1,0, + 0,0,5901,5902,3,1032,516,0,5902,5903,3,1070,535,0,5903,5904,3,1032, + 516,0,5904,1065,1,0,0,0,5905,5906,3,1032,516,0,5906,5907,3,1070, + 535,0,5907,5908,5,542,0,0,5908,5909,3,1068,534,0,5909,5910,5,549, + 0,0,5910,1067,1,0,0,0,5911,5914,3,1032,516,0,5912,5913,7,64,0,0, + 5913,5915,3,1032,516,0,5914,5912,1,0,0,0,5915,5916,1,0,0,0,5916, + 5914,1,0,0,0,5916,5917,1,0,0,0,5917,1069,1,0,0,0,5918,5920,7,8,0, + 0,5919,5918,1,0,0,0,5919,5920,1,0,0,0,5920,5962,1,0,0,0,5921,5923, + 5,312,0,0,5922,5921,1,0,0,0,5922,5923,1,0,0,0,5923,5939,1,0,0,0, + 5924,5926,5,225,0,0,5925,5927,5,479,0,0,5926,5925,1,0,0,0,5926,5927, + 1,0,0,0,5927,5940,1,0,0,0,5928,5940,5,544,0,0,5929,5931,5,271,0, + 0,5930,5932,5,479,0,0,5931,5930,1,0,0,0,5931,5932,1,0,0,0,5932,5940, + 1,0,0,0,5933,5940,5,540,0,0,5934,5936,5,186,0,0,5935,5937,5,489, + 0,0,5936,5935,1,0,0,0,5936,5937,1,0,0,0,5937,5940,1,0,0,0,5938,5940, + 5,536,0,0,5939,5924,1,0,0,0,5939,5928,1,0,0,0,5939,5929,1,0,0,0, + 5939,5933,1,0,0,0,5939,5934,1,0,0,0,5939,5938,1,0,0,0,5940,5963, + 1,0,0,0,5941,5963,5,546,0,0,5942,5944,5,225,0,0,5943,5945,5,479, + 0,0,5944,5943,1,0,0,0,5944,5945,1,0,0,0,5945,5946,1,0,0,0,5946,5947, + 5,329,0,0,5947,5949,5,186,0,0,5948,5950,5,489,0,0,5949,5948,1,0, + 0,0,5949,5950,1,0,0,0,5950,5963,1,0,0,0,5951,5963,5,545,0,0,5952, + 5954,5,271,0,0,5953,5955,5,479,0,0,5954,5953,1,0,0,0,5954,5955,1, + 0,0,0,5955,5956,1,0,0,0,5956,5957,5,329,0,0,5957,5959,5,186,0,0, + 5958,5960,5,489,0,0,5959,5958,1,0,0,0,5959,5960,1,0,0,0,5960,5963, + 1,0,0,0,5961,5963,5,541,0,0,5962,5922,1,0,0,0,5962,5941,1,0,0,0, + 5962,5942,1,0,0,0,5962,5951,1,0,0,0,5962,5952,1,0,0,0,5962,5961, + 1,0,0,0,5963,1071,1,0,0,0,5964,5966,5,312,0,0,5965,5964,1,0,0,0, + 5965,5966,1,0,0,0,5966,5968,1,0,0,0,5967,5969,3,1070,535,0,5968, + 5967,1,0,0,0,5968,5969,1,0,0,0,5969,5976,1,0,0,0,5970,5977,3,1032, + 516,0,5971,5972,5,542,0,0,5972,5973,3,1032,516,0,5973,5974,3,1072, + 536,0,5974,5975,5,549,0,0,5975,5977,1,0,0,0,5976,5970,1,0,0,0,5976, + 5971,1,0,0,0,5977,1073,1,0,0,0,5978,5983,3,1090,545,0,5979,5983, + 3,1076,538,0,5980,5983,3,1078,539,0,5981,5983,3,1186,593,0,5982, + 5978,1,0,0,0,5982,5979,1,0,0,0,5982,5980,1,0,0,0,5982,5981,1,0,0, + 0,5983,1075,1,0,0,0,5984,6000,3,1090,545,0,5985,5986,5,542,0,0,5986, + 5993,3,1086,543,0,5987,5989,5,529,0,0,5988,5987,1,0,0,0,5988,5989, + 1,0,0,0,5989,5990,1,0,0,0,5990,5992,3,1086,543,0,5991,5988,1,0,0, + 0,5992,5995,1,0,0,0,5993,5991,1,0,0,0,5993,5994,1,0,0,0,5994,5996, + 1,0,0,0,5995,5993,1,0,0,0,5996,5997,5,549,0,0,5997,5999,1,0,0,0, + 5998,5985,1,0,0,0,5999,6002,1,0,0,0,6000,5998,1,0,0,0,6000,6001, + 1,0,0,0,6001,6004,1,0,0,0,6002,6000,1,0,0,0,6003,6005,3,1080,540, + 0,6004,6003,1,0,0,0,6004,6005,1,0,0,0,6005,1077,1,0,0,0,6006,6007, + 5,217,0,0,6007,6023,3,1136,568,0,6008,6009,5,542,0,0,6009,6016,3, + 1088,544,0,6010,6012,5,529,0,0,6011,6010,1,0,0,0,6011,6012,1,0,0, + 0,6012,6013,1,0,0,0,6013,6015,3,1088,544,0,6014,6011,1,0,0,0,6015, + 6018,1,0,0,0,6016,6014,1,0,0,0,6016,6017,1,0,0,0,6017,6019,1,0,0, + 0,6018,6016,1,0,0,0,6019,6020,5,549,0,0,6020,6022,1,0,0,0,6021,6008, + 1,0,0,0,6022,6025,1,0,0,0,6023,6021,1,0,0,0,6023,6024,1,0,0,0,6024, + 6027,1,0,0,0,6025,6023,1,0,0,0,6026,6028,3,1080,540,0,6027,6026, + 1,0,0,0,6027,6028,1,0,0,0,6028,1079,1,0,0,0,6029,6030,5,542,0,0, + 6030,6031,3,1082,541,0,6031,6033,5,528,0,0,6032,6034,3,1084,542, + 0,6033,6032,1,0,0,0,6033,6034,1,0,0,0,6034,6035,1,0,0,0,6035,6036, + 5,549,0,0,6036,1081,1,0,0,0,6037,6038,3,1032,516,0,6038,1083,1,0, + 0,0,6039,6040,3,1032,516,0,6040,1085,1,0,0,0,6041,6053,5,9,0,0,6042, + 6053,3,1178,589,0,6043,6045,3,1090,545,0,6044,6046,3,1178,589,0, + 6045,6044,1,0,0,0,6045,6046,1,0,0,0,6046,6053,1,0,0,0,6047,6049, + 3,1138,569,0,6048,6050,3,1178,589,0,6049,6048,1,0,0,0,6049,6050, + 1,0,0,0,6050,6053,1,0,0,0,6051,6053,3,1032,516,0,6052,6041,1,0,0, + 0,6052,6042,1,0,0,0,6052,6043,1,0,0,0,6052,6047,1,0,0,0,6052,6051, + 1,0,0,0,6053,1087,1,0,0,0,6054,6066,3,1172,586,0,6055,6066,3,1074, + 537,0,6056,6058,3,1090,545,0,6057,6059,3,1178,589,0,6058,6057,1, + 0,0,0,6058,6059,1,0,0,0,6059,6066,1,0,0,0,6060,6062,3,1138,569,0, + 6061,6063,3,1178,589,0,6062,6061,1,0,0,0,6062,6063,1,0,0,0,6063, + 6066,1,0,0,0,6064,6066,3,1032,516,0,6065,6054,1,0,0,0,6065,6055, + 1,0,0,0,6065,6056,1,0,0,0,6065,6060,1,0,0,0,6065,6064,1,0,0,0,6066, + 1089,1,0,0,0,6067,6072,3,1092,546,0,6068,6072,3,1094,547,0,6069, + 6072,3,1096,548,0,6070,6072,3,1098,549,0,6071,6067,1,0,0,0,6071, + 6068,1,0,0,0,6071,6069,1,0,0,0,6071,6070,1,0,0,0,6072,1091,1,0,0, + 0,6073,6076,3,1128,564,0,6074,6076,3,1126,563,0,6075,6073,1,0,0, + 0,6075,6074,1,0,0,0,6076,6086,1,0,0,0,6077,6079,3,1100,550,0,6078, + 6077,1,0,0,0,6079,6080,1,0,0,0,6080,6078,1,0,0,0,6080,6081,1,0,0, + 0,6081,6083,1,0,0,0,6082,6084,3,1104,552,0,6083,6082,1,0,0,0,6083, + 6084,1,0,0,0,6084,6087,1,0,0,0,6085,6087,3,1104,552,0,6086,6078, + 1,0,0,0,6086,6085,1,0,0,0,6086,6087,1,0,0,0,6087,1093,1,0,0,0,6088, + 6089,3,1148,574,0,6089,6090,3,1108,554,0,6090,1095,1,0,0,0,6091, + 6092,3,1168,584,0,6092,6093,3,1110,555,0,6093,1097,1,0,0,0,6094, + 6095,5,278,0,0,6095,6096,3,1104,552,0,6096,1099,1,0,0,0,6097,6100, + 3,1102,551,0,6098,6100,3,1112,556,0,6099,6097,1,0,0,0,6099,6098, + 1,0,0,0,6100,1101,1,0,0,0,6101,6102,7,66,0,0,6102,6103,3,1128,564, + 0,6103,1103,1,0,0,0,6104,6105,7,66,0,0,6105,6106,3,1134,567,0,6106, + 1105,1,0,0,0,6107,6108,7,66,0,0,6108,6109,3,1146,573,0,6109,1107, + 1,0,0,0,6110,6111,7,66,0,0,6111,6112,3,1162,581,0,6112,1109,1,0, + 0,0,6113,6114,7,66,0,0,6114,6115,3,1142,571,0,6115,1111,1,0,0,0, + 6116,6117,7,66,0,0,6117,6118,3,1076,538,0,6118,1113,1,0,0,0,6119, + 6120,3,1170,585,0,6120,1115,1,0,0,0,6121,6122,3,1164,582,0,6122, + 1117,1,0,0,0,6123,6124,3,1152,576,0,6124,1119,1,0,0,0,6125,6126, + 3,1170,585,0,6126,1121,1,0,0,0,6127,6128,3,1170,585,0,6128,1123, + 1,0,0,0,6129,6130,3,1164,582,0,6130,1125,1,0,0,0,6131,6132,3,1170, + 585,0,6132,1127,1,0,0,0,6133,6134,3,1170,585,0,6134,1129,1,0,0,0, + 6135,6139,5,208,0,0,6136,6139,5,108,0,0,6137,6139,3,1128,564,0,6138, + 6135,1,0,0,0,6138,6136,1,0,0,0,6138,6137,1,0,0,0,6139,1131,1,0,0, + 0,6140,6141,3,1164,582,0,6141,1133,1,0,0,0,6142,6143,3,1170,585, + 0,6143,1135,1,0,0,0,6144,6151,5,250,0,0,6145,6151,5,269,0,0,6146, + 6151,5,369,0,0,6147,6151,5,464,0,0,6148,6151,5,513,0,0,6149,6151, + 3,1170,585,0,6150,6144,1,0,0,0,6150,6145,1,0,0,0,6150,6146,1,0,0, + 0,6150,6147,1,0,0,0,6150,6148,1,0,0,0,6150,6149,1,0,0,0,6151,1137, + 1,0,0,0,6152,6153,3,1170,585,0,6153,1139,1,0,0,0,6154,6155,3,1164, + 582,0,6155,1141,1,0,0,0,6156,6157,3,1170,585,0,6157,1143,1,0,0,0, + 6158,6159,3,1170,585,0,6159,1145,1,0,0,0,6160,6161,3,1170,585,0, + 6161,1147,1,0,0,0,6162,6165,3,1170,585,0,6163,6165,3,1178,589,0, + 6164,6162,1,0,0,0,6164,6163,1,0,0,0,6165,1149,1,0,0,0,6166,6168, + 3,1148,574,0,6167,6169,3,1108,554,0,6168,6167,1,0,0,0,6168,6169, + 1,0,0,0,6169,6172,1,0,0,0,6170,6172,3,1162,581,0,6171,6166,1,0,0, + 0,6171,6170,1,0,0,0,6172,1151,1,0,0,0,6173,6176,5,551,0,0,6174,6176, + 3,1170,585,0,6175,6173,1,0,0,0,6175,6174,1,0,0,0,6176,1153,1,0,0, + 0,6177,6178,3,1090,545,0,6178,1155,1,0,0,0,6179,6180,3,1090,545, + 0,6180,1157,1,0,0,0,6181,6182,3,1170,585,0,6182,1159,1,0,0,0,6183, + 6184,3,1170,585,0,6184,1161,1,0,0,0,6185,6188,3,1170,585,0,6186, + 6188,3,1178,589,0,6187,6185,1,0,0,0,6187,6186,1,0,0,0,6188,1163, + 1,0,0,0,6189,6190,3,1170,585,0,6190,1165,1,0,0,0,6191,6192,3,1170, + 585,0,6192,1167,1,0,0,0,6193,6194,3,1170,585,0,6194,1169,1,0,0,0, + 6195,6196,7,67,0,0,6196,1171,1,0,0,0,6197,6204,5,551,0,0,6198,6204, + 3,1184,592,0,6199,6204,3,1176,588,0,6200,6204,3,1174,587,0,6201, + 6204,3,1180,590,0,6202,6204,3,1182,591,0,6203,6197,1,0,0,0,6203, + 6198,1,0,0,0,6203,6199,1,0,0,0,6203,6200,1,0,0,0,6203,6201,1,0,0, + 0,6203,6202,1,0,0,0,6204,1173,1,0,0,0,6205,6206,7,68,0,0,6206,1175, + 1,0,0,0,6207,6211,5,556,0,0,6208,6211,5,521,0,0,6209,6211,3,1178, + 589,0,6210,6207,1,0,0,0,6210,6208,1,0,0,0,6210,6209,1,0,0,0,6211, + 1177,1,0,0,0,6212,6213,7,69,0,0,6213,1179,1,0,0,0,6214,6215,5,138, + 0,0,6215,6218,5,542,0,0,6216,6219,3,1170,585,0,6217,6219,3,1172, + 586,0,6218,6216,1,0,0,0,6218,6217,1,0,0,0,6219,6220,1,0,0,0,6220, + 6221,5,549,0,0,6221,1181,1,0,0,0,6222,6223,5,139,0,0,6223,6226,5, + 542,0,0,6224,6227,3,1170,585,0,6225,6227,3,1172,586,0,6226,6224, + 1,0,0,0,6226,6225,1,0,0,0,6227,6228,1,0,0,0,6228,6229,5,549,0,0, + 6229,1183,1,0,0,0,6230,6231,5,9,0,0,6231,6246,3,1172,586,0,6232, + 6246,5,230,0,0,6233,6246,5,231,0,0,6234,6246,5,291,0,0,6235,6246, + 5,292,0,0,6236,6246,5,313,0,0,6237,6246,5,314,0,0,6238,6246,5,367, + 0,0,6239,6246,5,368,0,0,6240,6246,5,450,0,0,6241,6246,5,451,0,0, + 6242,6246,5,521,0,0,6243,6246,5,523,0,0,6244,6246,5,524,0,0,6245, + 6230,1,0,0,0,6245,6232,1,0,0,0,6245,6233,1,0,0,0,6245,6234,1,0,0, + 0,6245,6235,1,0,0,0,6245,6236,1,0,0,0,6245,6237,1,0,0,0,6245,6238, + 1,0,0,0,6245,6239,1,0,0,0,6245,6240,1,0,0,0,6245,6241,1,0,0,0,6245, + 6242,1,0,0,0,6245,6243,1,0,0,0,6245,6244,1,0,0,0,6246,1185,1,0,0, + 0,6247,6248,5,5,0,0,6248,6249,5,323,0,0,6249,6281,3,1074,537,0,6250, + 6281,5,111,0,0,6251,6281,5,114,0,0,6252,6281,5,115,0,0,6253,6281, + 5,118,0,0,6254,6281,5,119,0,0,6255,6281,5,120,0,0,6256,6281,5,121, + 0,0,6257,6281,5,122,0,0,6258,6281,5,123,0,0,6259,6281,5,124,0,0, + 6260,6262,5,269,0,0,6261,6263,5,323,0,0,6262,6261,1,0,0,0,6262,6263, + 1,0,0,0,6263,6264,1,0,0,0,6264,6281,3,1074,537,0,6265,6281,5,278, + 0,0,6266,6281,5,281,0,0,6267,6281,5,341,0,0,6268,6281,5,404,0,0, + 6269,6281,5,435,0,0,6270,6281,5,436,0,0,6271,6281,5,441,0,0,6272, + 6281,5,442,0,0,6273,6281,5,443,0,0,6274,6281,5,445,0,0,6275,6281, + 5,446,0,0,6276,6281,5,447,0,0,6277,6281,5,471,0,0,6278,6281,5,485, + 0,0,6279,6281,5,513,0,0,6280,6247,1,0,0,0,6280,6250,1,0,0,0,6280, + 6251,1,0,0,0,6280,6252,1,0,0,0,6280,6253,1,0,0,0,6280,6254,1,0,0, + 0,6280,6255,1,0,0,0,6280,6256,1,0,0,0,6280,6257,1,0,0,0,6280,6258, + 1,0,0,0,6280,6259,1,0,0,0,6280,6260,1,0,0,0,6280,6265,1,0,0,0,6280, + 6266,1,0,0,0,6280,6267,1,0,0,0,6280,6268,1,0,0,0,6280,6269,1,0,0, + 0,6280,6270,1,0,0,0,6280,6271,1,0,0,0,6280,6272,1,0,0,0,6280,6273, + 1,0,0,0,6280,6274,1,0,0,0,6280,6275,1,0,0,0,6280,6276,1,0,0,0,6280, + 6277,1,0,0,0,6280,6278,1,0,0,0,6280,6279,1,0,0,0,6281,1187,1,0,0, + 0,6282,6284,5,562,0,0,6283,6282,1,0,0,0,6284,6285,1,0,0,0,6285,6283, + 1,0,0,0,6285,6286,1,0,0,0,6286,1189,1,0,0,0,979,1196,1200,1203,1206, + 1211,1215,1229,1238,1244,1248,1250,1253,1256,1261,1266,1271,1276, + 1281,1286,1294,1300,1308,1314,1320,1324,1334,1344,1348,1352,1355, + 1359,1362,1366,1369,1372,1375,1379,1384,1387,1390,1393,1397,1402, + 1406,1412,1425,1429,1442,1446,1452,1455,1466,1468,1475,1477,1486, + 1491,1495,1500,1505,1512,1515,1518,1523,1528,1532,1536,1540,1543, + 1547,1552,1556,1562,1566,1568,1571,1575,1580,1582,1587,1589,1593, + 1597,1600,1604,1607,1612,1615,1618,1622,1625,1630,1633,1636,1638, + 1642,1648,1651,1654,1658,1662,1665,1668,1673,1677,1682,1685,1690, + 1698,1703,1707,1712,1721,1726,1741,1745,1758,1763,1766,1769,1773, + 1775,1782,1788,1791,1795,1800,1805,1809,1812,1818,1821,1825,1828, + 1831,1836,1839,1843,1846,1849,1853,1858,1862,1866,1870,1873,1882, + 1887,1891,1897,1903,1905,1911,1917,1920,1928,1932,1935,1938,1943, + 1948,1951,1956,1961,1966,1976,1988,1996,2002,2007,2014,2028,2031, + 2036,2042,2046,2049,2058,2061,2065,2068,2072,2075,2078,2082,2085, + 2087,2091,2094,2097,2102,2110,2114,2116,2123,2125,2132,2136,2140, + 2145,2149,2151,2156,2160,2164,2167,2172,2178,2181,2185,2189,2192, + 2195,2200,2203,2206,2211,2215,2218,2226,2232,2236,2238,2243,2251, + 2265,2274,2282,2284,2290,2295,2298,2310,2313,2315,2323,2332,2334, + 2342,2352,2355,2357,2365,2379,2381,2386,2393,2398,2402,2409,2416, + 2423,2428,2432,2437,2441,2446,2450,2455,2459,2464,2468,2475,2486, + 2491,2500,2506,2526,2538,2540,2565,2569,2573,2576,2579,2583,2587, + 2590,2593,2597,2601,2605,2609,2613,2617,2623,2629,2636,2639,2649, + 2655,2661,2665,2667,2672,2674,2684,2687,2691,2694,2699,2711,2718, + 2723,2727,2730,2733,2736,2738,2743,2750,2754,2756,2760,2779,2784, + 2787,2791,2797,2800,2807,2820,2823,2825,2832,2838,2841,2847,2851, + 2854,2857,2860,2864,2868,2872,2880,2885,2895,2901,2905,2909,2914, + 2918,2925,2930,2936,2941,2944,2948,2957,2962,2967,2972,2976,2983, + 2987,2991,2993,3000,3005,3009,3019,3024,3030,3033,3039,3042,3046, + 3048,3054,3057,3061,3065,3068,3071,3074,3082,3088,3095,3100,3103, + 3106,3109,3121,3125,3131,3135,3138,3143,3151,3156,3179,3181,3199, + 3202,3208,3215,3220,3223,3231,3236,3239,3243,3246,3251,3256,3259, + 3264,3266,3273,3276,3281,3285,3292,3295,3299,3317,3324,3327,3341, + 3345,3347,3352,3354,3358,3361,3367,3372,3378,3380,3384,3415,3420, + 3424,3428,3432,3434,3438,3443,3448,3452,3458,3466,3469,3473,3481, + 3488,3491,3494,3499,3502,3506,3509,3512,3518,3523,3530,3545,3551, + 3561,3567,3576,3579,3584,3638,3646,3649,3652,3655,3660,3664,3671, + 3677,3687,3695,3698,3701,3704,3709,3715,3720,3726,3728,3734,3743, + 3747,3751,3755,3759,3767,3773,3780,3783,3786,3789,3792,3795,3798, + 3804,3809,3812,3815,3820,3826,3831,3834,3837,3843,3849,3851,3855, + 3858,3864,3870,3872,3877,3886,3893,3899,3905,3909,3912,3915,3920, + 3922,3925,3930,3933,3939,3945,3947,3952,3956,3963,3967,3971,3977, + 3982,3985,3988,3992,3999,4002,4005,4008,4013,4018,4022,4027,4033, + 4036,4039,4042,4046,4051,4056,4059,4067,4072,4075,4078,4081,4084, + 4090,4095,4098,4103,4106,4112,4116,4120,4128,4133,4137,4142,4150, + 4152,4159,4165,4168,4171,4177,4185,4190,4198,4203,4207,4211,4224, + 4230,4235,4240,4245,4249,4252,4257,4261,4265,4274,4278,4286,4290, + 4293,4295,4301,4304,4307,4314,4317,4325,4328,4334,4337,4343,4347, + 4352,4358,4366,4372,4377,4379,4385,4390,4395,4401,4408,4410,4416, + 4424,4431,4437,4441,4446,4451,4457,4463,4468,4472,4476,4483,4486, + 4491,4495,4500,4504,4508,4513,4516,4520,4525,4528,4531,4534,4541, + 4545,4553,4558,4562,4571,4583,4587,4591,4598,4602,4610,4617,4622, + 4625,4628,4631,4636,4640,4647,4651,4655,4662,4664,4670,4675,4679, + 4685,4689,4693,4699,4705,4710,4713,4718,4726,4729,4734,4738,4743, + 4753,4755,4762,4767,4780,4786,4789,4798,4803,4806,4809,4812,4815, + 4818,4821,4824,4827,4830,4836,4841,4845,4852,4855,4858,4861,4871, + 4873,4882,4887,4891,4894,4901,4909,4914,4918,4921,4928,4934,4938, + 4942,4950,4955,4958,4962,4965,4973,4976,4979,4982,4989,4993,4996, + 5001,5004,5016,5019,5024,5027,5030,5034,5037,5040,5043,5046,5060, + 5064,5068,5073,5079,5082,5090,5093,5098,5104,5109,5115,5126,5130, + 5134,5141,5144,5147,5150,5155,5159,5164,5168,5172,5177,5180,5184, + 5187,5190,5194,5199,5202,5205,5208,5215,5219,5226,5230,5239,5244, + 5248,5257,5269,5274,5277,5280,5283,5287,5291,5296,5302,5308,5313, + 5316,5323,5329,5333,5336,5339,5342,5347,5351,5355,5359,5364,5369, + 5375,5384,5387,5390,5393,5398,5404,5409,5417,5426,5430,5434,5438, + 5442,5451,5454,5457,5460,5463,5470,5473,5477,5480,5484,5488,5492, + 5498,5502,5505,5509,5515,5520,5527,5534,5537,5541,5546,5557,5559, + 5562,5566,5571,5577,5580,5585,5590,5593,5596,5599,5602,5605,5608, + 5613,5617,5622,5628,5631,5636,5642,5647,5653,5657,5663,5668,5674, + 5679,5684,5690,5695,5699,5705,5710,5716,5720,5727,5732,5739,5743, + 5749,5754,5760,5767,5777,5784,5790,5802,5808,5816,5818,5821,5832, + 5836,5839,5848,5854,5858,5863,5869,5872,5877,5882,5890,5894,5897, + 5916,5919,5922,5926,5931,5936,5939,5944,5949,5954,5959,5962,5965, + 5968,5976,5982,5988,5993,6000,6004,6011,6016,6023,6027,6033,6045, + 6049,6052,6058,6062,6065,6071,6075,6080,6083,6086,6099,6138,6150, + 6164,6168,6171,6175,6187,6203,6210,6218,6226,6245,6262,6280,6285 + ] + +class Cobol85Parser ( Parser ): + + grammarFileName = "Cobol85.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + sharedContextCache = PredictionContextCache() + + literalNames = [ "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "'&'", "'*'", "'**'", "':'", "','", "'*>CE'", + "'*>'", "'$'", "'\"'", "", "'.'", "'='", "'*>EXECCICS'", + "'*>EXECSQL'", "'*>EXECSQLIMS'", "'<'", "'<='", "'('", + "'-'", "'>'", "'>='", "'<>'", "'+'", "'''", "')'", + "'/'", "", "'66'", "'77'", "'88'", "", + "", "", "", "", + "", "", "", "", + "", "', '" ] + + symbolicNames = [ "", "ABORT", "ACCEPT", "ACCESS", "ADD", "ADDRESS", + "ADVANCING", "AFTER", "ALIGNED", "ALL", "ALPHABET", + "ALPHABETIC", "ALPHABETIC_LOWER", "ALPHABETIC_UPPER", + "ALPHANUMERIC", "ALPHANUMERIC_EDITED", "ALSO", "ALTER", + "ALTERNATE", "AND", "ANY", "ARE", "AREA", "AREAS", + "AS", "ASCENDING", "ASCII", "ASSIGN", "ASSOCIATED_DATA", + "ASSOCIATED_DATA_LENGTH", "AT", "ATTRIBUTE", "AUTHOR", + "AUTO", "AUTO_SKIP", "BACKGROUND_COLOR", "BACKGROUND_COLOUR", + "BASIS", "BEEP", "BEFORE", "BEGINNING", "BELL", "BINARY", + "BIT", "BLANK", "BLINK", "BLOCK", "BOUNDS", "BOTTOM", + "BY", "BYFUNCTION", "BYTITLE", "CALL", "CANCEL", "CAPABLE", + "CCSVERSION", "CD", "CF", "CH", "CHAINING", "CHANGED", + "CHANNEL", "CHARACTER", "CHARACTERS", "CLASS", "CLASS_ID", + "CLOCK_UNITS", "CLOSE", "CLOSE_DISPOSITION", "COBOL", + "CODE", "CODE_SET", "COLLATING", "COL", "COLUMN", + "COM_REG", "COMMA", "COMMITMENT", "COMMON", "COMMUNICATION", + "COMP", "COMP_1", "COMP_2", "COMP_3", "COMP_4", "COMP_5", + "COMPUTATIONAL", "COMPUTATIONAL_1", "COMPUTATIONAL_2", + "COMPUTATIONAL_3", "COMPUTATIONAL_4", "COMPUTATIONAL_5", + "COMPUTE", "CONFIGURATION", "CONTAINS", "CONTENT", + "CONTINUE", "CONTROL", "CONTROL_POINT", "CONTROLS", + "CONVENTION", "CONVERTING", "COPY", "CORR", "CORRESPONDING", + "COUNT", "CRUNCH", "CURRENCY", "CURSOR", "DATA", "DATA_BASE", + "DATE", "DATE_COMPILED", "DATE_WRITTEN", "DAY", "DAY_OF_WEEK", + "DBCS", "DE", "DEBUG_CONTENTS", "DEBUG_ITEM", "DEBUG_LINE", + "DEBUG_NAME", "DEBUG_SUB_1", "DEBUG_SUB_2", "DEBUG_SUB_3", + "DEBUGGING", "DECIMAL_POINT", "DECLARATIVES", "DEFAULT", + "DEFAULT_DISPLAY", "DEFINITION", "DELETE", "DELIMITED", + "DELIMITER", "DEPENDING", "DESCENDING", "DESTINATION", + "DETAIL", "DFHRESP", "DFHVALUE", "DISABLE", "DISK", + "DISPLAY", "DISPLAY_1", "DIVIDE", "DIVISION", "DONTCARE", + "DOUBLE", "DOWN", "DUPLICATES", "DYNAMIC", "EBCDIC", + "EGCS", "EGI", "ELSE", "EMI", "EMPTY_CHECK", "ENABLE", + "END", "END_ACCEPT", "END_ADD", "END_CALL", "END_COMPUTE", + "END_DELETE", "END_DIVIDE", "END_EVALUATE", "END_IF", + "END_MULTIPLY", "END_OF_PAGE", "END_PERFORM", "END_READ", + "END_RECEIVE", "END_RETURN", "END_REWRITE", "END_SEARCH", + "END_START", "END_STRING", "END_SUBTRACT", "END_UNSTRING", + "END_WRITE", "ENDING", "ENTER", "ENTRY", "ENTRY_PROCEDURE", + "ENVIRONMENT", "EOP", "EQUAL", "ERASE", "ERROR", "EOL", + "EOS", "ESCAPE", "ESI", "EVALUATE", "EVENT", "EVERY", + "EXCEPTION", "EXCLUSIVE", "EXHIBIT", "EXIT", "EXPORT", + "EXTEND", "EXTENDED", "EXTERNAL", "FALSE", "FD", "FILE", + "FILE_CONTROL", "FILLER", "FINAL", "FIRST", "FOOTING", + "FOR", "FOREGROUND_COLOR", "FOREGROUND_COLOUR", "FROM", + "FULL", "FUNCTION", "FUNCTIONNAME", "FUNCTION_POINTER", + "GENERATE", "GOBACK", "GIVING", "GLOBAL", "GO", "GREATER", + "GRID", "GROUP", "HEADING", "HIGHLIGHT", "HIGH_VALUE", + "HIGH_VALUES", "I_O", "I_O_CONTROL", "ID", "IDENTIFICATION", + "IF", "IMPLICIT", "IMPORT", "IN", "INDEX", "INDEXED", + "INDICATE", "INITIAL", "INITIALIZE", "INITIATE", "INPUT", + "INPUT_OUTPUT", "INSPECT", "INSTALLATION", "INTEGER", + "INTO", "INVALID", "INVOKE", "IS", "JUST", "JUSTIFIED", + "KANJI", "KEPT", "KEY", "KEYBOARD", "LABEL", "LANGUAGE", + "LAST", "LB", "LD", "LEADING", "LEFT", "LEFTLINE", + "LENGTH", "LENGTH_CHECK", "LESS", "LIBACCESS", "LIBPARAMETER", + "LIBRARY", "LIMIT", "LIMITS", "LINAGE", "LINAGE_COUNTER", + "LINE", "LINES", "LINE_COUNTER", "LINKAGE", "LIST", + "LOCAL", "LOCAL_STORAGE", "LOCK", "LONG_DATE", "LONG_TIME", + "LOWER", "LOWLIGHT", "LOW_VALUE", "LOW_VALUES", "MEMORY", + "MERGE", "MESSAGE", "MMDDYYYY", "MODE", "MODULES", + "MORE_LABELS", "MOVE", "MULTIPLE", "MULTIPLY", "NAMED", + "NATIONAL", "NATIONAL_EDITED", "NATIVE", "NEGATIVE", + "NETWORK", "NEXT", "NO", "NO_ECHO", "NOT", "NULL_", + "NULLS", "NUMBER", "NUMERIC", "NUMERIC_DATE", "NUMERIC_EDITED", + "NUMERIC_TIME", "OBJECT_COMPUTER", "OCCURS", "ODT", + "OF", "OFF", "OMITTED", "ON", "OPEN", "OPTIONAL", + "OR", "ORDER", "ORDERLY", "ORGANIZATION", "OTHER", + "OUTPUT", "OVERFLOW", "OVERLINE", "OWN", "PACKED_DECIMAL", + "PADDING", "PAGE", "PAGE_COUNTER", "PASSWORD", "PERFORM", + "PF", "PH", "PIC", "PICTURE", "PLUS", "POINTER", "POSITION", + "POSITIVE", "PORT", "PRINTER", "PRINTING", "PRIVATE", + "PROCEDURE", "PROCEDURE_POINTER", "PROCEDURES", "PROCEED", + "PROCESS", "PROGRAM", "PROGRAM_ID", "PROGRAM_LIBRARY", + "PROMPT", "PURGE", "QUEUE", "QUOTE", "QUOTES", "RANDOM", + "READER", "REMOTE", "RD", "REAL", "READ", "RECEIVE", + "RECEIVED", "RECORD", "RECORDING", "RECORDS", "RECURSIVE", + "REDEFINES", "REEL", "REF", "REFERENCE", "REFERENCES", + "RELATIVE", "RELEASE", "REMAINDER", "REMARKS", "REMOVAL", + "REMOVE", "RENAMES", "REPLACE", "REPLACING", "REPORT", + "REPORTING", "REPORTS", "REQUIRED", "RERUN", "RESERVE", + "REVERSE_VIDEO", "RESET", "RETURN", "RETURN_CODE", + "RETURNING", "REVERSED", "REWIND", "REWRITE", "RF", + "RH", "RIGHT", "ROUNDED", "RUN", "SAME", "SAVE", "SCREEN", + "SD", "SEARCH", "SECTION", "SECURE", "SECURITY", "SEGMENT", + "SEGMENT_LIMIT", "SELECT", "SEND", "SENTENCE", "SEPARATE", + "SEQUENCE", "SEQUENTIAL", "SET", "SHARED", "SHAREDBYALL", + "SHAREDBYRUNUNIT", "SHARING", "SHIFT_IN", "SHIFT_OUT", + "SHORT_DATE", "SIGN", "SIZE", "SORT", "SORT_CONTROL", + "SORT_CORE_SIZE", "SORT_FILE_SIZE", "SORT_MERGE", + "SORT_MESSAGE", "SORT_MODE_SIZE", "SORT_RETURN", "SOURCE", + "SOURCE_COMPUTER", "SPACE", "SPACES", "SPECIAL_NAMES", + "STANDARD", "STANDARD_1", "STANDARD_2", "START", "STATUS", + "STOP", "STRING", "SUB_QUEUE_1", "SUB_QUEUE_2", "SUB_QUEUE_3", + "SUBTRACT", "SUM", "SUPPRESS", "SYMBOL", "SYMBOLIC", + "SYNC", "SYNCHRONIZED", "TABLE", "TALLY", "TALLYING", + "TASK", "TAPE", "TERMINAL", "TERMINATE", "TEST", "TEXT", + "THAN", "THEN", "THREAD", "THREAD_LOCAL", "THROUGH", + "THRU", "TIME", "TIMER", "TIMES", "TITLE", "TO", "TODAYS_DATE", + "TODAYS_NAME", "TOP", "TRAILING", "TRUE", "TRUNCATED", + "TYPE", "TYPEDEF", "UNDERLINE", "UNIT", "UNSTRING", + "UNTIL", "UP", "UPON", "USAGE", "USE", "USING", "VALUE", + "VALUES", "VARYING", "VIRTUAL", "WAIT", "WHEN", "WHEN_COMPILED", + "WITH", "WORDS", "WORKING_STORAGE", "WRITE", "YEAR", + "YYYYMMDD", "YYYYDDD", "ZERO", "ZERO_FILL", "ZEROS", + "ZEROES", "AMPCHAR", "ASTERISKCHAR", "DOUBLEASTERISKCHAR", + "COLONCHAR", "COMMACHAR", "COMMENTENTRYTAG", "COMMENTTAG", + "DOLLARCHAR", "DOUBLEQUOTE", "DOT_FS", "DOT", "EQUALCHAR", + "EXECCICSTAG", "EXECSQLTAG", "EXECSQLIMSTAG", "LESSTHANCHAR", + "LESSTHANOREQUAL", "LPARENCHAR", "MINUSCHAR", "MORETHANCHAR", + "MORETHANOREQUAL", "NOTEQUALCHAR", "PLUSCHAR", "SINGLEQUOTE", + "RPARENCHAR", "SLASHCHAR", "NONNUMERICLITERAL", "LEVEL_NUMBER_66", + "LEVEL_NUMBER_77", "LEVEL_NUMBER_88", "INTEGERLITERAL", + "NUMERICLITERAL", "IDENTIFIER", "NEWLINE", "EXECCICSLINE", + "EXECSQLIMSLINE", "EXECSQLLINE", "COMMENTENTRYLINE", + "COMMENTLINE", "WS", "SEPARATOR" ] + + RULE_startRule = 0 + RULE_compilationUnit = 1 + RULE_programUnit = 2 + RULE_endProgramStatement = 3 + RULE_identificationDivision = 4 + RULE_identificationDivisionBody = 5 + RULE_programIdParagraph = 6 + RULE_authorParagraph = 7 + RULE_installationParagraph = 8 + RULE_dateWrittenParagraph = 9 + RULE_dateCompiledParagraph = 10 + RULE_securityParagraph = 11 + RULE_remarksParagraph = 12 + RULE_environmentDivision = 13 + RULE_environmentDivisionBody = 14 + RULE_configurationSection = 15 + RULE_configurationSectionParagraph = 16 + RULE_sourceComputerParagraph = 17 + RULE_objectComputerParagraph = 18 + RULE_objectComputerClause = 19 + RULE_memorySizeClause = 20 + RULE_diskSizeClause = 21 + RULE_collatingSequenceClause = 22 + RULE_collatingSequenceClauseAlphanumeric = 23 + RULE_collatingSequenceClauseNational = 24 + RULE_segmentLimitClause = 25 + RULE_characterSetClause = 26 + RULE_specialNamesParagraph = 27 + RULE_specialNameClause = 28 + RULE_alphabetClause = 29 + RULE_alphabetClauseFormat1 = 30 + RULE_alphabetLiterals = 31 + RULE_alphabetThrough = 32 + RULE_alphabetAlso = 33 + RULE_alphabetClauseFormat2 = 34 + RULE_channelClause = 35 + RULE_classClause = 36 + RULE_classClauseThrough = 37 + RULE_classClauseFrom = 38 + RULE_classClauseTo = 39 + RULE_currencySignClause = 40 + RULE_decimalPointClause = 41 + RULE_defaultComputationalSignClause = 42 + RULE_defaultDisplaySignClause = 43 + RULE_environmentSwitchNameClause = 44 + RULE_environmentSwitchNameSpecialNamesStatusPhrase = 45 + RULE_odtClause = 46 + RULE_reserveNetworkClause = 47 + RULE_symbolicCharactersClause = 48 + RULE_symbolicCharacters = 49 + RULE_inputOutputSection = 50 + RULE_inputOutputSectionParagraph = 51 + RULE_fileControlParagraph = 52 + RULE_fileControlEntry = 53 + RULE_selectClause = 54 + RULE_fileControlClause = 55 + RULE_assignClause = 56 + RULE_reserveClause = 57 + RULE_organizationClause = 58 + RULE_paddingCharacterClause = 59 + RULE_recordDelimiterClause = 60 + RULE_accessModeClause = 61 + RULE_recordKeyClause = 62 + RULE_alternateRecordKeyClause = 63 + RULE_passwordClause = 64 + RULE_fileStatusClause = 65 + RULE_relativeKeyClause = 66 + RULE_ioControlParagraph = 67 + RULE_ioControlClause = 68 + RULE_rerunClause = 69 + RULE_rerunEveryRecords = 70 + RULE_rerunEveryOf = 71 + RULE_rerunEveryClock = 72 + RULE_sameClause = 73 + RULE_multipleFileClause = 74 + RULE_multipleFilePosition = 75 + RULE_commitmentControlClause = 76 + RULE_dataDivision = 77 + RULE_dataDivisionSection = 78 + RULE_fileSection = 79 + RULE_fileDescriptionEntry = 80 + RULE_fileDescriptionEntryClause = 81 + RULE_externalClause = 82 + RULE_globalClause = 83 + RULE_blockContainsClause = 84 + RULE_blockContainsTo = 85 + RULE_recordContainsClause = 86 + RULE_recordContainsClauseFormat1 = 87 + RULE_recordContainsClauseFormat2 = 88 + RULE_recordContainsClauseFormat3 = 89 + RULE_recordContainsTo = 90 + RULE_labelRecordsClause = 91 + RULE_valueOfClause = 92 + RULE_valuePair = 93 + RULE_dataRecordsClause = 94 + RULE_linageClause = 95 + RULE_linageAt = 96 + RULE_linageFootingAt = 97 + RULE_linageLinesAtTop = 98 + RULE_linageLinesAtBottom = 99 + RULE_recordingModeClause = 100 + RULE_modeStatement = 101 + RULE_codeSetClause = 102 + RULE_reportClause = 103 + RULE_dataBaseSection = 104 + RULE_dataBaseSectionEntry = 105 + RULE_workingStorageSection = 106 + RULE_linkageSection = 107 + RULE_communicationSection = 108 + RULE_communicationDescriptionEntry = 109 + RULE_communicationDescriptionEntryFormat1 = 110 + RULE_communicationDescriptionEntryFormat2 = 111 + RULE_communicationDescriptionEntryFormat3 = 112 + RULE_destinationCountClause = 113 + RULE_destinationTableClause = 114 + RULE_endKeyClause = 115 + RULE_errorKeyClause = 116 + RULE_messageCountClause = 117 + RULE_messageDateClause = 118 + RULE_messageTimeClause = 119 + RULE_statusKeyClause = 120 + RULE_symbolicDestinationClause = 121 + RULE_symbolicQueueClause = 122 + RULE_symbolicSourceClause = 123 + RULE_symbolicTerminalClause = 124 + RULE_symbolicSubQueueClause = 125 + RULE_textLengthClause = 126 + RULE_localStorageSection = 127 + RULE_screenSection = 128 + RULE_screenDescriptionEntry = 129 + RULE_screenDescriptionBlankClause = 130 + RULE_screenDescriptionBellClause = 131 + RULE_screenDescriptionBlinkClause = 132 + RULE_screenDescriptionEraseClause = 133 + RULE_screenDescriptionLightClause = 134 + RULE_screenDescriptionGridClause = 135 + RULE_screenDescriptionReverseVideoClause = 136 + RULE_screenDescriptionUnderlineClause = 137 + RULE_screenDescriptionSizeClause = 138 + RULE_screenDescriptionLineClause = 139 + RULE_screenDescriptionColumnClause = 140 + RULE_screenDescriptionForegroundColorClause = 141 + RULE_screenDescriptionBackgroundColorClause = 142 + RULE_screenDescriptionControlClause = 143 + RULE_screenDescriptionValueClause = 144 + RULE_screenDescriptionPictureClause = 145 + RULE_screenDescriptionFromClause = 146 + RULE_screenDescriptionToClause = 147 + RULE_screenDescriptionUsingClause = 148 + RULE_screenDescriptionUsageClause = 149 + RULE_screenDescriptionBlankWhenZeroClause = 150 + RULE_screenDescriptionJustifiedClause = 151 + RULE_screenDescriptionSignClause = 152 + RULE_screenDescriptionAutoClause = 153 + RULE_screenDescriptionSecureClause = 154 + RULE_screenDescriptionRequiredClause = 155 + RULE_screenDescriptionPromptClause = 156 + RULE_screenDescriptionPromptOccursClause = 157 + RULE_screenDescriptionFullClause = 158 + RULE_screenDescriptionZeroFillClause = 159 + RULE_reportSection = 160 + RULE_reportDescription = 161 + RULE_reportDescriptionEntry = 162 + RULE_reportDescriptionGlobalClause = 163 + RULE_reportDescriptionPageLimitClause = 164 + RULE_reportDescriptionHeadingClause = 165 + RULE_reportDescriptionFirstDetailClause = 166 + RULE_reportDescriptionLastDetailClause = 167 + RULE_reportDescriptionFootingClause = 168 + RULE_reportGroupDescriptionEntry = 169 + RULE_reportGroupDescriptionEntryFormat1 = 170 + RULE_reportGroupDescriptionEntryFormat2 = 171 + RULE_reportGroupDescriptionEntryFormat3 = 172 + RULE_reportGroupBlankWhenZeroClause = 173 + RULE_reportGroupColumnNumberClause = 174 + RULE_reportGroupIndicateClause = 175 + RULE_reportGroupJustifiedClause = 176 + RULE_reportGroupLineNumberClause = 177 + RULE_reportGroupLineNumberNextPage = 178 + RULE_reportGroupLineNumberPlus = 179 + RULE_reportGroupNextGroupClause = 180 + RULE_reportGroupNextGroupPlus = 181 + RULE_reportGroupNextGroupNextPage = 182 + RULE_reportGroupPictureClause = 183 + RULE_reportGroupResetClause = 184 + RULE_reportGroupSignClause = 185 + RULE_reportGroupSourceClause = 186 + RULE_reportGroupSumClause = 187 + RULE_reportGroupTypeClause = 188 + RULE_reportGroupTypeReportHeading = 189 + RULE_reportGroupTypePageHeading = 190 + RULE_reportGroupTypeControlHeading = 191 + RULE_reportGroupTypeDetail = 192 + RULE_reportGroupTypeControlFooting = 193 + RULE_reportGroupUsageClause = 194 + RULE_reportGroupTypePageFooting = 195 + RULE_reportGroupTypeReportFooting = 196 + RULE_reportGroupValueClause = 197 + RULE_programLibrarySection = 198 + RULE_libraryDescriptionEntry = 199 + RULE_libraryDescriptionEntryFormat1 = 200 + RULE_libraryDescriptionEntryFormat2 = 201 + RULE_libraryAttributeClauseFormat1 = 202 + RULE_libraryAttributeClauseFormat2 = 203 + RULE_libraryAttributeFunction = 204 + RULE_libraryAttributeParameter = 205 + RULE_libraryAttributeTitle = 206 + RULE_libraryEntryProcedureClauseFormat1 = 207 + RULE_libraryEntryProcedureClauseFormat2 = 208 + RULE_libraryEntryProcedureForClause = 209 + RULE_libraryEntryProcedureGivingClause = 210 + RULE_libraryEntryProcedureUsingClause = 211 + RULE_libraryEntryProcedureUsingName = 212 + RULE_libraryEntryProcedureWithClause = 213 + RULE_libraryEntryProcedureWithName = 214 + RULE_libraryIsCommonClause = 215 + RULE_libraryIsGlobalClause = 216 + RULE_dataDescriptionEntry = 217 + RULE_dataDescriptionEntryFormat1 = 218 + RULE_dataDescriptionEntryFormat2 = 219 + RULE_dataDescriptionEntryFormat3 = 220 + RULE_dataDescriptionEntryExecSql = 221 + RULE_dataAlignedClause = 222 + RULE_dataBlankWhenZeroClause = 223 + RULE_dataCommonOwnLocalClause = 224 + RULE_dataExternalClause = 225 + RULE_dataGlobalClause = 226 + RULE_dataIntegerStringClause = 227 + RULE_dataJustifiedClause = 228 + RULE_dataOccursClause = 229 + RULE_dataOccursTo = 230 + RULE_dataOccursSort = 231 + RULE_dataPictureClause = 232 + RULE_pictureString = 233 + RULE_pictureChars = 234 + RULE_pictureCardinality = 235 + RULE_dataReceivedByClause = 236 + RULE_dataRecordAreaClause = 237 + RULE_dataRedefinesClause = 238 + RULE_dataRenamesClause = 239 + RULE_dataSignClause = 240 + RULE_dataSynchronizedClause = 241 + RULE_dataThreadLocalClause = 242 + RULE_dataTypeClause = 243 + RULE_dataTypeDefClause = 244 + RULE_dataUsageClause = 245 + RULE_dataUsingClause = 246 + RULE_dataValueClause = 247 + RULE_dataValueInterval = 248 + RULE_dataValueIntervalFrom = 249 + RULE_dataValueIntervalTo = 250 + RULE_dataWithLowerBoundsClause = 251 + RULE_procedureDivision = 252 + RULE_procedureDivisionUsingClause = 253 + RULE_procedureDivisionGivingClause = 254 + RULE_procedureDivisionUsingParameter = 255 + RULE_procedureDivisionByReferencePhrase = 256 + RULE_procedureDivisionByReference = 257 + RULE_procedureDivisionByValuePhrase = 258 + RULE_procedureDivisionByValue = 259 + RULE_procedureDeclaratives = 260 + RULE_procedureDeclarative = 261 + RULE_procedureSectionHeader = 262 + RULE_procedureDivisionBody = 263 + RULE_procedureSection = 264 + RULE_paragraphs = 265 + RULE_paragraph = 266 + RULE_sentence = 267 + RULE_statement = 268 + RULE_acceptStatement = 269 + RULE_acceptFromDateStatement = 270 + RULE_acceptFromMnemonicStatement = 271 + RULE_acceptFromEscapeKeyStatement = 272 + RULE_acceptMessageCountStatement = 273 + RULE_addStatement = 274 + RULE_addToStatement = 275 + RULE_addToGivingStatement = 276 + RULE_addCorrespondingStatement = 277 + RULE_addFrom = 278 + RULE_addTo = 279 + RULE_addToGiving = 280 + RULE_addGiving = 281 + RULE_alteredGoTo = 282 + RULE_alterStatement = 283 + RULE_alterProceedTo = 284 + RULE_callStatement = 285 + RULE_callUsingPhrase = 286 + RULE_callUsingParameter = 287 + RULE_callByReferencePhrase = 288 + RULE_callByReference = 289 + RULE_callByValuePhrase = 290 + RULE_callByValue = 291 + RULE_callByContentPhrase = 292 + RULE_callByContent = 293 + RULE_callGivingPhrase = 294 + RULE_cancelStatement = 295 + RULE_cancelCall = 296 + RULE_closeStatement = 297 + RULE_closeFile = 298 + RULE_closeReelUnitStatement = 299 + RULE_closeRelativeStatement = 300 + RULE_closePortFileIOStatement = 301 + RULE_closePortFileIOUsing = 302 + RULE_closePortFileIOUsingCloseDisposition = 303 + RULE_closePortFileIOUsingAssociatedData = 304 + RULE_closePortFileIOUsingAssociatedDataLength = 305 + RULE_computeStatement = 306 + RULE_computeStore = 307 + RULE_continueStatement = 308 + RULE_deleteStatement = 309 + RULE_disableStatement = 310 + RULE_displayStatement = 311 + RULE_displayOperand = 312 + RULE_displayAt = 313 + RULE_displayUpon = 314 + RULE_displayWith = 315 + RULE_divideStatement = 316 + RULE_divideIntoStatement = 317 + RULE_divideIntoGivingStatement = 318 + RULE_divideByGivingStatement = 319 + RULE_divideGivingPhrase = 320 + RULE_divideInto = 321 + RULE_divideGiving = 322 + RULE_divideRemainder = 323 + RULE_enableStatement = 324 + RULE_entryStatement = 325 + RULE_evaluateStatement = 326 + RULE_evaluateSelect = 327 + RULE_evaluateAlsoSelect = 328 + RULE_evaluateWhenPhrase = 329 + RULE_evaluateWhen = 330 + RULE_evaluateCondition = 331 + RULE_evaluateThrough = 332 + RULE_evaluateAlsoCondition = 333 + RULE_evaluateWhenOther = 334 + RULE_evaluateValue = 335 + RULE_execCicsStatement = 336 + RULE_execSqlStatement = 337 + RULE_execSqlImsStatement = 338 + RULE_exhibitStatement = 339 + RULE_exhibitOperand = 340 + RULE_exitStatement = 341 + RULE_generateStatement = 342 + RULE_gobackStatement = 343 + RULE_goToStatement = 344 + RULE_goToStatementSimple = 345 + RULE_goToDependingOnStatement = 346 + RULE_ifStatement = 347 + RULE_ifThen = 348 + RULE_ifElse = 349 + RULE_initializeStatement = 350 + RULE_initializeReplacingPhrase = 351 + RULE_initializeReplacingBy = 352 + RULE_initiateStatement = 353 + RULE_inspectStatement = 354 + RULE_inspectTallyingPhrase = 355 + RULE_inspectReplacingPhrase = 356 + RULE_inspectTallyingReplacingPhrase = 357 + RULE_inspectConvertingPhrase = 358 + RULE_inspectFor = 359 + RULE_inspectCharacters = 360 + RULE_inspectReplacingCharacters = 361 + RULE_inspectAllLeadings = 362 + RULE_inspectReplacingAllLeadings = 363 + RULE_inspectAllLeading = 364 + RULE_inspectReplacingAllLeading = 365 + RULE_inspectBy = 366 + RULE_inspectTo = 367 + RULE_inspectBeforeAfter = 368 + RULE_mergeStatement = 369 + RULE_mergeOnKeyClause = 370 + RULE_mergeCollatingSequencePhrase = 371 + RULE_mergeCollatingAlphanumeric = 372 + RULE_mergeCollatingNational = 373 + RULE_mergeUsing = 374 + RULE_mergeOutputProcedurePhrase = 375 + RULE_mergeOutputThrough = 376 + RULE_mergeGivingPhrase = 377 + RULE_mergeGiving = 378 + RULE_moveStatement = 379 + RULE_moveToStatement = 380 + RULE_moveToSendingArea = 381 + RULE_moveCorrespondingToStatement = 382 + RULE_moveCorrespondingToSendingArea = 383 + RULE_multiplyStatement = 384 + RULE_multiplyRegular = 385 + RULE_multiplyRegularOperand = 386 + RULE_multiplyGiving = 387 + RULE_multiplyGivingOperand = 388 + RULE_multiplyGivingResult = 389 + RULE_openStatement = 390 + RULE_openInputStatement = 391 + RULE_openInput = 392 + RULE_openOutputStatement = 393 + RULE_openOutput = 394 + RULE_openIOStatement = 395 + RULE_openExtendStatement = 396 + RULE_performStatement = 397 + RULE_performInlineStatement = 398 + RULE_performProcedureStatement = 399 + RULE_performType = 400 + RULE_performTimes = 401 + RULE_performUntil = 402 + RULE_performVarying = 403 + RULE_performVaryingClause = 404 + RULE_performVaryingPhrase = 405 + RULE_performAfter = 406 + RULE_performFrom = 407 + RULE_performBy = 408 + RULE_performTestClause = 409 + RULE_purgeStatement = 410 + RULE_readStatement = 411 + RULE_readInto = 412 + RULE_readWith = 413 + RULE_readKey = 414 + RULE_receiveStatement = 415 + RULE_receiveFromStatement = 416 + RULE_receiveFrom = 417 + RULE_receiveIntoStatement = 418 + RULE_receiveNoData = 419 + RULE_receiveWithData = 420 + RULE_receiveBefore = 421 + RULE_receiveWith = 422 + RULE_receiveThread = 423 + RULE_receiveSize = 424 + RULE_receiveStatus = 425 + RULE_releaseStatement = 426 + RULE_returnStatement = 427 + RULE_returnInto = 428 + RULE_rewriteStatement = 429 + RULE_rewriteFrom = 430 + RULE_searchStatement = 431 + RULE_searchVarying = 432 + RULE_searchWhen = 433 + RULE_sendStatement = 434 + RULE_sendStatementSync = 435 + RULE_sendStatementAsync = 436 + RULE_sendFromPhrase = 437 + RULE_sendWithPhrase = 438 + RULE_sendReplacingPhrase = 439 + RULE_sendAdvancingPhrase = 440 + RULE_sendAdvancingPage = 441 + RULE_sendAdvancingLines = 442 + RULE_sendAdvancingMnemonic = 443 + RULE_setStatement = 444 + RULE_setToStatement = 445 + RULE_setUpDownByStatement = 446 + RULE_setTo = 447 + RULE_setToValue = 448 + RULE_setByValue = 449 + RULE_sortStatement = 450 + RULE_sortOnKeyClause = 451 + RULE_sortDuplicatesPhrase = 452 + RULE_sortCollatingSequencePhrase = 453 + RULE_sortCollatingAlphanumeric = 454 + RULE_sortCollatingNational = 455 + RULE_sortInputProcedurePhrase = 456 + RULE_sortInputThrough = 457 + RULE_sortUsing = 458 + RULE_sortOutputProcedurePhrase = 459 + RULE_sortOutputThrough = 460 + RULE_sortGivingPhrase = 461 + RULE_sortGiving = 462 + RULE_startStatement = 463 + RULE_startKey = 464 + RULE_stopStatement = 465 + RULE_stringStatement = 466 + RULE_stringSendingPhrase = 467 + RULE_stringSending = 468 + RULE_stringDelimitedByPhrase = 469 + RULE_stringForPhrase = 470 + RULE_stringIntoPhrase = 471 + RULE_stringWithPointerPhrase = 472 + RULE_subtractStatement = 473 + RULE_subtractFromStatement = 474 + RULE_subtractFromGivingStatement = 475 + RULE_subtractCorrespondingStatement = 476 + RULE_subtractSubtrahend = 477 + RULE_subtractMinuend = 478 + RULE_subtractMinuendGiving = 479 + RULE_subtractGiving = 480 + RULE_subtractMinuendCorresponding = 481 + RULE_terminateStatement = 482 + RULE_unstringStatement = 483 + RULE_unstringSendingPhrase = 484 + RULE_unstringDelimitedByPhrase = 485 + RULE_unstringOrAllPhrase = 486 + RULE_unstringIntoPhrase = 487 + RULE_unstringInto = 488 + RULE_unstringDelimiterIn = 489 + RULE_unstringCountIn = 490 + RULE_unstringWithPointerPhrase = 491 + RULE_unstringTallyingPhrase = 492 + RULE_useStatement = 493 + RULE_useAfterClause = 494 + RULE_useAfterOn = 495 + RULE_useDebugClause = 496 + RULE_useDebugOn = 497 + RULE_writeStatement = 498 + RULE_writeFromPhrase = 499 + RULE_writeAdvancingPhrase = 500 + RULE_writeAdvancingPage = 501 + RULE_writeAdvancingLines = 502 + RULE_writeAdvancingMnemonic = 503 + RULE_writeAtEndOfPagePhrase = 504 + RULE_writeNotAtEndOfPagePhrase = 505 + RULE_atEndPhrase = 506 + RULE_notAtEndPhrase = 507 + RULE_invalidKeyPhrase = 508 + RULE_notInvalidKeyPhrase = 509 + RULE_onOverflowPhrase = 510 + RULE_notOnOverflowPhrase = 511 + RULE_onSizeErrorPhrase = 512 + RULE_notOnSizeErrorPhrase = 513 + RULE_onExceptionClause = 514 + RULE_notOnExceptionClause = 515 + RULE_arithmeticExpression = 516 + RULE_plusMinus = 517 + RULE_multDivs = 518 + RULE_multDiv = 519 + RULE_powers = 520 + RULE_power = 521 + RULE_basis = 522 + RULE_condition = 523 + RULE_andOrCondition = 524 + RULE_combinableCondition = 525 + RULE_simpleCondition = 526 + RULE_classCondition = 527 + RULE_conditionNameReference = 528 + RULE_conditionNameSubscriptReference = 529 + RULE_relationCondition = 530 + RULE_relationSignCondition = 531 + RULE_relationArithmeticComparison = 532 + RULE_relationCombinedComparison = 533 + RULE_relationCombinedCondition = 534 + RULE_relationalOperator = 535 + RULE_abbreviation = 536 + RULE_identifier = 537 + RULE_tableCall = 538 + RULE_functionCall = 539 + RULE_referenceModifier = 540 + RULE_characterPosition = 541 + RULE_length = 542 + RULE_subscript_ = 543 + RULE_argument = 544 + RULE_qualifiedDataName = 545 + RULE_qualifiedDataNameFormat1 = 546 + RULE_qualifiedDataNameFormat2 = 547 + RULE_qualifiedDataNameFormat3 = 548 + RULE_qualifiedDataNameFormat4 = 549 + RULE_qualifiedInData = 550 + RULE_inData = 551 + RULE_inFile = 552 + RULE_inMnemonic = 553 + RULE_inSection = 554 + RULE_inLibrary = 555 + RULE_inTable = 556 + RULE_alphabetName = 557 + RULE_assignmentName = 558 + RULE_basisName = 559 + RULE_cdName = 560 + RULE_className = 561 + RULE_computerName = 562 + RULE_conditionName = 563 + RULE_dataName = 564 + RULE_dataDescName = 565 + RULE_environmentName = 566 + RULE_fileName = 567 + RULE_functionName = 568 + RULE_indexName = 569 + RULE_languageName = 570 + RULE_libraryName = 571 + RULE_localName = 572 + RULE_mnemonicName = 573 + RULE_paragraphName = 574 + RULE_procedureName = 575 + RULE_programName = 576 + RULE_recordName = 577 + RULE_reportName = 578 + RULE_routineName = 579 + RULE_screenName = 580 + RULE_sectionName = 581 + RULE_systemName = 582 + RULE_symbolicCharacter = 583 + RULE_textName = 584 + RULE_cobolWord = 585 + RULE_literal = 586 + RULE_booleanLiteral = 587 + RULE_numericLiteral = 588 + RULE_integerLiteral = 589 + RULE_cicsDfhRespLiteral = 590 + RULE_cicsDfhValueLiteral = 591 + RULE_figurativeConstant = 592 + RULE_specialRegister = 593 + RULE_commentEntry = 594 + + ruleNames = [ "startRule", "compilationUnit", "programUnit", "endProgramStatement", + "identificationDivision", "identificationDivisionBody", + "programIdParagraph", "authorParagraph", "installationParagraph", + "dateWrittenParagraph", "dateCompiledParagraph", "securityParagraph", + "remarksParagraph", "environmentDivision", "environmentDivisionBody", + "configurationSection", "configurationSectionParagraph", + "sourceComputerParagraph", "objectComputerParagraph", + "objectComputerClause", "memorySizeClause", "diskSizeClause", + "collatingSequenceClause", "collatingSequenceClauseAlphanumeric", + "collatingSequenceClauseNational", "segmentLimitClause", + "characterSetClause", "specialNamesParagraph", "specialNameClause", + "alphabetClause", "alphabetClauseFormat1", "alphabetLiterals", + "alphabetThrough", "alphabetAlso", "alphabetClauseFormat2", + "channelClause", "classClause", "classClauseThrough", + "classClauseFrom", "classClauseTo", "currencySignClause", + "decimalPointClause", "defaultComputationalSignClause", + "defaultDisplaySignClause", "environmentSwitchNameClause", + "environmentSwitchNameSpecialNamesStatusPhrase", "odtClause", + "reserveNetworkClause", "symbolicCharactersClause", "symbolicCharacters", + "inputOutputSection", "inputOutputSectionParagraph", + "fileControlParagraph", "fileControlEntry", "selectClause", + "fileControlClause", "assignClause", "reserveClause", + "organizationClause", "paddingCharacterClause", "recordDelimiterClause", + "accessModeClause", "recordKeyClause", "alternateRecordKeyClause", + "passwordClause", "fileStatusClause", "relativeKeyClause", + "ioControlParagraph", "ioControlClause", "rerunClause", + "rerunEveryRecords", "rerunEveryOf", "rerunEveryClock", + "sameClause", "multipleFileClause", "multipleFilePosition", + "commitmentControlClause", "dataDivision", "dataDivisionSection", + "fileSection", "fileDescriptionEntry", "fileDescriptionEntryClause", + "externalClause", "globalClause", "blockContainsClause", + "blockContainsTo", "recordContainsClause", "recordContainsClauseFormat1", + "recordContainsClauseFormat2", "recordContainsClauseFormat3", + "recordContainsTo", "labelRecordsClause", "valueOfClause", + "valuePair", "dataRecordsClause", "linageClause", "linageAt", + "linageFootingAt", "linageLinesAtTop", "linageLinesAtBottom", + "recordingModeClause", "modeStatement", "codeSetClause", + "reportClause", "dataBaseSection", "dataBaseSectionEntry", + "workingStorageSection", "linkageSection", "communicationSection", + "communicationDescriptionEntry", "communicationDescriptionEntryFormat1", + "communicationDescriptionEntryFormat2", "communicationDescriptionEntryFormat3", + "destinationCountClause", "destinationTableClause", "endKeyClause", + "errorKeyClause", "messageCountClause", "messageDateClause", + "messageTimeClause", "statusKeyClause", "symbolicDestinationClause", + "symbolicQueueClause", "symbolicSourceClause", "symbolicTerminalClause", + "symbolicSubQueueClause", "textLengthClause", "localStorageSection", + "screenSection", "screenDescriptionEntry", "screenDescriptionBlankClause", + "screenDescriptionBellClause", "screenDescriptionBlinkClause", + "screenDescriptionEraseClause", "screenDescriptionLightClause", + "screenDescriptionGridClause", "screenDescriptionReverseVideoClause", + "screenDescriptionUnderlineClause", "screenDescriptionSizeClause", + "screenDescriptionLineClause", "screenDescriptionColumnClause", + "screenDescriptionForegroundColorClause", "screenDescriptionBackgroundColorClause", + "screenDescriptionControlClause", "screenDescriptionValueClause", + "screenDescriptionPictureClause", "screenDescriptionFromClause", + "screenDescriptionToClause", "screenDescriptionUsingClause", + "screenDescriptionUsageClause", "screenDescriptionBlankWhenZeroClause", + "screenDescriptionJustifiedClause", "screenDescriptionSignClause", + "screenDescriptionAutoClause", "screenDescriptionSecureClause", + "screenDescriptionRequiredClause", "screenDescriptionPromptClause", + "screenDescriptionPromptOccursClause", "screenDescriptionFullClause", + "screenDescriptionZeroFillClause", "reportSection", "reportDescription", + "reportDescriptionEntry", "reportDescriptionGlobalClause", + "reportDescriptionPageLimitClause", "reportDescriptionHeadingClause", + "reportDescriptionFirstDetailClause", "reportDescriptionLastDetailClause", + "reportDescriptionFootingClause", "reportGroupDescriptionEntry", + "reportGroupDescriptionEntryFormat1", "reportGroupDescriptionEntryFormat2", + "reportGroupDescriptionEntryFormat3", "reportGroupBlankWhenZeroClause", + "reportGroupColumnNumberClause", "reportGroupIndicateClause", + "reportGroupJustifiedClause", "reportGroupLineNumberClause", + "reportGroupLineNumberNextPage", "reportGroupLineNumberPlus", + "reportGroupNextGroupClause", "reportGroupNextGroupPlus", + "reportGroupNextGroupNextPage", "reportGroupPictureClause", + "reportGroupResetClause", "reportGroupSignClause", "reportGroupSourceClause", + "reportGroupSumClause", "reportGroupTypeClause", "reportGroupTypeReportHeading", + "reportGroupTypePageHeading", "reportGroupTypeControlHeading", + "reportGroupTypeDetail", "reportGroupTypeControlFooting", + "reportGroupUsageClause", "reportGroupTypePageFooting", + "reportGroupTypeReportFooting", "reportGroupValueClause", + "programLibrarySection", "libraryDescriptionEntry", "libraryDescriptionEntryFormat1", + "libraryDescriptionEntryFormat2", "libraryAttributeClauseFormat1", + "libraryAttributeClauseFormat2", "libraryAttributeFunction", + "libraryAttributeParameter", "libraryAttributeTitle", + "libraryEntryProcedureClauseFormat1", "libraryEntryProcedureClauseFormat2", + "libraryEntryProcedureForClause", "libraryEntryProcedureGivingClause", + "libraryEntryProcedureUsingClause", "libraryEntryProcedureUsingName", + "libraryEntryProcedureWithClause", "libraryEntryProcedureWithName", + "libraryIsCommonClause", "libraryIsGlobalClause", "dataDescriptionEntry", + "dataDescriptionEntryFormat1", "dataDescriptionEntryFormat2", + "dataDescriptionEntryFormat3", "dataDescriptionEntryExecSql", + "dataAlignedClause", "dataBlankWhenZeroClause", "dataCommonOwnLocalClause", + "dataExternalClause", "dataGlobalClause", "dataIntegerStringClause", + "dataJustifiedClause", "dataOccursClause", "dataOccursTo", + "dataOccursSort", "dataPictureClause", "pictureString", + "pictureChars", "pictureCardinality", "dataReceivedByClause", + "dataRecordAreaClause", "dataRedefinesClause", "dataRenamesClause", + "dataSignClause", "dataSynchronizedClause", "dataThreadLocalClause", + "dataTypeClause", "dataTypeDefClause", "dataUsageClause", + "dataUsingClause", "dataValueClause", "dataValueInterval", + "dataValueIntervalFrom", "dataValueIntervalTo", "dataWithLowerBoundsClause", + "procedureDivision", "procedureDivisionUsingClause", + "procedureDivisionGivingClause", "procedureDivisionUsingParameter", + "procedureDivisionByReferencePhrase", "procedureDivisionByReference", + "procedureDivisionByValuePhrase", "procedureDivisionByValue", + "procedureDeclaratives", "procedureDeclarative", "procedureSectionHeader", + "procedureDivisionBody", "procedureSection", "paragraphs", + "paragraph", "sentence", "statement", "acceptStatement", + "acceptFromDateStatement", "acceptFromMnemonicStatement", + "acceptFromEscapeKeyStatement", "acceptMessageCountStatement", + "addStatement", "addToStatement", "addToGivingStatement", + "addCorrespondingStatement", "addFrom", "addTo", "addToGiving", + "addGiving", "alteredGoTo", "alterStatement", "alterProceedTo", + "callStatement", "callUsingPhrase", "callUsingParameter", + "callByReferencePhrase", "callByReference", "callByValuePhrase", + "callByValue", "callByContentPhrase", "callByContent", + "callGivingPhrase", "cancelStatement", "cancelCall", + "closeStatement", "closeFile", "closeReelUnitStatement", + "closeRelativeStatement", "closePortFileIOStatement", + "closePortFileIOUsing", "closePortFileIOUsingCloseDisposition", + "closePortFileIOUsingAssociatedData", "closePortFileIOUsingAssociatedDataLength", + "computeStatement", "computeStore", "continueStatement", + "deleteStatement", "disableStatement", "displayStatement", + "displayOperand", "displayAt", "displayUpon", "displayWith", + "divideStatement", "divideIntoStatement", "divideIntoGivingStatement", + "divideByGivingStatement", "divideGivingPhrase", "divideInto", + "divideGiving", "divideRemainder", "enableStatement", + "entryStatement", "evaluateStatement", "evaluateSelect", + "evaluateAlsoSelect", "evaluateWhenPhrase", "evaluateWhen", + "evaluateCondition", "evaluateThrough", "evaluateAlsoCondition", + "evaluateWhenOther", "evaluateValue", "execCicsStatement", + "execSqlStatement", "execSqlImsStatement", "exhibitStatement", + "exhibitOperand", "exitStatement", "generateStatement", + "gobackStatement", "goToStatement", "goToStatementSimple", + "goToDependingOnStatement", "ifStatement", "ifThen", + "ifElse", "initializeStatement", "initializeReplacingPhrase", + "initializeReplacingBy", "initiateStatement", "inspectStatement", + "inspectTallyingPhrase", "inspectReplacingPhrase", "inspectTallyingReplacingPhrase", + "inspectConvertingPhrase", "inspectFor", "inspectCharacters", + "inspectReplacingCharacters", "inspectAllLeadings", "inspectReplacingAllLeadings", + "inspectAllLeading", "inspectReplacingAllLeading", "inspectBy", + "inspectTo", "inspectBeforeAfter", "mergeStatement", + "mergeOnKeyClause", "mergeCollatingSequencePhrase", "mergeCollatingAlphanumeric", + "mergeCollatingNational", "mergeUsing", "mergeOutputProcedurePhrase", + "mergeOutputThrough", "mergeGivingPhrase", "mergeGiving", + "moveStatement", "moveToStatement", "moveToSendingArea", + "moveCorrespondingToStatement", "moveCorrespondingToSendingArea", + "multiplyStatement", "multiplyRegular", "multiplyRegularOperand", + "multiplyGiving", "multiplyGivingOperand", "multiplyGivingResult", + "openStatement", "openInputStatement", "openInput", "openOutputStatement", + "openOutput", "openIOStatement", "openExtendStatement", + "performStatement", "performInlineStatement", "performProcedureStatement", + "performType", "performTimes", "performUntil", "performVarying", + "performVaryingClause", "performVaryingPhrase", "performAfter", + "performFrom", "performBy", "performTestClause", "purgeStatement", + "readStatement", "readInto", "readWith", "readKey", "receiveStatement", + "receiveFromStatement", "receiveFrom", "receiveIntoStatement", + "receiveNoData", "receiveWithData", "receiveBefore", + "receiveWith", "receiveThread", "receiveSize", "receiveStatus", + "releaseStatement", "returnStatement", "returnInto", + "rewriteStatement", "rewriteFrom", "searchStatement", + "searchVarying", "searchWhen", "sendStatement", "sendStatementSync", + "sendStatementAsync", "sendFromPhrase", "sendWithPhrase", + "sendReplacingPhrase", "sendAdvancingPhrase", "sendAdvancingPage", + "sendAdvancingLines", "sendAdvancingMnemonic", "setStatement", + "setToStatement", "setUpDownByStatement", "setTo", "setToValue", + "setByValue", "sortStatement", "sortOnKeyClause", "sortDuplicatesPhrase", + "sortCollatingSequencePhrase", "sortCollatingAlphanumeric", + "sortCollatingNational", "sortInputProcedurePhrase", + "sortInputThrough", "sortUsing", "sortOutputProcedurePhrase", + "sortOutputThrough", "sortGivingPhrase", "sortGiving", + "startStatement", "startKey", "stopStatement", "stringStatement", + "stringSendingPhrase", "stringSending", "stringDelimitedByPhrase", + "stringForPhrase", "stringIntoPhrase", "stringWithPointerPhrase", + "subtractStatement", "subtractFromStatement", "subtractFromGivingStatement", + "subtractCorrespondingStatement", "subtractSubtrahend", + "subtractMinuend", "subtractMinuendGiving", "subtractGiving", + "subtractMinuendCorresponding", "terminateStatement", + "unstringStatement", "unstringSendingPhrase", "unstringDelimitedByPhrase", + "unstringOrAllPhrase", "unstringIntoPhrase", "unstringInto", + "unstringDelimiterIn", "unstringCountIn", "unstringWithPointerPhrase", + "unstringTallyingPhrase", "useStatement", "useAfterClause", + "useAfterOn", "useDebugClause", "useDebugOn", "writeStatement", + "writeFromPhrase", "writeAdvancingPhrase", "writeAdvancingPage", + "writeAdvancingLines", "writeAdvancingMnemonic", "writeAtEndOfPagePhrase", + "writeNotAtEndOfPagePhrase", "atEndPhrase", "notAtEndPhrase", + "invalidKeyPhrase", "notInvalidKeyPhrase", "onOverflowPhrase", + "notOnOverflowPhrase", "onSizeErrorPhrase", "notOnSizeErrorPhrase", + "onExceptionClause", "notOnExceptionClause", "arithmeticExpression", + "plusMinus", "multDivs", "multDiv", "powers", "power", + "basis", "condition", "andOrCondition", "combinableCondition", + "simpleCondition", "classCondition", "conditionNameReference", + "conditionNameSubscriptReference", "relationCondition", + "relationSignCondition", "relationArithmeticComparison", + "relationCombinedComparison", "relationCombinedCondition", + "relationalOperator", "abbreviation", "identifier", "tableCall", + "functionCall", "referenceModifier", "characterPosition", + "length", "subscript_", "argument", "qualifiedDataName", + "qualifiedDataNameFormat1", "qualifiedDataNameFormat2", + "qualifiedDataNameFormat3", "qualifiedDataNameFormat4", + "qualifiedInData", "inData", "inFile", "inMnemonic", + "inSection", "inLibrary", "inTable", "alphabetName", + "assignmentName", "basisName", "cdName", "className", + "computerName", "conditionName", "dataName", "dataDescName", + "environmentName", "fileName", "functionName", "indexName", + "languageName", "libraryName", "localName", "mnemonicName", + "paragraphName", "procedureName", "programName", "recordName", + "reportName", "routineName", "screenName", "sectionName", + "systemName", "symbolicCharacter", "textName", "cobolWord", + "literal", "booleanLiteral", "numericLiteral", "integerLiteral", + "cicsDfhRespLiteral", "cicsDfhValueLiteral", "figurativeConstant", + "specialRegister", "commentEntry" ] + + EOF = Token.EOF + ABORT=1 + ACCEPT=2 + ACCESS=3 + ADD=4 + ADDRESS=5 + ADVANCING=6 + AFTER=7 + ALIGNED=8 + ALL=9 + ALPHABET=10 + ALPHABETIC=11 + ALPHABETIC_LOWER=12 + ALPHABETIC_UPPER=13 + ALPHANUMERIC=14 + ALPHANUMERIC_EDITED=15 + ALSO=16 + ALTER=17 + ALTERNATE=18 + AND=19 + ANY=20 + ARE=21 + AREA=22 + AREAS=23 + AS=24 + ASCENDING=25 + ASCII=26 + ASSIGN=27 + ASSOCIATED_DATA=28 + ASSOCIATED_DATA_LENGTH=29 + AT=30 + ATTRIBUTE=31 + AUTHOR=32 + AUTO=33 + AUTO_SKIP=34 + BACKGROUND_COLOR=35 + BACKGROUND_COLOUR=36 + BASIS=37 + BEEP=38 + BEFORE=39 + BEGINNING=40 + BELL=41 + BINARY=42 + BIT=43 + BLANK=44 + BLINK=45 + BLOCK=46 + BOUNDS=47 + BOTTOM=48 + BY=49 + BYFUNCTION=50 + BYTITLE=51 + CALL=52 + CANCEL=53 + CAPABLE=54 + CCSVERSION=55 + CD=56 + CF=57 + CH=58 + CHAINING=59 + CHANGED=60 + CHANNEL=61 + CHARACTER=62 + CHARACTERS=63 + CLASS=64 + CLASS_ID=65 + CLOCK_UNITS=66 + CLOSE=67 + CLOSE_DISPOSITION=68 + COBOL=69 + CODE=70 + CODE_SET=71 + COLLATING=72 + COL=73 + COLUMN=74 + COM_REG=75 + COMMA=76 + COMMITMENT=77 + COMMON=78 + COMMUNICATION=79 + COMP=80 + COMP_1=81 + COMP_2=82 + COMP_3=83 + COMP_4=84 + COMP_5=85 + COMPUTATIONAL=86 + COMPUTATIONAL_1=87 + COMPUTATIONAL_2=88 + COMPUTATIONAL_3=89 + COMPUTATIONAL_4=90 + COMPUTATIONAL_5=91 + COMPUTE=92 + CONFIGURATION=93 + CONTAINS=94 + CONTENT=95 + CONTINUE=96 + CONTROL=97 + CONTROL_POINT=98 + CONTROLS=99 + CONVENTION=100 + CONVERTING=101 + COPY=102 + CORR=103 + CORRESPONDING=104 + COUNT=105 + CRUNCH=106 + CURRENCY=107 + CURSOR=108 + DATA=109 + DATA_BASE=110 + DATE=111 + DATE_COMPILED=112 + DATE_WRITTEN=113 + DAY=114 + DAY_OF_WEEK=115 + DBCS=116 + DE=117 + DEBUG_CONTENTS=118 + DEBUG_ITEM=119 + DEBUG_LINE=120 + DEBUG_NAME=121 + DEBUG_SUB_1=122 + DEBUG_SUB_2=123 + DEBUG_SUB_3=124 + DEBUGGING=125 + DECIMAL_POINT=126 + DECLARATIVES=127 + DEFAULT=128 + DEFAULT_DISPLAY=129 + DEFINITION=130 + DELETE=131 + DELIMITED=132 + DELIMITER=133 + DEPENDING=134 + DESCENDING=135 + DESTINATION=136 + DETAIL=137 + DFHRESP=138 + DFHVALUE=139 + DISABLE=140 + DISK=141 + DISPLAY=142 + DISPLAY_1=143 + DIVIDE=144 + DIVISION=145 + DONTCARE=146 + DOUBLE=147 + DOWN=148 + DUPLICATES=149 + DYNAMIC=150 + EBCDIC=151 + EGCS=152 + EGI=153 + ELSE=154 + EMI=155 + EMPTY_CHECK=156 + ENABLE=157 + END=158 + END_ACCEPT=159 + END_ADD=160 + END_CALL=161 + END_COMPUTE=162 + END_DELETE=163 + END_DIVIDE=164 + END_EVALUATE=165 + END_IF=166 + END_MULTIPLY=167 + END_OF_PAGE=168 + END_PERFORM=169 + END_READ=170 + END_RECEIVE=171 + END_RETURN=172 + END_REWRITE=173 + END_SEARCH=174 + END_START=175 + END_STRING=176 + END_SUBTRACT=177 + END_UNSTRING=178 + END_WRITE=179 + ENDING=180 + ENTER=181 + ENTRY=182 + ENTRY_PROCEDURE=183 + ENVIRONMENT=184 + EOP=185 + EQUAL=186 + ERASE=187 + ERROR=188 + EOL=189 + EOS=190 + ESCAPE=191 + ESI=192 + EVALUATE=193 + EVENT=194 + EVERY=195 + EXCEPTION=196 + EXCLUSIVE=197 + EXHIBIT=198 + EXIT=199 + EXPORT=200 + EXTEND=201 + EXTENDED=202 + EXTERNAL=203 + FALSE=204 + FD=205 + FILE=206 + FILE_CONTROL=207 + FILLER=208 + FINAL=209 + FIRST=210 + FOOTING=211 + FOR=212 + FOREGROUND_COLOR=213 + FOREGROUND_COLOUR=214 + FROM=215 + FULL=216 + FUNCTION=217 + FUNCTIONNAME=218 + FUNCTION_POINTER=219 + GENERATE=220 + GOBACK=221 + GIVING=222 + GLOBAL=223 + GO=224 + GREATER=225 + GRID=226 + GROUP=227 + HEADING=228 + HIGHLIGHT=229 + HIGH_VALUE=230 + HIGH_VALUES=231 + I_O=232 + I_O_CONTROL=233 + ID=234 + IDENTIFICATION=235 + IF=236 + IMPLICIT=237 + IMPORT=238 + IN=239 + INDEX=240 + INDEXED=241 + INDICATE=242 + INITIAL=243 + INITIALIZE=244 + INITIATE=245 + INPUT=246 + INPUT_OUTPUT=247 + INSPECT=248 + INSTALLATION=249 + INTEGER=250 + INTO=251 + INVALID=252 + INVOKE=253 + IS=254 + JUST=255 + JUSTIFIED=256 + KANJI=257 + KEPT=258 + KEY=259 + KEYBOARD=260 + LABEL=261 + LANGUAGE=262 + LAST=263 + LB=264 + LD=265 + LEADING=266 + LEFT=267 + LEFTLINE=268 + LENGTH=269 + LENGTH_CHECK=270 + LESS=271 + LIBACCESS=272 + LIBPARAMETER=273 + LIBRARY=274 + LIMIT=275 + LIMITS=276 + LINAGE=277 + LINAGE_COUNTER=278 + LINE=279 + LINES=280 + LINE_COUNTER=281 + LINKAGE=282 + LIST=283 + LOCAL=284 + LOCAL_STORAGE=285 + LOCK=286 + LONG_DATE=287 + LONG_TIME=288 + LOWER=289 + LOWLIGHT=290 + LOW_VALUE=291 + LOW_VALUES=292 + MEMORY=293 + MERGE=294 + MESSAGE=295 + MMDDYYYY=296 + MODE=297 + MODULES=298 + MORE_LABELS=299 + MOVE=300 + MULTIPLE=301 + MULTIPLY=302 + NAMED=303 + NATIONAL=304 + NATIONAL_EDITED=305 + NATIVE=306 + NEGATIVE=307 + NETWORK=308 + NEXT=309 + NO=310 + NO_ECHO=311 + NOT=312 + NULL_=313 + NULLS=314 + NUMBER=315 + NUMERIC=316 + NUMERIC_DATE=317 + NUMERIC_EDITED=318 + NUMERIC_TIME=319 + OBJECT_COMPUTER=320 + OCCURS=321 + ODT=322 + OF=323 + OFF=324 + OMITTED=325 + ON=326 + OPEN=327 + OPTIONAL=328 + OR=329 + ORDER=330 + ORDERLY=331 + ORGANIZATION=332 + OTHER=333 + OUTPUT=334 + OVERFLOW=335 + OVERLINE=336 + OWN=337 + PACKED_DECIMAL=338 + PADDING=339 + PAGE=340 + PAGE_COUNTER=341 + PASSWORD=342 + PERFORM=343 + PF=344 + PH=345 + PIC=346 + PICTURE=347 + PLUS=348 + POINTER=349 + POSITION=350 + POSITIVE=351 + PORT=352 + PRINTER=353 + PRINTING=354 + PRIVATE=355 + PROCEDURE=356 + PROCEDURE_POINTER=357 + PROCEDURES=358 + PROCEED=359 + PROCESS=360 + PROGRAM=361 + PROGRAM_ID=362 + PROGRAM_LIBRARY=363 + PROMPT=364 + PURGE=365 + QUEUE=366 + QUOTE=367 + QUOTES=368 + RANDOM=369 + READER=370 + REMOTE=371 + RD=372 + REAL=373 + READ=374 + RECEIVE=375 + RECEIVED=376 + RECORD=377 + RECORDING=378 + RECORDS=379 + RECURSIVE=380 + REDEFINES=381 + REEL=382 + REF=383 + REFERENCE=384 + REFERENCES=385 + RELATIVE=386 + RELEASE=387 + REMAINDER=388 + REMARKS=389 + REMOVAL=390 + REMOVE=391 + RENAMES=392 + REPLACE=393 + REPLACING=394 + REPORT=395 + REPORTING=396 + REPORTS=397 + REQUIRED=398 + RERUN=399 + RESERVE=400 + REVERSE_VIDEO=401 + RESET=402 + RETURN=403 + RETURN_CODE=404 + RETURNING=405 + REVERSED=406 + REWIND=407 + REWRITE=408 + RF=409 + RH=410 + RIGHT=411 + ROUNDED=412 + RUN=413 + SAME=414 + SAVE=415 + SCREEN=416 + SD=417 + SEARCH=418 + SECTION=419 + SECURE=420 + SECURITY=421 + SEGMENT=422 + SEGMENT_LIMIT=423 + SELECT=424 + SEND=425 + SENTENCE=426 + SEPARATE=427 + SEQUENCE=428 + SEQUENTIAL=429 + SET=430 + SHARED=431 + SHAREDBYALL=432 + SHAREDBYRUNUNIT=433 + SHARING=434 + SHIFT_IN=435 + SHIFT_OUT=436 + SHORT_DATE=437 + SIGN=438 + SIZE=439 + SORT=440 + SORT_CONTROL=441 + SORT_CORE_SIZE=442 + SORT_FILE_SIZE=443 + SORT_MERGE=444 + SORT_MESSAGE=445 + SORT_MODE_SIZE=446 + SORT_RETURN=447 + SOURCE=448 + SOURCE_COMPUTER=449 + SPACE=450 + SPACES=451 + SPECIAL_NAMES=452 + STANDARD=453 + STANDARD_1=454 + STANDARD_2=455 + START=456 + STATUS=457 + STOP=458 + STRING=459 + SUB_QUEUE_1=460 + SUB_QUEUE_2=461 + SUB_QUEUE_3=462 + SUBTRACT=463 + SUM=464 + SUPPRESS=465 + SYMBOL=466 + SYMBOLIC=467 + SYNC=468 + SYNCHRONIZED=469 + TABLE=470 + TALLY=471 + TALLYING=472 + TASK=473 + TAPE=474 + TERMINAL=475 + TERMINATE=476 + TEST=477 + TEXT=478 + THAN=479 + THEN=480 + THREAD=481 + THREAD_LOCAL=482 + THROUGH=483 + THRU=484 + TIME=485 + TIMER=486 + TIMES=487 + TITLE=488 + TO=489 + TODAYS_DATE=490 + TODAYS_NAME=491 + TOP=492 + TRAILING=493 + TRUE=494 + TRUNCATED=495 + TYPE=496 + TYPEDEF=497 + UNDERLINE=498 + UNIT=499 + UNSTRING=500 + UNTIL=501 + UP=502 + UPON=503 + USAGE=504 + USE=505 + USING=506 + VALUE=507 + VALUES=508 + VARYING=509 + VIRTUAL=510 + WAIT=511 + WHEN=512 + WHEN_COMPILED=513 + WITH=514 + WORDS=515 + WORKING_STORAGE=516 + WRITE=517 + YEAR=518 + YYYYMMDD=519 + YYYYDDD=520 + ZERO=521 + ZERO_FILL=522 + ZEROS=523 + ZEROES=524 + AMPCHAR=525 + ASTERISKCHAR=526 + DOUBLEASTERISKCHAR=527 + COLONCHAR=528 + COMMACHAR=529 + COMMENTENTRYTAG=530 + COMMENTTAG=531 + DOLLARCHAR=532 + DOUBLEQUOTE=533 + DOT_FS=534 + DOT=535 + EQUALCHAR=536 + EXECCICSTAG=537 + EXECSQLTAG=538 + EXECSQLIMSTAG=539 + LESSTHANCHAR=540 + LESSTHANOREQUAL=541 + LPARENCHAR=542 + MINUSCHAR=543 + MORETHANCHAR=544 + MORETHANOREQUAL=545 + NOTEQUALCHAR=546 + PLUSCHAR=547 + SINGLEQUOTE=548 + RPARENCHAR=549 + SLASHCHAR=550 + NONNUMERICLITERAL=551 + LEVEL_NUMBER_66=552 + LEVEL_NUMBER_77=553 + LEVEL_NUMBER_88=554 + INTEGERLITERAL=555 + NUMERICLITERAL=556 + IDENTIFIER=557 + NEWLINE=558 + EXECCICSLINE=559 + EXECSQLIMSLINE=560 + EXECSQLLINE=561 + COMMENTENTRYLINE=562 + COMMENTLINE=563 + WS=564 + SEPARATOR=565 + + 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 StartRuleContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def compilationUnit(self): + return self.getTypedRuleContext(Cobol85Parser.CompilationUnitContext,0) + + + def EOF(self): + return self.getToken(Cobol85Parser.EOF, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_startRule + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStartRule" ): + listener.enterStartRule(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStartRule" ): + listener.exitStartRule(self) + + + + + def startRule(self): + + localctx = Cobol85Parser.StartRuleContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_startRule) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1190 + self.compilationUnit() + self.state = 1191 + self.match(Cobol85Parser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CompilationUnitContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def programUnit(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ProgramUnitContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ProgramUnitContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_compilationUnit + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCompilationUnit" ): + listener.enterCompilationUnit(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCompilationUnit" ): + listener.exitCompilationUnit(self) + + + + + def compilationUnit(self): + + localctx = Cobol85Parser.CompilationUnitContext(self, self._ctx, self.state) + self.enterRule(localctx, 2, self.RULE_compilationUnit) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1194 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 1193 + self.programUnit() + self.state = 1196 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==234 or _la==235): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ProgramUnitContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def identificationDivision(self): + return self.getTypedRuleContext(Cobol85Parser.IdentificationDivisionContext,0) + + + def environmentDivision(self): + return self.getTypedRuleContext(Cobol85Parser.EnvironmentDivisionContext,0) + + + def dataDivision(self): + return self.getTypedRuleContext(Cobol85Parser.DataDivisionContext,0) + + + def procedureDivision(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureDivisionContext,0) + + + def programUnit(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ProgramUnitContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ProgramUnitContext,i) + + + def endProgramStatement(self): + return self.getTypedRuleContext(Cobol85Parser.EndProgramStatementContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_programUnit + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProgramUnit" ): + listener.enterProgramUnit(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProgramUnit" ): + listener.exitProgramUnit(self) + + + + + def programUnit(self): + + localctx = Cobol85Parser.ProgramUnitContext(self, self._ctx, self.state) + self.enterRule(localctx, 4, self.RULE_programUnit) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1198 + self.identificationDivision() + self.state = 1200 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==184: + self.state = 1199 + self.environmentDivision() + + + self.state = 1203 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==109: + self.state = 1202 + self.dataDivision() + + + self.state = 1206 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==356: + self.state = 1205 + self.procedureDivision() + + + self.state = 1211 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,4,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 1208 + self.programUnit() + self.state = 1213 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,4,self._ctx) + + self.state = 1215 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,5,self._ctx) + if la_ == 1: + self.state = 1214 + self.endProgramStatement() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class EndProgramStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def END(self): + return self.getToken(Cobol85Parser.END, 0) + + def PROGRAM(self): + return self.getToken(Cobol85Parser.PROGRAM, 0) + + def programName(self): + return self.getTypedRuleContext(Cobol85Parser.ProgramNameContext,0) + + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_endProgramStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEndProgramStatement" ): + listener.enterEndProgramStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEndProgramStatement" ): + listener.exitEndProgramStatement(self) + + + + + def endProgramStatement(self): + + localctx = Cobol85Parser.EndProgramStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 6, self.RULE_endProgramStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1217 + self.match(Cobol85Parser.END) + self.state = 1218 + self.match(Cobol85Parser.PROGRAM) + self.state = 1219 + self.programName() + self.state = 1220 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IdentificationDivisionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DIVISION(self): + return self.getToken(Cobol85Parser.DIVISION, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def programIdParagraph(self): + return self.getTypedRuleContext(Cobol85Parser.ProgramIdParagraphContext,0) + + + def IDENTIFICATION(self): + return self.getToken(Cobol85Parser.IDENTIFICATION, 0) + + def ID(self): + return self.getToken(Cobol85Parser.ID, 0) + + def identificationDivisionBody(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.IdentificationDivisionBodyContext) + else: + return self.getTypedRuleContext(Cobol85Parser.IdentificationDivisionBodyContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_identificationDivision + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIdentificationDivision" ): + listener.enterIdentificationDivision(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIdentificationDivision" ): + listener.exitIdentificationDivision(self) + + + + + def identificationDivision(self): + + localctx = Cobol85Parser.IdentificationDivisionContext(self, self._ctx, self.state) + self.enterRule(localctx, 8, self.RULE_identificationDivision) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1222 + _la = self._input.LA(1) + if not(_la==234 or _la==235): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1223 + self.match(Cobol85Parser.DIVISION) + self.state = 1224 + self.match(Cobol85Parser.DOT_FS) + self.state = 1225 + self.programIdParagraph() + self.state = 1229 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==32 or _la==112 or _la==113 or _la==249 or _la==389 or _la==421: + self.state = 1226 + self.identificationDivisionBody() + self.state = 1231 + 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 IdentificationDivisionBodyContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def authorParagraph(self): + return self.getTypedRuleContext(Cobol85Parser.AuthorParagraphContext,0) + + + def installationParagraph(self): + return self.getTypedRuleContext(Cobol85Parser.InstallationParagraphContext,0) + + + def dateWrittenParagraph(self): + return self.getTypedRuleContext(Cobol85Parser.DateWrittenParagraphContext,0) + + + def dateCompiledParagraph(self): + return self.getTypedRuleContext(Cobol85Parser.DateCompiledParagraphContext,0) + + + def securityParagraph(self): + return self.getTypedRuleContext(Cobol85Parser.SecurityParagraphContext,0) + + + def remarksParagraph(self): + return self.getTypedRuleContext(Cobol85Parser.RemarksParagraphContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_identificationDivisionBody + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIdentificationDivisionBody" ): + listener.enterIdentificationDivisionBody(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIdentificationDivisionBody" ): + listener.exitIdentificationDivisionBody(self) + + + + + def identificationDivisionBody(self): + + localctx = Cobol85Parser.IdentificationDivisionBodyContext(self, self._ctx, self.state) + self.enterRule(localctx, 10, self.RULE_identificationDivisionBody) + try: + self.state = 1238 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [32]: + self.enterOuterAlt(localctx, 1) + self.state = 1232 + self.authorParagraph() + pass + elif token in [249]: + self.enterOuterAlt(localctx, 2) + self.state = 1233 + self.installationParagraph() + pass + elif token in [113]: + self.enterOuterAlt(localctx, 3) + self.state = 1234 + self.dateWrittenParagraph() + pass + elif token in [112]: + self.enterOuterAlt(localctx, 4) + self.state = 1235 + self.dateCompiledParagraph() + pass + elif token in [421]: + self.enterOuterAlt(localctx, 5) + self.state = 1236 + self.securityParagraph() + pass + elif token in [389]: + self.enterOuterAlt(localctx, 6) + self.state = 1237 + self.remarksParagraph() + 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 ProgramIdParagraphContext(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.getToken(Cobol85Parser.PROGRAM_ID, 0) + + def DOT_FS(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.DOT_FS) + else: + return self.getToken(Cobol85Parser.DOT_FS, i) + + def programName(self): + return self.getTypedRuleContext(Cobol85Parser.ProgramNameContext,0) + + + def commentEntry(self): + return self.getTypedRuleContext(Cobol85Parser.CommentEntryContext,0) + + + def COMMON(self): + return self.getToken(Cobol85Parser.COMMON, 0) + + def INITIAL(self): + return self.getToken(Cobol85Parser.INITIAL, 0) + + def LIBRARY(self): + return self.getToken(Cobol85Parser.LIBRARY, 0) + + def DEFINITION(self): + return self.getToken(Cobol85Parser.DEFINITION, 0) + + def RECURSIVE(self): + return self.getToken(Cobol85Parser.RECURSIVE, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def PROGRAM(self): + return self.getToken(Cobol85Parser.PROGRAM, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_programIdParagraph + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProgramIdParagraph" ): + listener.enterProgramIdParagraph(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProgramIdParagraph" ): + listener.exitProgramIdParagraph(self) + + + + + def programIdParagraph(self): + + localctx = Cobol85Parser.ProgramIdParagraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 12, self.RULE_programIdParagraph) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1240 + self.match(Cobol85Parser.PROGRAM_ID) + self.state = 1241 + self.match(Cobol85Parser.DOT_FS) + self.state = 1242 + self.programName() + self.state = 1250 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==78 or _la==130 or ((((_la - 243)) & ~0x3f) == 0 and ((1 << (_la - 243)) & 2147485697) != 0) or _la==380: + self.state = 1244 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1243 + self.match(Cobol85Parser.IS) + + + self.state = 1246 + _la = self._input.LA(1) + if not(_la==78 or _la==130 or _la==243 or _la==274 or _la==380): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1248 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==361: + self.state = 1247 + self.match(Cobol85Parser.PROGRAM) + + + + + self.state = 1253 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==534: + self.state = 1252 + self.match(Cobol85Parser.DOT_FS) + + + self.state = 1256 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==562: + self.state = 1255 + self.commentEntry() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AuthorParagraphContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def AUTHOR(self): + return self.getToken(Cobol85Parser.AUTHOR, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def commentEntry(self): + return self.getTypedRuleContext(Cobol85Parser.CommentEntryContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_authorParagraph + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAuthorParagraph" ): + listener.enterAuthorParagraph(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAuthorParagraph" ): + listener.exitAuthorParagraph(self) + + + + + def authorParagraph(self): + + localctx = Cobol85Parser.AuthorParagraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 14, self.RULE_authorParagraph) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1258 + self.match(Cobol85Parser.AUTHOR) + self.state = 1259 + self.match(Cobol85Parser.DOT_FS) + self.state = 1261 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==562: + self.state = 1260 + self.commentEntry() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InstallationParagraphContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INSTALLATION(self): + return self.getToken(Cobol85Parser.INSTALLATION, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def commentEntry(self): + return self.getTypedRuleContext(Cobol85Parser.CommentEntryContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_installationParagraph + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInstallationParagraph" ): + listener.enterInstallationParagraph(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInstallationParagraph" ): + listener.exitInstallationParagraph(self) + + + + + def installationParagraph(self): + + localctx = Cobol85Parser.InstallationParagraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 16, self.RULE_installationParagraph) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1263 + self.match(Cobol85Parser.INSTALLATION) + self.state = 1264 + self.match(Cobol85Parser.DOT_FS) + self.state = 1266 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==562: + self.state = 1265 + self.commentEntry() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DateWrittenParagraphContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DATE_WRITTEN(self): + return self.getToken(Cobol85Parser.DATE_WRITTEN, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def commentEntry(self): + return self.getTypedRuleContext(Cobol85Parser.CommentEntryContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dateWrittenParagraph + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDateWrittenParagraph" ): + listener.enterDateWrittenParagraph(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDateWrittenParagraph" ): + listener.exitDateWrittenParagraph(self) + + + + + def dateWrittenParagraph(self): + + localctx = Cobol85Parser.DateWrittenParagraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 18, self.RULE_dateWrittenParagraph) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1268 + self.match(Cobol85Parser.DATE_WRITTEN) + self.state = 1269 + self.match(Cobol85Parser.DOT_FS) + self.state = 1271 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==562: + self.state = 1270 + self.commentEntry() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DateCompiledParagraphContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DATE_COMPILED(self): + return self.getToken(Cobol85Parser.DATE_COMPILED, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def commentEntry(self): + return self.getTypedRuleContext(Cobol85Parser.CommentEntryContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dateCompiledParagraph + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDateCompiledParagraph" ): + listener.enterDateCompiledParagraph(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDateCompiledParagraph" ): + listener.exitDateCompiledParagraph(self) + + + + + def dateCompiledParagraph(self): + + localctx = Cobol85Parser.DateCompiledParagraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 20, self.RULE_dateCompiledParagraph) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1273 + self.match(Cobol85Parser.DATE_COMPILED) + self.state = 1274 + self.match(Cobol85Parser.DOT_FS) + self.state = 1276 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==562: + self.state = 1275 + self.commentEntry() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SecurityParagraphContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SECURITY(self): + return self.getToken(Cobol85Parser.SECURITY, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def commentEntry(self): + return self.getTypedRuleContext(Cobol85Parser.CommentEntryContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_securityParagraph + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSecurityParagraph" ): + listener.enterSecurityParagraph(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSecurityParagraph" ): + listener.exitSecurityParagraph(self) + + + + + def securityParagraph(self): + + localctx = Cobol85Parser.SecurityParagraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 22, self.RULE_securityParagraph) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1278 + self.match(Cobol85Parser.SECURITY) + self.state = 1279 + self.match(Cobol85Parser.DOT_FS) + self.state = 1281 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==562: + self.state = 1280 + self.commentEntry() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RemarksParagraphContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REMARKS(self): + return self.getToken(Cobol85Parser.REMARKS, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def commentEntry(self): + return self.getTypedRuleContext(Cobol85Parser.CommentEntryContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_remarksParagraph + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRemarksParagraph" ): + listener.enterRemarksParagraph(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRemarksParagraph" ): + listener.exitRemarksParagraph(self) + + + + + def remarksParagraph(self): + + localctx = Cobol85Parser.RemarksParagraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 24, self.RULE_remarksParagraph) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1283 + self.match(Cobol85Parser.REMARKS) + self.state = 1284 + self.match(Cobol85Parser.DOT_FS) + self.state = 1286 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==562: + self.state = 1285 + self.commentEntry() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class EnvironmentDivisionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ENVIRONMENT(self): + return self.getToken(Cobol85Parser.ENVIRONMENT, 0) + + def DIVISION(self): + return self.getToken(Cobol85Parser.DIVISION, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def environmentDivisionBody(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.EnvironmentDivisionBodyContext) + else: + return self.getTypedRuleContext(Cobol85Parser.EnvironmentDivisionBodyContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_environmentDivision + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEnvironmentDivision" ): + listener.enterEnvironmentDivision(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEnvironmentDivision" ): + listener.exitEnvironmentDivision(self) + + + + + def environmentDivision(self): + + localctx = Cobol85Parser.EnvironmentDivisionContext(self, self._ctx, self.state) + self.enterRule(localctx, 26, self.RULE_environmentDivision) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1288 + self.match(Cobol85Parser.ENVIRONMENT) + self.state = 1289 + self.match(Cobol85Parser.DIVISION) + self.state = 1290 + self.match(Cobol85Parser.DOT_FS) + self.state = 1294 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==93 or _la==247 or _la==452: + self.state = 1291 + self.environmentDivisionBody() + self.state = 1296 + 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 EnvironmentDivisionBodyContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def configurationSection(self): + return self.getTypedRuleContext(Cobol85Parser.ConfigurationSectionContext,0) + + + def specialNamesParagraph(self): + return self.getTypedRuleContext(Cobol85Parser.SpecialNamesParagraphContext,0) + + + def inputOutputSection(self): + return self.getTypedRuleContext(Cobol85Parser.InputOutputSectionContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_environmentDivisionBody + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEnvironmentDivisionBody" ): + listener.enterEnvironmentDivisionBody(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEnvironmentDivisionBody" ): + listener.exitEnvironmentDivisionBody(self) + + + + + def environmentDivisionBody(self): + + localctx = Cobol85Parser.EnvironmentDivisionBodyContext(self, self._ctx, self.state) + self.enterRule(localctx, 28, self.RULE_environmentDivisionBody) + try: + self.state = 1300 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [93]: + self.enterOuterAlt(localctx, 1) + self.state = 1297 + self.configurationSection() + pass + elif token in [452]: + self.enterOuterAlt(localctx, 2) + self.state = 1298 + self.specialNamesParagraph() + pass + elif token in [247]: + self.enterOuterAlt(localctx, 3) + self.state = 1299 + self.inputOutputSection() + 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 ConfigurationSectionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CONFIGURATION(self): + return self.getToken(Cobol85Parser.CONFIGURATION, 0) + + def SECTION(self): + return self.getToken(Cobol85Parser.SECTION, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def configurationSectionParagraph(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ConfigurationSectionParagraphContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ConfigurationSectionParagraphContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_configurationSection + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConfigurationSection" ): + listener.enterConfigurationSection(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConfigurationSection" ): + listener.exitConfigurationSection(self) + + + + + def configurationSection(self): + + localctx = Cobol85Parser.ConfigurationSectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 30, self.RULE_configurationSection) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1302 + self.match(Cobol85Parser.CONFIGURATION) + self.state = 1303 + self.match(Cobol85Parser.SECTION) + self.state = 1304 + self.match(Cobol85Parser.DOT_FS) + self.state = 1308 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,21,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 1305 + self.configurationSectionParagraph() + self.state = 1310 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,21,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ConfigurationSectionParagraphContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def sourceComputerParagraph(self): + return self.getTypedRuleContext(Cobol85Parser.SourceComputerParagraphContext,0) + + + def objectComputerParagraph(self): + return self.getTypedRuleContext(Cobol85Parser.ObjectComputerParagraphContext,0) + + + def specialNamesParagraph(self): + return self.getTypedRuleContext(Cobol85Parser.SpecialNamesParagraphContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_configurationSectionParagraph + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConfigurationSectionParagraph" ): + listener.enterConfigurationSectionParagraph(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConfigurationSectionParagraph" ): + listener.exitConfigurationSectionParagraph(self) + + + + + def configurationSectionParagraph(self): + + localctx = Cobol85Parser.ConfigurationSectionParagraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 32, self.RULE_configurationSectionParagraph) + try: + self.state = 1314 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [449]: + self.enterOuterAlt(localctx, 1) + self.state = 1311 + self.sourceComputerParagraph() + pass + elif token in [320]: + self.enterOuterAlt(localctx, 2) + self.state = 1312 + self.objectComputerParagraph() + pass + elif token in [452]: + self.enterOuterAlt(localctx, 3) + self.state = 1313 + self.specialNamesParagraph() + 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 SourceComputerParagraphContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SOURCE_COMPUTER(self): + return self.getToken(Cobol85Parser.SOURCE_COMPUTER, 0) + + def DOT_FS(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.DOT_FS) + else: + return self.getToken(Cobol85Parser.DOT_FS, i) + + def computerName(self): + return self.getTypedRuleContext(Cobol85Parser.ComputerNameContext,0) + + + def DEBUGGING(self): + return self.getToken(Cobol85Parser.DEBUGGING, 0) + + def MODE(self): + return self.getToken(Cobol85Parser.MODE, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_sourceComputerParagraph + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSourceComputerParagraph" ): + listener.enterSourceComputerParagraph(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSourceComputerParagraph" ): + listener.exitSourceComputerParagraph(self) + + + + + def sourceComputerParagraph(self): + + localctx = Cobol85Parser.SourceComputerParagraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 34, self.RULE_sourceComputerParagraph) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1316 + self.match(Cobol85Parser.SOURCE_COMPUTER) + self.state = 1317 + self.match(Cobol85Parser.DOT_FS) + self.state = 1318 + self.computerName() + self.state = 1324 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==125 or _la==514: + self.state = 1320 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 1319 + self.match(Cobol85Parser.WITH) + + + self.state = 1322 + self.match(Cobol85Parser.DEBUGGING) + self.state = 1323 + self.match(Cobol85Parser.MODE) + + + self.state = 1326 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ObjectComputerParagraphContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OBJECT_COMPUTER(self): + return self.getToken(Cobol85Parser.OBJECT_COMPUTER, 0) + + def DOT_FS(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.DOT_FS) + else: + return self.getToken(Cobol85Parser.DOT_FS, i) + + def computerName(self): + return self.getTypedRuleContext(Cobol85Parser.ComputerNameContext,0) + + + def objectComputerClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ObjectComputerClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ObjectComputerClauseContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_objectComputerParagraph + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterObjectComputerParagraph" ): + listener.enterObjectComputerParagraph(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitObjectComputerParagraph" ): + listener.exitObjectComputerParagraph(self) + + + + + def objectComputerParagraph(self): + + localctx = Cobol85Parser.ObjectComputerParagraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 36, self.RULE_objectComputerParagraph) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1328 + self.match(Cobol85Parser.OBJECT_COMPUTER) + self.state = 1329 + self.match(Cobol85Parser.DOT_FS) + self.state = 1330 + self.computerName() + self.state = 1334 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==62 or _la==72 or _la==141 or _la==293 or _la==361 or _la==423 or _la==428: + self.state = 1331 + self.objectComputerClause() + self.state = 1336 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 1337 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ObjectComputerClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def memorySizeClause(self): + return self.getTypedRuleContext(Cobol85Parser.MemorySizeClauseContext,0) + + + def diskSizeClause(self): + return self.getTypedRuleContext(Cobol85Parser.DiskSizeClauseContext,0) + + + def collatingSequenceClause(self): + return self.getTypedRuleContext(Cobol85Parser.CollatingSequenceClauseContext,0) + + + def segmentLimitClause(self): + return self.getTypedRuleContext(Cobol85Parser.SegmentLimitClauseContext,0) + + + def characterSetClause(self): + return self.getTypedRuleContext(Cobol85Parser.CharacterSetClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_objectComputerClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterObjectComputerClause" ): + listener.enterObjectComputerClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitObjectComputerClause" ): + listener.exitObjectComputerClause(self) + + + + + def objectComputerClause(self): + + localctx = Cobol85Parser.ObjectComputerClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 38, self.RULE_objectComputerClause) + try: + self.state = 1344 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [293]: + self.enterOuterAlt(localctx, 1) + self.state = 1339 + self.memorySizeClause() + pass + elif token in [141]: + self.enterOuterAlt(localctx, 2) + self.state = 1340 + self.diskSizeClause() + pass + elif token in [72, 361, 428]: + self.enterOuterAlt(localctx, 3) + self.state = 1341 + self.collatingSequenceClause() + pass + elif token in [423]: + self.enterOuterAlt(localctx, 4) + self.state = 1342 + self.segmentLimitClause() + pass + elif token in [62]: + self.enterOuterAlt(localctx, 5) + self.state = 1343 + self.characterSetClause() + 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 MemorySizeClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def MEMORY(self): + return self.getToken(Cobol85Parser.MEMORY, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def SIZE(self): + return self.getToken(Cobol85Parser.SIZE, 0) + + def WORDS(self): + return self.getToken(Cobol85Parser.WORDS, 0) + + def CHARACTERS(self): + return self.getToken(Cobol85Parser.CHARACTERS, 0) + + def MODULES(self): + return self.getToken(Cobol85Parser.MODULES, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_memorySizeClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMemorySizeClause" ): + listener.enterMemorySizeClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMemorySizeClause" ): + listener.exitMemorySizeClause(self) + + + + + def memorySizeClause(self): + + localctx = Cobol85Parser.MemorySizeClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 40, self.RULE_memorySizeClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1346 + self.match(Cobol85Parser.MEMORY) + self.state = 1348 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==439: + self.state = 1347 + self.match(Cobol85Parser.SIZE) + + + self.state = 1352 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [552, 553, 554, 555]: + self.state = 1350 + self.integerLiteral() + pass + elif token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.state = 1351 + self.cobolWord() + pass + else: + raise NoViableAltException(self) + + self.state = 1355 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==63 or _la==298 or _la==515: + self.state = 1354 + _la = self._input.LA(1) + if not(_la==63 or _la==298 or _la==515): + 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 DiskSizeClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DISK(self): + return self.getToken(Cobol85Parser.DISK, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def SIZE(self): + return self.getToken(Cobol85Parser.SIZE, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def WORDS(self): + return self.getToken(Cobol85Parser.WORDS, 0) + + def MODULES(self): + return self.getToken(Cobol85Parser.MODULES, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_diskSizeClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDiskSizeClause" ): + listener.enterDiskSizeClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDiskSizeClause" ): + listener.exitDiskSizeClause(self) + + + + + def diskSizeClause(self): + + localctx = Cobol85Parser.DiskSizeClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 42, self.RULE_diskSizeClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1357 + self.match(Cobol85Parser.DISK) + self.state = 1359 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==439: + self.state = 1358 + self.match(Cobol85Parser.SIZE) + + + self.state = 1362 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1361 + self.match(Cobol85Parser.IS) + + + self.state = 1366 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [552, 553, 554, 555]: + self.state = 1364 + self.integerLiteral() + pass + elif token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.state = 1365 + self.cobolWord() + pass + else: + raise NoViableAltException(self) + + self.state = 1369 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==298 or _la==515: + self.state = 1368 + _la = self._input.LA(1) + if not(_la==298 or _la==515): + 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 CollatingSequenceClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SEQUENCE(self): + return self.getToken(Cobol85Parser.SEQUENCE, 0) + + def PROGRAM(self): + return self.getToken(Cobol85Parser.PROGRAM, 0) + + def COLLATING(self): + return self.getToken(Cobol85Parser.COLLATING, 0) + + def collatingSequenceClauseAlphanumeric(self): + return self.getTypedRuleContext(Cobol85Parser.CollatingSequenceClauseAlphanumericContext,0) + + + def collatingSequenceClauseNational(self): + return self.getTypedRuleContext(Cobol85Parser.CollatingSequenceClauseNationalContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def alphabetName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.AlphabetNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.AlphabetNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_collatingSequenceClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCollatingSequenceClause" ): + listener.enterCollatingSequenceClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCollatingSequenceClause" ): + listener.exitCollatingSequenceClause(self) + + + + + def collatingSequenceClause(self): + + localctx = Cobol85Parser.CollatingSequenceClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 44, self.RULE_collatingSequenceClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1372 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==361: + self.state = 1371 + self.match(Cobol85Parser.PROGRAM) + + + self.state = 1375 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==72: + self.state = 1374 + self.match(Cobol85Parser.COLLATING) + + + self.state = 1377 + self.match(Cobol85Parser.SEQUENCE) + + self.state = 1379 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1378 + self.match(Cobol85Parser.IS) + + + self.state = 1382 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1381 + self.alphabetName() + + else: + raise NoViableAltException(self) + self.state = 1384 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,37,self._ctx) + + self.state = 1387 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,38,self._ctx) + if la_ == 1: + self.state = 1386 + self.collatingSequenceClauseAlphanumeric() + + + self.state = 1390 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212 or _la==304: + self.state = 1389 + self.collatingSequenceClauseNational() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CollatingSequenceClauseAlphanumericContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALPHANUMERIC(self): + return self.getToken(Cobol85Parser.ALPHANUMERIC, 0) + + def alphabetName(self): + return self.getTypedRuleContext(Cobol85Parser.AlphabetNameContext,0) + + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_collatingSequenceClauseAlphanumeric + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCollatingSequenceClauseAlphanumeric" ): + listener.enterCollatingSequenceClauseAlphanumeric(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCollatingSequenceClauseAlphanumeric" ): + listener.exitCollatingSequenceClauseAlphanumeric(self) + + + + + def collatingSequenceClauseAlphanumeric(self): + + localctx = Cobol85Parser.CollatingSequenceClauseAlphanumericContext(self, self._ctx, self.state) + self.enterRule(localctx, 46, self.RULE_collatingSequenceClauseAlphanumeric) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1393 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 1392 + self.match(Cobol85Parser.FOR) + + + self.state = 1395 + self.match(Cobol85Parser.ALPHANUMERIC) + self.state = 1397 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1396 + self.match(Cobol85Parser.IS) + + + self.state = 1399 + self.alphabetName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CollatingSequenceClauseNationalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NATIONAL(self): + return self.getToken(Cobol85Parser.NATIONAL, 0) + + def alphabetName(self): + return self.getTypedRuleContext(Cobol85Parser.AlphabetNameContext,0) + + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_collatingSequenceClauseNational + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCollatingSequenceClauseNational" ): + listener.enterCollatingSequenceClauseNational(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCollatingSequenceClauseNational" ): + listener.exitCollatingSequenceClauseNational(self) + + + + + def collatingSequenceClauseNational(self): + + localctx = Cobol85Parser.CollatingSequenceClauseNationalContext(self, self._ctx, self.state) + self.enterRule(localctx, 48, self.RULE_collatingSequenceClauseNational) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1402 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 1401 + self.match(Cobol85Parser.FOR) + + + self.state = 1404 + self.match(Cobol85Parser.NATIONAL) + self.state = 1406 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1405 + self.match(Cobol85Parser.IS) + + + self.state = 1408 + self.alphabetName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SegmentLimitClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SEGMENT_LIMIT(self): + return self.getToken(Cobol85Parser.SEGMENT_LIMIT, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_segmentLimitClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSegmentLimitClause" ): + listener.enterSegmentLimitClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSegmentLimitClause" ): + listener.exitSegmentLimitClause(self) + + + + + def segmentLimitClause(self): + + localctx = Cobol85Parser.SegmentLimitClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 50, self.RULE_segmentLimitClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1410 + self.match(Cobol85Parser.SEGMENT_LIMIT) + self.state = 1412 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1411 + self.match(Cobol85Parser.IS) + + + self.state = 1414 + self.integerLiteral() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CharacterSetClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CHARACTER(self): + return self.getToken(Cobol85Parser.CHARACTER, 0) + + def SET(self): + return self.getToken(Cobol85Parser.SET, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_characterSetClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCharacterSetClause" ): + listener.enterCharacterSetClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCharacterSetClause" ): + listener.exitCharacterSetClause(self) + + + + + def characterSetClause(self): + + localctx = Cobol85Parser.CharacterSetClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 52, self.RULE_characterSetClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1416 + self.match(Cobol85Parser.CHARACTER) + self.state = 1417 + self.match(Cobol85Parser.SET) + self.state = 1418 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SpecialNamesParagraphContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SPECIAL_NAMES(self): + return self.getToken(Cobol85Parser.SPECIAL_NAMES, 0) + + def DOT_FS(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.DOT_FS) + else: + return self.getToken(Cobol85Parser.DOT_FS, i) + + def specialNameClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SpecialNameClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SpecialNameClauseContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_specialNamesParagraph + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSpecialNamesParagraph" ): + listener.enterSpecialNamesParagraph(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSpecialNamesParagraph" ): + listener.exitSpecialNamesParagraph(self) + + + + + def specialNamesParagraph(self): + + localctx = Cobol85Parser.SpecialNamesParagraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 54, self.RULE_specialNamesParagraph) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1420 + self.match(Cobol85Parser.SPECIAL_NAMES) + self.state = 1421 + self.match(Cobol85Parser.DOT_FS) + self.state = 1429 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822850) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 4611716890652319793) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & -1684346260358943737) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 72084021027799369) != 0) or ((((_la - 258)) & ~0x3f) == 0 and ((1 << (_la - 258)) & 2892683434315076821) != 0) or ((((_la - 322)) & ~0x3f) == 0 and ((1 << (_la - 322)) & 2615189243111195157) != 0) or ((((_la - 391)) & ~0x3f) == 0 and ((1 << (_la - 391)) & 86861972244097) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455171) != 0) or _la==557: + self.state = 1423 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 1422 + self.specialNameClause() + self.state = 1425 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822850) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 4611716890652319793) != 0) or ((((_la - 128)) & ~0x3f) == 0 and ((1 << (_la - 128)) & -1684346260358943737) != 0) or ((((_la - 194)) & ~0x3f) == 0 and ((1 << (_la - 194)) & 72084021027799369) != 0) or ((((_la - 258)) & ~0x3f) == 0 and ((1 << (_la - 258)) & 2892683434315076821) != 0) or ((((_la - 322)) & ~0x3f) == 0 and ((1 << (_la - 322)) & 2615189243111195157) != 0) or ((((_la - 391)) & ~0x3f) == 0 and ((1 << (_la - 391)) & 86861972244097) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455171) != 0) or _la==557): + break + + self.state = 1427 + self.match(Cobol85Parser.DOT_FS) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SpecialNameClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def channelClause(self): + return self.getTypedRuleContext(Cobol85Parser.ChannelClauseContext,0) + + + def odtClause(self): + return self.getTypedRuleContext(Cobol85Parser.OdtClauseContext,0) + + + def alphabetClause(self): + return self.getTypedRuleContext(Cobol85Parser.AlphabetClauseContext,0) + + + def classClause(self): + return self.getTypedRuleContext(Cobol85Parser.ClassClauseContext,0) + + + def currencySignClause(self): + return self.getTypedRuleContext(Cobol85Parser.CurrencySignClauseContext,0) + + + def decimalPointClause(self): + return self.getTypedRuleContext(Cobol85Parser.DecimalPointClauseContext,0) + + + def symbolicCharactersClause(self): + return self.getTypedRuleContext(Cobol85Parser.SymbolicCharactersClauseContext,0) + + + def environmentSwitchNameClause(self): + return self.getTypedRuleContext(Cobol85Parser.EnvironmentSwitchNameClauseContext,0) + + + def defaultDisplaySignClause(self): + return self.getTypedRuleContext(Cobol85Parser.DefaultDisplaySignClauseContext,0) + + + def defaultComputationalSignClause(self): + return self.getTypedRuleContext(Cobol85Parser.DefaultComputationalSignClauseContext,0) + + + def reserveNetworkClause(self): + return self.getTypedRuleContext(Cobol85Parser.ReserveNetworkClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_specialNameClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSpecialNameClause" ): + listener.enterSpecialNameClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSpecialNameClause" ): + listener.exitSpecialNameClause(self) + + + + + def specialNameClause(self): + + localctx = Cobol85Parser.SpecialNameClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 56, self.RULE_specialNameClause) + try: + self.state = 1442 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,47,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1431 + self.channelClause() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1432 + self.odtClause() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 1433 + self.alphabetClause() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 1434 + self.classClause() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 1435 + self.currencySignClause() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 1436 + self.decimalPointClause() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 1437 + self.symbolicCharactersClause() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 1438 + self.environmentSwitchNameClause() + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 1439 + self.defaultDisplaySignClause() + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 1440 + self.defaultComputationalSignClause() + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 1441 + self.reserveNetworkClause() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AlphabetClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def alphabetClauseFormat1(self): + return self.getTypedRuleContext(Cobol85Parser.AlphabetClauseFormat1Context,0) + + + def alphabetClauseFormat2(self): + return self.getTypedRuleContext(Cobol85Parser.AlphabetClauseFormat2Context,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_alphabetClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlphabetClause" ): + listener.enterAlphabetClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlphabetClause" ): + listener.exitAlphabetClause(self) + + + + + def alphabetClause(self): + + localctx = Cobol85Parser.AlphabetClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 58, self.RULE_alphabetClause) + try: + self.state = 1446 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,48,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1444 + self.alphabetClauseFormat1() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1445 + self.alphabetClauseFormat2() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AlphabetClauseFormat1Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALPHABET(self): + return self.getToken(Cobol85Parser.ALPHABET, 0) + + def alphabetName(self): + return self.getTypedRuleContext(Cobol85Parser.AlphabetNameContext,0) + + + def EBCDIC(self): + return self.getToken(Cobol85Parser.EBCDIC, 0) + + def ASCII(self): + return self.getToken(Cobol85Parser.ASCII, 0) + + def STANDARD_1(self): + return self.getToken(Cobol85Parser.STANDARD_1, 0) + + def STANDARD_2(self): + return self.getToken(Cobol85Parser.STANDARD_2, 0) + + def NATIVE(self): + return self.getToken(Cobol85Parser.NATIVE, 0) + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def ALPHANUMERIC(self): + return self.getToken(Cobol85Parser.ALPHANUMERIC, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def alphabetLiterals(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.AlphabetLiteralsContext) + else: + return self.getTypedRuleContext(Cobol85Parser.AlphabetLiteralsContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_alphabetClauseFormat1 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlphabetClauseFormat1" ): + listener.enterAlphabetClauseFormat1(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlphabetClauseFormat1" ): + listener.exitAlphabetClauseFormat1(self) + + + + + def alphabetClauseFormat1(self): + + localctx = Cobol85Parser.AlphabetClauseFormat1Context(self, self._ctx, self.state) + self.enterRule(localctx, 60, self.RULE_alphabetClauseFormat1) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1448 + self.match(Cobol85Parser.ALPHABET) + self.state = 1449 + self.alphabetName() + self.state = 1452 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 1450 + self.match(Cobol85Parser.FOR) + self.state = 1451 + self.match(Cobol85Parser.ALPHANUMERIC) + + + self.state = 1455 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1454 + self.match(Cobol85Parser.IS) + + + self.state = 1468 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,52,self._ctx) + if la_ == 1: + self.state = 1457 + self.match(Cobol85Parser.EBCDIC) + pass + + elif la_ == 2: + self.state = 1458 + self.match(Cobol85Parser.ASCII) + pass + + elif la_ == 3: + self.state = 1459 + self.match(Cobol85Parser.STANDARD_1) + pass + + elif la_ == 4: + self.state = 1460 + self.match(Cobol85Parser.STANDARD_2) + pass + + elif la_ == 5: + self.state = 1461 + self.match(Cobol85Parser.NATIVE) + pass + + elif la_ == 6: + self.state = 1462 + self.cobolWord() + pass + + elif la_ == 7: + self.state = 1464 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1463 + self.alphabetLiterals() + + else: + raise NoViableAltException(self) + self.state = 1466 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,51,self._ctx) + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AlphabetLiteralsContext(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(Cobol85Parser.LiteralContext,0) + + + def alphabetThrough(self): + return self.getTypedRuleContext(Cobol85Parser.AlphabetThroughContext,0) + + + def alphabetAlso(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.AlphabetAlsoContext) + else: + return self.getTypedRuleContext(Cobol85Parser.AlphabetAlsoContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_alphabetLiterals + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlphabetLiterals" ): + listener.enterAlphabetLiterals(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlphabetLiterals" ): + listener.exitAlphabetLiterals(self) + + + + + def alphabetLiterals(self): + + localctx = Cobol85Parser.AlphabetLiteralsContext(self, self._ctx, self.state) + self.enterRule(localctx, 62, self.RULE_alphabetLiterals) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1470 + self.literal() + self.state = 1477 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [483, 484]: + self.state = 1471 + self.alphabetThrough() + pass + elif token in [16]: + self.state = 1473 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 1472 + self.alphabetAlso() + self.state = 1475 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==16): + break + + pass + elif token in [1, 9, 10, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 64, 68, 69, 77, 98, 100, 106, 107, 108, 126, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 204, 213, 214, 216, 218, 219, 226, 229, 230, 231, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 291, 292, 296, 303, 304, 305, 308, 311, 313, 314, 317, 319, 322, 324, 326, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 367, 368, 370, 371, 373, 376, 380, 383, 391, 398, 400, 401, 415, 420, 431, 432, 433, 434, 437, 450, 451, 466, 467, 473, 481, 482, 486, 490, 491, 494, 495, 497, 498, 510, 511, 518, 519, 520, 521, 522, 523, 524, 534, 551, 552, 553, 554, 555, 556, 557]: + pass + else: + pass + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AlphabetThroughContext(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(Cobol85Parser.LiteralContext,0) + + + def THROUGH(self): + return self.getToken(Cobol85Parser.THROUGH, 0) + + def THRU(self): + return self.getToken(Cobol85Parser.THRU, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_alphabetThrough + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlphabetThrough" ): + listener.enterAlphabetThrough(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlphabetThrough" ): + listener.exitAlphabetThrough(self) + + + + + def alphabetThrough(self): + + localctx = Cobol85Parser.AlphabetThroughContext(self, self._ctx, self.state) + self.enterRule(localctx, 64, self.RULE_alphabetThrough) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1479 + _la = self._input.LA(1) + if not(_la==483 or _la==484): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1480 + self.literal() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AlphabetAlsoContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALSO(self): + return self.getToken(Cobol85Parser.ALSO, 0) + + def literal(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.LiteralContext) + else: + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_alphabetAlso + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlphabetAlso" ): + listener.enterAlphabetAlso(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlphabetAlso" ): + listener.exitAlphabetAlso(self) + + + + + def alphabetAlso(self): + + localctx = Cobol85Parser.AlphabetAlsoContext(self, self._ctx, self.state) + self.enterRule(localctx, 66, self.RULE_alphabetAlso) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1482 + self.match(Cobol85Parser.ALSO) + self.state = 1484 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1483 + self.literal() + + else: + raise NoViableAltException(self) + self.state = 1486 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,55,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AlphabetClauseFormat2Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALPHABET(self): + return self.getToken(Cobol85Parser.ALPHABET, 0) + + def alphabetName(self): + return self.getTypedRuleContext(Cobol85Parser.AlphabetNameContext,0) + + + def NATIONAL(self): + return self.getToken(Cobol85Parser.NATIONAL, 0) + + def NATIVE(self): + return self.getToken(Cobol85Parser.NATIVE, 0) + + def CCSVERSION(self): + return self.getToken(Cobol85Parser.CCSVERSION, 0) + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_alphabetClauseFormat2 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlphabetClauseFormat2" ): + listener.enterAlphabetClauseFormat2(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlphabetClauseFormat2" ): + listener.exitAlphabetClauseFormat2(self) + + + + + def alphabetClauseFormat2(self): + + localctx = Cobol85Parser.AlphabetClauseFormat2Context(self, self._ctx, self.state) + self.enterRule(localctx, 68, self.RULE_alphabetClauseFormat2) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1488 + self.match(Cobol85Parser.ALPHABET) + self.state = 1489 + self.alphabetName() + self.state = 1491 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 1490 + self.match(Cobol85Parser.FOR) + + + self.state = 1493 + self.match(Cobol85Parser.NATIONAL) + self.state = 1495 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1494 + self.match(Cobol85Parser.IS) + + + self.state = 1500 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [306]: + self.state = 1497 + self.match(Cobol85Parser.NATIVE) + pass + elif token in [55]: + self.state = 1498 + self.match(Cobol85Parser.CCSVERSION) + self.state = 1499 + self.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 ChannelClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CHANNEL(self): + return self.getToken(Cobol85Parser.CHANNEL, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def mnemonicName(self): + return self.getTypedRuleContext(Cobol85Parser.MnemonicNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_channelClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterChannelClause" ): + listener.enterChannelClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitChannelClause" ): + listener.exitChannelClause(self) + + + + + def channelClause(self): + + localctx = Cobol85Parser.ChannelClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 70, self.RULE_channelClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1502 + self.match(Cobol85Parser.CHANNEL) + self.state = 1503 + self.integerLiteral() + self.state = 1505 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1504 + self.match(Cobol85Parser.IS) + + + self.state = 1507 + self.mnemonicName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ClassClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CLASS(self): + return self.getToken(Cobol85Parser.CLASS, 0) + + def className(self): + return self.getTypedRuleContext(Cobol85Parser.ClassNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def classClauseThrough(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ClassClauseThroughContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ClassClauseThroughContext,i) + + + def ALPHANUMERIC(self): + return self.getToken(Cobol85Parser.ALPHANUMERIC, 0) + + def NATIONAL(self): + return self.getToken(Cobol85Parser.NATIONAL, 0) + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_classClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterClassClause" ): + listener.enterClassClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitClassClause" ): + listener.exitClassClause(self) + + + + + def classClause(self): + + localctx = Cobol85Parser.ClassClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 72, self.RULE_classClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1509 + self.match(Cobol85Parser.CLASS) + self.state = 1510 + self.className() + self.state = 1515 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,61,self._ctx) + if la_ == 1: + self.state = 1512 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 1511 + self.match(Cobol85Parser.FOR) + + + self.state = 1514 + _la = self._input.LA(1) + if not(_la==14 or _la==304): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 1518 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1517 + self.match(Cobol85Parser.IS) + + + self.state = 1521 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1520 + self.classClauseThrough() + + else: + raise NoViableAltException(self) + self.state = 1523 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,63,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ClassClauseThroughContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def classClauseFrom(self): + return self.getTypedRuleContext(Cobol85Parser.ClassClauseFromContext,0) + + + def classClauseTo(self): + return self.getTypedRuleContext(Cobol85Parser.ClassClauseToContext,0) + + + def THROUGH(self): + return self.getToken(Cobol85Parser.THROUGH, 0) + + def THRU(self): + return self.getToken(Cobol85Parser.THRU, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_classClauseThrough + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterClassClauseThrough" ): + listener.enterClassClauseThrough(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitClassClauseThrough" ): + listener.exitClassClauseThrough(self) + + + + + def classClauseThrough(self): + + localctx = Cobol85Parser.ClassClauseThroughContext(self, self._ctx, self.state) + self.enterRule(localctx, 74, self.RULE_classClauseThrough) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1525 + self.classClauseFrom() + self.state = 1528 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==483 or _la==484: + self.state = 1526 + _la = self._input.LA(1) + if not(_la==483 or _la==484): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1527 + self.classClauseTo() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ClassClauseFromContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_classClauseFrom + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterClassClauseFrom" ): + listener.enterClassClauseFrom(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitClassClauseFrom" ): + listener.exitClassClauseFrom(self) + + + + + def classClauseFrom(self): + + localctx = Cobol85Parser.ClassClauseFromContext(self, self._ctx, self.state) + self.enterRule(localctx, 76, self.RULE_classClauseFrom) + try: + self.state = 1532 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,65,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1530 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1531 + self.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 ClassClauseToContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_classClauseTo + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterClassClauseTo" ): + listener.enterClassClauseTo(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitClassClauseTo" ): + listener.exitClassClauseTo(self) + + + + + def classClauseTo(self): + + localctx = Cobol85Parser.ClassClauseToContext(self, self._ctx, self.state) + self.enterRule(localctx, 78, self.RULE_classClauseTo) + try: + self.state = 1536 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,66,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1534 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1535 + self.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 CurrencySignClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CURRENCY(self): + return self.getToken(Cobol85Parser.CURRENCY, 0) + + def literal(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.LiteralContext) + else: + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,i) + + + def SIGN(self): + return self.getToken(Cobol85Parser.SIGN, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def PICTURE(self): + return self.getToken(Cobol85Parser.PICTURE, 0) + + def SYMBOL(self): + return self.getToken(Cobol85Parser.SYMBOL, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_currencySignClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCurrencySignClause" ): + listener.enterCurrencySignClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCurrencySignClause" ): + listener.exitCurrencySignClause(self) + + + + + def currencySignClause(self): + + localctx = Cobol85Parser.CurrencySignClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 80, self.RULE_currencySignClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1538 + self.match(Cobol85Parser.CURRENCY) + self.state = 1540 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==438: + self.state = 1539 + self.match(Cobol85Parser.SIGN) + + + self.state = 1543 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1542 + self.match(Cobol85Parser.IS) + + + self.state = 1545 + self.literal() + self.state = 1552 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==347 or _la==514: + self.state = 1547 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 1546 + self.match(Cobol85Parser.WITH) + + + self.state = 1549 + self.match(Cobol85Parser.PICTURE) + self.state = 1550 + self.match(Cobol85Parser.SYMBOL) + self.state = 1551 + self.literal() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DecimalPointClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DECIMAL_POINT(self): + return self.getToken(Cobol85Parser.DECIMAL_POINT, 0) + + def COMMA(self): + return self.getToken(Cobol85Parser.COMMA, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_decimalPointClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDecimalPointClause" ): + listener.enterDecimalPointClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDecimalPointClause" ): + listener.exitDecimalPointClause(self) + + + + + def decimalPointClause(self): + + localctx = Cobol85Parser.DecimalPointClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 82, self.RULE_decimalPointClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1554 + self.match(Cobol85Parser.DECIMAL_POINT) + self.state = 1556 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1555 + self.match(Cobol85Parser.IS) + + + self.state = 1558 + self.match(Cobol85Parser.COMMA) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DefaultComputationalSignClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DEFAULT(self): + return self.getToken(Cobol85Parser.DEFAULT, 0) + + def SEPARATE(self): + return self.getToken(Cobol85Parser.SEPARATE, 0) + + def SIGN(self): + return self.getToken(Cobol85Parser.SIGN, 0) + + def COMPUTATIONAL(self): + return self.getToken(Cobol85Parser.COMPUTATIONAL, 0) + + def COMP(self): + return self.getToken(Cobol85Parser.COMP, 0) + + def LEADING(self): + return self.getToken(Cobol85Parser.LEADING, 0) + + def TRAILING(self): + return self.getToken(Cobol85Parser.TRAILING, 0) + + def CHARACTER(self): + return self.getToken(Cobol85Parser.CHARACTER, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_defaultComputationalSignClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDefaultComputationalSignClause" ): + listener.enterDefaultComputationalSignClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDefaultComputationalSignClause" ): + listener.exitDefaultComputationalSignClause(self) + + + + + def defaultComputationalSignClause(self): + + localctx = Cobol85Parser.DefaultComputationalSignClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 84, self.RULE_defaultComputationalSignClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1560 + self.match(Cobol85Parser.DEFAULT) + self.state = 1562 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==80 or _la==86: + self.state = 1561 + _la = self._input.LA(1) + if not(_la==80 or _la==86): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 1568 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==438: + self.state = 1564 + self.match(Cobol85Parser.SIGN) + self.state = 1566 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1565 + self.match(Cobol85Parser.IS) + + + + + self.state = 1571 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==266 or _la==493: + self.state = 1570 + _la = self._input.LA(1) + if not(_la==266 or _la==493): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 1573 + self.match(Cobol85Parser.SEPARATE) + self.state = 1575 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==62: + self.state = 1574 + self.match(Cobol85Parser.CHARACTER) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DefaultDisplaySignClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DEFAULT_DISPLAY(self): + return self.getToken(Cobol85Parser.DEFAULT_DISPLAY, 0) + + def LEADING(self): + return self.getToken(Cobol85Parser.LEADING, 0) + + def TRAILING(self): + return self.getToken(Cobol85Parser.TRAILING, 0) + + def SIGN(self): + return self.getToken(Cobol85Parser.SIGN, 0) + + def SEPARATE(self): + return self.getToken(Cobol85Parser.SEPARATE, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def CHARACTER(self): + return self.getToken(Cobol85Parser.CHARACTER, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_defaultDisplaySignClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDefaultDisplaySignClause" ): + listener.enterDefaultDisplaySignClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDefaultDisplaySignClause" ): + listener.exitDefaultDisplaySignClause(self) + + + + + def defaultDisplaySignClause(self): + + localctx = Cobol85Parser.DefaultDisplaySignClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 86, self.RULE_defaultDisplaySignClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1577 + self.match(Cobol85Parser.DEFAULT_DISPLAY) + self.state = 1582 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==438: + self.state = 1578 + self.match(Cobol85Parser.SIGN) + self.state = 1580 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1579 + self.match(Cobol85Parser.IS) + + + + + self.state = 1584 + _la = self._input.LA(1) + if not(_la==266 or _la==493): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1589 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==427: + self.state = 1585 + self.match(Cobol85Parser.SEPARATE) + self.state = 1587 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==62: + self.state = 1586 + self.match(Cobol85Parser.CHARACTER) + + + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class EnvironmentSwitchNameClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def environmentName(self): + return self.getTypedRuleContext(Cobol85Parser.EnvironmentNameContext,0) + + + def mnemonicName(self): + return self.getTypedRuleContext(Cobol85Parser.MnemonicNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def environmentSwitchNameSpecialNamesStatusPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.EnvironmentSwitchNameSpecialNamesStatusPhraseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_environmentSwitchNameClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEnvironmentSwitchNameClause" ): + listener.enterEnvironmentSwitchNameClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEnvironmentSwitchNameClause" ): + listener.exitEnvironmentSwitchNameClause(self) + + + + + def environmentSwitchNameClause(self): + + localctx = Cobol85Parser.EnvironmentSwitchNameClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 88, self.RULE_environmentSwitchNameClause) + self._la = 0 # Token type + try: + self.state = 1600 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.enterOuterAlt(localctx, 1) + self.state = 1591 + self.environmentName() + self.state = 1593 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1592 + self.match(Cobol85Parser.IS) + + + self.state = 1595 + self.mnemonicName() + self.state = 1597 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,82,self._ctx) + if la_ == 1: + self.state = 1596 + self.environmentSwitchNameSpecialNamesStatusPhrase() + + + pass + elif token in [324, 326]: + self.enterOuterAlt(localctx, 2) + self.state = 1599 + self.environmentSwitchNameSpecialNamesStatusPhrase() + 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 EnvironmentSwitchNameSpecialNamesStatusPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def condition(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ConditionContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ConditionContext,i) + + + def STATUS(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.STATUS) + else: + return self.getToken(Cobol85Parser.STATUS, i) + + def IS(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.IS) + else: + return self.getToken(Cobol85Parser.IS, i) + + def OFF(self): + return self.getToken(Cobol85Parser.OFF, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_environmentSwitchNameSpecialNamesStatusPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEnvironmentSwitchNameSpecialNamesStatusPhrase" ): + listener.enterEnvironmentSwitchNameSpecialNamesStatusPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEnvironmentSwitchNameSpecialNamesStatusPhrase" ): + listener.exitEnvironmentSwitchNameSpecialNamesStatusPhrase(self) + + + + + def environmentSwitchNameSpecialNamesStatusPhrase(self): + + localctx = Cobol85Parser.EnvironmentSwitchNameSpecialNamesStatusPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 90, self.RULE_environmentSwitchNameSpecialNamesStatusPhrase) + self._la = 0 # Token type + try: + self.state = 1638 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [326]: + self.enterOuterAlt(localctx, 1) + self.state = 1602 + self.match(Cobol85Parser.ON) + self.state = 1604 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==457: + self.state = 1603 + self.match(Cobol85Parser.STATUS) + + + self.state = 1607 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1606 + self.match(Cobol85Parser.IS) + + + self.state = 1609 + self.condition() + self.state = 1618 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,88,self._ctx) + if la_ == 1: + self.state = 1610 + self.match(Cobol85Parser.OFF) + self.state = 1612 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==457: + self.state = 1611 + self.match(Cobol85Parser.STATUS) + + + self.state = 1615 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1614 + self.match(Cobol85Parser.IS) + + + self.state = 1617 + self.condition() + + + pass + elif token in [324]: + self.enterOuterAlt(localctx, 2) + self.state = 1620 + self.match(Cobol85Parser.OFF) + self.state = 1622 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==457: + self.state = 1621 + self.match(Cobol85Parser.STATUS) + + + self.state = 1625 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1624 + self.match(Cobol85Parser.IS) + + + self.state = 1627 + self.condition() + self.state = 1636 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,93,self._ctx) + if la_ == 1: + self.state = 1628 + self.match(Cobol85Parser.ON) + self.state = 1630 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==457: + self.state = 1629 + self.match(Cobol85Parser.STATUS) + + + self.state = 1633 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1632 + self.match(Cobol85Parser.IS) + + + self.state = 1635 + self.condition() + + + 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 OdtClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ODT(self): + return self.getToken(Cobol85Parser.ODT, 0) + + def mnemonicName(self): + return self.getTypedRuleContext(Cobol85Parser.MnemonicNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_odtClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOdtClause" ): + listener.enterOdtClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOdtClause" ): + listener.exitOdtClause(self) + + + + + def odtClause(self): + + localctx = Cobol85Parser.OdtClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 92, self.RULE_odtClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1640 + self.match(Cobol85Parser.ODT) + self.state = 1642 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1641 + self.match(Cobol85Parser.IS) + + + self.state = 1644 + self.mnemonicName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReserveNetworkClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RESERVE(self): + return self.getToken(Cobol85Parser.RESERVE, 0) + + def NETWORK(self): + return self.getToken(Cobol85Parser.NETWORK, 0) + + def WORDS(self): + return self.getToken(Cobol85Parser.WORDS, 0) + + def LIST(self): + return self.getToken(Cobol85Parser.LIST, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def CAPABLE(self): + return self.getToken(Cobol85Parser.CAPABLE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reserveNetworkClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReserveNetworkClause" ): + listener.enterReserveNetworkClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReserveNetworkClause" ): + listener.exitReserveNetworkClause(self) + + + + + def reserveNetworkClause(self): + + localctx = Cobol85Parser.ReserveNetworkClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 94, self.RULE_reserveNetworkClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1646 + self.match(Cobol85Parser.RESERVE) + self.state = 1648 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==515: + self.state = 1647 + self.match(Cobol85Parser.WORDS) + + + self.state = 1651 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==283: + self.state = 1650 + self.match(Cobol85Parser.LIST) + + + self.state = 1654 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1653 + self.match(Cobol85Parser.IS) + + + self.state = 1656 + self.match(Cobol85Parser.NETWORK) + self.state = 1658 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,99,self._ctx) + if la_ == 1: + self.state = 1657 + self.match(Cobol85Parser.CAPABLE) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SymbolicCharactersClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SYMBOLIC(self): + return self.getToken(Cobol85Parser.SYMBOLIC, 0) + + def CHARACTERS(self): + return self.getToken(Cobol85Parser.CHARACTERS, 0) + + def symbolicCharacters(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SymbolicCharactersContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SymbolicCharactersContext,i) + + + def IN(self): + return self.getToken(Cobol85Parser.IN, 0) + + def alphabetName(self): + return self.getTypedRuleContext(Cobol85Parser.AlphabetNameContext,0) + + + def ALPHANUMERIC(self): + return self.getToken(Cobol85Parser.ALPHANUMERIC, 0) + + def NATIONAL(self): + return self.getToken(Cobol85Parser.NATIONAL, 0) + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_symbolicCharactersClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSymbolicCharactersClause" ): + listener.enterSymbolicCharactersClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSymbolicCharactersClause" ): + listener.exitSymbolicCharactersClause(self) + + + + + def symbolicCharactersClause(self): + + localctx = Cobol85Parser.SymbolicCharactersClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 96, self.RULE_symbolicCharactersClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1660 + self.match(Cobol85Parser.SYMBOLIC) + self.state = 1662 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==63: + self.state = 1661 + self.match(Cobol85Parser.CHARACTERS) + + + self.state = 1668 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,102,self._ctx) + if la_ == 1: + self.state = 1665 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 1664 + self.match(Cobol85Parser.FOR) + + + self.state = 1667 + _la = self._input.LA(1) + if not(_la==14 or _la==304): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 1671 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1670 + self.symbolicCharacters() + + else: + raise NoViableAltException(self) + self.state = 1673 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,103,self._ctx) + + self.state = 1677 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==239: + self.state = 1675 + self.match(Cobol85Parser.IN) + self.state = 1676 + self.alphabetName() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SymbolicCharactersContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def symbolicCharacter(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SymbolicCharacterContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SymbolicCharacterContext,i) + + + def integerLiteral(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.IntegerLiteralContext) + else: + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,i) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def ARE(self): + return self.getToken(Cobol85Parser.ARE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_symbolicCharacters + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSymbolicCharacters" ): + listener.enterSymbolicCharacters(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSymbolicCharacters" ): + listener.exitSymbolicCharacters(self) + + + + + def symbolicCharacters(self): + + localctx = Cobol85Parser.SymbolicCharactersContext(self, self._ctx, self.state) + self.enterRule(localctx, 98, self.RULE_symbolicCharacters) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1680 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 1679 + self.symbolicCharacter() + self.state = 1682 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + self.state = 1685 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==21 or _la==254: + self.state = 1684 + _la = self._input.LA(1) + if not(_la==21 or _la==254): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 1688 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 1687 + self.integerLiteral() + self.state = 1690 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 15) != 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 InputOutputSectionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INPUT_OUTPUT(self): + return self.getToken(Cobol85Parser.INPUT_OUTPUT, 0) + + def SECTION(self): + return self.getToken(Cobol85Parser.SECTION, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def inputOutputSectionParagraph(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InputOutputSectionParagraphContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InputOutputSectionParagraphContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inputOutputSection + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInputOutputSection" ): + listener.enterInputOutputSection(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInputOutputSection" ): + listener.exitInputOutputSection(self) + + + + + def inputOutputSection(self): + + localctx = Cobol85Parser.InputOutputSectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 100, self.RULE_inputOutputSection) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1692 + self.match(Cobol85Parser.INPUT_OUTPUT) + self.state = 1693 + self.match(Cobol85Parser.SECTION) + self.state = 1694 + self.match(Cobol85Parser.DOT_FS) + self.state = 1698 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==207 or _la==233: + self.state = 1695 + self.inputOutputSectionParagraph() + self.state = 1700 + 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 InputOutputSectionParagraphContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def fileControlParagraph(self): + return self.getTypedRuleContext(Cobol85Parser.FileControlParagraphContext,0) + + + def ioControlParagraph(self): + return self.getTypedRuleContext(Cobol85Parser.IoControlParagraphContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inputOutputSectionParagraph + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInputOutputSectionParagraph" ): + listener.enterInputOutputSectionParagraph(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInputOutputSectionParagraph" ): + listener.exitInputOutputSectionParagraph(self) + + + + + def inputOutputSectionParagraph(self): + + localctx = Cobol85Parser.InputOutputSectionParagraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 102, self.RULE_inputOutputSectionParagraph) + try: + self.state = 1703 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [207]: + self.enterOuterAlt(localctx, 1) + self.state = 1701 + self.fileControlParagraph() + pass + elif token in [233]: + self.enterOuterAlt(localctx, 2) + self.state = 1702 + self.ioControlParagraph() + 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 FileControlParagraphContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FILE_CONTROL(self): + return self.getToken(Cobol85Parser.FILE_CONTROL, 0) + + def DOT_FS(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.DOT_FS) + else: + return self.getToken(Cobol85Parser.DOT_FS, i) + + def fileControlEntry(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.FileControlEntryContext) + else: + return self.getTypedRuleContext(Cobol85Parser.FileControlEntryContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_fileControlParagraph + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFileControlParagraph" ): + listener.enterFileControlParagraph(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFileControlParagraph" ): + listener.exitFileControlParagraph(self) + + + + + def fileControlParagraph(self): + + localctx = Cobol85Parser.FileControlParagraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 104, self.RULE_fileControlParagraph) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1705 + self.match(Cobol85Parser.FILE_CONTROL) + self.state = 1712 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,111,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 1707 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==534: + self.state = 1706 + self.match(Cobol85Parser.DOT_FS) + + + self.state = 1709 + self.fileControlEntry() + self.state = 1714 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,111,self._ctx) + + self.state = 1715 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class FileControlEntryContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def selectClause(self): + return self.getTypedRuleContext(Cobol85Parser.SelectClauseContext,0) + + + def fileControlClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.FileControlClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.FileControlClauseContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_fileControlEntry + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFileControlEntry" ): + listener.enterFileControlEntry(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFileControlEntry" ): + listener.exitFileControlEntry(self) + + + + + def fileControlEntry(self): + + localctx = Cobol85Parser.FileControlEntryContext(self, self._ctx, self.state) + self.enterRule(localctx, 106, self.RULE_fileControlEntry) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1717 + self.selectClause() + self.state = 1721 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 4398180990984) != 0) or _la==206 or _la==241 or ((((_la - 279)) & ~0x3f) == 0 and ((1 << (_la - 279)) & -8061443332993187839) != 0) or ((((_la - 377)) & ~0x3f) == 0 and ((1 << (_la - 377)) & 4503599635759617) != 0) or _la==457: + self.state = 1718 + self.fileControlClause() + self.state = 1723 + 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 SelectClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SELECT(self): + return self.getToken(Cobol85Parser.SELECT, 0) + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def OPTIONAL(self): + return self.getToken(Cobol85Parser.OPTIONAL, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_selectClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSelectClause" ): + listener.enterSelectClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSelectClause" ): + listener.exitSelectClause(self) + + + + + def selectClause(self): + + localctx = Cobol85Parser.SelectClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 108, self.RULE_selectClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1724 + self.match(Cobol85Parser.SELECT) + self.state = 1726 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==328: + self.state = 1725 + self.match(Cobol85Parser.OPTIONAL) + + + self.state = 1728 + self.fileName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class FileControlClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def assignClause(self): + return self.getTypedRuleContext(Cobol85Parser.AssignClauseContext,0) + + + def reserveClause(self): + return self.getTypedRuleContext(Cobol85Parser.ReserveClauseContext,0) + + + def organizationClause(self): + return self.getTypedRuleContext(Cobol85Parser.OrganizationClauseContext,0) + + + def paddingCharacterClause(self): + return self.getTypedRuleContext(Cobol85Parser.PaddingCharacterClauseContext,0) + + + def recordDelimiterClause(self): + return self.getTypedRuleContext(Cobol85Parser.RecordDelimiterClauseContext,0) + + + def accessModeClause(self): + return self.getTypedRuleContext(Cobol85Parser.AccessModeClauseContext,0) + + + def recordKeyClause(self): + return self.getTypedRuleContext(Cobol85Parser.RecordKeyClauseContext,0) + + + def alternateRecordKeyClause(self): + return self.getTypedRuleContext(Cobol85Parser.AlternateRecordKeyClauseContext,0) + + + def fileStatusClause(self): + return self.getTypedRuleContext(Cobol85Parser.FileStatusClauseContext,0) + + + def passwordClause(self): + return self.getTypedRuleContext(Cobol85Parser.PasswordClauseContext,0) + + + def relativeKeyClause(self): + return self.getTypedRuleContext(Cobol85Parser.RelativeKeyClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_fileControlClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFileControlClause" ): + listener.enterFileControlClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFileControlClause" ): + listener.exitFileControlClause(self) + + + + + def fileControlClause(self): + + localctx = Cobol85Parser.FileControlClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 110, self.RULE_fileControlClause) + try: + self.state = 1741 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,114,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 1730 + self.assignClause() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 1731 + self.reserveClause() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 1732 + self.organizationClause() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 1733 + self.paddingCharacterClause() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 1734 + self.recordDelimiterClause() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 1735 + self.accessModeClause() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 1736 + self.recordKeyClause() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 1737 + self.alternateRecordKeyClause() + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 1738 + self.fileStatusClause() + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 1739 + self.passwordClause() + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 1740 + self.relativeKeyClause() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AssignClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ASSIGN(self): + return self.getToken(Cobol85Parser.ASSIGN, 0) + + def DISK(self): + return self.getToken(Cobol85Parser.DISK, 0) + + def DISPLAY(self): + return self.getToken(Cobol85Parser.DISPLAY, 0) + + def KEYBOARD(self): + return self.getToken(Cobol85Parser.KEYBOARD, 0) + + def PORT(self): + return self.getToken(Cobol85Parser.PORT, 0) + + def PRINTER(self): + return self.getToken(Cobol85Parser.PRINTER, 0) + + def READER(self): + return self.getToken(Cobol85Parser.READER, 0) + + def REMOTE(self): + return self.getToken(Cobol85Parser.REMOTE, 0) + + def TAPE(self): + return self.getToken(Cobol85Parser.TAPE, 0) + + def VIRTUAL(self): + return self.getToken(Cobol85Parser.VIRTUAL, 0) + + def assignmentName(self): + return self.getTypedRuleContext(Cobol85Parser.AssignmentNameContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_assignClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAssignClause" ): + listener.enterAssignClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAssignClause" ): + listener.exitAssignClause(self) + + + + + def assignClause(self): + + localctx = Cobol85Parser.AssignClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 112, self.RULE_assignClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1743 + self.match(Cobol85Parser.ASSIGN) + self.state = 1745 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==489: + self.state = 1744 + self.match(Cobol85Parser.TO) + + + self.state = 1758 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,116,self._ctx) + if la_ == 1: + self.state = 1747 + self.match(Cobol85Parser.DISK) + pass + + elif la_ == 2: + self.state = 1748 + self.match(Cobol85Parser.DISPLAY) + pass + + elif la_ == 3: + self.state = 1749 + self.match(Cobol85Parser.KEYBOARD) + pass + + elif la_ == 4: + self.state = 1750 + self.match(Cobol85Parser.PORT) + pass + + elif la_ == 5: + self.state = 1751 + self.match(Cobol85Parser.PRINTER) + pass + + elif la_ == 6: + self.state = 1752 + self.match(Cobol85Parser.READER) + pass + + elif la_ == 7: + self.state = 1753 + self.match(Cobol85Parser.REMOTE) + pass + + elif la_ == 8: + self.state = 1754 + self.match(Cobol85Parser.TAPE) + pass + + elif la_ == 9: + self.state = 1755 + self.match(Cobol85Parser.VIRTUAL) + pass + + elif la_ == 10: + self.state = 1756 + self.assignmentName() + pass + + elif la_ == 11: + self.state = 1757 + self.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 ReserveClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RESERVE(self): + return self.getToken(Cobol85Parser.RESERVE, 0) + + def NO(self): + return self.getToken(Cobol85Parser.NO, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def ALTERNATE(self): + return self.getToken(Cobol85Parser.ALTERNATE, 0) + + def AREA(self): + return self.getToken(Cobol85Parser.AREA, 0) + + def AREAS(self): + return self.getToken(Cobol85Parser.AREAS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reserveClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReserveClause" ): + listener.enterReserveClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReserveClause" ): + listener.exitReserveClause(self) + + + + + def reserveClause(self): + + localctx = Cobol85Parser.ReserveClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 114, self.RULE_reserveClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1760 + self.match(Cobol85Parser.RESERVE) + self.state = 1763 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [310]: + self.state = 1761 + self.match(Cobol85Parser.NO) + pass + elif token in [552, 553, 554, 555]: + self.state = 1762 + self.integerLiteral() + pass + else: + raise NoViableAltException(self) + + self.state = 1766 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,118,self._ctx) + if la_ == 1: + self.state = 1765 + self.match(Cobol85Parser.ALTERNATE) + + + self.state = 1769 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==22 or _la==23: + self.state = 1768 + _la = self._input.LA(1) + if not(_la==22 or _la==23): + 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 OrganizationClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SEQUENTIAL(self): + return self.getToken(Cobol85Parser.SEQUENTIAL, 0) + + def RELATIVE(self): + return self.getToken(Cobol85Parser.RELATIVE, 0) + + def INDEXED(self): + return self.getToken(Cobol85Parser.INDEXED, 0) + + def ORGANIZATION(self): + return self.getToken(Cobol85Parser.ORGANIZATION, 0) + + def LINE(self): + return self.getToken(Cobol85Parser.LINE, 0) + + def RECORD(self): + return self.getToken(Cobol85Parser.RECORD, 0) + + def BINARY(self): + return self.getToken(Cobol85Parser.BINARY, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_organizationClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOrganizationClause" ): + listener.enterOrganizationClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOrganizationClause" ): + listener.exitOrganizationClause(self) + + + + + def organizationClause(self): + + localctx = Cobol85Parser.OrganizationClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 116, self.RULE_organizationClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1775 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==332: + self.state = 1771 + self.match(Cobol85Parser.ORGANIZATION) + self.state = 1773 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1772 + self.match(Cobol85Parser.IS) + + + + + self.state = 1782 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,122,self._ctx) + if la_ == 1: + self.state = 1777 + self.match(Cobol85Parser.LINE) + + elif la_ == 2: + self.state = 1778 + self.match(Cobol85Parser.RECORD) + self.state = 1779 + self.match(Cobol85Parser.BINARY) + + elif la_ == 3: + self.state = 1780 + self.match(Cobol85Parser.RECORD) + + elif la_ == 4: + self.state = 1781 + self.match(Cobol85Parser.BINARY) + + + self.state = 1784 + _la = self._input.LA(1) + if not(_la==241 or _la==386 or _la==429): + 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 PaddingCharacterClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PADDING(self): + return self.getToken(Cobol85Parser.PADDING, 0) + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def CHARACTER(self): + return self.getToken(Cobol85Parser.CHARACTER, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_paddingCharacterClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPaddingCharacterClause" ): + listener.enterPaddingCharacterClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPaddingCharacterClause" ): + listener.exitPaddingCharacterClause(self) + + + + + def paddingCharacterClause(self): + + localctx = Cobol85Parser.PaddingCharacterClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 118, self.RULE_paddingCharacterClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1786 + self.match(Cobol85Parser.PADDING) + self.state = 1788 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==62: + self.state = 1787 + self.match(Cobol85Parser.CHARACTER) + + + self.state = 1791 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1790 + self.match(Cobol85Parser.IS) + + + self.state = 1795 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,125,self._ctx) + if la_ == 1: + self.state = 1793 + self.qualifiedDataName() + pass + + elif la_ == 2: + self.state = 1794 + self.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 RecordDelimiterClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RECORD(self): + return self.getToken(Cobol85Parser.RECORD, 0) + + def DELIMITER(self): + return self.getToken(Cobol85Parser.DELIMITER, 0) + + def STANDARD_1(self): + return self.getToken(Cobol85Parser.STANDARD_1, 0) + + def IMPLICIT(self): + return self.getToken(Cobol85Parser.IMPLICIT, 0) + + def assignmentName(self): + return self.getTypedRuleContext(Cobol85Parser.AssignmentNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_recordDelimiterClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRecordDelimiterClause" ): + listener.enterRecordDelimiterClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRecordDelimiterClause" ): + listener.exitRecordDelimiterClause(self) + + + + + def recordDelimiterClause(self): + + localctx = Cobol85Parser.RecordDelimiterClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 120, self.RULE_recordDelimiterClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1797 + self.match(Cobol85Parser.RECORD) + self.state = 1798 + self.match(Cobol85Parser.DELIMITER) + self.state = 1800 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1799 + self.match(Cobol85Parser.IS) + + + self.state = 1805 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,127,self._ctx) + if la_ == 1: + self.state = 1802 + self.match(Cobol85Parser.STANDARD_1) + pass + + elif la_ == 2: + self.state = 1803 + self.match(Cobol85Parser.IMPLICIT) + pass + + elif la_ == 3: + self.state = 1804 + self.assignmentName() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AccessModeClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ACCESS(self): + return self.getToken(Cobol85Parser.ACCESS, 0) + + def SEQUENTIAL(self): + return self.getToken(Cobol85Parser.SEQUENTIAL, 0) + + def RANDOM(self): + return self.getToken(Cobol85Parser.RANDOM, 0) + + def DYNAMIC(self): + return self.getToken(Cobol85Parser.DYNAMIC, 0) + + def EXCLUSIVE(self): + return self.getToken(Cobol85Parser.EXCLUSIVE, 0) + + def MODE(self): + return self.getToken(Cobol85Parser.MODE, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_accessModeClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAccessModeClause" ): + listener.enterAccessModeClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAccessModeClause" ): + listener.exitAccessModeClause(self) + + + + + def accessModeClause(self): + + localctx = Cobol85Parser.AccessModeClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 122, self.RULE_accessModeClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1807 + self.match(Cobol85Parser.ACCESS) + self.state = 1809 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==297: + self.state = 1808 + self.match(Cobol85Parser.MODE) + + + self.state = 1812 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1811 + self.match(Cobol85Parser.IS) + + + self.state = 1814 + _la = self._input.LA(1) + if not(_la==150 or _la==197 or _la==369 or _la==429): + 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 RecordKeyClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RECORD(self): + return self.getToken(Cobol85Parser.RECORD, 0) + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def passwordClause(self): + return self.getTypedRuleContext(Cobol85Parser.PasswordClauseContext,0) + + + def DUPLICATES(self): + return self.getToken(Cobol85Parser.DUPLICATES, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_recordKeyClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRecordKeyClause" ): + listener.enterRecordKeyClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRecordKeyClause" ): + listener.exitRecordKeyClause(self) + + + + + def recordKeyClause(self): + + localctx = Cobol85Parser.RecordKeyClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 124, self.RULE_recordKeyClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1816 + self.match(Cobol85Parser.RECORD) + self.state = 1818 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==259: + self.state = 1817 + self.match(Cobol85Parser.KEY) + + + self.state = 1821 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1820 + self.match(Cobol85Parser.IS) + + + self.state = 1823 + self.qualifiedDataName() + self.state = 1825 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,132,self._ctx) + if la_ == 1: + self.state = 1824 + self.passwordClause() + + + self.state = 1831 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==149 or _la==514: + self.state = 1828 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 1827 + self.match(Cobol85Parser.WITH) + + + self.state = 1830 + self.match(Cobol85Parser.DUPLICATES) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AlternateRecordKeyClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALTERNATE(self): + return self.getToken(Cobol85Parser.ALTERNATE, 0) + + def RECORD(self): + return self.getToken(Cobol85Parser.RECORD, 0) + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def passwordClause(self): + return self.getTypedRuleContext(Cobol85Parser.PasswordClauseContext,0) + + + def DUPLICATES(self): + return self.getToken(Cobol85Parser.DUPLICATES, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_alternateRecordKeyClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlternateRecordKeyClause" ): + listener.enterAlternateRecordKeyClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlternateRecordKeyClause" ): + listener.exitAlternateRecordKeyClause(self) + + + + + def alternateRecordKeyClause(self): + + localctx = Cobol85Parser.AlternateRecordKeyClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 126, self.RULE_alternateRecordKeyClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1833 + self.match(Cobol85Parser.ALTERNATE) + self.state = 1834 + self.match(Cobol85Parser.RECORD) + self.state = 1836 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==259: + self.state = 1835 + self.match(Cobol85Parser.KEY) + + + self.state = 1839 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1838 + self.match(Cobol85Parser.IS) + + + self.state = 1841 + self.qualifiedDataName() + self.state = 1843 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,137,self._ctx) + if la_ == 1: + self.state = 1842 + self.passwordClause() + + + self.state = 1849 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==149 or _la==514: + self.state = 1846 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 1845 + self.match(Cobol85Parser.WITH) + + + self.state = 1848 + self.match(Cobol85Parser.DUPLICATES) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PasswordClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PASSWORD(self): + return self.getToken(Cobol85Parser.PASSWORD, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_passwordClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPasswordClause" ): + listener.enterPasswordClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPasswordClause" ): + listener.exitPasswordClause(self) + + + + + def passwordClause(self): + + localctx = Cobol85Parser.PasswordClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 128, self.RULE_passwordClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1851 + self.match(Cobol85Parser.PASSWORD) + self.state = 1853 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1852 + self.match(Cobol85Parser.IS) + + + self.state = 1855 + self.dataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class FileStatusClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def STATUS(self): + return self.getToken(Cobol85Parser.STATUS, 0) + + def qualifiedDataName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.QualifiedDataNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,i) + + + def FILE(self): + return self.getToken(Cobol85Parser.FILE, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_fileStatusClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFileStatusClause" ): + listener.enterFileStatusClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFileStatusClause" ): + listener.exitFileStatusClause(self) + + + + + def fileStatusClause(self): + + localctx = Cobol85Parser.FileStatusClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 130, self.RULE_fileStatusClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1858 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==206: + self.state = 1857 + self.match(Cobol85Parser.FILE) + + + self.state = 1860 + self.match(Cobol85Parser.STATUS) + self.state = 1862 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1861 + self.match(Cobol85Parser.IS) + + + self.state = 1864 + self.qualifiedDataName() + self.state = 1866 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,143,self._ctx) + if la_ == 1: + self.state = 1865 + self.qualifiedDataName() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RelativeKeyClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RELATIVE(self): + return self.getToken(Cobol85Parser.RELATIVE, 0) + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_relativeKeyClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRelativeKeyClause" ): + listener.enterRelativeKeyClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRelativeKeyClause" ): + listener.exitRelativeKeyClause(self) + + + + + def relativeKeyClause(self): + + localctx = Cobol85Parser.RelativeKeyClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 132, self.RULE_relativeKeyClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1868 + self.match(Cobol85Parser.RELATIVE) + self.state = 1870 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==259: + self.state = 1869 + self.match(Cobol85Parser.KEY) + + + self.state = 1873 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 1872 + self.match(Cobol85Parser.IS) + + + self.state = 1875 + self.qualifiedDataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IoControlParagraphContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def I_O_CONTROL(self): + return self.getToken(Cobol85Parser.I_O_CONTROL, 0) + + def DOT_FS(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.DOT_FS) + else: + return self.getToken(Cobol85Parser.DOT_FS, i) + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def ioControlClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.IoControlClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.IoControlClauseContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_ioControlParagraph + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIoControlParagraph" ): + listener.enterIoControlParagraph(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIoControlParagraph" ): + listener.exitIoControlParagraph(self) + + + + + def ioControlParagraph(self): + + localctx = Cobol85Parser.IoControlParagraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 134, self.RULE_ioControlParagraph) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1877 + self.match(Cobol85Parser.I_O_CONTROL) + self.state = 1878 + self.match(Cobol85Parser.DOT_FS) + self.state = 1882 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,146,self._ctx) + if la_ == 1: + self.state = 1879 + self.fileName() + self.state = 1880 + self.match(Cobol85Parser.DOT_FS) + + + self.state = 1891 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==77 or _la==301 or _la==399 or _la==414 or _la==534: + self.state = 1887 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==77 or _la==301 or _la==399 or _la==414: + self.state = 1884 + self.ioControlClause() + self.state = 1889 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 1890 + self.match(Cobol85Parser.DOT_FS) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IoControlClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def rerunClause(self): + return self.getTypedRuleContext(Cobol85Parser.RerunClauseContext,0) + + + def sameClause(self): + return self.getTypedRuleContext(Cobol85Parser.SameClauseContext,0) + + + def multipleFileClause(self): + return self.getTypedRuleContext(Cobol85Parser.MultipleFileClauseContext,0) + + + def commitmentControlClause(self): + return self.getTypedRuleContext(Cobol85Parser.CommitmentControlClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_ioControlClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIoControlClause" ): + listener.enterIoControlClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIoControlClause" ): + listener.exitIoControlClause(self) + + + + + def ioControlClause(self): + + localctx = Cobol85Parser.IoControlClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 136, self.RULE_ioControlClause) + try: + self.state = 1897 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [399]: + self.enterOuterAlt(localctx, 1) + self.state = 1893 + self.rerunClause() + pass + elif token in [414]: + self.enterOuterAlt(localctx, 2) + self.state = 1894 + self.sameClause() + pass + elif token in [301]: + self.enterOuterAlt(localctx, 3) + self.state = 1895 + self.multipleFileClause() + pass + elif token in [77]: + self.enterOuterAlt(localctx, 4) + self.state = 1896 + self.commitmentControlClause() + 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 RerunClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RERUN(self): + return self.getToken(Cobol85Parser.RERUN, 0) + + def EVERY(self): + return self.getToken(Cobol85Parser.EVERY, 0) + + def rerunEveryRecords(self): + return self.getTypedRuleContext(Cobol85Parser.RerunEveryRecordsContext,0) + + + def rerunEveryOf(self): + return self.getTypedRuleContext(Cobol85Parser.RerunEveryOfContext,0) + + + def rerunEveryClock(self): + return self.getTypedRuleContext(Cobol85Parser.RerunEveryClockContext,0) + + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def assignmentName(self): + return self.getTypedRuleContext(Cobol85Parser.AssignmentNameContext,0) + + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_rerunClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRerunClause" ): + listener.enterRerunClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRerunClause" ): + listener.exitRerunClause(self) + + + + + def rerunClause(self): + + localctx = Cobol85Parser.RerunClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 138, self.RULE_rerunClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1899 + self.match(Cobol85Parser.RERUN) + self.state = 1905 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 1900 + self.match(Cobol85Parser.ON) + self.state = 1903 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,150,self._ctx) + if la_ == 1: + self.state = 1901 + self.assignmentName() + pass + + elif la_ == 2: + self.state = 1902 + self.fileName() + pass + + + + + self.state = 1907 + self.match(Cobol85Parser.EVERY) + self.state = 1911 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,152,self._ctx) + if la_ == 1: + self.state = 1908 + self.rerunEveryRecords() + pass + + elif la_ == 2: + self.state = 1909 + self.rerunEveryOf() + pass + + elif la_ == 3: + self.state = 1910 + self.rerunEveryClock() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RerunEveryRecordsContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def RECORDS(self): + return self.getToken(Cobol85Parser.RECORDS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_rerunEveryRecords + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRerunEveryRecords" ): + listener.enterRerunEveryRecords(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRerunEveryRecords" ): + listener.exitRerunEveryRecords(self) + + + + + def rerunEveryRecords(self): + + localctx = Cobol85Parser.RerunEveryRecordsContext(self, self._ctx, self.state) + self.enterRule(localctx, 140, self.RULE_rerunEveryRecords) + try: + self.enterOuterAlt(localctx, 1) + self.state = 1913 + self.integerLiteral() + self.state = 1914 + self.match(Cobol85Parser.RECORDS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RerunEveryOfContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OF(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.OF) + else: + return self.getToken(Cobol85Parser.OF, i) + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def REEL(self): + return self.getToken(Cobol85Parser.REEL, 0) + + def UNIT(self): + return self.getToken(Cobol85Parser.UNIT, 0) + + def END(self): + return self.getToken(Cobol85Parser.END, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_rerunEveryOf + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRerunEveryOf" ): + listener.enterRerunEveryOf(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRerunEveryOf" ): + listener.exitRerunEveryOf(self) + + + + + def rerunEveryOf(self): + + localctx = Cobol85Parser.RerunEveryOfContext(self, self._ctx, self.state) + self.enterRule(localctx, 142, self.RULE_rerunEveryOf) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1917 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==158: + self.state = 1916 + self.match(Cobol85Parser.END) + + + self.state = 1920 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==323: + self.state = 1919 + self.match(Cobol85Parser.OF) + + + self.state = 1922 + _la = self._input.LA(1) + if not(_la==382 or _la==499): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 1923 + self.match(Cobol85Parser.OF) + self.state = 1924 + self.fileName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RerunEveryClockContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def CLOCK_UNITS(self): + return self.getToken(Cobol85Parser.CLOCK_UNITS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_rerunEveryClock + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRerunEveryClock" ): + listener.enterRerunEveryClock(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRerunEveryClock" ): + listener.exitRerunEveryClock(self) + + + + + def rerunEveryClock(self): + + localctx = Cobol85Parser.RerunEveryClockContext(self, self._ctx, self.state) + self.enterRule(localctx, 144, self.RULE_rerunEveryClock) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1926 + self.integerLiteral() + self.state = 1928 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==66: + self.state = 1927 + self.match(Cobol85Parser.CLOCK_UNITS) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SameClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SAME(self): + return self.getToken(Cobol85Parser.SAME, 0) + + def AREA(self): + return self.getToken(Cobol85Parser.AREA, 0) + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def fileName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.FileNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,i) + + + def RECORD(self): + return self.getToken(Cobol85Parser.RECORD, 0) + + def SORT(self): + return self.getToken(Cobol85Parser.SORT, 0) + + def SORT_MERGE(self): + return self.getToken(Cobol85Parser.SORT_MERGE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_sameClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSameClause" ): + listener.enterSameClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSameClause" ): + listener.exitSameClause(self) + + + + + def sameClause(self): + + localctx = Cobol85Parser.SameClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 146, self.RULE_sameClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1930 + self.match(Cobol85Parser.SAME) + self.state = 1932 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==377 or _la==440 or _la==444: + self.state = 1931 + _la = self._input.LA(1) + if not(_la==377 or _la==440 or _la==444): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 1935 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==22: + self.state = 1934 + self.match(Cobol85Parser.AREA) + + + self.state = 1938 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 1937 + self.match(Cobol85Parser.FOR) + + + self.state = 1941 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1940 + self.fileName() + + else: + raise NoViableAltException(self) + self.state = 1943 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,159,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MultipleFileClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def MULTIPLE(self): + return self.getToken(Cobol85Parser.MULTIPLE, 0) + + def FILE(self): + return self.getToken(Cobol85Parser.FILE, 0) + + def TAPE(self): + return self.getToken(Cobol85Parser.TAPE, 0) + + def CONTAINS(self): + return self.getToken(Cobol85Parser.CONTAINS, 0) + + def multipleFilePosition(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.MultipleFilePositionContext) + else: + return self.getTypedRuleContext(Cobol85Parser.MultipleFilePositionContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_multipleFileClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMultipleFileClause" ): + listener.enterMultipleFileClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMultipleFileClause" ): + listener.exitMultipleFileClause(self) + + + + + def multipleFileClause(self): + + localctx = Cobol85Parser.MultipleFileClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 148, self.RULE_multipleFileClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1945 + self.match(Cobol85Parser.MULTIPLE) + self.state = 1946 + self.match(Cobol85Parser.FILE) + self.state = 1948 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==474: + self.state = 1947 + self.match(Cobol85Parser.TAPE) + + + self.state = 1951 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==94: + self.state = 1950 + self.match(Cobol85Parser.CONTAINS) + + + self.state = 1954 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 1953 + self.multipleFilePosition() + + else: + raise NoViableAltException(self) + self.state = 1956 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,162,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MultipleFilePositionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def POSITION(self): + return self.getToken(Cobol85Parser.POSITION, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_multipleFilePosition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMultipleFilePosition" ): + listener.enterMultipleFilePosition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMultipleFilePosition" ): + listener.exitMultipleFilePosition(self) + + + + + def multipleFilePosition(self): + + localctx = Cobol85Parser.MultipleFilePositionContext(self, self._ctx, self.state) + self.enterRule(localctx, 150, self.RULE_multipleFilePosition) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1958 + self.fileName() + self.state = 1961 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==350: + self.state = 1959 + self.match(Cobol85Parser.POSITION) + self.state = 1960 + self.integerLiteral() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CommitmentControlClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def COMMITMENT(self): + return self.getToken(Cobol85Parser.COMMITMENT, 0) + + def CONTROL(self): + return self.getToken(Cobol85Parser.CONTROL, 0) + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_commitmentControlClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCommitmentControlClause" ): + listener.enterCommitmentControlClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCommitmentControlClause" ): + listener.exitCommitmentControlClause(self) + + + + + def commitmentControlClause(self): + + localctx = Cobol85Parser.CommitmentControlClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 152, self.RULE_commitmentControlClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1963 + self.match(Cobol85Parser.COMMITMENT) + self.state = 1964 + self.match(Cobol85Parser.CONTROL) + self.state = 1966 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 1965 + self.match(Cobol85Parser.FOR) + + + self.state = 1968 + self.fileName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataDivisionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DATA(self): + return self.getToken(Cobol85Parser.DATA, 0) + + def DIVISION(self): + return self.getToken(Cobol85Parser.DIVISION, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def dataDivisionSection(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataDivisionSectionContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataDivisionSectionContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataDivision + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataDivision" ): + listener.enterDataDivision(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataDivision" ): + listener.exitDataDivision(self) + + + + + def dataDivision(self): + + localctx = Cobol85Parser.DataDivisionContext(self, self._ctx, self.state) + self.enterRule(localctx, 154, self.RULE_dataDivision) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1970 + self.match(Cobol85Parser.DATA) + self.state = 1971 + self.match(Cobol85Parser.DIVISION) + self.state = 1972 + self.match(Cobol85Parser.DOT_FS) + self.state = 1976 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==79 or _la==110 or _la==206 or _la==282 or _la==285 or ((((_la - 363)) & ~0x3f) == 0 and ((1 << (_la - 363)) & 9007203549708289) != 0) or _la==516: + self.state = 1973 + self.dataDivisionSection() + self.state = 1978 + 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 DataDivisionSectionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def fileSection(self): + return self.getTypedRuleContext(Cobol85Parser.FileSectionContext,0) + + + def dataBaseSection(self): + return self.getTypedRuleContext(Cobol85Parser.DataBaseSectionContext,0) + + + def workingStorageSection(self): + return self.getTypedRuleContext(Cobol85Parser.WorkingStorageSectionContext,0) + + + def linkageSection(self): + return self.getTypedRuleContext(Cobol85Parser.LinkageSectionContext,0) + + + def communicationSection(self): + return self.getTypedRuleContext(Cobol85Parser.CommunicationSectionContext,0) + + + def localStorageSection(self): + return self.getTypedRuleContext(Cobol85Parser.LocalStorageSectionContext,0) + + + def screenSection(self): + return self.getTypedRuleContext(Cobol85Parser.ScreenSectionContext,0) + + + def reportSection(self): + return self.getTypedRuleContext(Cobol85Parser.ReportSectionContext,0) + + + def programLibrarySection(self): + return self.getTypedRuleContext(Cobol85Parser.ProgramLibrarySectionContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataDivisionSection + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataDivisionSection" ): + listener.enterDataDivisionSection(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataDivisionSection" ): + listener.exitDataDivisionSection(self) + + + + + def dataDivisionSection(self): + + localctx = Cobol85Parser.DataDivisionSectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 156, self.RULE_dataDivisionSection) + try: + self.state = 1988 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [206]: + self.enterOuterAlt(localctx, 1) + self.state = 1979 + self.fileSection() + pass + elif token in [110]: + self.enterOuterAlt(localctx, 2) + self.state = 1980 + self.dataBaseSection() + pass + elif token in [516]: + self.enterOuterAlt(localctx, 3) + self.state = 1981 + self.workingStorageSection() + pass + elif token in [282]: + self.enterOuterAlt(localctx, 4) + self.state = 1982 + self.linkageSection() + pass + elif token in [79]: + self.enterOuterAlt(localctx, 5) + self.state = 1983 + self.communicationSection() + pass + elif token in [285]: + self.enterOuterAlt(localctx, 6) + self.state = 1984 + self.localStorageSection() + pass + elif token in [416]: + self.enterOuterAlt(localctx, 7) + self.state = 1985 + self.screenSection() + pass + elif token in [395]: + self.enterOuterAlt(localctx, 8) + self.state = 1986 + self.reportSection() + pass + elif token in [363]: + self.enterOuterAlt(localctx, 9) + self.state = 1987 + self.programLibrarySection() + 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 FileSectionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FILE(self): + return self.getToken(Cobol85Parser.FILE, 0) + + def SECTION(self): + return self.getToken(Cobol85Parser.SECTION, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def fileDescriptionEntry(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.FileDescriptionEntryContext) + else: + return self.getTypedRuleContext(Cobol85Parser.FileDescriptionEntryContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_fileSection + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFileSection" ): + listener.enterFileSection(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFileSection" ): + listener.exitFileSection(self) + + + + + def fileSection(self): + + localctx = Cobol85Parser.FileSectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 158, self.RULE_fileSection) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1990 + self.match(Cobol85Parser.FILE) + self.state = 1991 + self.match(Cobol85Parser.SECTION) + self.state = 1992 + self.match(Cobol85Parser.DOT_FS) + self.state = 1996 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==205 or _la==417: + self.state = 1993 + self.fileDescriptionEntry() + self.state = 1998 + 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 FileDescriptionEntryContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def DOT_FS(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.DOT_FS) + else: + return self.getToken(Cobol85Parser.DOT_FS, i) + + def FD(self): + return self.getToken(Cobol85Parser.FD, 0) + + def SD(self): + return self.getToken(Cobol85Parser.SD, 0) + + def fileDescriptionEntryClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.FileDescriptionEntryClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.FileDescriptionEntryClauseContext,i) + + + def dataDescriptionEntry(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataDescriptionEntryContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataDescriptionEntryContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_fileDescriptionEntry + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFileDescriptionEntry" ): + listener.enterFileDescriptionEntry(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFileDescriptionEntry" ): + listener.exitFileDescriptionEntry(self) + + + + + def fileDescriptionEntry(self): + + localctx = Cobol85Parser.FileDescriptionEntryContext(self, self._ctx, self.state) + self.enterRule(localctx, 160, self.RULE_fileDescriptionEntry) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 1999 + _la = self._input.LA(1) + if not(_la==205 or _la==417): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2000 + self.fileName() + self.state = 2007 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,169,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 2002 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==534: + self.state = 2001 + self.match(Cobol85Parser.DOT_FS) + + + self.state = 2004 + self.fileDescriptionEntryClause() + self.state = 2009 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,169,self._ctx) + + self.state = 2010 + self.match(Cobol85Parser.DOT_FS) + self.state = 2014 + self._errHandler.sync(self) + _la = self._input.LA(1) + while ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 527) != 0): + self.state = 2011 + self.dataDescriptionEntry() + self.state = 2016 + 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 FileDescriptionEntryClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def externalClause(self): + return self.getTypedRuleContext(Cobol85Parser.ExternalClauseContext,0) + + + def globalClause(self): + return self.getTypedRuleContext(Cobol85Parser.GlobalClauseContext,0) + + + def blockContainsClause(self): + return self.getTypedRuleContext(Cobol85Parser.BlockContainsClauseContext,0) + + + def recordContainsClause(self): + return self.getTypedRuleContext(Cobol85Parser.RecordContainsClauseContext,0) + + + def labelRecordsClause(self): + return self.getTypedRuleContext(Cobol85Parser.LabelRecordsClauseContext,0) + + + def valueOfClause(self): + return self.getTypedRuleContext(Cobol85Parser.ValueOfClauseContext,0) + + + def dataRecordsClause(self): + return self.getTypedRuleContext(Cobol85Parser.DataRecordsClauseContext,0) + + + def linageClause(self): + return self.getTypedRuleContext(Cobol85Parser.LinageClauseContext,0) + + + def codeSetClause(self): + return self.getTypedRuleContext(Cobol85Parser.CodeSetClauseContext,0) + + + def reportClause(self): + return self.getTypedRuleContext(Cobol85Parser.ReportClauseContext,0) + + + def recordingModeClause(self): + return self.getTypedRuleContext(Cobol85Parser.RecordingModeClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_fileDescriptionEntryClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFileDescriptionEntryClause" ): + listener.enterFileDescriptionEntryClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFileDescriptionEntryClause" ): + listener.exitFileDescriptionEntryClause(self) + + + + + def fileDescriptionEntryClause(self): + + localctx = Cobol85Parser.FileDescriptionEntryClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 162, self.RULE_fileDescriptionEntryClause) + try: + self.state = 2028 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,171,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2017 + self.externalClause() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2018 + self.globalClause() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2019 + self.blockContainsClause() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 2020 + self.recordContainsClause() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 2021 + self.labelRecordsClause() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 2022 + self.valueOfClause() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 2023 + self.dataRecordsClause() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 2024 + self.linageClause() + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 2025 + self.codeSetClause() + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 2026 + self.reportClause() + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 2027 + self.recordingModeClause() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ExternalClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXTERNAL(self): + return self.getToken(Cobol85Parser.EXTERNAL, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_externalClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExternalClause" ): + listener.enterExternalClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExternalClause" ): + listener.exitExternalClause(self) + + + + + def externalClause(self): + + localctx = Cobol85Parser.ExternalClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 164, self.RULE_externalClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2031 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2030 + self.match(Cobol85Parser.IS) + + + self.state = 2033 + self.match(Cobol85Parser.EXTERNAL) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class GlobalClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GLOBAL(self): + return self.getToken(Cobol85Parser.GLOBAL, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_globalClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGlobalClause" ): + listener.enterGlobalClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGlobalClause" ): + listener.exitGlobalClause(self) + + + + + def globalClause(self): + + localctx = Cobol85Parser.GlobalClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 166, self.RULE_globalClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2036 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2035 + self.match(Cobol85Parser.IS) + + + self.state = 2038 + self.match(Cobol85Parser.GLOBAL) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class BlockContainsClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BLOCK(self): + return self.getToken(Cobol85Parser.BLOCK, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def CONTAINS(self): + return self.getToken(Cobol85Parser.CONTAINS, 0) + + def blockContainsTo(self): + return self.getTypedRuleContext(Cobol85Parser.BlockContainsToContext,0) + + + def RECORDS(self): + return self.getToken(Cobol85Parser.RECORDS, 0) + + def CHARACTERS(self): + return self.getToken(Cobol85Parser.CHARACTERS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_blockContainsClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBlockContainsClause" ): + listener.enterBlockContainsClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBlockContainsClause" ): + listener.exitBlockContainsClause(self) + + + + + def blockContainsClause(self): + + localctx = Cobol85Parser.BlockContainsClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 168, self.RULE_blockContainsClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2040 + self.match(Cobol85Parser.BLOCK) + self.state = 2042 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==94: + self.state = 2041 + self.match(Cobol85Parser.CONTAINS) + + + self.state = 2044 + self.integerLiteral() + self.state = 2046 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==489: + self.state = 2045 + self.blockContainsTo() + + + self.state = 2049 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==63 or _la==379: + self.state = 2048 + _la = self._input.LA(1) + if not(_la==63 or _la==379): + 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 BlockContainsToContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_blockContainsTo + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBlockContainsTo" ): + listener.enterBlockContainsTo(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBlockContainsTo" ): + listener.exitBlockContainsTo(self) + + + + + def blockContainsTo(self): + + localctx = Cobol85Parser.BlockContainsToContext(self, self._ctx, self.state) + self.enterRule(localctx, 170, self.RULE_blockContainsTo) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2051 + self.match(Cobol85Parser.TO) + self.state = 2052 + self.integerLiteral() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RecordContainsClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RECORD(self): + return self.getToken(Cobol85Parser.RECORD, 0) + + def recordContainsClauseFormat1(self): + return self.getTypedRuleContext(Cobol85Parser.RecordContainsClauseFormat1Context,0) + + + def recordContainsClauseFormat2(self): + return self.getTypedRuleContext(Cobol85Parser.RecordContainsClauseFormat2Context,0) + + + def recordContainsClauseFormat3(self): + return self.getTypedRuleContext(Cobol85Parser.RecordContainsClauseFormat3Context,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_recordContainsClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRecordContainsClause" ): + listener.enterRecordContainsClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRecordContainsClause" ): + listener.exitRecordContainsClause(self) + + + + + def recordContainsClause(self): + + localctx = Cobol85Parser.RecordContainsClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 172, self.RULE_recordContainsClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2054 + self.match(Cobol85Parser.RECORD) + self.state = 2058 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,177,self._ctx) + if la_ == 1: + self.state = 2055 + self.recordContainsClauseFormat1() + pass + + elif la_ == 2: + self.state = 2056 + self.recordContainsClauseFormat2() + pass + + elif la_ == 3: + self.state = 2057 + self.recordContainsClauseFormat3() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RecordContainsClauseFormat1Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def CONTAINS(self): + return self.getToken(Cobol85Parser.CONTAINS, 0) + + def CHARACTERS(self): + return self.getToken(Cobol85Parser.CHARACTERS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_recordContainsClauseFormat1 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRecordContainsClauseFormat1" ): + listener.enterRecordContainsClauseFormat1(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRecordContainsClauseFormat1" ): + listener.exitRecordContainsClauseFormat1(self) + + + + + def recordContainsClauseFormat1(self): + + localctx = Cobol85Parser.RecordContainsClauseFormat1Context(self, self._ctx, self.state) + self.enterRule(localctx, 174, self.RULE_recordContainsClauseFormat1) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2061 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==94: + self.state = 2060 + self.match(Cobol85Parser.CONTAINS) + + + self.state = 2063 + self.integerLiteral() + self.state = 2065 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==63: + self.state = 2064 + self.match(Cobol85Parser.CHARACTERS) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RecordContainsClauseFormat2Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def VARYING(self): + return self.getToken(Cobol85Parser.VARYING, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def IN(self): + return self.getToken(Cobol85Parser.IN, 0) + + def SIZE(self): + return self.getToken(Cobol85Parser.SIZE, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def DEPENDING(self): + return self.getToken(Cobol85Parser.DEPENDING, 0) + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def FROM(self): + return self.getToken(Cobol85Parser.FROM, 0) + + def recordContainsTo(self): + return self.getTypedRuleContext(Cobol85Parser.RecordContainsToContext,0) + + + def CHARACTERS(self): + return self.getToken(Cobol85Parser.CHARACTERS, 0) + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_recordContainsClauseFormat2 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRecordContainsClauseFormat2" ): + listener.enterRecordContainsClauseFormat2(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRecordContainsClauseFormat2" ): + listener.exitRecordContainsClauseFormat2(self) + + + + + def recordContainsClauseFormat2(self): + + localctx = Cobol85Parser.RecordContainsClauseFormat2Context(self, self._ctx, self.state) + self.enterRule(localctx, 176, self.RULE_recordContainsClauseFormat2) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2068 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2067 + self.match(Cobol85Parser.IS) + + + self.state = 2070 + self.match(Cobol85Parser.VARYING) + self.state = 2072 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==239: + self.state = 2071 + self.match(Cobol85Parser.IN) + + + self.state = 2075 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==439: + self.state = 2074 + self.match(Cobol85Parser.SIZE) + + + self.state = 2087 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==215 or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 15) != 0): + self.state = 2078 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==215: + self.state = 2077 + self.match(Cobol85Parser.FROM) + + + self.state = 2080 + self.integerLiteral() + self.state = 2082 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==489: + self.state = 2081 + self.recordContainsTo() + + + self.state = 2085 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==63: + self.state = 2084 + self.match(Cobol85Parser.CHARACTERS) + + + + + self.state = 2094 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==134: + self.state = 2089 + self.match(Cobol85Parser.DEPENDING) + self.state = 2091 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 2090 + self.match(Cobol85Parser.ON) + + + self.state = 2093 + self.qualifiedDataName() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RecordContainsClauseFormat3Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def recordContainsTo(self): + return self.getTypedRuleContext(Cobol85Parser.RecordContainsToContext,0) + + + def CONTAINS(self): + return self.getToken(Cobol85Parser.CONTAINS, 0) + + def CHARACTERS(self): + return self.getToken(Cobol85Parser.CHARACTERS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_recordContainsClauseFormat3 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRecordContainsClauseFormat3" ): + listener.enterRecordContainsClauseFormat3(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRecordContainsClauseFormat3" ): + listener.exitRecordContainsClauseFormat3(self) + + + + + def recordContainsClauseFormat3(self): + + localctx = Cobol85Parser.RecordContainsClauseFormat3Context(self, self._ctx, self.state) + self.enterRule(localctx, 178, self.RULE_recordContainsClauseFormat3) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2097 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==94: + self.state = 2096 + self.match(Cobol85Parser.CONTAINS) + + + self.state = 2099 + self.integerLiteral() + self.state = 2100 + self.recordContainsTo() + self.state = 2102 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==63: + self.state = 2101 + self.match(Cobol85Parser.CHARACTERS) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RecordContainsToContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_recordContainsTo + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRecordContainsTo" ): + listener.enterRecordContainsTo(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRecordContainsTo" ): + listener.exitRecordContainsTo(self) + + + + + def recordContainsTo(self): + + localctx = Cobol85Parser.RecordContainsToContext(self, self._ctx, self.state) + self.enterRule(localctx, 180, self.RULE_recordContainsTo) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2104 + self.match(Cobol85Parser.TO) + self.state = 2105 + self.integerLiteral() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LabelRecordsClauseContext(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.getToken(Cobol85Parser.LABEL, 0) + + def RECORD(self): + return self.getToken(Cobol85Parser.RECORD, 0) + + def RECORDS(self): + return self.getToken(Cobol85Parser.RECORDS, 0) + + def OMITTED(self): + return self.getToken(Cobol85Parser.OMITTED, 0) + + def STANDARD(self): + return self.getToken(Cobol85Parser.STANDARD, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def ARE(self): + return self.getToken(Cobol85Parser.ARE, 0) + + def dataName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_labelRecordsClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLabelRecordsClause" ): + listener.enterLabelRecordsClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLabelRecordsClause" ): + listener.exitLabelRecordsClause(self) + + + + + def labelRecordsClause(self): + + localctx = Cobol85Parser.LabelRecordsClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 182, self.RULE_labelRecordsClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2107 + self.match(Cobol85Parser.LABEL) + self.state = 2116 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [377]: + self.state = 2108 + self.match(Cobol85Parser.RECORD) + self.state = 2110 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2109 + self.match(Cobol85Parser.IS) + + + pass + elif token in [379]: + self.state = 2112 + self.match(Cobol85Parser.RECORDS) + self.state = 2114 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==21: + self.state = 2113 + self.match(Cobol85Parser.ARE) + + + pass + else: + raise NoViableAltException(self) + + self.state = 2125 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [325]: + self.state = 2118 + self.match(Cobol85Parser.OMITTED) + pass + elif token in [453]: + self.state = 2119 + self.match(Cobol85Parser.STANDARD) + pass + elif token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.state = 2121 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 2120 + self.dataName() + self.state = 2123 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + 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 ValueOfClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def VALUE(self): + return self.getToken(Cobol85Parser.VALUE, 0) + + def OF(self): + return self.getToken(Cobol85Parser.OF, 0) + + def valuePair(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ValuePairContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ValuePairContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_valueOfClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValueOfClause" ): + listener.enterValueOfClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValueOfClause" ): + listener.exitValueOfClause(self) + + + + + def valueOfClause(self): + + localctx = Cobol85Parser.ValueOfClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 184, self.RULE_valueOfClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2127 + self.match(Cobol85Parser.VALUE) + self.state = 2128 + self.match(Cobol85Parser.OF) + self.state = 2130 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 2129 + self.valuePair() + self.state = 2132 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ValuePairContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def systemName(self): + return self.getTypedRuleContext(Cobol85Parser.SystemNameContext,0) + + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_valuePair + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterValuePair" ): + listener.enterValuePair(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitValuePair" ): + listener.exitValuePair(self) + + + + + def valuePair(self): + + localctx = Cobol85Parser.ValuePairContext(self, self._ctx, self.state) + self.enterRule(localctx, 186, self.RULE_valuePair) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2134 + self.systemName() + self.state = 2136 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2135 + self.match(Cobol85Parser.IS) + + + self.state = 2140 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,198,self._ctx) + if la_ == 1: + self.state = 2138 + self.qualifiedDataName() + pass + + elif la_ == 2: + self.state = 2139 + self.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 DataRecordsClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DATA(self): + return self.getToken(Cobol85Parser.DATA, 0) + + def RECORD(self): + return self.getToken(Cobol85Parser.RECORD, 0) + + def RECORDS(self): + return self.getToken(Cobol85Parser.RECORDS, 0) + + def dataName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,i) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def ARE(self): + return self.getToken(Cobol85Parser.ARE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataRecordsClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataRecordsClause" ): + listener.enterDataRecordsClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataRecordsClause" ): + listener.exitDataRecordsClause(self) + + + + + def dataRecordsClause(self): + + localctx = Cobol85Parser.DataRecordsClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 188, self.RULE_dataRecordsClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2142 + self.match(Cobol85Parser.DATA) + self.state = 2151 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [377]: + self.state = 2143 + self.match(Cobol85Parser.RECORD) + self.state = 2145 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2144 + self.match(Cobol85Parser.IS) + + + pass + elif token in [379]: + self.state = 2147 + self.match(Cobol85Parser.RECORDS) + self.state = 2149 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==21: + self.state = 2148 + self.match(Cobol85Parser.ARE) + + + pass + else: + raise NoViableAltException(self) + + self.state = 2154 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 2153 + self.dataName() + self.state = 2156 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LinageClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LINAGE(self): + return self.getToken(Cobol85Parser.LINAGE, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def LINES(self): + return self.getToken(Cobol85Parser.LINES, 0) + + def linageAt(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.LinageAtContext) + else: + return self.getTypedRuleContext(Cobol85Parser.LinageAtContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_linageClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLinageClause" ): + listener.enterLinageClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLinageClause" ): + listener.exitLinageClause(self) + + + + + def linageClause(self): + + localctx = Cobol85Parser.LinageClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 190, self.RULE_linageClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2158 + self.match(Cobol85Parser.LINAGE) + self.state = 2160 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2159 + self.match(Cobol85Parser.IS) + + + self.state = 2164 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.state = 2162 + self.dataName() + pass + elif token in [552, 553, 554, 555]: + self.state = 2163 + self.integerLiteral() + pass + else: + raise NoViableAltException(self) + + self.state = 2167 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,205,self._ctx) + if la_ == 1: + self.state = 2166 + self.match(Cobol85Parser.LINES) + + + self.state = 2172 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==30 or _la==48 or _la==211 or _la==280 or _la==492 or _la==514: + self.state = 2169 + self.linageAt() + self.state = 2174 + 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 LinageAtContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def linageFootingAt(self): + return self.getTypedRuleContext(Cobol85Parser.LinageFootingAtContext,0) + + + def linageLinesAtTop(self): + return self.getTypedRuleContext(Cobol85Parser.LinageLinesAtTopContext,0) + + + def linageLinesAtBottom(self): + return self.getTypedRuleContext(Cobol85Parser.LinageLinesAtBottomContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_linageAt + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLinageAt" ): + listener.enterLinageAt(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLinageAt" ): + listener.exitLinageAt(self) + + + + + def linageAt(self): + + localctx = Cobol85Parser.LinageAtContext(self, self._ctx, self.state) + self.enterRule(localctx, 192, self.RULE_linageAt) + try: + self.state = 2178 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,207,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2175 + self.linageFootingAt() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2176 + self.linageLinesAtTop() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2177 + self.linageLinesAtBottom() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LinageFootingAtContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FOOTING(self): + return self.getToken(Cobol85Parser.FOOTING, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def AT(self): + return self.getToken(Cobol85Parser.AT, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_linageFootingAt + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLinageFootingAt" ): + listener.enterLinageFootingAt(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLinageFootingAt" ): + listener.exitLinageFootingAt(self) + + + + + def linageFootingAt(self): + + localctx = Cobol85Parser.LinageFootingAtContext(self, self._ctx, self.state) + self.enterRule(localctx, 194, self.RULE_linageFootingAt) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2181 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 2180 + self.match(Cobol85Parser.WITH) + + + self.state = 2183 + self.match(Cobol85Parser.FOOTING) + self.state = 2185 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==30: + self.state = 2184 + self.match(Cobol85Parser.AT) + + + self.state = 2189 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.state = 2187 + self.dataName() + pass + elif token in [552, 553, 554, 555]: + self.state = 2188 + self.integerLiteral() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LinageLinesAtTopContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TOP(self): + return self.getToken(Cobol85Parser.TOP, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def LINES(self): + return self.getToken(Cobol85Parser.LINES, 0) + + def AT(self): + return self.getToken(Cobol85Parser.AT, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_linageLinesAtTop + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLinageLinesAtTop" ): + listener.enterLinageLinesAtTop(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLinageLinesAtTop" ): + listener.exitLinageLinesAtTop(self) + + + + + def linageLinesAtTop(self): + + localctx = Cobol85Parser.LinageLinesAtTopContext(self, self._ctx, self.state) + self.enterRule(localctx, 196, self.RULE_linageLinesAtTop) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2192 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==280: + self.state = 2191 + self.match(Cobol85Parser.LINES) + + + self.state = 2195 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==30: + self.state = 2194 + self.match(Cobol85Parser.AT) + + + self.state = 2197 + self.match(Cobol85Parser.TOP) + self.state = 2200 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.state = 2198 + self.dataName() + pass + elif token in [552, 553, 554, 555]: + self.state = 2199 + self.integerLiteral() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LinageLinesAtBottomContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BOTTOM(self): + return self.getToken(Cobol85Parser.BOTTOM, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def LINES(self): + return self.getToken(Cobol85Parser.LINES, 0) + + def AT(self): + return self.getToken(Cobol85Parser.AT, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_linageLinesAtBottom + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLinageLinesAtBottom" ): + listener.enterLinageLinesAtBottom(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLinageLinesAtBottom" ): + listener.exitLinageLinesAtBottom(self) + + + + + def linageLinesAtBottom(self): + + localctx = Cobol85Parser.LinageLinesAtBottomContext(self, self._ctx, self.state) + self.enterRule(localctx, 198, self.RULE_linageLinesAtBottom) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2203 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==280: + self.state = 2202 + self.match(Cobol85Parser.LINES) + + + self.state = 2206 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==30: + self.state = 2205 + self.match(Cobol85Parser.AT) + + + self.state = 2208 + self.match(Cobol85Parser.BOTTOM) + self.state = 2211 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.state = 2209 + self.dataName() + pass + elif token in [552, 553, 554, 555]: + self.state = 2210 + self.integerLiteral() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RecordingModeClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RECORDING(self): + return self.getToken(Cobol85Parser.RECORDING, 0) + + def modeStatement(self): + return self.getTypedRuleContext(Cobol85Parser.ModeStatementContext,0) + + + def MODE(self): + return self.getToken(Cobol85Parser.MODE, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_recordingModeClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRecordingModeClause" ): + listener.enterRecordingModeClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRecordingModeClause" ): + listener.exitRecordingModeClause(self) + + + + + def recordingModeClause(self): + + localctx = Cobol85Parser.RecordingModeClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 200, self.RULE_recordingModeClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2213 + self.match(Cobol85Parser.RECORDING) + self.state = 2215 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==297: + self.state = 2214 + self.match(Cobol85Parser.MODE) + + + self.state = 2218 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2217 + self.match(Cobol85Parser.IS) + + + self.state = 2220 + self.modeStatement() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ModeStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_modeStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterModeStatement" ): + listener.enterModeStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitModeStatement" ): + listener.exitModeStatement(self) + + + + + def modeStatement(self): + + localctx = Cobol85Parser.ModeStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 202, self.RULE_modeStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2222 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CodeSetClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CODE_SET(self): + return self.getToken(Cobol85Parser.CODE_SET, 0) + + def alphabetName(self): + return self.getTypedRuleContext(Cobol85Parser.AlphabetNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_codeSetClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCodeSetClause" ): + listener.enterCodeSetClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCodeSetClause" ): + listener.exitCodeSetClause(self) + + + + + def codeSetClause(self): + + localctx = Cobol85Parser.CodeSetClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 204, self.RULE_codeSetClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2224 + self.match(Cobol85Parser.CODE_SET) + self.state = 2226 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2225 + self.match(Cobol85Parser.IS) + + + self.state = 2228 + self.alphabetName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REPORT(self): + return self.getToken(Cobol85Parser.REPORT, 0) + + def REPORTS(self): + return self.getToken(Cobol85Parser.REPORTS, 0) + + def reportName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportNameContext,i) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def ARE(self): + return self.getToken(Cobol85Parser.ARE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportClause" ): + listener.enterReportClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportClause" ): + listener.exitReportClause(self) + + + + + def reportClause(self): + + localctx = Cobol85Parser.ReportClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 206, self.RULE_reportClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2238 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [395]: + self.state = 2230 + self.match(Cobol85Parser.REPORT) + self.state = 2232 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2231 + self.match(Cobol85Parser.IS) + + + pass + elif token in [397]: + self.state = 2234 + self.match(Cobol85Parser.REPORTS) + self.state = 2236 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==21: + self.state = 2235 + self.match(Cobol85Parser.ARE) + + + pass + else: + raise NoViableAltException(self) + + self.state = 2241 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 2240 + self.reportName() + self.state = 2243 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178969483) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 DataBaseSectionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DATA_BASE(self): + return self.getToken(Cobol85Parser.DATA_BASE, 0) + + def SECTION(self): + return self.getToken(Cobol85Parser.SECTION, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def dataBaseSectionEntry(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataBaseSectionEntryContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataBaseSectionEntryContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataBaseSection + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataBaseSection" ): + listener.enterDataBaseSection(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataBaseSection" ): + listener.exitDataBaseSection(self) + + + + + def dataBaseSection(self): + + localctx = Cobol85Parser.DataBaseSectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 208, self.RULE_dataBaseSection) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2245 + self.match(Cobol85Parser.DATA_BASE) + self.state = 2246 + self.match(Cobol85Parser.SECTION) + self.state = 2247 + self.match(Cobol85Parser.DOT_FS) + self.state = 2251 + self._errHandler.sync(self) + _la = self._input.LA(1) + while ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 15) != 0): + self.state = 2248 + self.dataBaseSectionEntry() + self.state = 2253 + 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 DataBaseSectionEntryContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def literal(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.LiteralContext) + else: + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,i) + + + def INVOKE(self): + return self.getToken(Cobol85Parser.INVOKE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataBaseSectionEntry + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataBaseSectionEntry" ): + listener.enterDataBaseSectionEntry(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataBaseSectionEntry" ): + listener.exitDataBaseSectionEntry(self) + + + + + def dataBaseSectionEntry(self): + + localctx = Cobol85Parser.DataBaseSectionEntryContext(self, self._ctx, self.state) + self.enterRule(localctx, 210, self.RULE_dataBaseSectionEntry) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2254 + self.integerLiteral() + self.state = 2255 + self.literal() + self.state = 2256 + self.match(Cobol85Parser.INVOKE) + self.state = 2257 + self.literal() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class WorkingStorageSectionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def WORKING_STORAGE(self): + return self.getToken(Cobol85Parser.WORKING_STORAGE, 0) + + def SECTION(self): + return self.getToken(Cobol85Parser.SECTION, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def dataDescriptionEntry(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataDescriptionEntryContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataDescriptionEntryContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_workingStorageSection + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWorkingStorageSection" ): + listener.enterWorkingStorageSection(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWorkingStorageSection" ): + listener.exitWorkingStorageSection(self) + + + + + def workingStorageSection(self): + + localctx = Cobol85Parser.WorkingStorageSectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 212, self.RULE_workingStorageSection) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2259 + self.match(Cobol85Parser.WORKING_STORAGE) + self.state = 2260 + self.match(Cobol85Parser.SECTION) + self.state = 2261 + self.match(Cobol85Parser.DOT_FS) + self.state = 2265 + self._errHandler.sync(self) + _la = self._input.LA(1) + while ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 527) != 0): + self.state = 2262 + self.dataDescriptionEntry() + self.state = 2267 + 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 LinkageSectionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LINKAGE(self): + return self.getToken(Cobol85Parser.LINKAGE, 0) + + def SECTION(self): + return self.getToken(Cobol85Parser.SECTION, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def dataDescriptionEntry(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataDescriptionEntryContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataDescriptionEntryContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_linkageSection + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLinkageSection" ): + listener.enterLinkageSection(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLinkageSection" ): + listener.exitLinkageSection(self) + + + + + def linkageSection(self): + + localctx = Cobol85Parser.LinkageSectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 214, self.RULE_linkageSection) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2268 + self.match(Cobol85Parser.LINKAGE) + self.state = 2269 + self.match(Cobol85Parser.SECTION) + self.state = 2270 + self.match(Cobol85Parser.DOT_FS) + self.state = 2274 + self._errHandler.sync(self) + _la = self._input.LA(1) + while ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 527) != 0): + self.state = 2271 + self.dataDescriptionEntry() + self.state = 2276 + 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 CommunicationSectionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def COMMUNICATION(self): + return self.getToken(Cobol85Parser.COMMUNICATION, 0) + + def SECTION(self): + return self.getToken(Cobol85Parser.SECTION, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def communicationDescriptionEntry(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.CommunicationDescriptionEntryContext) + else: + return self.getTypedRuleContext(Cobol85Parser.CommunicationDescriptionEntryContext,i) + + + def dataDescriptionEntry(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataDescriptionEntryContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataDescriptionEntryContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_communicationSection + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCommunicationSection" ): + listener.enterCommunicationSection(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCommunicationSection" ): + listener.exitCommunicationSection(self) + + + + + def communicationSection(self): + + localctx = Cobol85Parser.CommunicationSectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 216, self.RULE_communicationSection) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2277 + self.match(Cobol85Parser.COMMUNICATION) + self.state = 2278 + self.match(Cobol85Parser.SECTION) + self.state = 2279 + self.match(Cobol85Parser.DOT_FS) + self.state = 2284 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==56 or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 527) != 0): + self.state = 2282 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [56]: + self.state = 2280 + self.communicationDescriptionEntry() + pass + elif token in [552, 553, 554, 555, 561]: + self.state = 2281 + self.dataDescriptionEntry() + pass + else: + raise NoViableAltException(self) + + self.state = 2286 + 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 CommunicationDescriptionEntryContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def communicationDescriptionEntryFormat1(self): + return self.getTypedRuleContext(Cobol85Parser.CommunicationDescriptionEntryFormat1Context,0) + + + def communicationDescriptionEntryFormat2(self): + return self.getTypedRuleContext(Cobol85Parser.CommunicationDescriptionEntryFormat2Context,0) + + + def communicationDescriptionEntryFormat3(self): + return self.getTypedRuleContext(Cobol85Parser.CommunicationDescriptionEntryFormat3Context,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_communicationDescriptionEntry + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCommunicationDescriptionEntry" ): + listener.enterCommunicationDescriptionEntry(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCommunicationDescriptionEntry" ): + listener.exitCommunicationDescriptionEntry(self) + + + + + def communicationDescriptionEntry(self): + + localctx = Cobol85Parser.CommunicationDescriptionEntryContext(self, self._ctx, self.state) + self.enterRule(localctx, 218, self.RULE_communicationDescriptionEntry) + try: + self.state = 2290 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,229,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2287 + self.communicationDescriptionEntryFormat1() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2288 + self.communicationDescriptionEntryFormat2() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2289 + self.communicationDescriptionEntryFormat3() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CommunicationDescriptionEntryFormat1Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CD(self): + return self.getToken(Cobol85Parser.CD, 0) + + def cdName(self): + return self.getTypedRuleContext(Cobol85Parser.CdNameContext,0) + + + def INPUT(self): + return self.getToken(Cobol85Parser.INPUT, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def INITIAL(self): + return self.getToken(Cobol85Parser.INITIAL, 0) + + def dataDescName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataDescNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataDescNameContext,i) + + + def symbolicQueueClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SymbolicQueueClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SymbolicQueueClauseContext,i) + + + def symbolicSubQueueClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SymbolicSubQueueClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SymbolicSubQueueClauseContext,i) + + + def messageDateClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.MessageDateClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.MessageDateClauseContext,i) + + + def messageTimeClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.MessageTimeClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.MessageTimeClauseContext,i) + + + def symbolicSourceClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SymbolicSourceClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SymbolicSourceClauseContext,i) + + + def textLengthClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.TextLengthClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.TextLengthClauseContext,i) + + + def endKeyClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.EndKeyClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.EndKeyClauseContext,i) + + + def statusKeyClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatusKeyClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatusKeyClauseContext,i) + + + def messageCountClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.MessageCountClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.MessageCountClauseContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_communicationDescriptionEntryFormat1 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCommunicationDescriptionEntryFormat1" ): + listener.enterCommunicationDescriptionEntryFormat1(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCommunicationDescriptionEntryFormat1" ): + listener.exitCommunicationDescriptionEntryFormat1(self) + + + + + def communicationDescriptionEntryFormat1(self): + + localctx = Cobol85Parser.CommunicationDescriptionEntryFormat1Context(self, self._ctx, self.state) + self.enterRule(localctx, 220, self.RULE_communicationDescriptionEntryFormat1) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2292 + self.match(Cobol85Parser.CD) + self.state = 2293 + self.cdName() + self.state = 2295 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 2294 + self.match(Cobol85Parser.FOR) + + + self.state = 2298 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==243: + self.state = 2297 + self.match(Cobol85Parser.INITIAL) + + + self.state = 2300 + self.match(Cobol85Parser.INPUT) + self.state = 2315 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070452049445126659) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893884388107) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761343) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752044752779) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874435004170307) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 4107423682476392449) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018459267) != 0) or _la==557: + self.state = 2313 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [105, 158, 295, 366, 448, 457, 460, 461, 462, 467, 478]: + self.state = 2310 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,232,self._ctx) + if la_ == 1: + self.state = 2301 + self.symbolicQueueClause() + pass + + elif la_ == 2: + self.state = 2302 + self.symbolicSubQueueClause() + pass + + elif la_ == 3: + self.state = 2303 + self.messageDateClause() + pass + + elif la_ == 4: + self.state = 2304 + self.messageTimeClause() + pass + + elif la_ == 5: + self.state = 2305 + self.symbolicSourceClause() + pass + + elif la_ == 6: + self.state = 2306 + self.textLengthClause() + pass + + elif la_ == 7: + self.state = 2307 + self.endKeyClause() + pass + + elif la_ == 8: + self.state = 2308 + self.statusKeyClause() + pass + + elif la_ == 9: + self.state = 2309 + self.messageCountClause() + pass + + + pass + elif token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 208, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.state = 2312 + self.dataDescName() + pass + else: + raise NoViableAltException(self) + + self.state = 2317 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2318 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CommunicationDescriptionEntryFormat2Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CD(self): + return self.getToken(Cobol85Parser.CD, 0) + + def cdName(self): + return self.getTypedRuleContext(Cobol85Parser.CdNameContext,0) + + + def OUTPUT(self): + return self.getToken(Cobol85Parser.OUTPUT, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def destinationCountClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DestinationCountClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DestinationCountClauseContext,i) + + + def textLengthClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.TextLengthClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.TextLengthClauseContext,i) + + + def statusKeyClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatusKeyClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatusKeyClauseContext,i) + + + def destinationTableClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DestinationTableClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DestinationTableClauseContext,i) + + + def errorKeyClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ErrorKeyClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ErrorKeyClauseContext,i) + + + def symbolicDestinationClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SymbolicDestinationClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SymbolicDestinationClauseContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_communicationDescriptionEntryFormat2 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCommunicationDescriptionEntryFormat2" ): + listener.enterCommunicationDescriptionEntryFormat2(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCommunicationDescriptionEntryFormat2" ): + listener.exitCommunicationDescriptionEntryFormat2(self) + + + + + def communicationDescriptionEntryFormat2(self): + + localctx = Cobol85Parser.CommunicationDescriptionEntryFormat2Context(self, self._ctx, self.state) + self.enterRule(localctx, 222, self.RULE_communicationDescriptionEntryFormat2) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2320 + self.match(Cobol85Parser.CD) + self.state = 2321 + self.cdName() + self.state = 2323 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 2322 + self.match(Cobol85Parser.FOR) + + + self.state = 2325 + self.match(Cobol85Parser.OUTPUT) + self.state = 2334 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==136 or _la==188 or ((((_la - 457)) & ~0x3f) == 0 and ((1 << (_la - 457)) & 2098177) != 0): + self.state = 2332 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,236,self._ctx) + if la_ == 1: + self.state = 2326 + self.destinationCountClause() + pass + + elif la_ == 2: + self.state = 2327 + self.textLengthClause() + pass + + elif la_ == 3: + self.state = 2328 + self.statusKeyClause() + pass + + elif la_ == 4: + self.state = 2329 + self.destinationTableClause() + pass + + elif la_ == 5: + self.state = 2330 + self.errorKeyClause() + pass + + elif la_ == 6: + self.state = 2331 + self.symbolicDestinationClause() + pass + + + self.state = 2336 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2337 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CommunicationDescriptionEntryFormat3Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CD(self): + return self.getToken(Cobol85Parser.CD, 0) + + def cdName(self): + return self.getTypedRuleContext(Cobol85Parser.CdNameContext,0) + + + def INITIAL(self): + return self.getToken(Cobol85Parser.INITIAL, 0) + + def I_O(self): + return self.getToken(Cobol85Parser.I_O, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def dataDescName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataDescNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataDescNameContext,i) + + + def messageDateClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.MessageDateClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.MessageDateClauseContext,i) + + + def messageTimeClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.MessageTimeClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.MessageTimeClauseContext,i) + + + def symbolicTerminalClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SymbolicTerminalClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SymbolicTerminalClauseContext,i) + + + def textLengthClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.TextLengthClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.TextLengthClauseContext,i) + + + def endKeyClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.EndKeyClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.EndKeyClauseContext,i) + + + def statusKeyClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatusKeyClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatusKeyClauseContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_communicationDescriptionEntryFormat3 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCommunicationDescriptionEntryFormat3" ): + listener.enterCommunicationDescriptionEntryFormat3(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCommunicationDescriptionEntryFormat3" ): + listener.exitCommunicationDescriptionEntryFormat3(self) + + + + + def communicationDescriptionEntryFormat3(self): + + localctx = Cobol85Parser.CommunicationDescriptionEntryFormat3Context(self, self._ctx, self.state) + self.enterRule(localctx, 224, self.RULE_communicationDescriptionEntryFormat3) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2339 + self.match(Cobol85Parser.CD) + self.state = 2340 + self.cdName() + self.state = 2342 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 2341 + self.match(Cobol85Parser.FOR) + + + self.state = 2344 + self.match(Cobol85Parser.INITIAL) + self.state = 2345 + self.match(Cobol85Parser.I_O) + self.state = 2357 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893884388107) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761343) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752044752779) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 72057678864072705) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018459779) != 0) or _la==557: + self.state = 2355 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [158, 295, 457, 467, 475, 478]: + self.state = 2352 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,239,self._ctx) + if la_ == 1: + self.state = 2346 + self.messageDateClause() + pass + + elif la_ == 2: + self.state = 2347 + self.messageTimeClause() + pass + + elif la_ == 3: + self.state = 2348 + self.symbolicTerminalClause() + pass + + elif la_ == 4: + self.state = 2349 + self.textLengthClause() + pass + + elif la_ == 5: + self.state = 2350 + self.endKeyClause() + pass + + elif la_ == 6: + self.state = 2351 + self.statusKeyClause() + pass + + + pass + elif token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 208, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.state = 2354 + self.dataDescName() + pass + else: + raise NoViableAltException(self) + + self.state = 2359 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2360 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DestinationCountClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DESTINATION(self): + return self.getToken(Cobol85Parser.DESTINATION, 0) + + def COUNT(self): + return self.getToken(Cobol85Parser.COUNT, 0) + + def dataDescName(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_destinationCountClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDestinationCountClause" ): + listener.enterDestinationCountClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDestinationCountClause" ): + listener.exitDestinationCountClause(self) + + + + + def destinationCountClause(self): + + localctx = Cobol85Parser.DestinationCountClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 226, self.RULE_destinationCountClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2362 + self.match(Cobol85Parser.DESTINATION) + self.state = 2363 + self.match(Cobol85Parser.COUNT) + self.state = 2365 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2364 + self.match(Cobol85Parser.IS) + + + self.state = 2367 + self.dataDescName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DestinationTableClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DESTINATION(self): + return self.getToken(Cobol85Parser.DESTINATION, 0) + + def TABLE(self): + return self.getToken(Cobol85Parser.TABLE, 0) + + def OCCURS(self): + return self.getToken(Cobol85Parser.OCCURS, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def TIMES(self): + return self.getToken(Cobol85Parser.TIMES, 0) + + def INDEXED(self): + return self.getToken(Cobol85Parser.INDEXED, 0) + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def indexName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.IndexNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.IndexNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_destinationTableClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDestinationTableClause" ): + listener.enterDestinationTableClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDestinationTableClause" ): + listener.exitDestinationTableClause(self) + + + + + def destinationTableClause(self): + + localctx = Cobol85Parser.DestinationTableClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 228, self.RULE_destinationTableClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2369 + self.match(Cobol85Parser.DESTINATION) + self.state = 2370 + self.match(Cobol85Parser.TABLE) + self.state = 2371 + self.match(Cobol85Parser.OCCURS) + self.state = 2372 + self.integerLiteral() + self.state = 2373 + self.match(Cobol85Parser.TIMES) + self.state = 2381 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==241: + self.state = 2374 + self.match(Cobol85Parser.INDEXED) + self.state = 2375 + self.match(Cobol85Parser.BY) + self.state = 2377 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 2376 + self.indexName() + self.state = 2379 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class EndKeyClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def END(self): + return self.getToken(Cobol85Parser.END, 0) + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def dataDescName(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_endKeyClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEndKeyClause" ): + listener.enterEndKeyClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEndKeyClause" ): + listener.exitEndKeyClause(self) + + + + + def endKeyClause(self): + + localctx = Cobol85Parser.EndKeyClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 230, self.RULE_endKeyClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2383 + self.match(Cobol85Parser.END) + self.state = 2384 + self.match(Cobol85Parser.KEY) + self.state = 2386 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2385 + self.match(Cobol85Parser.IS) + + + self.state = 2388 + self.dataDescName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ErrorKeyClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ERROR(self): + return self.getToken(Cobol85Parser.ERROR, 0) + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def dataDescName(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_errorKeyClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterErrorKeyClause" ): + listener.enterErrorKeyClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitErrorKeyClause" ): + listener.exitErrorKeyClause(self) + + + + + def errorKeyClause(self): + + localctx = Cobol85Parser.ErrorKeyClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 232, self.RULE_errorKeyClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2390 + self.match(Cobol85Parser.ERROR) + self.state = 2391 + self.match(Cobol85Parser.KEY) + self.state = 2393 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2392 + self.match(Cobol85Parser.IS) + + + self.state = 2395 + self.dataDescName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MessageCountClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def COUNT(self): + return self.getToken(Cobol85Parser.COUNT, 0) + + def dataDescName(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescNameContext,0) + + + def MESSAGE(self): + return self.getToken(Cobol85Parser.MESSAGE, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_messageCountClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMessageCountClause" ): + listener.enterMessageCountClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMessageCountClause" ): + listener.exitMessageCountClause(self) + + + + + def messageCountClause(self): + + localctx = Cobol85Parser.MessageCountClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 234, self.RULE_messageCountClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2398 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==295: + self.state = 2397 + self.match(Cobol85Parser.MESSAGE) + + + self.state = 2400 + self.match(Cobol85Parser.COUNT) + self.state = 2402 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2401 + self.match(Cobol85Parser.IS) + + + self.state = 2404 + self.dataDescName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MessageDateClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def MESSAGE(self): + return self.getToken(Cobol85Parser.MESSAGE, 0) + + def DATE(self): + return self.getToken(Cobol85Parser.DATE, 0) + + def dataDescName(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_messageDateClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMessageDateClause" ): + listener.enterMessageDateClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMessageDateClause" ): + listener.exitMessageDateClause(self) + + + + + def messageDateClause(self): + + localctx = Cobol85Parser.MessageDateClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 236, self.RULE_messageDateClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2406 + self.match(Cobol85Parser.MESSAGE) + self.state = 2407 + self.match(Cobol85Parser.DATE) + self.state = 2409 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2408 + self.match(Cobol85Parser.IS) + + + self.state = 2411 + self.dataDescName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MessageTimeClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def MESSAGE(self): + return self.getToken(Cobol85Parser.MESSAGE, 0) + + def TIME(self): + return self.getToken(Cobol85Parser.TIME, 0) + + def dataDescName(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_messageTimeClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMessageTimeClause" ): + listener.enterMessageTimeClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMessageTimeClause" ): + listener.exitMessageTimeClause(self) + + + + + def messageTimeClause(self): + + localctx = Cobol85Parser.MessageTimeClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 238, self.RULE_messageTimeClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2413 + self.match(Cobol85Parser.MESSAGE) + self.state = 2414 + self.match(Cobol85Parser.TIME) + self.state = 2416 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2415 + self.match(Cobol85Parser.IS) + + + self.state = 2418 + self.dataDescName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class StatusKeyClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def STATUS(self): + return self.getToken(Cobol85Parser.STATUS, 0) + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def dataDescName(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_statusKeyClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStatusKeyClause" ): + listener.enterStatusKeyClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStatusKeyClause" ): + listener.exitStatusKeyClause(self) + + + + + def statusKeyClause(self): + + localctx = Cobol85Parser.StatusKeyClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 240, self.RULE_statusKeyClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2420 + self.match(Cobol85Parser.STATUS) + self.state = 2421 + self.match(Cobol85Parser.KEY) + self.state = 2423 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2422 + self.match(Cobol85Parser.IS) + + + self.state = 2425 + self.dataDescName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SymbolicDestinationClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DESTINATION(self): + return self.getToken(Cobol85Parser.DESTINATION, 0) + + def dataDescName(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescNameContext,0) + + + def SYMBOLIC(self): + return self.getToken(Cobol85Parser.SYMBOLIC, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_symbolicDestinationClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSymbolicDestinationClause" ): + listener.enterSymbolicDestinationClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSymbolicDestinationClause" ): + listener.exitSymbolicDestinationClause(self) + + + + + def symbolicDestinationClause(self): + + localctx = Cobol85Parser.SymbolicDestinationClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 242, self.RULE_symbolicDestinationClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2428 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==467: + self.state = 2427 + self.match(Cobol85Parser.SYMBOLIC) + + + self.state = 2430 + self.match(Cobol85Parser.DESTINATION) + self.state = 2432 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2431 + self.match(Cobol85Parser.IS) + + + self.state = 2434 + self.dataDescName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SymbolicQueueClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def QUEUE(self): + return self.getToken(Cobol85Parser.QUEUE, 0) + + def dataDescName(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescNameContext,0) + + + def SYMBOLIC(self): + return self.getToken(Cobol85Parser.SYMBOLIC, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_symbolicQueueClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSymbolicQueueClause" ): + listener.enterSymbolicQueueClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSymbolicQueueClause" ): + listener.exitSymbolicQueueClause(self) + + + + + def symbolicQueueClause(self): + + localctx = Cobol85Parser.SymbolicQueueClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 244, self.RULE_symbolicQueueClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2437 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==467: + self.state = 2436 + self.match(Cobol85Parser.SYMBOLIC) + + + self.state = 2439 + self.match(Cobol85Parser.QUEUE) + self.state = 2441 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2440 + self.match(Cobol85Parser.IS) + + + self.state = 2443 + self.dataDescName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SymbolicSourceClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SOURCE(self): + return self.getToken(Cobol85Parser.SOURCE, 0) + + def dataDescName(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescNameContext,0) + + + def SYMBOLIC(self): + return self.getToken(Cobol85Parser.SYMBOLIC, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_symbolicSourceClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSymbolicSourceClause" ): + listener.enterSymbolicSourceClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSymbolicSourceClause" ): + listener.exitSymbolicSourceClause(self) + + + + + def symbolicSourceClause(self): + + localctx = Cobol85Parser.SymbolicSourceClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 246, self.RULE_symbolicSourceClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2446 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==467: + self.state = 2445 + self.match(Cobol85Parser.SYMBOLIC) + + + self.state = 2448 + self.match(Cobol85Parser.SOURCE) + self.state = 2450 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2449 + self.match(Cobol85Parser.IS) + + + self.state = 2452 + self.dataDescName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SymbolicTerminalClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TERMINAL(self): + return self.getToken(Cobol85Parser.TERMINAL, 0) + + def dataDescName(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescNameContext,0) + + + def SYMBOLIC(self): + return self.getToken(Cobol85Parser.SYMBOLIC, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_symbolicTerminalClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSymbolicTerminalClause" ): + listener.enterSymbolicTerminalClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSymbolicTerminalClause" ): + listener.exitSymbolicTerminalClause(self) + + + + + def symbolicTerminalClause(self): + + localctx = Cobol85Parser.SymbolicTerminalClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 248, self.RULE_symbolicTerminalClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2455 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==467: + self.state = 2454 + self.match(Cobol85Parser.SYMBOLIC) + + + self.state = 2457 + self.match(Cobol85Parser.TERMINAL) + self.state = 2459 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2458 + self.match(Cobol85Parser.IS) + + + self.state = 2461 + self.dataDescName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SymbolicSubQueueClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def dataDescName(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescNameContext,0) + + + def SUB_QUEUE_1(self): + return self.getToken(Cobol85Parser.SUB_QUEUE_1, 0) + + def SUB_QUEUE_2(self): + return self.getToken(Cobol85Parser.SUB_QUEUE_2, 0) + + def SUB_QUEUE_3(self): + return self.getToken(Cobol85Parser.SUB_QUEUE_3, 0) + + def SYMBOLIC(self): + return self.getToken(Cobol85Parser.SYMBOLIC, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_symbolicSubQueueClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSymbolicSubQueueClause" ): + listener.enterSymbolicSubQueueClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSymbolicSubQueueClause" ): + listener.exitSymbolicSubQueueClause(self) + + + + + def symbolicSubQueueClause(self): + + localctx = Cobol85Parser.SymbolicSubQueueClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 250, self.RULE_symbolicSubQueueClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2464 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==467: + self.state = 2463 + self.match(Cobol85Parser.SYMBOLIC) + + + self.state = 2466 + _la = self._input.LA(1) + if not(((((_la - 460)) & ~0x3f) == 0 and ((1 << (_la - 460)) & 7) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2468 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2467 + self.match(Cobol85Parser.IS) + + + self.state = 2470 + self.dataDescName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TextLengthClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TEXT(self): + return self.getToken(Cobol85Parser.TEXT, 0) + + def LENGTH(self): + return self.getToken(Cobol85Parser.LENGTH, 0) + + def dataDescName(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_textLengthClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTextLengthClause" ): + listener.enterTextLengthClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTextLengthClause" ): + listener.exitTextLengthClause(self) + + + + + def textLengthClause(self): + + localctx = Cobol85Parser.TextLengthClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 252, self.RULE_textLengthClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2472 + self.match(Cobol85Parser.TEXT) + self.state = 2473 + self.match(Cobol85Parser.LENGTH) + self.state = 2475 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2474 + self.match(Cobol85Parser.IS) + + + self.state = 2477 + self.dataDescName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LocalStorageSectionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LOCAL_STORAGE(self): + return self.getToken(Cobol85Parser.LOCAL_STORAGE, 0) + + def SECTION(self): + return self.getToken(Cobol85Parser.SECTION, 0) + + def DOT_FS(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.DOT_FS) + else: + return self.getToken(Cobol85Parser.DOT_FS, i) + + def LD(self): + return self.getToken(Cobol85Parser.LD, 0) + + def localName(self): + return self.getTypedRuleContext(Cobol85Parser.LocalNameContext,0) + + + def dataDescriptionEntry(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataDescriptionEntryContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataDescriptionEntryContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_localStorageSection + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLocalStorageSection" ): + listener.enterLocalStorageSection(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLocalStorageSection" ): + listener.exitLocalStorageSection(self) + + + + + def localStorageSection(self): + + localctx = Cobol85Parser.LocalStorageSectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 254, self.RULE_localStorageSection) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2479 + self.match(Cobol85Parser.LOCAL_STORAGE) + self.state = 2480 + self.match(Cobol85Parser.SECTION) + self.state = 2481 + self.match(Cobol85Parser.DOT_FS) + self.state = 2486 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==265: + self.state = 2482 + self.match(Cobol85Parser.LD) + self.state = 2483 + self.localName() + self.state = 2484 + self.match(Cobol85Parser.DOT_FS) + + + self.state = 2491 + self._errHandler.sync(self) + _la = self._input.LA(1) + while ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 527) != 0): + self.state = 2488 + self.dataDescriptionEntry() + self.state = 2493 + 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 ScreenSectionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SCREEN(self): + return self.getToken(Cobol85Parser.SCREEN, 0) + + def SECTION(self): + return self.getToken(Cobol85Parser.SECTION, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def screenDescriptionEntry(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionEntryContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionEntryContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenSection + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenSection" ): + listener.enterScreenSection(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenSection" ): + listener.exitScreenSection(self) + + + + + def screenSection(self): + + localctx = Cobol85Parser.ScreenSectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 256, self.RULE_screenSection) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2494 + self.match(Cobol85Parser.SCREEN) + self.state = 2495 + self.match(Cobol85Parser.SECTION) + self.state = 2496 + self.match(Cobol85Parser.DOT_FS) + self.state = 2500 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==555: + self.state = 2497 + self.screenDescriptionEntry() + self.state = 2502 + 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 ScreenDescriptionEntryContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTEGERLITERAL(self): + return self.getToken(Cobol85Parser.INTEGERLITERAL, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def FILLER(self): + return self.getToken(Cobol85Parser.FILLER, 0) + + def screenName(self): + return self.getTypedRuleContext(Cobol85Parser.ScreenNameContext,0) + + + def screenDescriptionBlankClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionBlankClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionBlankClauseContext,i) + + + def screenDescriptionBellClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionBellClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionBellClauseContext,i) + + + def screenDescriptionBlinkClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionBlinkClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionBlinkClauseContext,i) + + + def screenDescriptionEraseClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionEraseClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionEraseClauseContext,i) + + + def screenDescriptionLightClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionLightClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionLightClauseContext,i) + + + def screenDescriptionGridClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionGridClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionGridClauseContext,i) + + + def screenDescriptionReverseVideoClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionReverseVideoClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionReverseVideoClauseContext,i) + + + def screenDescriptionUnderlineClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionUnderlineClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionUnderlineClauseContext,i) + + + def screenDescriptionSizeClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionSizeClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionSizeClauseContext,i) + + + def screenDescriptionLineClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionLineClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionLineClauseContext,i) + + + def screenDescriptionColumnClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionColumnClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionColumnClauseContext,i) + + + def screenDescriptionForegroundColorClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionForegroundColorClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionForegroundColorClauseContext,i) + + + def screenDescriptionBackgroundColorClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionBackgroundColorClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionBackgroundColorClauseContext,i) + + + def screenDescriptionControlClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionControlClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionControlClauseContext,i) + + + def screenDescriptionValueClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionValueClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionValueClauseContext,i) + + + def screenDescriptionPictureClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionPictureClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionPictureClauseContext,i) + + + def screenDescriptionUsageClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionUsageClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionUsageClauseContext,i) + + + def screenDescriptionBlankWhenZeroClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionBlankWhenZeroClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionBlankWhenZeroClauseContext,i) + + + def screenDescriptionJustifiedClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionJustifiedClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionJustifiedClauseContext,i) + + + def screenDescriptionSignClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionSignClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionSignClauseContext,i) + + + def screenDescriptionAutoClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionAutoClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionAutoClauseContext,i) + + + def screenDescriptionSecureClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionSecureClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionSecureClauseContext,i) + + + def screenDescriptionRequiredClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionRequiredClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionRequiredClauseContext,i) + + + def screenDescriptionPromptClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionPromptClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionPromptClauseContext,i) + + + def screenDescriptionFullClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionFullClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionFullClauseContext,i) + + + def screenDescriptionZeroFillClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionZeroFillClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionZeroFillClauseContext,i) + + + def screenDescriptionFromClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionFromClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionFromClauseContext,i) + + + def screenDescriptionUsingClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ScreenDescriptionUsingClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionUsingClauseContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionEntry + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionEntry" ): + listener.enterScreenDescriptionEntry(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionEntry" ): + listener.exitScreenDescriptionEntry(self) + + + + + def screenDescriptionEntry(self): + + localctx = Cobol85Parser.ScreenDescriptionEntryContext(self, self._ctx, self.state) + self.enterRule(localctx, 258, self.RULE_screenDescriptionEntry) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2503 + self.match(Cobol85Parser.INTEGERLITERAL) + self.state = 2506 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,266,self._ctx) + if la_ == 1: + self.state = 2504 + self.match(Cobol85Parser.FILLER) + + elif la_ == 2: + self.state = 2505 + self.screenName() + + + self.state = 2540 + self._errHandler.sync(self) + _la = self._input.LA(1) + while ((((_la - 33)) & ~0x3f) == 0 and ((1 << (_la - 33)) & 3298534889775) != 0) or _la==97 or _la==156 or ((((_la - 187)) & ~0x3f) == 0 and ((1 << (_la - 187)) & 4948808957953) != 0) or ((((_la - 255)) & ~0x3f) == 0 and ((1 << (_la - 255)) & 72057628414486531) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4611686018695826433) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 412317384705) != 0) or ((((_la - 493)) & ~0x3f) == 0 and ((1 << (_la - 493)) & 536897569) != 0): + self.state = 2538 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,268,self._ctx) + if la_ == 1: + self.state = 2508 + self.screenDescriptionBlankClause() + pass + + elif la_ == 2: + self.state = 2509 + self.screenDescriptionBellClause() + pass + + elif la_ == 3: + self.state = 2510 + self.screenDescriptionBlinkClause() + pass + + elif la_ == 4: + self.state = 2511 + self.screenDescriptionEraseClause() + pass + + elif la_ == 5: + self.state = 2512 + self.screenDescriptionLightClause() + pass + + elif la_ == 6: + self.state = 2513 + self.screenDescriptionGridClause() + pass + + elif la_ == 7: + self.state = 2514 + self.screenDescriptionReverseVideoClause() + pass + + elif la_ == 8: + self.state = 2515 + self.screenDescriptionUnderlineClause() + pass + + elif la_ == 9: + self.state = 2516 + self.screenDescriptionSizeClause() + pass + + elif la_ == 10: + self.state = 2517 + self.screenDescriptionLineClause() + pass + + elif la_ == 11: + self.state = 2518 + self.screenDescriptionColumnClause() + pass + + elif la_ == 12: + self.state = 2519 + self.screenDescriptionForegroundColorClause() + pass + + elif la_ == 13: + self.state = 2520 + self.screenDescriptionBackgroundColorClause() + pass + + elif la_ == 14: + self.state = 2521 + self.screenDescriptionControlClause() + pass + + elif la_ == 15: + self.state = 2522 + self.screenDescriptionValueClause() + pass + + elif la_ == 16: + self.state = 2523 + self.screenDescriptionPictureClause() + pass + + elif la_ == 17: + self.state = 2526 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [215]: + self.state = 2524 + self.screenDescriptionFromClause() + pass + elif token in [506]: + self.state = 2525 + self.screenDescriptionUsingClause() + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 18: + self.state = 2528 + self.screenDescriptionUsageClause() + pass + + elif la_ == 19: + self.state = 2529 + self.screenDescriptionBlankWhenZeroClause() + pass + + elif la_ == 20: + self.state = 2530 + self.screenDescriptionJustifiedClause() + pass + + elif la_ == 21: + self.state = 2531 + self.screenDescriptionSignClause() + pass + + elif la_ == 22: + self.state = 2532 + self.screenDescriptionAutoClause() + pass + + elif la_ == 23: + self.state = 2533 + self.screenDescriptionSecureClause() + pass + + elif la_ == 24: + self.state = 2534 + self.screenDescriptionRequiredClause() + pass + + elif la_ == 25: + self.state = 2535 + self.screenDescriptionPromptClause() + pass + + elif la_ == 26: + self.state = 2536 + self.screenDescriptionFullClause() + pass + + elif la_ == 27: + self.state = 2537 + self.screenDescriptionZeroFillClause() + pass + + + self.state = 2542 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2543 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionBlankClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BLANK(self): + return self.getToken(Cobol85Parser.BLANK, 0) + + def SCREEN(self): + return self.getToken(Cobol85Parser.SCREEN, 0) + + def LINE(self): + return self.getToken(Cobol85Parser.LINE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionBlankClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionBlankClause" ): + listener.enterScreenDescriptionBlankClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionBlankClause" ): + listener.exitScreenDescriptionBlankClause(self) + + + + + def screenDescriptionBlankClause(self): + + localctx = Cobol85Parser.ScreenDescriptionBlankClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 260, self.RULE_screenDescriptionBlankClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2545 + self.match(Cobol85Parser.BLANK) + self.state = 2546 + _la = self._input.LA(1) + if not(_la==279 or _la==416): + 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 ScreenDescriptionBellClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BELL(self): + return self.getToken(Cobol85Parser.BELL, 0) + + def BEEP(self): + return self.getToken(Cobol85Parser.BEEP, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionBellClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionBellClause" ): + listener.enterScreenDescriptionBellClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionBellClause" ): + listener.exitScreenDescriptionBellClause(self) + + + + + def screenDescriptionBellClause(self): + + localctx = Cobol85Parser.ScreenDescriptionBellClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 262, self.RULE_screenDescriptionBellClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2548 + _la = self._input.LA(1) + if not(_la==38 or _la==41): + 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 ScreenDescriptionBlinkClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BLINK(self): + return self.getToken(Cobol85Parser.BLINK, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionBlinkClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionBlinkClause" ): + listener.enterScreenDescriptionBlinkClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionBlinkClause" ): + listener.exitScreenDescriptionBlinkClause(self) + + + + + def screenDescriptionBlinkClause(self): + + localctx = Cobol85Parser.ScreenDescriptionBlinkClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 264, self.RULE_screenDescriptionBlinkClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2550 + self.match(Cobol85Parser.BLINK) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionEraseClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ERASE(self): + return self.getToken(Cobol85Parser.ERASE, 0) + + def EOL(self): + return self.getToken(Cobol85Parser.EOL, 0) + + def EOS(self): + return self.getToken(Cobol85Parser.EOS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionEraseClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionEraseClause" ): + listener.enterScreenDescriptionEraseClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionEraseClause" ): + listener.exitScreenDescriptionEraseClause(self) + + + + + def screenDescriptionEraseClause(self): + + localctx = Cobol85Parser.ScreenDescriptionEraseClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 266, self.RULE_screenDescriptionEraseClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2552 + self.match(Cobol85Parser.ERASE) + self.state = 2553 + _la = self._input.LA(1) + if not(_la==189 or _la==190): + 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 ScreenDescriptionLightClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def HIGHLIGHT(self): + return self.getToken(Cobol85Parser.HIGHLIGHT, 0) + + def LOWLIGHT(self): + return self.getToken(Cobol85Parser.LOWLIGHT, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionLightClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionLightClause" ): + listener.enterScreenDescriptionLightClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionLightClause" ): + listener.exitScreenDescriptionLightClause(self) + + + + + def screenDescriptionLightClause(self): + + localctx = Cobol85Parser.ScreenDescriptionLightClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 268, self.RULE_screenDescriptionLightClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2555 + _la = self._input.LA(1) + if not(_la==229 or _la==290): + 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 ScreenDescriptionGridClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GRID(self): + return self.getToken(Cobol85Parser.GRID, 0) + + def LEFTLINE(self): + return self.getToken(Cobol85Parser.LEFTLINE, 0) + + def OVERLINE(self): + return self.getToken(Cobol85Parser.OVERLINE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionGridClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionGridClause" ): + listener.enterScreenDescriptionGridClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionGridClause" ): + listener.exitScreenDescriptionGridClause(self) + + + + + def screenDescriptionGridClause(self): + + localctx = Cobol85Parser.ScreenDescriptionGridClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 270, self.RULE_screenDescriptionGridClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2557 + _la = self._input.LA(1) + if not(_la==226 or _la==268 or _la==336): + 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 ScreenDescriptionReverseVideoClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REVERSE_VIDEO(self): + return self.getToken(Cobol85Parser.REVERSE_VIDEO, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionReverseVideoClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionReverseVideoClause" ): + listener.enterScreenDescriptionReverseVideoClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionReverseVideoClause" ): + listener.exitScreenDescriptionReverseVideoClause(self) + + + + + def screenDescriptionReverseVideoClause(self): + + localctx = Cobol85Parser.ScreenDescriptionReverseVideoClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 272, self.RULE_screenDescriptionReverseVideoClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2559 + self.match(Cobol85Parser.REVERSE_VIDEO) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionUnderlineClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def UNDERLINE(self): + return self.getToken(Cobol85Parser.UNDERLINE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionUnderlineClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionUnderlineClause" ): + listener.enterScreenDescriptionUnderlineClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionUnderlineClause" ): + listener.exitScreenDescriptionUnderlineClause(self) + + + + + def screenDescriptionUnderlineClause(self): + + localctx = Cobol85Parser.ScreenDescriptionUnderlineClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 274, self.RULE_screenDescriptionUnderlineClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2561 + self.match(Cobol85Parser.UNDERLINE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionSizeClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SIZE(self): + return self.getToken(Cobol85Parser.SIZE, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionSizeClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionSizeClause" ): + listener.enterScreenDescriptionSizeClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionSizeClause" ): + listener.exitScreenDescriptionSizeClause(self) + + + + + def screenDescriptionSizeClause(self): + + localctx = Cobol85Parser.ScreenDescriptionSizeClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 276, self.RULE_screenDescriptionSizeClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2563 + self.match(Cobol85Parser.SIZE) + self.state = 2565 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2564 + self.match(Cobol85Parser.IS) + + + self.state = 2569 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,271,self._ctx) + if la_ == 1: + self.state = 2567 + self.identifier() + pass + + elif la_ == 2: + self.state = 2568 + self.integerLiteral() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionLineClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LINE(self): + return self.getToken(Cobol85Parser.LINE, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def PLUS(self): + return self.getToken(Cobol85Parser.PLUS, 0) + + def PLUSCHAR(self): + return self.getToken(Cobol85Parser.PLUSCHAR, 0) + + def MINUSCHAR(self): + return self.getToken(Cobol85Parser.MINUSCHAR, 0) + + def NUMBER(self): + return self.getToken(Cobol85Parser.NUMBER, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionLineClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionLineClause" ): + listener.enterScreenDescriptionLineClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionLineClause" ): + listener.exitScreenDescriptionLineClause(self) + + + + + def screenDescriptionLineClause(self): + + localctx = Cobol85Parser.ScreenDescriptionLineClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 278, self.RULE_screenDescriptionLineClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2571 + self.match(Cobol85Parser.LINE) + self.state = 2579 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254 or _la==315 or _la==348 or _la==543 or _la==547: + self.state = 2573 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==315: + self.state = 2572 + self.match(Cobol85Parser.NUMBER) + + + self.state = 2576 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2575 + self.match(Cobol85Parser.IS) + + + self.state = 2578 + _la = self._input.LA(1) + if not(_la==348 or _la==543 or _la==547): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 2583 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,275,self._ctx) + if la_ == 1: + self.state = 2581 + self.identifier() + pass + + elif la_ == 2: + self.state = 2582 + self.integerLiteral() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionColumnClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def COLUMN(self): + return self.getToken(Cobol85Parser.COLUMN, 0) + + def COL(self): + return self.getToken(Cobol85Parser.COL, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def PLUS(self): + return self.getToken(Cobol85Parser.PLUS, 0) + + def PLUSCHAR(self): + return self.getToken(Cobol85Parser.PLUSCHAR, 0) + + def MINUSCHAR(self): + return self.getToken(Cobol85Parser.MINUSCHAR, 0) + + def NUMBER(self): + return self.getToken(Cobol85Parser.NUMBER, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionColumnClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionColumnClause" ): + listener.enterScreenDescriptionColumnClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionColumnClause" ): + listener.exitScreenDescriptionColumnClause(self) + + + + + def screenDescriptionColumnClause(self): + + localctx = Cobol85Parser.ScreenDescriptionColumnClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 280, self.RULE_screenDescriptionColumnClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2585 + _la = self._input.LA(1) + if not(_la==73 or _la==74): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2593 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254 or _la==315 or _la==348 or _la==543 or _la==547: + self.state = 2587 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==315: + self.state = 2586 + self.match(Cobol85Parser.NUMBER) + + + self.state = 2590 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2589 + self.match(Cobol85Parser.IS) + + + self.state = 2592 + _la = self._input.LA(1) + if not(_la==348 or _la==543 or _la==547): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 2597 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,279,self._ctx) + if la_ == 1: + self.state = 2595 + self.identifier() + pass + + elif la_ == 2: + self.state = 2596 + self.integerLiteral() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionForegroundColorClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FOREGROUND_COLOR(self): + return self.getToken(Cobol85Parser.FOREGROUND_COLOR, 0) + + def FOREGROUND_COLOUR(self): + return self.getToken(Cobol85Parser.FOREGROUND_COLOUR, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionForegroundColorClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionForegroundColorClause" ): + listener.enterScreenDescriptionForegroundColorClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionForegroundColorClause" ): + listener.exitScreenDescriptionForegroundColorClause(self) + + + + + def screenDescriptionForegroundColorClause(self): + + localctx = Cobol85Parser.ScreenDescriptionForegroundColorClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 282, self.RULE_screenDescriptionForegroundColorClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2599 + _la = self._input.LA(1) + if not(_la==213 or _la==214): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2601 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2600 + self.match(Cobol85Parser.IS) + + + self.state = 2605 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,281,self._ctx) + if la_ == 1: + self.state = 2603 + self.identifier() + pass + + elif la_ == 2: + self.state = 2604 + self.integerLiteral() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionBackgroundColorClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BACKGROUND_COLOR(self): + return self.getToken(Cobol85Parser.BACKGROUND_COLOR, 0) + + def BACKGROUND_COLOUR(self): + return self.getToken(Cobol85Parser.BACKGROUND_COLOUR, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionBackgroundColorClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionBackgroundColorClause" ): + listener.enterScreenDescriptionBackgroundColorClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionBackgroundColorClause" ): + listener.exitScreenDescriptionBackgroundColorClause(self) + + + + + def screenDescriptionBackgroundColorClause(self): + + localctx = Cobol85Parser.ScreenDescriptionBackgroundColorClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 284, self.RULE_screenDescriptionBackgroundColorClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2607 + _la = self._input.LA(1) + if not(_la==35 or _la==36): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2609 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2608 + self.match(Cobol85Parser.IS) + + + self.state = 2613 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,283,self._ctx) + if la_ == 1: + self.state = 2611 + self.identifier() + pass + + elif la_ == 2: + self.state = 2612 + self.integerLiteral() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionControlClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CONTROL(self): + return self.getToken(Cobol85Parser.CONTROL, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionControlClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionControlClause" ): + listener.enterScreenDescriptionControlClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionControlClause" ): + listener.exitScreenDescriptionControlClause(self) + + + + + def screenDescriptionControlClause(self): + + localctx = Cobol85Parser.ScreenDescriptionControlClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 286, self.RULE_screenDescriptionControlClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2615 + self.match(Cobol85Parser.CONTROL) + self.state = 2617 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2616 + self.match(Cobol85Parser.IS) + + + self.state = 2619 + 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 ScreenDescriptionValueClauseContext(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(Cobol85Parser.LiteralContext,0) + + + def VALUE(self): + return self.getToken(Cobol85Parser.VALUE, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionValueClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionValueClause" ): + listener.enterScreenDescriptionValueClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionValueClause" ): + listener.exitScreenDescriptionValueClause(self) + + + + + def screenDescriptionValueClause(self): + + localctx = Cobol85Parser.ScreenDescriptionValueClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 288, self.RULE_screenDescriptionValueClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2621 + self.match(Cobol85Parser.VALUE) + self.state = 2623 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2622 + self.match(Cobol85Parser.IS) + + + self.state = 2625 + self.literal() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionPictureClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def pictureString(self): + return self.getTypedRuleContext(Cobol85Parser.PictureStringContext,0) + + + def PICTURE(self): + return self.getToken(Cobol85Parser.PICTURE, 0) + + def PIC(self): + return self.getToken(Cobol85Parser.PIC, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionPictureClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionPictureClause" ): + listener.enterScreenDescriptionPictureClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionPictureClause" ): + listener.exitScreenDescriptionPictureClause(self) + + + + + def screenDescriptionPictureClause(self): + + localctx = Cobol85Parser.ScreenDescriptionPictureClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 290, self.RULE_screenDescriptionPictureClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2627 + _la = self._input.LA(1) + if not(_la==346 or _la==347): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2629 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2628 + self.match(Cobol85Parser.IS) + + + self.state = 2631 + self.pictureString() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionFromClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FROM(self): + return self.getToken(Cobol85Parser.FROM, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def screenDescriptionToClause(self): + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionToClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionFromClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionFromClause" ): + listener.enterScreenDescriptionFromClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionFromClause" ): + listener.exitScreenDescriptionFromClause(self) + + + + + def screenDescriptionFromClause(self): + + localctx = Cobol85Parser.ScreenDescriptionFromClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 292, self.RULE_screenDescriptionFromClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2633 + self.match(Cobol85Parser.FROM) + self.state = 2636 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,287,self._ctx) + if la_ == 1: + self.state = 2634 + self.identifier() + pass + + elif la_ == 2: + self.state = 2635 + self.literal() + pass + + + self.state = 2639 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==489: + self.state = 2638 + self.screenDescriptionToClause() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionToClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionToClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionToClause" ): + listener.enterScreenDescriptionToClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionToClause" ): + listener.exitScreenDescriptionToClause(self) + + + + + def screenDescriptionToClause(self): + + localctx = Cobol85Parser.ScreenDescriptionToClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 294, self.RULE_screenDescriptionToClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2641 + self.match(Cobol85Parser.TO) + self.state = 2642 + 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 ScreenDescriptionUsingClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def USING(self): + return self.getToken(Cobol85Parser.USING, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionUsingClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionUsingClause" ): + listener.enterScreenDescriptionUsingClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionUsingClause" ): + listener.exitScreenDescriptionUsingClause(self) + + + + + def screenDescriptionUsingClause(self): + + localctx = Cobol85Parser.ScreenDescriptionUsingClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 296, self.RULE_screenDescriptionUsingClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2644 + self.match(Cobol85Parser.USING) + self.state = 2645 + 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 ScreenDescriptionUsageClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DISPLAY(self): + return self.getToken(Cobol85Parser.DISPLAY, 0) + + def DISPLAY_1(self): + return self.getToken(Cobol85Parser.DISPLAY_1, 0) + + def USAGE(self): + return self.getToken(Cobol85Parser.USAGE, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionUsageClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionUsageClause" ): + listener.enterScreenDescriptionUsageClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionUsageClause" ): + listener.exitScreenDescriptionUsageClause(self) + + + + + def screenDescriptionUsageClause(self): + + localctx = Cobol85Parser.ScreenDescriptionUsageClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 298, self.RULE_screenDescriptionUsageClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2647 + self.match(Cobol85Parser.USAGE) + self.state = 2649 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2648 + self.match(Cobol85Parser.IS) + + + self.state = 2651 + _la = self._input.LA(1) + if not(_la==142 or _la==143): + 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 ScreenDescriptionBlankWhenZeroClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BLANK(self): + return self.getToken(Cobol85Parser.BLANK, 0) + + def ZERO(self): + return self.getToken(Cobol85Parser.ZERO, 0) + + def WHEN(self): + return self.getToken(Cobol85Parser.WHEN, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionBlankWhenZeroClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionBlankWhenZeroClause" ): + listener.enterScreenDescriptionBlankWhenZeroClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionBlankWhenZeroClause" ): + listener.exitScreenDescriptionBlankWhenZeroClause(self) + + + + + def screenDescriptionBlankWhenZeroClause(self): + + localctx = Cobol85Parser.ScreenDescriptionBlankWhenZeroClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 300, self.RULE_screenDescriptionBlankWhenZeroClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2653 + self.match(Cobol85Parser.BLANK) + self.state = 2655 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==512: + self.state = 2654 + self.match(Cobol85Parser.WHEN) + + + self.state = 2657 + self.match(Cobol85Parser.ZERO) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionJustifiedClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def JUSTIFIED(self): + return self.getToken(Cobol85Parser.JUSTIFIED, 0) + + def JUST(self): + return self.getToken(Cobol85Parser.JUST, 0) + + def RIGHT(self): + return self.getToken(Cobol85Parser.RIGHT, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionJustifiedClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionJustifiedClause" ): + listener.enterScreenDescriptionJustifiedClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionJustifiedClause" ): + listener.exitScreenDescriptionJustifiedClause(self) + + + + + def screenDescriptionJustifiedClause(self): + + localctx = Cobol85Parser.ScreenDescriptionJustifiedClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 302, self.RULE_screenDescriptionJustifiedClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2659 + _la = self._input.LA(1) + if not(_la==255 or _la==256): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2661 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==411: + self.state = 2660 + self.match(Cobol85Parser.RIGHT) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionSignClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEADING(self): + return self.getToken(Cobol85Parser.LEADING, 0) + + def TRAILING(self): + return self.getToken(Cobol85Parser.TRAILING, 0) + + def SIGN(self): + return self.getToken(Cobol85Parser.SIGN, 0) + + def SEPARATE(self): + return self.getToken(Cobol85Parser.SEPARATE, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def CHARACTER(self): + return self.getToken(Cobol85Parser.CHARACTER, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionSignClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionSignClause" ): + listener.enterScreenDescriptionSignClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionSignClause" ): + listener.exitScreenDescriptionSignClause(self) + + + + + def screenDescriptionSignClause(self): + + localctx = Cobol85Parser.ScreenDescriptionSignClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 304, self.RULE_screenDescriptionSignClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2667 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==438: + self.state = 2663 + self.match(Cobol85Parser.SIGN) + self.state = 2665 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2664 + self.match(Cobol85Parser.IS) + + + + + self.state = 2669 + _la = self._input.LA(1) + if not(_la==266 or _la==493): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2674 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==427: + self.state = 2670 + self.match(Cobol85Parser.SEPARATE) + self.state = 2672 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==62: + self.state = 2671 + self.match(Cobol85Parser.CHARACTER) + + + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionAutoClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def AUTO(self): + return self.getToken(Cobol85Parser.AUTO, 0) + + def AUTO_SKIP(self): + return self.getToken(Cobol85Parser.AUTO_SKIP, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionAutoClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionAutoClause" ): + listener.enterScreenDescriptionAutoClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionAutoClause" ): + listener.exitScreenDescriptionAutoClause(self) + + + + + def screenDescriptionAutoClause(self): + + localctx = Cobol85Parser.ScreenDescriptionAutoClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 306, self.RULE_screenDescriptionAutoClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2676 + _la = self._input.LA(1) + if not(_la==33 or _la==34): + 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 ScreenDescriptionSecureClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SECURE(self): + return self.getToken(Cobol85Parser.SECURE, 0) + + def NO_ECHO(self): + return self.getToken(Cobol85Parser.NO_ECHO, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionSecureClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionSecureClause" ): + listener.enterScreenDescriptionSecureClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionSecureClause" ): + listener.exitScreenDescriptionSecureClause(self) + + + + + def screenDescriptionSecureClause(self): + + localctx = Cobol85Parser.ScreenDescriptionSecureClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 308, self.RULE_screenDescriptionSecureClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2678 + _la = self._input.LA(1) + if not(_la==311 or _la==420): + 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 ScreenDescriptionRequiredClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REQUIRED(self): + return self.getToken(Cobol85Parser.REQUIRED, 0) + + def EMPTY_CHECK(self): + return self.getToken(Cobol85Parser.EMPTY_CHECK, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionRequiredClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionRequiredClause" ): + listener.enterScreenDescriptionRequiredClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionRequiredClause" ): + listener.exitScreenDescriptionRequiredClause(self) + + + + + def screenDescriptionRequiredClause(self): + + localctx = Cobol85Parser.ScreenDescriptionRequiredClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 310, self.RULE_screenDescriptionRequiredClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2680 + _la = self._input.LA(1) + if not(_la==156 or _la==398): + 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 ScreenDescriptionPromptClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PROMPT(self): + return self.getToken(Cobol85Parser.PROMPT, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def CHARACTER(self): + return self.getToken(Cobol85Parser.CHARACTER, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def screenDescriptionPromptOccursClause(self): + return self.getTypedRuleContext(Cobol85Parser.ScreenDescriptionPromptOccursClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionPromptClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionPromptClause" ): + listener.enterScreenDescriptionPromptClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionPromptClause" ): + listener.exitScreenDescriptionPromptClause(self) + + + + + def screenDescriptionPromptClause(self): + + localctx = Cobol85Parser.ScreenDescriptionPromptClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 312, self.RULE_screenDescriptionPromptClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2682 + self.match(Cobol85Parser.PROMPT) + self.state = 2684 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==62: + self.state = 2683 + self.match(Cobol85Parser.CHARACTER) + + + self.state = 2687 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2686 + self.match(Cobol85Parser.IS) + + + self.state = 2691 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,298,self._ctx) + if la_ == 1: + self.state = 2689 + self.identifier() + pass + + elif la_ == 2: + self.state = 2690 + self.literal() + pass + + + self.state = 2694 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==321: + self.state = 2693 + self.screenDescriptionPromptOccursClause() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionPromptOccursClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OCCURS(self): + return self.getToken(Cobol85Parser.OCCURS, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def TIMES(self): + return self.getToken(Cobol85Parser.TIMES, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionPromptOccursClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionPromptOccursClause" ): + listener.enterScreenDescriptionPromptOccursClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionPromptOccursClause" ): + listener.exitScreenDescriptionPromptOccursClause(self) + + + + + def screenDescriptionPromptOccursClause(self): + + localctx = Cobol85Parser.ScreenDescriptionPromptOccursClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 314, self.RULE_screenDescriptionPromptOccursClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2696 + self.match(Cobol85Parser.OCCURS) + self.state = 2697 + self.integerLiteral() + self.state = 2699 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==487: + self.state = 2698 + self.match(Cobol85Parser.TIMES) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenDescriptionFullClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FULL(self): + return self.getToken(Cobol85Parser.FULL, 0) + + def LENGTH_CHECK(self): + return self.getToken(Cobol85Parser.LENGTH_CHECK, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionFullClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionFullClause" ): + listener.enterScreenDescriptionFullClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionFullClause" ): + listener.exitScreenDescriptionFullClause(self) + + + + + def screenDescriptionFullClause(self): + + localctx = Cobol85Parser.ScreenDescriptionFullClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 316, self.RULE_screenDescriptionFullClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2701 + _la = self._input.LA(1) + if not(_la==216 or _la==270): + 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 ScreenDescriptionZeroFillClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ZERO_FILL(self): + return self.getToken(Cobol85Parser.ZERO_FILL, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenDescriptionZeroFillClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenDescriptionZeroFillClause" ): + listener.enterScreenDescriptionZeroFillClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenDescriptionZeroFillClause" ): + listener.exitScreenDescriptionZeroFillClause(self) + + + + + def screenDescriptionZeroFillClause(self): + + localctx = Cobol85Parser.ScreenDescriptionZeroFillClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 318, self.RULE_screenDescriptionZeroFillClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2703 + self.match(Cobol85Parser.ZERO_FILL) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportSectionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REPORT(self): + return self.getToken(Cobol85Parser.REPORT, 0) + + def SECTION(self): + return self.getToken(Cobol85Parser.SECTION, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def reportDescription(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportDescriptionContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportDescriptionContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportSection + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportSection" ): + listener.enterReportSection(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportSection" ): + listener.exitReportSection(self) + + + + + def reportSection(self): + + localctx = Cobol85Parser.ReportSectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 320, self.RULE_reportSection) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2705 + self.match(Cobol85Parser.REPORT) + self.state = 2706 + self.match(Cobol85Parser.SECTION) + self.state = 2707 + self.match(Cobol85Parser.DOT_FS) + self.state = 2711 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==372: + self.state = 2708 + self.reportDescription() + self.state = 2713 + 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 ReportDescriptionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def reportDescriptionEntry(self): + return self.getTypedRuleContext(Cobol85Parser.ReportDescriptionEntryContext,0) + + + def reportGroupDescriptionEntry(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportGroupDescriptionEntryContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportGroupDescriptionEntryContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportDescription + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportDescription" ): + listener.enterReportDescription(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportDescription" ): + listener.exitReportDescription(self) + + + + + def reportDescription(self): + + localctx = Cobol85Parser.ReportDescriptionContext(self, self._ctx, self.state) + self.enterRule(localctx, 322, self.RULE_reportDescription) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2714 + self.reportDescriptionEntry() + self.state = 2716 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 2715 + self.reportGroupDescriptionEntry() + self.state = 2718 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 15) != 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 ReportDescriptionEntryContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RD(self): + return self.getToken(Cobol85Parser.RD, 0) + + def reportName(self): + return self.getTypedRuleContext(Cobol85Parser.ReportNameContext,0) + + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def reportDescriptionGlobalClause(self): + return self.getTypedRuleContext(Cobol85Parser.ReportDescriptionGlobalClauseContext,0) + + + def reportDescriptionPageLimitClause(self): + return self.getTypedRuleContext(Cobol85Parser.ReportDescriptionPageLimitClauseContext,0) + + + def reportDescriptionHeadingClause(self): + return self.getTypedRuleContext(Cobol85Parser.ReportDescriptionHeadingClauseContext,0) + + + def reportDescriptionFirstDetailClause(self): + return self.getTypedRuleContext(Cobol85Parser.ReportDescriptionFirstDetailClauseContext,0) + + + def reportDescriptionLastDetailClause(self): + return self.getTypedRuleContext(Cobol85Parser.ReportDescriptionLastDetailClauseContext,0) + + + def reportDescriptionFootingClause(self): + return self.getTypedRuleContext(Cobol85Parser.ReportDescriptionFootingClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportDescriptionEntry + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportDescriptionEntry" ): + listener.enterReportDescriptionEntry(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportDescriptionEntry" ): + listener.exitReportDescriptionEntry(self) + + + + + def reportDescriptionEntry(self): + + localctx = Cobol85Parser.ReportDescriptionEntryContext(self, self._ctx, self.state) + self.enterRule(localctx, 324, self.RULE_reportDescriptionEntry) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2720 + self.match(Cobol85Parser.RD) + self.state = 2721 + self.reportName() + self.state = 2723 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==223 or _la==254: + self.state = 2722 + self.reportDescriptionGlobalClause() + + + self.state = 2738 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==340: + self.state = 2725 + self.reportDescriptionPageLimitClause() + self.state = 2727 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==228: + self.state = 2726 + self.reportDescriptionHeadingClause() + + + self.state = 2730 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==210: + self.state = 2729 + self.reportDescriptionFirstDetailClause() + + + self.state = 2733 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==263: + self.state = 2732 + self.reportDescriptionLastDetailClause() + + + self.state = 2736 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==211: + self.state = 2735 + self.reportDescriptionFootingClause() + + + + + self.state = 2740 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportDescriptionGlobalClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GLOBAL(self): + return self.getToken(Cobol85Parser.GLOBAL, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportDescriptionGlobalClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportDescriptionGlobalClause" ): + listener.enterReportDescriptionGlobalClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportDescriptionGlobalClause" ): + listener.exitReportDescriptionGlobalClause(self) + + + + + def reportDescriptionGlobalClause(self): + + localctx = Cobol85Parser.ReportDescriptionGlobalClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 326, self.RULE_reportDescriptionGlobalClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2743 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2742 + self.match(Cobol85Parser.IS) + + + self.state = 2745 + self.match(Cobol85Parser.GLOBAL) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportDescriptionPageLimitClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PAGE(self): + return self.getToken(Cobol85Parser.PAGE, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def LIMIT(self): + return self.getToken(Cobol85Parser.LIMIT, 0) + + def LIMITS(self): + return self.getToken(Cobol85Parser.LIMITS, 0) + + def LINE(self): + return self.getToken(Cobol85Parser.LINE, 0) + + def LINES(self): + return self.getToken(Cobol85Parser.LINES, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def ARE(self): + return self.getToken(Cobol85Parser.ARE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportDescriptionPageLimitClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportDescriptionPageLimitClause" ): + listener.enterReportDescriptionPageLimitClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportDescriptionPageLimitClause" ): + listener.exitReportDescriptionPageLimitClause(self) + + + + + def reportDescriptionPageLimitClause(self): + + localctx = Cobol85Parser.ReportDescriptionPageLimitClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 328, self.RULE_reportDescriptionPageLimitClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2747 + self.match(Cobol85Parser.PAGE) + self.state = 2756 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [275]: + self.state = 2748 + self.match(Cobol85Parser.LIMIT) + self.state = 2750 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2749 + self.match(Cobol85Parser.IS) + + + pass + elif token in [276]: + self.state = 2752 + self.match(Cobol85Parser.LIMITS) + self.state = 2754 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==21: + self.state = 2753 + self.match(Cobol85Parser.ARE) + + + pass + elif token in [552, 553, 554, 555]: + pass + else: + pass + self.state = 2758 + self.integerLiteral() + self.state = 2760 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==279 or _la==280: + self.state = 2759 + _la = self._input.LA(1) + if not(_la==279 or _la==280): + 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 ReportDescriptionHeadingClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def HEADING(self): + return self.getToken(Cobol85Parser.HEADING, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportDescriptionHeadingClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportDescriptionHeadingClause" ): + listener.enterReportDescriptionHeadingClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportDescriptionHeadingClause" ): + listener.exitReportDescriptionHeadingClause(self) + + + + + def reportDescriptionHeadingClause(self): + + localctx = Cobol85Parser.ReportDescriptionHeadingClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 330, self.RULE_reportDescriptionHeadingClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2762 + self.match(Cobol85Parser.HEADING) + self.state = 2763 + self.integerLiteral() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportDescriptionFirstDetailClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FIRST(self): + return self.getToken(Cobol85Parser.FIRST, 0) + + def DETAIL(self): + return self.getToken(Cobol85Parser.DETAIL, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportDescriptionFirstDetailClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportDescriptionFirstDetailClause" ): + listener.enterReportDescriptionFirstDetailClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportDescriptionFirstDetailClause" ): + listener.exitReportDescriptionFirstDetailClause(self) + + + + + def reportDescriptionFirstDetailClause(self): + + localctx = Cobol85Parser.ReportDescriptionFirstDetailClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 332, self.RULE_reportDescriptionFirstDetailClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2765 + self.match(Cobol85Parser.FIRST) + self.state = 2766 + self.match(Cobol85Parser.DETAIL) + self.state = 2767 + self.integerLiteral() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportDescriptionLastDetailClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LAST(self): + return self.getToken(Cobol85Parser.LAST, 0) + + def DETAIL(self): + return self.getToken(Cobol85Parser.DETAIL, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportDescriptionLastDetailClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportDescriptionLastDetailClause" ): + listener.enterReportDescriptionLastDetailClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportDescriptionLastDetailClause" ): + listener.exitReportDescriptionLastDetailClause(self) + + + + + def reportDescriptionLastDetailClause(self): + + localctx = Cobol85Parser.ReportDescriptionLastDetailClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 334, self.RULE_reportDescriptionLastDetailClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2769 + self.match(Cobol85Parser.LAST) + self.state = 2770 + self.match(Cobol85Parser.DETAIL) + self.state = 2771 + self.integerLiteral() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportDescriptionFootingClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FOOTING(self): + return self.getToken(Cobol85Parser.FOOTING, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportDescriptionFootingClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportDescriptionFootingClause" ): + listener.enterReportDescriptionFootingClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportDescriptionFootingClause" ): + listener.exitReportDescriptionFootingClause(self) + + + + + def reportDescriptionFootingClause(self): + + localctx = Cobol85Parser.ReportDescriptionFootingClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 336, self.RULE_reportDescriptionFootingClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2773 + self.match(Cobol85Parser.FOOTING) + self.state = 2774 + self.integerLiteral() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupDescriptionEntryContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def reportGroupDescriptionEntryFormat1(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupDescriptionEntryFormat1Context,0) + + + def reportGroupDescriptionEntryFormat2(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupDescriptionEntryFormat2Context,0) + + + def reportGroupDescriptionEntryFormat3(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupDescriptionEntryFormat3Context,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupDescriptionEntry + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupDescriptionEntry" ): + listener.enterReportGroupDescriptionEntry(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupDescriptionEntry" ): + listener.exitReportGroupDescriptionEntry(self) + + + + + def reportGroupDescriptionEntry(self): + + localctx = Cobol85Parser.ReportGroupDescriptionEntryContext(self, self._ctx, self.state) + self.enterRule(localctx, 338, self.RULE_reportGroupDescriptionEntry) + try: + self.state = 2779 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,314,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 2776 + self.reportGroupDescriptionEntryFormat1() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 2777 + self.reportGroupDescriptionEntryFormat2() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 2778 + self.reportGroupDescriptionEntryFormat3() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupDescriptionEntryFormat1Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def reportGroupTypeClause(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupTypeClauseContext,0) + + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def reportGroupLineNumberClause(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupLineNumberClauseContext,0) + + + def reportGroupNextGroupClause(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupNextGroupClauseContext,0) + + + def reportGroupUsageClause(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupUsageClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupDescriptionEntryFormat1 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupDescriptionEntryFormat1" ): + listener.enterReportGroupDescriptionEntryFormat1(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupDescriptionEntryFormat1" ): + listener.exitReportGroupDescriptionEntryFormat1(self) + + + + + def reportGroupDescriptionEntryFormat1(self): + + localctx = Cobol85Parser.ReportGroupDescriptionEntryFormat1Context(self, self._ctx, self.state) + self.enterRule(localctx, 340, self.RULE_reportGroupDescriptionEntryFormat1) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2781 + self.integerLiteral() + self.state = 2782 + self.dataName() + self.state = 2784 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ((((_la - 254)) & ~0x3f) == 0 and ((1 << (_la - 254)) & 2305843009247248385) != 0) or _la==348 or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 15) != 0): + self.state = 2783 + self.reportGroupLineNumberClause() + + + self.state = 2787 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==309: + self.state = 2786 + self.reportGroupNextGroupClause() + + + self.state = 2789 + self.reportGroupTypeClause() + self.state = 2791 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==142 or _la==143 or _la==504: + self.state = 2790 + self.reportGroupUsageClause() + + + self.state = 2793 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupDescriptionEntryFormat2Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def reportGroupUsageClause(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupUsageClauseContext,0) + + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def reportGroupLineNumberClause(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupLineNumberClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupDescriptionEntryFormat2 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupDescriptionEntryFormat2" ): + listener.enterReportGroupDescriptionEntryFormat2(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupDescriptionEntryFormat2" ): + listener.exitReportGroupDescriptionEntryFormat2(self) + + + + + def reportGroupDescriptionEntryFormat2(self): + + localctx = Cobol85Parser.ReportGroupDescriptionEntryFormat2Context(self, self._ctx, self.state) + self.enterRule(localctx, 342, self.RULE_reportGroupDescriptionEntryFormat2) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2795 + self.integerLiteral() + self.state = 2797 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557: + self.state = 2796 + self.dataName() + + + self.state = 2800 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ((((_la - 254)) & ~0x3f) == 0 and ((1 << (_la - 254)) & 2305843009247248385) != 0) or _la==348 or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 15) != 0): + self.state = 2799 + self.reportGroupLineNumberClause() + + + self.state = 2802 + self.reportGroupUsageClause() + self.state = 2803 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupDescriptionEntryFormat3Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def reportGroupPictureClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportGroupPictureClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportGroupPictureClauseContext,i) + + + def reportGroupUsageClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportGroupUsageClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportGroupUsageClauseContext,i) + + + def reportGroupSignClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportGroupSignClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportGroupSignClauseContext,i) + + + def reportGroupJustifiedClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportGroupJustifiedClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportGroupJustifiedClauseContext,i) + + + def reportGroupBlankWhenZeroClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportGroupBlankWhenZeroClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportGroupBlankWhenZeroClauseContext,i) + + + def reportGroupLineNumberClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportGroupLineNumberClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportGroupLineNumberClauseContext,i) + + + def reportGroupColumnNumberClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportGroupColumnNumberClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportGroupColumnNumberClauseContext,i) + + + def reportGroupIndicateClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportGroupIndicateClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportGroupIndicateClauseContext,i) + + + def reportGroupSourceClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportGroupSourceClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportGroupSourceClauseContext,i) + + + def reportGroupValueClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportGroupValueClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportGroupValueClauseContext,i) + + + def reportGroupSumClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportGroupSumClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportGroupSumClauseContext,i) + + + def reportGroupResetClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportGroupResetClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportGroupResetClauseContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupDescriptionEntryFormat3 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupDescriptionEntryFormat3" ): + listener.enterReportGroupDescriptionEntryFormat3(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupDescriptionEntryFormat3" ): + listener.exitReportGroupDescriptionEntryFormat3(self) + + + + + def reportGroupDescriptionEntryFormat3(self): + + localctx = Cobol85Parser.ReportGroupDescriptionEntryFormat3Context(self, self._ctx, self.state) + self.enterRule(localctx, 344, self.RULE_reportGroupDescriptionEntryFormat3) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2805 + self.integerLiteral() + self.state = 2807 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557: + self.state = 2806 + self.dataName() + + + self.state = 2825 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==44 or _la==74 or _la==142 or _la==143 or ((((_la - 227)) & ~0x3f) == 0 and ((1 << (_la - 227)) & 4503600566894593) != 0) or ((((_la - 315)) & ~0x3f) == 0 and ((1 << (_la - 315)) & 15032385537) != 0) or ((((_la - 402)) & ~0x3f) == 0 and ((1 << (_la - 402)) & 4611756455891042305) != 0) or ((((_la - 504)) & ~0x3f) == 0 and ((1 << (_la - 504)) & 4222124650659849) != 0): + self.state = 2823 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [346, 347]: + self.state = 2809 + self.reportGroupPictureClause() + pass + elif token in [142, 143, 504]: + self.state = 2810 + self.reportGroupUsageClause() + pass + elif token in [438]: + self.state = 2811 + self.reportGroupSignClause() + pass + elif token in [255, 256]: + self.state = 2812 + self.reportGroupJustifiedClause() + pass + elif token in [44]: + self.state = 2813 + self.reportGroupBlankWhenZeroClause() + pass + elif token in [254, 279, 315, 348, 552, 553, 554, 555]: + self.state = 2814 + self.reportGroupLineNumberClause() + pass + elif token in [74]: + self.state = 2815 + self.reportGroupColumnNumberClause() + pass + elif token in [402, 448, 464, 507]: + self.state = 2820 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [448]: + self.state = 2816 + self.reportGroupSourceClause() + pass + elif token in [507]: + self.state = 2817 + self.reportGroupValueClause() + pass + elif token in [464]: + self.state = 2818 + self.reportGroupSumClause() + pass + elif token in [402]: + self.state = 2819 + self.reportGroupResetClause() + pass + else: + raise NoViableAltException(self) + + pass + elif token in [227]: + self.state = 2822 + self.reportGroupIndicateClause() + pass + else: + raise NoViableAltException(self) + + self.state = 2827 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 2828 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupBlankWhenZeroClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BLANK(self): + return self.getToken(Cobol85Parser.BLANK, 0) + + def ZERO(self): + return self.getToken(Cobol85Parser.ZERO, 0) + + def WHEN(self): + return self.getToken(Cobol85Parser.WHEN, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupBlankWhenZeroClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupBlankWhenZeroClause" ): + listener.enterReportGroupBlankWhenZeroClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupBlankWhenZeroClause" ): + listener.exitReportGroupBlankWhenZeroClause(self) + + + + + def reportGroupBlankWhenZeroClause(self): + + localctx = Cobol85Parser.ReportGroupBlankWhenZeroClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 346, self.RULE_reportGroupBlankWhenZeroClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2830 + self.match(Cobol85Parser.BLANK) + self.state = 2832 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==512: + self.state = 2831 + self.match(Cobol85Parser.WHEN) + + + self.state = 2834 + self.match(Cobol85Parser.ZERO) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupColumnNumberClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def COLUMN(self): + return self.getToken(Cobol85Parser.COLUMN, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def NUMBER(self): + return self.getToken(Cobol85Parser.NUMBER, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupColumnNumberClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupColumnNumberClause" ): + listener.enterReportGroupColumnNumberClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupColumnNumberClause" ): + listener.exitReportGroupColumnNumberClause(self) + + + + + def reportGroupColumnNumberClause(self): + + localctx = Cobol85Parser.ReportGroupColumnNumberClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 348, self.RULE_reportGroupColumnNumberClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2836 + self.match(Cobol85Parser.COLUMN) + self.state = 2838 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==315: + self.state = 2837 + self.match(Cobol85Parser.NUMBER) + + + self.state = 2841 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2840 + self.match(Cobol85Parser.IS) + + + self.state = 2843 + self.integerLiteral() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupIndicateClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GROUP(self): + return self.getToken(Cobol85Parser.GROUP, 0) + + def INDICATE(self): + return self.getToken(Cobol85Parser.INDICATE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupIndicateClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupIndicateClause" ): + listener.enterReportGroupIndicateClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupIndicateClause" ): + listener.exitReportGroupIndicateClause(self) + + + + + def reportGroupIndicateClause(self): + + localctx = Cobol85Parser.ReportGroupIndicateClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 350, self.RULE_reportGroupIndicateClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2845 + self.match(Cobol85Parser.GROUP) + self.state = 2847 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==242: + self.state = 2846 + self.match(Cobol85Parser.INDICATE) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupJustifiedClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def JUSTIFIED(self): + return self.getToken(Cobol85Parser.JUSTIFIED, 0) + + def JUST(self): + return self.getToken(Cobol85Parser.JUST, 0) + + def RIGHT(self): + return self.getToken(Cobol85Parser.RIGHT, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupJustifiedClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupJustifiedClause" ): + listener.enterReportGroupJustifiedClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupJustifiedClause" ): + listener.exitReportGroupJustifiedClause(self) + + + + + def reportGroupJustifiedClause(self): + + localctx = Cobol85Parser.ReportGroupJustifiedClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 352, self.RULE_reportGroupJustifiedClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2849 + _la = self._input.LA(1) + if not(_la==255 or _la==256): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2851 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==411: + self.state = 2850 + self.match(Cobol85Parser.RIGHT) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupLineNumberClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def reportGroupLineNumberNextPage(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupLineNumberNextPageContext,0) + + + def reportGroupLineNumberPlus(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupLineNumberPlusContext,0) + + + def LINE(self): + return self.getToken(Cobol85Parser.LINE, 0) + + def NUMBER(self): + return self.getToken(Cobol85Parser.NUMBER, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupLineNumberClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupLineNumberClause" ): + listener.enterReportGroupLineNumberClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupLineNumberClause" ): + listener.exitReportGroupLineNumberClause(self) + + + + + def reportGroupLineNumberClause(self): + + localctx = Cobol85Parser.ReportGroupLineNumberClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 354, self.RULE_reportGroupLineNumberClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2854 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==279: + self.state = 2853 + self.match(Cobol85Parser.LINE) + + + self.state = 2857 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==315: + self.state = 2856 + self.match(Cobol85Parser.NUMBER) + + + self.state = 2860 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2859 + self.match(Cobol85Parser.IS) + + + self.state = 2864 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [552, 553, 554, 555]: + self.state = 2862 + self.reportGroupLineNumberNextPage() + pass + elif token in [348]: + self.state = 2863 + self.reportGroupLineNumberPlus() + 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 ReportGroupLineNumberNextPageContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def NEXT(self): + return self.getToken(Cobol85Parser.NEXT, 0) + + def PAGE(self): + return self.getToken(Cobol85Parser.PAGE, 0) + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupLineNumberNextPage + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupLineNumberNextPage" ): + listener.enterReportGroupLineNumberNextPage(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupLineNumberNextPage" ): + listener.exitReportGroupLineNumberNextPage(self) + + + + + def reportGroupLineNumberNextPage(self): + + localctx = Cobol85Parser.ReportGroupLineNumberNextPageContext(self, self._ctx, self.state) + self.enterRule(localctx, 356, self.RULE_reportGroupLineNumberNextPage) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2866 + self.integerLiteral() + self.state = 2872 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,334,self._ctx) + if la_ == 1: + self.state = 2868 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 2867 + self.match(Cobol85Parser.ON) + + + self.state = 2870 + self.match(Cobol85Parser.NEXT) + self.state = 2871 + self.match(Cobol85Parser.PAGE) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupLineNumberPlusContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PLUS(self): + return self.getToken(Cobol85Parser.PLUS, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupLineNumberPlus + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupLineNumberPlus" ): + listener.enterReportGroupLineNumberPlus(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupLineNumberPlus" ): + listener.exitReportGroupLineNumberPlus(self) + + + + + def reportGroupLineNumberPlus(self): + + localctx = Cobol85Parser.ReportGroupLineNumberPlusContext(self, self._ctx, self.state) + self.enterRule(localctx, 358, self.RULE_reportGroupLineNumberPlus) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2874 + self.match(Cobol85Parser.PLUS) + self.state = 2875 + self.integerLiteral() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupNextGroupClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NEXT(self): + return self.getToken(Cobol85Parser.NEXT, 0) + + def GROUP(self): + return self.getToken(Cobol85Parser.GROUP, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def reportGroupNextGroupNextPage(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupNextGroupNextPageContext,0) + + + def reportGroupNextGroupPlus(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupNextGroupPlusContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupNextGroupClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupNextGroupClause" ): + listener.enterReportGroupNextGroupClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupNextGroupClause" ): + listener.exitReportGroupNextGroupClause(self) + + + + + def reportGroupNextGroupClause(self): + + localctx = Cobol85Parser.ReportGroupNextGroupClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 360, self.RULE_reportGroupNextGroupClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2877 + self.match(Cobol85Parser.NEXT) + self.state = 2878 + self.match(Cobol85Parser.GROUP) + self.state = 2880 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2879 + self.match(Cobol85Parser.IS) + + + self.state = 2885 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [552, 553, 554, 555]: + self.state = 2882 + self.integerLiteral() + pass + elif token in [309]: + self.state = 2883 + self.reportGroupNextGroupNextPage() + pass + elif token in [348]: + self.state = 2884 + self.reportGroupNextGroupPlus() + 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 ReportGroupNextGroupPlusContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PLUS(self): + return self.getToken(Cobol85Parser.PLUS, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupNextGroupPlus + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupNextGroupPlus" ): + listener.enterReportGroupNextGroupPlus(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupNextGroupPlus" ): + listener.exitReportGroupNextGroupPlus(self) + + + + + def reportGroupNextGroupPlus(self): + + localctx = Cobol85Parser.ReportGroupNextGroupPlusContext(self, self._ctx, self.state) + self.enterRule(localctx, 362, self.RULE_reportGroupNextGroupPlus) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2887 + self.match(Cobol85Parser.PLUS) + self.state = 2888 + self.integerLiteral() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupNextGroupNextPageContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NEXT(self): + return self.getToken(Cobol85Parser.NEXT, 0) + + def PAGE(self): + return self.getToken(Cobol85Parser.PAGE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupNextGroupNextPage + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupNextGroupNextPage" ): + listener.enterReportGroupNextGroupNextPage(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupNextGroupNextPage" ): + listener.exitReportGroupNextGroupNextPage(self) + + + + + def reportGroupNextGroupNextPage(self): + + localctx = Cobol85Parser.ReportGroupNextGroupNextPageContext(self, self._ctx, self.state) + self.enterRule(localctx, 364, self.RULE_reportGroupNextGroupNextPage) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2890 + self.match(Cobol85Parser.NEXT) + self.state = 2891 + self.match(Cobol85Parser.PAGE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupPictureClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def pictureString(self): + return self.getTypedRuleContext(Cobol85Parser.PictureStringContext,0) + + + def PICTURE(self): + return self.getToken(Cobol85Parser.PICTURE, 0) + + def PIC(self): + return self.getToken(Cobol85Parser.PIC, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupPictureClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupPictureClause" ): + listener.enterReportGroupPictureClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupPictureClause" ): + listener.exitReportGroupPictureClause(self) + + + + + def reportGroupPictureClause(self): + + localctx = Cobol85Parser.ReportGroupPictureClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 366, self.RULE_reportGroupPictureClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2893 + _la = self._input.LA(1) + if not(_la==346 or _la==347): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2895 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2894 + self.match(Cobol85Parser.IS) + + + self.state = 2897 + self.pictureString() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupResetClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RESET(self): + return self.getToken(Cobol85Parser.RESET, 0) + + def FINAL(self): + return self.getToken(Cobol85Parser.FINAL, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupResetClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupResetClause" ): + listener.enterReportGroupResetClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupResetClause" ): + listener.exitReportGroupResetClause(self) + + + + + def reportGroupResetClause(self): + + localctx = Cobol85Parser.ReportGroupResetClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 368, self.RULE_reportGroupResetClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2899 + self.match(Cobol85Parser.RESET) + self.state = 2901 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 2900 + self.match(Cobol85Parser.ON) + + + self.state = 2905 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [209]: + self.state = 2903 + self.match(Cobol85Parser.FINAL) + pass + elif token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.state = 2904 + self.dataName() + 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 ReportGroupSignClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SIGN(self): + return self.getToken(Cobol85Parser.SIGN, 0) + + def SEPARATE(self): + return self.getToken(Cobol85Parser.SEPARATE, 0) + + def LEADING(self): + return self.getToken(Cobol85Parser.LEADING, 0) + + def TRAILING(self): + return self.getToken(Cobol85Parser.TRAILING, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def CHARACTER(self): + return self.getToken(Cobol85Parser.CHARACTER, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupSignClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupSignClause" ): + listener.enterReportGroupSignClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupSignClause" ): + listener.exitReportGroupSignClause(self) + + + + + def reportGroupSignClause(self): + + localctx = Cobol85Parser.ReportGroupSignClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 370, self.RULE_reportGroupSignClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2907 + self.match(Cobol85Parser.SIGN) + self.state = 2909 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2908 + self.match(Cobol85Parser.IS) + + + self.state = 2911 + _la = self._input.LA(1) + if not(_la==266 or _la==493): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 2912 + self.match(Cobol85Parser.SEPARATE) + self.state = 2914 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==62: + self.state = 2913 + self.match(Cobol85Parser.CHARACTER) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupSourceClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SOURCE(self): + return self.getToken(Cobol85Parser.SOURCE, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupSourceClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupSourceClause" ): + listener.enterReportGroupSourceClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupSourceClause" ): + listener.exitReportGroupSourceClause(self) + + + + + def reportGroupSourceClause(self): + + localctx = Cobol85Parser.ReportGroupSourceClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 372, self.RULE_reportGroupSourceClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2916 + self.match(Cobol85Parser.SOURCE) + self.state = 2918 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2917 + self.match(Cobol85Parser.IS) + + + self.state = 2920 + 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 ReportGroupSumClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SUM(self): + return self.getToken(Cobol85Parser.SUM, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.IdentifierContext) + else: + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,i) + + + def UPON(self): + return self.getToken(Cobol85Parser.UPON, 0) + + def dataName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,i) + + + def COMMACHAR(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.COMMACHAR) + else: + return self.getToken(Cobol85Parser.COMMACHAR, i) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupSumClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupSumClause" ): + listener.enterReportGroupSumClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupSumClause" ): + listener.exitReportGroupSumClause(self) + + + + + def reportGroupSumClause(self): + + localctx = Cobol85Parser.ReportGroupSumClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 374, self.RULE_reportGroupSumClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2922 + self.match(Cobol85Parser.SUM) + self.state = 2923 + self.identifier() + self.state = 2930 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,344,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 2925 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==529: + self.state = 2924 + self.match(Cobol85Parser.COMMACHAR) + + + self.state = 2927 + self.identifier() + self.state = 2932 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,344,self._ctx) + + self.state = 2944 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==503: + self.state = 2933 + self.match(Cobol85Parser.UPON) + self.state = 2934 + self.dataName() + self.state = 2941 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & -9119736461836320639) != 0) or _la==557: + self.state = 2936 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==529: + self.state = 2935 + self.match(Cobol85Parser.COMMACHAR) + + + self.state = 2938 + self.dataName() + self.state = 2943 + 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 ReportGroupTypeClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TYPE(self): + return self.getToken(Cobol85Parser.TYPE, 0) + + def reportGroupTypeReportHeading(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupTypeReportHeadingContext,0) + + + def reportGroupTypePageHeading(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupTypePageHeadingContext,0) + + + def reportGroupTypeControlHeading(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupTypeControlHeadingContext,0) + + + def reportGroupTypeDetail(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupTypeDetailContext,0) + + + def reportGroupTypeControlFooting(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupTypeControlFootingContext,0) + + + def reportGroupTypePageFooting(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupTypePageFootingContext,0) + + + def reportGroupTypeReportFooting(self): + return self.getTypedRuleContext(Cobol85Parser.ReportGroupTypeReportFootingContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupTypeClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupTypeClause" ): + listener.enterReportGroupTypeClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupTypeClause" ): + listener.exitReportGroupTypeClause(self) + + + + + def reportGroupTypeClause(self): + + localctx = Cobol85Parser.ReportGroupTypeClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 376, self.RULE_reportGroupTypeClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2946 + self.match(Cobol85Parser.TYPE) + self.state = 2948 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2947 + self.match(Cobol85Parser.IS) + + + self.state = 2957 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,349,self._ctx) + if la_ == 1: + self.state = 2950 + self.reportGroupTypeReportHeading() + pass + + elif la_ == 2: + self.state = 2951 + self.reportGroupTypePageHeading() + pass + + elif la_ == 3: + self.state = 2952 + self.reportGroupTypeControlHeading() + pass + + elif la_ == 4: + self.state = 2953 + self.reportGroupTypeDetail() + pass + + elif la_ == 5: + self.state = 2954 + self.reportGroupTypeControlFooting() + pass + + elif la_ == 6: + self.state = 2955 + self.reportGroupTypePageFooting() + pass + + elif la_ == 7: + self.state = 2956 + self.reportGroupTypeReportFooting() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportGroupTypeReportHeadingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REPORT(self): + return self.getToken(Cobol85Parser.REPORT, 0) + + def HEADING(self): + return self.getToken(Cobol85Parser.HEADING, 0) + + def RH(self): + return self.getToken(Cobol85Parser.RH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupTypeReportHeading + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupTypeReportHeading" ): + listener.enterReportGroupTypeReportHeading(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupTypeReportHeading" ): + listener.exitReportGroupTypeReportHeading(self) + + + + + def reportGroupTypeReportHeading(self): + + localctx = Cobol85Parser.ReportGroupTypeReportHeadingContext(self, self._ctx, self.state) + self.enterRule(localctx, 378, self.RULE_reportGroupTypeReportHeading) + try: + self.state = 2962 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [395]: + self.enterOuterAlt(localctx, 1) + self.state = 2959 + self.match(Cobol85Parser.REPORT) + self.state = 2960 + self.match(Cobol85Parser.HEADING) + pass + elif token in [410]: + self.enterOuterAlt(localctx, 2) + self.state = 2961 + self.match(Cobol85Parser.RH) + 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 ReportGroupTypePageHeadingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PAGE(self): + return self.getToken(Cobol85Parser.PAGE, 0) + + def HEADING(self): + return self.getToken(Cobol85Parser.HEADING, 0) + + def PH(self): + return self.getToken(Cobol85Parser.PH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupTypePageHeading + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupTypePageHeading" ): + listener.enterReportGroupTypePageHeading(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupTypePageHeading" ): + listener.exitReportGroupTypePageHeading(self) + + + + + def reportGroupTypePageHeading(self): + + localctx = Cobol85Parser.ReportGroupTypePageHeadingContext(self, self._ctx, self.state) + self.enterRule(localctx, 380, self.RULE_reportGroupTypePageHeading) + try: + self.state = 2967 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [340]: + self.enterOuterAlt(localctx, 1) + self.state = 2964 + self.match(Cobol85Parser.PAGE) + self.state = 2965 + self.match(Cobol85Parser.HEADING) + pass + elif token in [345]: + self.enterOuterAlt(localctx, 2) + self.state = 2966 + self.match(Cobol85Parser.PH) + 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 ReportGroupTypeControlHeadingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CONTROL(self): + return self.getToken(Cobol85Parser.CONTROL, 0) + + def HEADING(self): + return self.getToken(Cobol85Parser.HEADING, 0) + + def CH(self): + return self.getToken(Cobol85Parser.CH, 0) + + def FINAL(self): + return self.getToken(Cobol85Parser.FINAL, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupTypeControlHeading + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupTypeControlHeading" ): + listener.enterReportGroupTypeControlHeading(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupTypeControlHeading" ): + listener.exitReportGroupTypeControlHeading(self) + + + + + def reportGroupTypeControlHeading(self): + + localctx = Cobol85Parser.ReportGroupTypeControlHeadingContext(self, self._ctx, self.state) + self.enterRule(localctx, 382, self.RULE_reportGroupTypeControlHeading) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2972 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [97]: + self.state = 2969 + self.match(Cobol85Parser.CONTROL) + self.state = 2970 + self.match(Cobol85Parser.HEADING) + pass + elif token in [58]: + self.state = 2971 + self.match(Cobol85Parser.CH) + pass + else: + raise NoViableAltException(self) + + self.state = 2976 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [209]: + self.state = 2974 + self.match(Cobol85Parser.FINAL) + pass + elif token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.state = 2975 + self.dataName() + 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 ReportGroupTypeDetailContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DETAIL(self): + return self.getToken(Cobol85Parser.DETAIL, 0) + + def DE(self): + return self.getToken(Cobol85Parser.DE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupTypeDetail + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupTypeDetail" ): + listener.enterReportGroupTypeDetail(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupTypeDetail" ): + listener.exitReportGroupTypeDetail(self) + + + + + def reportGroupTypeDetail(self): + + localctx = Cobol85Parser.ReportGroupTypeDetailContext(self, self._ctx, self.state) + self.enterRule(localctx, 384, self.RULE_reportGroupTypeDetail) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2978 + _la = self._input.LA(1) + if not(_la==117 or _la==137): + 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 ReportGroupTypeControlFootingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CONTROL(self): + return self.getToken(Cobol85Parser.CONTROL, 0) + + def FOOTING(self): + return self.getToken(Cobol85Parser.FOOTING, 0) + + def CF(self): + return self.getToken(Cobol85Parser.CF, 0) + + def FINAL(self): + return self.getToken(Cobol85Parser.FINAL, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupTypeControlFooting + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupTypeControlFooting" ): + listener.enterReportGroupTypeControlFooting(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupTypeControlFooting" ): + listener.exitReportGroupTypeControlFooting(self) + + + + + def reportGroupTypeControlFooting(self): + + localctx = Cobol85Parser.ReportGroupTypeControlFootingContext(self, self._ctx, self.state) + self.enterRule(localctx, 386, self.RULE_reportGroupTypeControlFooting) + try: + self.enterOuterAlt(localctx, 1) + self.state = 2983 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [97]: + self.state = 2980 + self.match(Cobol85Parser.CONTROL) + self.state = 2981 + self.match(Cobol85Parser.FOOTING) + pass + elif token in [57]: + self.state = 2982 + self.match(Cobol85Parser.CF) + pass + else: + raise NoViableAltException(self) + + self.state = 2987 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [209]: + self.state = 2985 + self.match(Cobol85Parser.FINAL) + pass + elif token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.state = 2986 + self.dataName() + 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 ReportGroupUsageClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DISPLAY(self): + return self.getToken(Cobol85Parser.DISPLAY, 0) + + def DISPLAY_1(self): + return self.getToken(Cobol85Parser.DISPLAY_1, 0) + + def USAGE(self): + return self.getToken(Cobol85Parser.USAGE, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupUsageClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupUsageClause" ): + listener.enterReportGroupUsageClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupUsageClause" ): + listener.exitReportGroupUsageClause(self) + + + + + def reportGroupUsageClause(self): + + localctx = Cobol85Parser.ReportGroupUsageClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 388, self.RULE_reportGroupUsageClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 2993 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==504: + self.state = 2989 + self.match(Cobol85Parser.USAGE) + self.state = 2991 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 2990 + self.match(Cobol85Parser.IS) + + + + + self.state = 2995 + _la = self._input.LA(1) + if not(_la==142 or _la==143): + 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 ReportGroupTypePageFootingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PAGE(self): + return self.getToken(Cobol85Parser.PAGE, 0) + + def FOOTING(self): + return self.getToken(Cobol85Parser.FOOTING, 0) + + def PF(self): + return self.getToken(Cobol85Parser.PF, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupTypePageFooting + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupTypePageFooting" ): + listener.enterReportGroupTypePageFooting(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupTypePageFooting" ): + listener.exitReportGroupTypePageFooting(self) + + + + + def reportGroupTypePageFooting(self): + + localctx = Cobol85Parser.ReportGroupTypePageFootingContext(self, self._ctx, self.state) + self.enterRule(localctx, 390, self.RULE_reportGroupTypePageFooting) + try: + self.state = 3000 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [340]: + self.enterOuterAlt(localctx, 1) + self.state = 2997 + self.match(Cobol85Parser.PAGE) + self.state = 2998 + self.match(Cobol85Parser.FOOTING) + pass + elif token in [344]: + self.enterOuterAlt(localctx, 2) + self.state = 2999 + self.match(Cobol85Parser.PF) + 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 ReportGroupTypeReportFootingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REPORT(self): + return self.getToken(Cobol85Parser.REPORT, 0) + + def FOOTING(self): + return self.getToken(Cobol85Parser.FOOTING, 0) + + def RF(self): + return self.getToken(Cobol85Parser.RF, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupTypeReportFooting + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupTypeReportFooting" ): + listener.enterReportGroupTypeReportFooting(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupTypeReportFooting" ): + listener.exitReportGroupTypeReportFooting(self) + + + + + def reportGroupTypeReportFooting(self): + + localctx = Cobol85Parser.ReportGroupTypeReportFootingContext(self, self._ctx, self.state) + self.enterRule(localctx, 392, self.RULE_reportGroupTypeReportFooting) + try: + self.state = 3005 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [395]: + self.enterOuterAlt(localctx, 1) + self.state = 3002 + self.match(Cobol85Parser.REPORT) + self.state = 3003 + self.match(Cobol85Parser.FOOTING) + pass + elif token in [409]: + self.enterOuterAlt(localctx, 2) + self.state = 3004 + self.match(Cobol85Parser.RF) + 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 ReportGroupValueClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def VALUE(self): + return self.getToken(Cobol85Parser.VALUE, 0) + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportGroupValueClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportGroupValueClause" ): + listener.enterReportGroupValueClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportGroupValueClause" ): + listener.exitReportGroupValueClause(self) + + + + + def reportGroupValueClause(self): + + localctx = Cobol85Parser.ReportGroupValueClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 394, self.RULE_reportGroupValueClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3007 + self.match(Cobol85Parser.VALUE) + self.state = 3009 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3008 + self.match(Cobol85Parser.IS) + + + self.state = 3011 + self.literal() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ProgramLibrarySectionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PROGRAM_LIBRARY(self): + return self.getToken(Cobol85Parser.PROGRAM_LIBRARY, 0) + + def SECTION(self): + return self.getToken(Cobol85Parser.SECTION, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def libraryDescriptionEntry(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.LibraryDescriptionEntryContext) + else: + return self.getTypedRuleContext(Cobol85Parser.LibraryDescriptionEntryContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_programLibrarySection + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProgramLibrarySection" ): + listener.enterProgramLibrarySection(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProgramLibrarySection" ): + listener.exitProgramLibrarySection(self) + + + + + def programLibrarySection(self): + + localctx = Cobol85Parser.ProgramLibrarySectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 396, self.RULE_programLibrarySection) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3013 + self.match(Cobol85Parser.PROGRAM_LIBRARY) + self.state = 3014 + self.match(Cobol85Parser.SECTION) + self.state = 3015 + self.match(Cobol85Parser.DOT_FS) + self.state = 3019 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==264 or _la==265: + self.state = 3016 + self.libraryDescriptionEntry() + self.state = 3021 + 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 LibraryDescriptionEntryContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def libraryDescriptionEntryFormat1(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryDescriptionEntryFormat1Context,0) + + + def libraryDescriptionEntryFormat2(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryDescriptionEntryFormat2Context,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryDescriptionEntry + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryDescriptionEntry" ): + listener.enterLibraryDescriptionEntry(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryDescriptionEntry" ): + listener.exitLibraryDescriptionEntry(self) + + + + + def libraryDescriptionEntry(self): + + localctx = Cobol85Parser.LibraryDescriptionEntryContext(self, self._ctx, self.state) + self.enterRule(localctx, 398, self.RULE_libraryDescriptionEntry) + try: + self.state = 3024 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [265]: + self.enterOuterAlt(localctx, 1) + self.state = 3022 + self.libraryDescriptionEntryFormat1() + pass + elif token in [264]: + self.enterOuterAlt(localctx, 2) + self.state = 3023 + self.libraryDescriptionEntryFormat2() + 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 LibraryDescriptionEntryFormat1Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LD(self): + return self.getToken(Cobol85Parser.LD, 0) + + def libraryName(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryNameContext,0) + + + def EXPORT(self): + return self.getToken(Cobol85Parser.EXPORT, 0) + + def libraryAttributeClauseFormat1(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryAttributeClauseFormat1Context,0) + + + def libraryEntryProcedureClauseFormat1(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryEntryProcedureClauseFormat1Context,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryDescriptionEntryFormat1 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryDescriptionEntryFormat1" ): + listener.enterLibraryDescriptionEntryFormat1(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryDescriptionEntryFormat1" ): + listener.exitLibraryDescriptionEntryFormat1(self) + + + + + def libraryDescriptionEntryFormat1(self): + + localctx = Cobol85Parser.LibraryDescriptionEntryFormat1Context(self, self._ctx, self.state) + self.enterRule(localctx, 400, self.RULE_libraryDescriptionEntryFormat1) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3026 + self.match(Cobol85Parser.LD) + self.state = 3027 + self.libraryName() + self.state = 3028 + self.match(Cobol85Parser.EXPORT) + self.state = 3030 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==31: + self.state = 3029 + self.libraryAttributeClauseFormat1() + + + self.state = 3033 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==183: + self.state = 3032 + self.libraryEntryProcedureClauseFormat1() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LibraryDescriptionEntryFormat2Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LB(self): + return self.getToken(Cobol85Parser.LB, 0) + + def libraryName(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryNameContext,0) + + + def IMPORT(self): + return self.getToken(Cobol85Parser.IMPORT, 0) + + def libraryIsGlobalClause(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryIsGlobalClauseContext,0) + + + def libraryIsCommonClause(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryIsCommonClauseContext,0) + + + def libraryAttributeClauseFormat2(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.LibraryAttributeClauseFormat2Context) + else: + return self.getTypedRuleContext(Cobol85Parser.LibraryAttributeClauseFormat2Context,i) + + + def libraryEntryProcedureClauseFormat2(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.LibraryEntryProcedureClauseFormat2Context) + else: + return self.getTypedRuleContext(Cobol85Parser.LibraryEntryProcedureClauseFormat2Context,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryDescriptionEntryFormat2 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryDescriptionEntryFormat2" ): + listener.enterLibraryDescriptionEntryFormat2(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryDescriptionEntryFormat2" ): + listener.exitLibraryDescriptionEntryFormat2(self) + + + + + def libraryDescriptionEntryFormat2(self): + + localctx = Cobol85Parser.LibraryDescriptionEntryFormat2Context(self, self._ctx, self.state) + self.enterRule(localctx, 402, self.RULE_libraryDescriptionEntryFormat2) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3035 + self.match(Cobol85Parser.LB) + self.state = 3036 + self.libraryName() + self.state = 3037 + self.match(Cobol85Parser.IMPORT) + self.state = 3039 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,365,self._ctx) + if la_ == 1: + self.state = 3038 + self.libraryIsGlobalClause() + + + self.state = 3042 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==78 or _la==254: + self.state = 3041 + self.libraryIsCommonClause() + + + self.state = 3048 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==31 or _la==183: + self.state = 3046 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [31]: + self.state = 3044 + self.libraryAttributeClauseFormat2() + pass + elif token in [183]: + self.state = 3045 + self.libraryEntryProcedureClauseFormat2() + pass + else: + raise NoViableAltException(self) + + self.state = 3050 + 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 LibraryAttributeClauseFormat1Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ATTRIBUTE(self): + return self.getToken(Cobol85Parser.ATTRIBUTE, 0) + + def SHARING(self): + return self.getToken(Cobol85Parser.SHARING, 0) + + def DONTCARE(self): + return self.getToken(Cobol85Parser.DONTCARE, 0) + + def PRIVATE(self): + return self.getToken(Cobol85Parser.PRIVATE, 0) + + def SHAREDBYRUNUNIT(self): + return self.getToken(Cobol85Parser.SHAREDBYRUNUNIT, 0) + + def SHAREDBYALL(self): + return self.getToken(Cobol85Parser.SHAREDBYALL, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryAttributeClauseFormat1 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryAttributeClauseFormat1" ): + listener.enterLibraryAttributeClauseFormat1(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryAttributeClauseFormat1" ): + listener.exitLibraryAttributeClauseFormat1(self) + + + + + def libraryAttributeClauseFormat1(self): + + localctx = Cobol85Parser.LibraryAttributeClauseFormat1Context(self, self._ctx, self.state) + self.enterRule(localctx, 404, self.RULE_libraryAttributeClauseFormat1) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3051 + self.match(Cobol85Parser.ATTRIBUTE) + self.state = 3057 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==434: + self.state = 3052 + self.match(Cobol85Parser.SHARING) + self.state = 3054 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3053 + self.match(Cobol85Parser.IS) + + + self.state = 3056 + _la = self._input.LA(1) + if not(_la==146 or _la==355 or _la==432 or _la==433): + 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 LibraryAttributeClauseFormat2Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ATTRIBUTE(self): + return self.getToken(Cobol85Parser.ATTRIBUTE, 0) + + def libraryAttributeFunction(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryAttributeFunctionContext,0) + + + def LIBACCESS(self): + return self.getToken(Cobol85Parser.LIBACCESS, 0) + + def libraryAttributeParameter(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryAttributeParameterContext,0) + + + def libraryAttributeTitle(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryAttributeTitleContext,0) + + + def BYFUNCTION(self): + return self.getToken(Cobol85Parser.BYFUNCTION, 0) + + def BYTITLE(self): + return self.getToken(Cobol85Parser.BYTITLE, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryAttributeClauseFormat2 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryAttributeClauseFormat2" ): + listener.enterLibraryAttributeClauseFormat2(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryAttributeClauseFormat2" ): + listener.exitLibraryAttributeClauseFormat2(self) + + + + + def libraryAttributeClauseFormat2(self): + + localctx = Cobol85Parser.LibraryAttributeClauseFormat2Context(self, self._ctx, self.state) + self.enterRule(localctx, 406, self.RULE_libraryAttributeClauseFormat2) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3059 + self.match(Cobol85Parser.ATTRIBUTE) + self.state = 3061 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==218: + self.state = 3060 + self.libraryAttributeFunction() + + + self.state = 3068 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==272: + self.state = 3063 + self.match(Cobol85Parser.LIBACCESS) + self.state = 3065 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3064 + self.match(Cobol85Parser.IS) + + + self.state = 3067 + _la = self._input.LA(1) + if not(_la==50 or _la==51): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 3071 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==273: + self.state = 3070 + self.libraryAttributeParameter() + + + self.state = 3074 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==488: + self.state = 3073 + self.libraryAttributeTitle() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LibraryAttributeFunctionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FUNCTIONNAME(self): + return self.getToken(Cobol85Parser.FUNCTIONNAME, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryAttributeFunction + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryAttributeFunction" ): + listener.enterLibraryAttributeFunction(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryAttributeFunction" ): + listener.exitLibraryAttributeFunction(self) + + + + + def libraryAttributeFunction(self): + + localctx = Cobol85Parser.LibraryAttributeFunctionContext(self, self._ctx, self.state) + self.enterRule(localctx, 408, self.RULE_libraryAttributeFunction) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3076 + self.match(Cobol85Parser.FUNCTIONNAME) + self.state = 3077 + self.match(Cobol85Parser.IS) + self.state = 3078 + self.literal() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LibraryAttributeParameterContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LIBPARAMETER(self): + return self.getToken(Cobol85Parser.LIBPARAMETER, 0) + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryAttributeParameter + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryAttributeParameter" ): + listener.enterLibraryAttributeParameter(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryAttributeParameter" ): + listener.exitLibraryAttributeParameter(self) + + + + + def libraryAttributeParameter(self): + + localctx = Cobol85Parser.LibraryAttributeParameterContext(self, self._ctx, self.state) + self.enterRule(localctx, 410, self.RULE_libraryAttributeParameter) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3080 + self.match(Cobol85Parser.LIBPARAMETER) + self.state = 3082 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3081 + self.match(Cobol85Parser.IS) + + + self.state = 3084 + self.literal() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LibraryAttributeTitleContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TITLE(self): + return self.getToken(Cobol85Parser.TITLE, 0) + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryAttributeTitle + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryAttributeTitle" ): + listener.enterLibraryAttributeTitle(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryAttributeTitle" ): + listener.exitLibraryAttributeTitle(self) + + + + + def libraryAttributeTitle(self): + + localctx = Cobol85Parser.LibraryAttributeTitleContext(self, self._ctx, self.state) + self.enterRule(localctx, 412, self.RULE_libraryAttributeTitle) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3086 + self.match(Cobol85Parser.TITLE) + self.state = 3088 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3087 + self.match(Cobol85Parser.IS) + + + self.state = 3090 + self.literal() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LibraryEntryProcedureClauseFormat1Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ENTRY_PROCEDURE(self): + return self.getToken(Cobol85Parser.ENTRY_PROCEDURE, 0) + + def programName(self): + return self.getTypedRuleContext(Cobol85Parser.ProgramNameContext,0) + + + def libraryEntryProcedureForClause(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryEntryProcedureForClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryEntryProcedureClauseFormat1 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryEntryProcedureClauseFormat1" ): + listener.enterLibraryEntryProcedureClauseFormat1(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryEntryProcedureClauseFormat1" ): + listener.exitLibraryEntryProcedureClauseFormat1(self) + + + + + def libraryEntryProcedureClauseFormat1(self): + + localctx = Cobol85Parser.LibraryEntryProcedureClauseFormat1Context(self, self._ctx, self.state) + self.enterRule(localctx, 414, self.RULE_libraryEntryProcedureClauseFormat1) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3092 + self.match(Cobol85Parser.ENTRY_PROCEDURE) + self.state = 3093 + self.programName() + self.state = 3095 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 3094 + self.libraryEntryProcedureForClause() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LibraryEntryProcedureClauseFormat2Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ENTRY_PROCEDURE(self): + return self.getToken(Cobol85Parser.ENTRY_PROCEDURE, 0) + + def programName(self): + return self.getTypedRuleContext(Cobol85Parser.ProgramNameContext,0) + + + def libraryEntryProcedureForClause(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryEntryProcedureForClauseContext,0) + + + def libraryEntryProcedureWithClause(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryEntryProcedureWithClauseContext,0) + + + def libraryEntryProcedureUsingClause(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryEntryProcedureUsingClauseContext,0) + + + def libraryEntryProcedureGivingClause(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryEntryProcedureGivingClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryEntryProcedureClauseFormat2 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryEntryProcedureClauseFormat2" ): + listener.enterLibraryEntryProcedureClauseFormat2(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryEntryProcedureClauseFormat2" ): + listener.exitLibraryEntryProcedureClauseFormat2(self) + + + + + def libraryEntryProcedureClauseFormat2(self): + + localctx = Cobol85Parser.LibraryEntryProcedureClauseFormat2Context(self, self._ctx, self.state) + self.enterRule(localctx, 416, self.RULE_libraryEntryProcedureClauseFormat2) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3097 + self.match(Cobol85Parser.ENTRY_PROCEDURE) + self.state = 3098 + self.programName() + self.state = 3100 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 3099 + self.libraryEntryProcedureForClause() + + + self.state = 3103 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 3102 + self.libraryEntryProcedureWithClause() + + + self.state = 3106 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==506: + self.state = 3105 + self.libraryEntryProcedureUsingClause() + + + self.state = 3109 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==222: + self.state = 3108 + self.libraryEntryProcedureGivingClause() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LibraryEntryProcedureForClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryEntryProcedureForClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryEntryProcedureForClause" ): + listener.enterLibraryEntryProcedureForClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryEntryProcedureForClause" ): + listener.exitLibraryEntryProcedureForClause(self) + + + + + def libraryEntryProcedureForClause(self): + + localctx = Cobol85Parser.LibraryEntryProcedureForClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 418, self.RULE_libraryEntryProcedureForClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3111 + self.match(Cobol85Parser.FOR) + self.state = 3112 + self.literal() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LibraryEntryProcedureGivingClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GIVING(self): + return self.getToken(Cobol85Parser.GIVING, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryEntryProcedureGivingClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryEntryProcedureGivingClause" ): + listener.enterLibraryEntryProcedureGivingClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryEntryProcedureGivingClause" ): + listener.exitLibraryEntryProcedureGivingClause(self) + + + + + def libraryEntryProcedureGivingClause(self): + + localctx = Cobol85Parser.LibraryEntryProcedureGivingClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 420, self.RULE_libraryEntryProcedureGivingClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3114 + self.match(Cobol85Parser.GIVING) + self.state = 3115 + self.dataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LibraryEntryProcedureUsingClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def USING(self): + return self.getToken(Cobol85Parser.USING, 0) + + def libraryEntryProcedureUsingName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.LibraryEntryProcedureUsingNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.LibraryEntryProcedureUsingNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryEntryProcedureUsingClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryEntryProcedureUsingClause" ): + listener.enterLibraryEntryProcedureUsingClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryEntryProcedureUsingClause" ): + listener.exitLibraryEntryProcedureUsingClause(self) + + + + + def libraryEntryProcedureUsingClause(self): + + localctx = Cobol85Parser.LibraryEntryProcedureUsingClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 422, self.RULE_libraryEntryProcedureUsingClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3117 + self.match(Cobol85Parser.USING) + self.state = 3119 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 3118 + self.libraryEntryProcedureUsingName() + + else: + raise NoViableAltException(self) + self.state = 3121 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,383,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LibraryEntryProcedureUsingNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryEntryProcedureUsingName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryEntryProcedureUsingName" ): + listener.enterLibraryEntryProcedureUsingName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryEntryProcedureUsingName" ): + listener.exitLibraryEntryProcedureUsingName(self) + + + + + def libraryEntryProcedureUsingName(self): + + localctx = Cobol85Parser.LibraryEntryProcedureUsingNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 424, self.RULE_libraryEntryProcedureUsingName) + try: + self.state = 3125 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,384,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3123 + self.dataName() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3124 + self.fileName() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LibraryEntryProcedureWithClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def libraryEntryProcedureWithName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.LibraryEntryProcedureWithNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.LibraryEntryProcedureWithNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryEntryProcedureWithClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryEntryProcedureWithClause" ): + listener.enterLibraryEntryProcedureWithClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryEntryProcedureWithClause" ): + listener.exitLibraryEntryProcedureWithClause(self) + + + + + def libraryEntryProcedureWithClause(self): + + localctx = Cobol85Parser.LibraryEntryProcedureWithClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 426, self.RULE_libraryEntryProcedureWithClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3127 + self.match(Cobol85Parser.WITH) + self.state = 3129 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 3128 + self.libraryEntryProcedureWithName() + + else: + raise NoViableAltException(self) + self.state = 3131 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,385,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LibraryEntryProcedureWithNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def localName(self): + return self.getTypedRuleContext(Cobol85Parser.LocalNameContext,0) + + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryEntryProcedureWithName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryEntryProcedureWithName" ): + listener.enterLibraryEntryProcedureWithName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryEntryProcedureWithName" ): + listener.exitLibraryEntryProcedureWithName(self) + + + + + def libraryEntryProcedureWithName(self): + + localctx = Cobol85Parser.LibraryEntryProcedureWithNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 428, self.RULE_libraryEntryProcedureWithName) + try: + self.state = 3135 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,386,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3133 + self.localName() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3134 + self.fileName() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LibraryIsCommonClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def COMMON(self): + return self.getToken(Cobol85Parser.COMMON, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryIsCommonClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryIsCommonClause" ): + listener.enterLibraryIsCommonClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryIsCommonClause" ): + listener.exitLibraryIsCommonClause(self) + + + + + def libraryIsCommonClause(self): + + localctx = Cobol85Parser.LibraryIsCommonClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 430, self.RULE_libraryIsCommonClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3138 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3137 + self.match(Cobol85Parser.IS) + + + self.state = 3140 + self.match(Cobol85Parser.COMMON) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LibraryIsGlobalClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GLOBAL(self): + return self.getToken(Cobol85Parser.GLOBAL, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryIsGlobalClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryIsGlobalClause" ): + listener.enterLibraryIsGlobalClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryIsGlobalClause" ): + listener.exitLibraryIsGlobalClause(self) + + + + + def libraryIsGlobalClause(self): + + localctx = Cobol85Parser.LibraryIsGlobalClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 432, self.RULE_libraryIsGlobalClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3143 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3142 + self.match(Cobol85Parser.IS) + + + self.state = 3145 + self.match(Cobol85Parser.GLOBAL) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataDescriptionEntryContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def dataDescriptionEntryFormat1(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescriptionEntryFormat1Context,0) + + + def dataDescriptionEntryFormat2(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescriptionEntryFormat2Context,0) + + + def dataDescriptionEntryFormat3(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescriptionEntryFormat3Context,0) + + + def dataDescriptionEntryExecSql(self): + return self.getTypedRuleContext(Cobol85Parser.DataDescriptionEntryExecSqlContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataDescriptionEntry + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataDescriptionEntry" ): + listener.enterDataDescriptionEntry(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataDescriptionEntry" ): + listener.exitDataDescriptionEntry(self) + + + + + def dataDescriptionEntry(self): + + localctx = Cobol85Parser.DataDescriptionEntryContext(self, self._ctx, self.state) + self.enterRule(localctx, 434, self.RULE_dataDescriptionEntry) + try: + self.state = 3151 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [553, 555]: + self.enterOuterAlt(localctx, 1) + self.state = 3147 + self.dataDescriptionEntryFormat1() + pass + elif token in [552]: + self.enterOuterAlt(localctx, 2) + self.state = 3148 + self.dataDescriptionEntryFormat2() + pass + elif token in [554]: + self.enterOuterAlt(localctx, 3) + self.state = 3149 + self.dataDescriptionEntryFormat3() + pass + elif token in [561]: + self.enterOuterAlt(localctx, 4) + self.state = 3150 + self.dataDescriptionEntryExecSql() + 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 DataDescriptionEntryFormat1Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def INTEGERLITERAL(self): + return self.getToken(Cobol85Parser.INTEGERLITERAL, 0) + + def LEVEL_NUMBER_77(self): + return self.getToken(Cobol85Parser.LEVEL_NUMBER_77, 0) + + def FILLER(self): + return self.getToken(Cobol85Parser.FILLER, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def dataRedefinesClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataRedefinesClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataRedefinesClauseContext,i) + + + def dataIntegerStringClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataIntegerStringClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataIntegerStringClauseContext,i) + + + def dataExternalClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataExternalClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataExternalClauseContext,i) + + + def dataGlobalClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataGlobalClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataGlobalClauseContext,i) + + + def dataTypeDefClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataTypeDefClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataTypeDefClauseContext,i) + + + def dataThreadLocalClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataThreadLocalClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataThreadLocalClauseContext,i) + + + def dataPictureClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataPictureClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataPictureClauseContext,i) + + + def dataCommonOwnLocalClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataCommonOwnLocalClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataCommonOwnLocalClauseContext,i) + + + def dataTypeClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataTypeClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataTypeClauseContext,i) + + + def dataUsingClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataUsingClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataUsingClauseContext,i) + + + def dataUsageClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataUsageClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataUsageClauseContext,i) + + + def dataValueClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataValueClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataValueClauseContext,i) + + + def dataReceivedByClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataReceivedByClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataReceivedByClauseContext,i) + + + def dataOccursClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataOccursClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataOccursClauseContext,i) + + + def dataSignClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataSignClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataSignClauseContext,i) + + + def dataSynchronizedClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataSynchronizedClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataSynchronizedClauseContext,i) + + + def dataJustifiedClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataJustifiedClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataJustifiedClauseContext,i) + + + def dataBlankWhenZeroClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataBlankWhenZeroClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataBlankWhenZeroClauseContext,i) + + + def dataWithLowerBoundsClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataWithLowerBoundsClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataWithLowerBoundsClauseContext,i) + + + def dataAlignedClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataAlignedClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataAlignedClauseContext,i) + + + def dataRecordAreaClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataRecordAreaClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataRecordAreaClauseContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataDescriptionEntryFormat1 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataDescriptionEntryFormat1" ): + listener.enterDataDescriptionEntryFormat1(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataDescriptionEntryFormat1" ): + listener.exitDataDescriptionEntryFormat1(self) + + + + + def dataDescriptionEntryFormat1(self): + + localctx = Cobol85Parser.DataDescriptionEntryFormat1Context(self, self._ctx, self.state) + self.enterRule(localctx, 436, self.RULE_dataDescriptionEntryFormat1) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3153 + _la = self._input.LA(1) + if not(_la==553 or _la==555): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3156 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,390,self._ctx) + if la_ == 1: + self.state = 3154 + self.match(Cobol85Parser.FILLER) + + elif la_ == 2: + self.state = 3155 + self.dataName() + + + self.state = 3181 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3513579973275288322) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070460708250187267) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339579) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3030640695327893497) != 0) or ((((_la - 266)) & ~0x3f) == 0 and ((1 << (_la - 266)) & 119808148288963029) != 0) or ((((_la - 331)) & ~0x3f) == 0 and ((1 << (_la - 331)) & 1168232970228959457) != 0) or ((((_la - 398)) & ~0x3f) == 0 and ((1 << (_la - 398)) & 2319355586216591369) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 572299384177393805) != 0) or ((((_la - 551)) & ~0x3f) == 0 and ((1 << (_la - 551)) & 127) != 0): + self.state = 3179 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,391,self._ctx) + if la_ == 1: + self.state = 3158 + self.dataRedefinesClause() + pass + + elif la_ == 2: + self.state = 3159 + self.dataIntegerStringClause() + pass + + elif la_ == 3: + self.state = 3160 + self.dataExternalClause() + pass + + elif la_ == 4: + self.state = 3161 + self.dataGlobalClause() + pass + + elif la_ == 5: + self.state = 3162 + self.dataTypeDefClause() + pass + + elif la_ == 6: + self.state = 3163 + self.dataThreadLocalClause() + pass + + elif la_ == 7: + self.state = 3164 + self.dataPictureClause() + pass + + elif la_ == 8: + self.state = 3165 + self.dataCommonOwnLocalClause() + pass + + elif la_ == 9: + self.state = 3166 + self.dataTypeClause() + pass + + elif la_ == 10: + self.state = 3167 + self.dataUsingClause() + pass + + elif la_ == 11: + self.state = 3168 + self.dataUsageClause() + pass + + elif la_ == 12: + self.state = 3169 + self.dataValueClause() + pass + + elif la_ == 13: + self.state = 3170 + self.dataReceivedByClause() + pass + + elif la_ == 14: + self.state = 3171 + self.dataOccursClause() + pass + + elif la_ == 15: + self.state = 3172 + self.dataSignClause() + pass + + elif la_ == 16: + self.state = 3173 + self.dataSynchronizedClause() + pass + + elif la_ == 17: + self.state = 3174 + self.dataJustifiedClause() + pass + + elif la_ == 18: + self.state = 3175 + self.dataBlankWhenZeroClause() + pass + + elif la_ == 19: + self.state = 3176 + self.dataWithLowerBoundsClause() + pass + + elif la_ == 20: + self.state = 3177 + self.dataAlignedClause() + pass + + elif la_ == 21: + self.state = 3178 + self.dataRecordAreaClause() + pass + + + self.state = 3183 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 3184 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataDescriptionEntryFormat2Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEVEL_NUMBER_66(self): + return self.getToken(Cobol85Parser.LEVEL_NUMBER_66, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def dataRenamesClause(self): + return self.getTypedRuleContext(Cobol85Parser.DataRenamesClauseContext,0) + + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataDescriptionEntryFormat2 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataDescriptionEntryFormat2" ): + listener.enterDataDescriptionEntryFormat2(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataDescriptionEntryFormat2" ): + listener.exitDataDescriptionEntryFormat2(self) + + + + + def dataDescriptionEntryFormat2(self): + + localctx = Cobol85Parser.DataDescriptionEntryFormat2Context(self, self._ctx, self.state) + self.enterRule(localctx, 438, self.RULE_dataDescriptionEntryFormat2) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3186 + self.match(Cobol85Parser.LEVEL_NUMBER_66) + self.state = 3187 + self.dataName() + self.state = 3188 + self.dataRenamesClause() + self.state = 3189 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataDescriptionEntryFormat3Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEVEL_NUMBER_88(self): + return self.getToken(Cobol85Parser.LEVEL_NUMBER_88, 0) + + def conditionName(self): + return self.getTypedRuleContext(Cobol85Parser.ConditionNameContext,0) + + + def dataValueClause(self): + return self.getTypedRuleContext(Cobol85Parser.DataValueClauseContext,0) + + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataDescriptionEntryFormat3 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataDescriptionEntryFormat3" ): + listener.enterDataDescriptionEntryFormat3(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataDescriptionEntryFormat3" ): + listener.exitDataDescriptionEntryFormat3(self) + + + + + def dataDescriptionEntryFormat3(self): + + localctx = Cobol85Parser.DataDescriptionEntryFormat3Context(self, self._ctx, self.state) + self.enterRule(localctx, 440, self.RULE_dataDescriptionEntryFormat3) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3191 + self.match(Cobol85Parser.LEVEL_NUMBER_88) + self.state = 3192 + self.conditionName() + self.state = 3193 + self.dataValueClause() + self.state = 3194 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataDescriptionEntryExecSqlContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXECSQLLINE(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.EXECSQLLINE) + else: + return self.getToken(Cobol85Parser.EXECSQLLINE, i) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataDescriptionEntryExecSql + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataDescriptionEntryExecSql" ): + listener.enterDataDescriptionEntryExecSql(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataDescriptionEntryExecSql" ): + listener.exitDataDescriptionEntryExecSql(self) + + + + + def dataDescriptionEntryExecSql(self): + + localctx = Cobol85Parser.DataDescriptionEntryExecSqlContext(self, self._ctx, self.state) + self.enterRule(localctx, 442, self.RULE_dataDescriptionEntryExecSql) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3197 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 3196 + self.match(Cobol85Parser.EXECSQLLINE) + + else: + raise NoViableAltException(self) + self.state = 3199 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,393,self._ctx) + + self.state = 3202 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==534: + self.state = 3201 + self.match(Cobol85Parser.DOT_FS) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataAlignedClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALIGNED(self): + return self.getToken(Cobol85Parser.ALIGNED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataAlignedClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataAlignedClause" ): + listener.enterDataAlignedClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataAlignedClause" ): + listener.exitDataAlignedClause(self) + + + + + def dataAlignedClause(self): + + localctx = Cobol85Parser.DataAlignedClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 444, self.RULE_dataAlignedClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3204 + self.match(Cobol85Parser.ALIGNED) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataBlankWhenZeroClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BLANK(self): + return self.getToken(Cobol85Parser.BLANK, 0) + + def ZERO(self): + return self.getToken(Cobol85Parser.ZERO, 0) + + def ZEROS(self): + return self.getToken(Cobol85Parser.ZEROS, 0) + + def ZEROES(self): + return self.getToken(Cobol85Parser.ZEROES, 0) + + def WHEN(self): + return self.getToken(Cobol85Parser.WHEN, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataBlankWhenZeroClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataBlankWhenZeroClause" ): + listener.enterDataBlankWhenZeroClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataBlankWhenZeroClause" ): + listener.exitDataBlankWhenZeroClause(self) + + + + + def dataBlankWhenZeroClause(self): + + localctx = Cobol85Parser.DataBlankWhenZeroClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 446, self.RULE_dataBlankWhenZeroClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3206 + self.match(Cobol85Parser.BLANK) + self.state = 3208 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==512: + self.state = 3207 + self.match(Cobol85Parser.WHEN) + + + self.state = 3210 + _la = self._input.LA(1) + if not(((((_la - 521)) & ~0x3f) == 0 and ((1 << (_la - 521)) & 13) != 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 DataCommonOwnLocalClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def COMMON(self): + return self.getToken(Cobol85Parser.COMMON, 0) + + def OWN(self): + return self.getToken(Cobol85Parser.OWN, 0) + + def LOCAL(self): + return self.getToken(Cobol85Parser.LOCAL, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataCommonOwnLocalClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataCommonOwnLocalClause" ): + listener.enterDataCommonOwnLocalClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataCommonOwnLocalClause" ): + listener.exitDataCommonOwnLocalClause(self) + + + + + def dataCommonOwnLocalClause(self): + + localctx = Cobol85Parser.DataCommonOwnLocalClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 448, self.RULE_dataCommonOwnLocalClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3212 + _la = self._input.LA(1) + if not(_la==78 or _la==284 or _la==337): + 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 DataExternalClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXTERNAL(self): + return self.getToken(Cobol85Parser.EXTERNAL, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataExternalClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataExternalClause" ): + listener.enterDataExternalClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataExternalClause" ): + listener.exitDataExternalClause(self) + + + + + def dataExternalClause(self): + + localctx = Cobol85Parser.DataExternalClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 450, self.RULE_dataExternalClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3215 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3214 + self.match(Cobol85Parser.IS) + + + self.state = 3217 + self.match(Cobol85Parser.EXTERNAL) + self.state = 3220 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,397,self._ctx) + if la_ == 1: + self.state = 3218 + self.match(Cobol85Parser.BY) + self.state = 3219 + self.literal() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataGlobalClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GLOBAL(self): + return self.getToken(Cobol85Parser.GLOBAL, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataGlobalClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataGlobalClause" ): + listener.enterDataGlobalClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataGlobalClause" ): + listener.exitDataGlobalClause(self) + + + + + def dataGlobalClause(self): + + localctx = Cobol85Parser.DataGlobalClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 452, self.RULE_dataGlobalClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3223 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3222 + self.match(Cobol85Parser.IS) + + + self.state = 3225 + self.match(Cobol85Parser.GLOBAL) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataIntegerStringClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTEGER(self): + return self.getToken(Cobol85Parser.INTEGER, 0) + + def STRING(self): + return self.getToken(Cobol85Parser.STRING, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataIntegerStringClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataIntegerStringClause" ): + listener.enterDataIntegerStringClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataIntegerStringClause" ): + listener.exitDataIntegerStringClause(self) + + + + + def dataIntegerStringClause(self): + + localctx = Cobol85Parser.DataIntegerStringClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 454, self.RULE_dataIntegerStringClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3227 + _la = self._input.LA(1) + if not(_la==250 or _la==459): + 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 DataJustifiedClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def JUSTIFIED(self): + return self.getToken(Cobol85Parser.JUSTIFIED, 0) + + def JUST(self): + return self.getToken(Cobol85Parser.JUST, 0) + + def RIGHT(self): + return self.getToken(Cobol85Parser.RIGHT, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataJustifiedClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataJustifiedClause" ): + listener.enterDataJustifiedClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataJustifiedClause" ): + listener.exitDataJustifiedClause(self) + + + + + def dataJustifiedClause(self): + + localctx = Cobol85Parser.DataJustifiedClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 456, self.RULE_dataJustifiedClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3229 + _la = self._input.LA(1) + if not(_la==255 or _la==256): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3231 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==411: + self.state = 3230 + self.match(Cobol85Parser.RIGHT) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataOccursClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OCCURS(self): + return self.getToken(Cobol85Parser.OCCURS, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def dataOccursTo(self): + return self.getTypedRuleContext(Cobol85Parser.DataOccursToContext,0) + + + def TIMES(self): + return self.getToken(Cobol85Parser.TIMES, 0) + + def DEPENDING(self): + return self.getToken(Cobol85Parser.DEPENDING, 0) + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def dataOccursSort(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataOccursSortContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataOccursSortContext,i) + + + def INDEXED(self): + return self.getToken(Cobol85Parser.INDEXED, 0) + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def LOCAL(self): + return self.getToken(Cobol85Parser.LOCAL, 0) + + def indexName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.IndexNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.IndexNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataOccursClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataOccursClause" ): + listener.enterDataOccursClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataOccursClause" ): + listener.exitDataOccursClause(self) + + + + + def dataOccursClause(self): + + localctx = Cobol85Parser.DataOccursClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 458, self.RULE_dataOccursClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3233 + self.match(Cobol85Parser.OCCURS) + self.state = 3234 + self.integerLiteral() + self.state = 3236 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==489: + self.state = 3235 + self.dataOccursTo() + + + self.state = 3239 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==487: + self.state = 3238 + self.match(Cobol85Parser.TIMES) + + + self.state = 3246 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==134: + self.state = 3241 + self.match(Cobol85Parser.DEPENDING) + self.state = 3243 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 3242 + self.match(Cobol85Parser.ON) + + + self.state = 3245 + self.qualifiedDataName() + + + self.state = 3251 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==25 or _la==135: + self.state = 3248 + self.dataOccursSort() + self.state = 3253 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 3266 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==241: + self.state = 3254 + self.match(Cobol85Parser.INDEXED) + self.state = 3256 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==49: + self.state = 3255 + self.match(Cobol85Parser.BY) + + + self.state = 3259 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,406,self._ctx) + if la_ == 1: + self.state = 3258 + self.match(Cobol85Parser.LOCAL) + + + self.state = 3262 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 3261 + self.indexName() + + else: + raise NoViableAltException(self) + self.state = 3264 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,407,self._ctx) + + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataOccursToContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataOccursTo + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataOccursTo" ): + listener.enterDataOccursTo(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataOccursTo" ): + listener.exitDataOccursTo(self) + + + + + def dataOccursTo(self): + + localctx = Cobol85Parser.DataOccursToContext(self, self._ctx, self.state) + self.enterRule(localctx, 460, self.RULE_dataOccursTo) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3268 + self.match(Cobol85Parser.TO) + self.state = 3269 + self.integerLiteral() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataOccursSortContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ASCENDING(self): + return self.getToken(Cobol85Parser.ASCENDING, 0) + + def DESCENDING(self): + return self.getToken(Cobol85Parser.DESCENDING, 0) + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def qualifiedDataName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.QualifiedDataNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataOccursSort + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataOccursSort" ): + listener.enterDataOccursSort(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataOccursSort" ): + listener.exitDataOccursSort(self) + + + + + def dataOccursSort(self): + + localctx = Cobol85Parser.DataOccursSortContext(self, self._ctx, self.state) + self.enterRule(localctx, 462, self.RULE_dataOccursSort) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3271 + _la = self._input.LA(1) + if not(_la==25 or _la==135): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3273 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==259: + self.state = 3272 + self.match(Cobol85Parser.KEY) + + + self.state = 3276 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3275 + self.match(Cobol85Parser.IS) + + + self.state = 3279 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 3278 + self.qualifiedDataName() + + else: + raise NoViableAltException(self) + self.state = 3281 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,411,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataPictureClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def pictureString(self): + return self.getTypedRuleContext(Cobol85Parser.PictureStringContext,0) + + + def PICTURE(self): + return self.getToken(Cobol85Parser.PICTURE, 0) + + def PIC(self): + return self.getToken(Cobol85Parser.PIC, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataPictureClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataPictureClause" ): + listener.enterDataPictureClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataPictureClause" ): + listener.exitDataPictureClause(self) + + + + + def dataPictureClause(self): + + localctx = Cobol85Parser.DataPictureClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 464, self.RULE_dataPictureClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3283 + _la = self._input.LA(1) + if not(_la==346 or _la==347): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3285 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3284 + self.match(Cobol85Parser.IS) + + + self.state = 3287 + self.pictureString() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PictureStringContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def pictureChars(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.PictureCharsContext) + else: + return self.getTypedRuleContext(Cobol85Parser.PictureCharsContext,i) + + + def pictureCardinality(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.PictureCardinalityContext) + else: + return self.getTypedRuleContext(Cobol85Parser.PictureCardinalityContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_pictureString + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPictureString" ): + listener.enterPictureString(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPictureString" ): + listener.exitPictureString(self) + + + + + def pictureString(self): + + localctx = Cobol85Parser.PictureStringContext(self, self._ctx, self.state) + self.enterRule(localctx, 466, self.RULE_pictureString) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3297 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 3290 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 3289 + self.pictureChars() + + else: + raise NoViableAltException(self) + self.state = 3292 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,413,self._ctx) + + self.state = 3295 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,414,self._ctx) + if la_ == 1: + self.state = 3294 + self.pictureCardinality() + + + + else: + raise NoViableAltException(self) + self.state = 3299 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,415,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PictureCharsContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DOLLARCHAR(self): + return self.getToken(Cobol85Parser.DOLLARCHAR, 0) + + def IDENTIFIER(self): + return self.getToken(Cobol85Parser.IDENTIFIER, 0) + + def NUMERICLITERAL(self): + return self.getToken(Cobol85Parser.NUMERICLITERAL, 0) + + def SLASHCHAR(self): + return self.getToken(Cobol85Parser.SLASHCHAR, 0) + + def COMMACHAR(self): + return self.getToken(Cobol85Parser.COMMACHAR, 0) + + def DOT(self): + return self.getToken(Cobol85Parser.DOT, 0) + + def COLONCHAR(self): + return self.getToken(Cobol85Parser.COLONCHAR, 0) + + def ASTERISKCHAR(self): + return self.getToken(Cobol85Parser.ASTERISKCHAR, 0) + + def DOUBLEASTERISKCHAR(self): + return self.getToken(Cobol85Parser.DOUBLEASTERISKCHAR, 0) + + def LPARENCHAR(self): + return self.getToken(Cobol85Parser.LPARENCHAR, 0) + + def RPARENCHAR(self): + return self.getToken(Cobol85Parser.RPARENCHAR, 0) + + def PLUSCHAR(self): + return self.getToken(Cobol85Parser.PLUSCHAR, 0) + + def MINUSCHAR(self): + return self.getToken(Cobol85Parser.MINUSCHAR, 0) + + def LESSTHANCHAR(self): + return self.getToken(Cobol85Parser.LESSTHANCHAR, 0) + + def MORETHANCHAR(self): + return self.getToken(Cobol85Parser.MORETHANCHAR, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_pictureChars + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPictureChars" ): + listener.enterPictureChars(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPictureChars" ): + listener.exitPictureChars(self) + + + + + def pictureChars(self): + + localctx = Cobol85Parser.PictureCharsContext(self, self._ctx, self.state) + self.enterRule(localctx, 468, self.RULE_pictureChars) + try: + self.state = 3317 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [532]: + self.enterOuterAlt(localctx, 1) + self.state = 3301 + self.match(Cobol85Parser.DOLLARCHAR) + pass + elif token in [557]: + self.enterOuterAlt(localctx, 2) + self.state = 3302 + self.match(Cobol85Parser.IDENTIFIER) + pass + elif token in [556]: + self.enterOuterAlt(localctx, 3) + self.state = 3303 + self.match(Cobol85Parser.NUMERICLITERAL) + pass + elif token in [550]: + self.enterOuterAlt(localctx, 4) + self.state = 3304 + self.match(Cobol85Parser.SLASHCHAR) + pass + elif token in [529]: + self.enterOuterAlt(localctx, 5) + self.state = 3305 + self.match(Cobol85Parser.COMMACHAR) + pass + elif token in [535]: + self.enterOuterAlt(localctx, 6) + self.state = 3306 + self.match(Cobol85Parser.DOT) + pass + elif token in [528]: + self.enterOuterAlt(localctx, 7) + self.state = 3307 + self.match(Cobol85Parser.COLONCHAR) + pass + elif token in [526]: + self.enterOuterAlt(localctx, 8) + self.state = 3308 + self.match(Cobol85Parser.ASTERISKCHAR) + pass + elif token in [527]: + self.enterOuterAlt(localctx, 9) + self.state = 3309 + self.match(Cobol85Parser.DOUBLEASTERISKCHAR) + pass + elif token in [542]: + self.enterOuterAlt(localctx, 10) + self.state = 3310 + self.match(Cobol85Parser.LPARENCHAR) + pass + elif token in [549]: + self.enterOuterAlt(localctx, 11) + self.state = 3311 + self.match(Cobol85Parser.RPARENCHAR) + pass + elif token in [547]: + self.enterOuterAlt(localctx, 12) + self.state = 3312 + self.match(Cobol85Parser.PLUSCHAR) + pass + elif token in [543]: + self.enterOuterAlt(localctx, 13) + self.state = 3313 + self.match(Cobol85Parser.MINUSCHAR) + pass + elif token in [540]: + self.enterOuterAlt(localctx, 14) + self.state = 3314 + self.match(Cobol85Parser.LESSTHANCHAR) + pass + elif token in [544]: + self.enterOuterAlt(localctx, 15) + self.state = 3315 + self.match(Cobol85Parser.MORETHANCHAR) + pass + elif token in [552, 553, 554, 555]: + self.enterOuterAlt(localctx, 16) + self.state = 3316 + self.integerLiteral() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PictureCardinalityContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPARENCHAR(self): + return self.getToken(Cobol85Parser.LPARENCHAR, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def RPARENCHAR(self): + return self.getToken(Cobol85Parser.RPARENCHAR, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_pictureCardinality + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPictureCardinality" ): + listener.enterPictureCardinality(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPictureCardinality" ): + listener.exitPictureCardinality(self) + + + + + def pictureCardinality(self): + + localctx = Cobol85Parser.PictureCardinalityContext(self, self._ctx, self.state) + self.enterRule(localctx, 470, self.RULE_pictureCardinality) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3319 + self.match(Cobol85Parser.LPARENCHAR) + self.state = 3320 + self.integerLiteral() + self.state = 3321 + self.match(Cobol85Parser.RPARENCHAR) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataReceivedByClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CONTENT(self): + return self.getToken(Cobol85Parser.CONTENT, 0) + + def REFERENCE(self): + return self.getToken(Cobol85Parser.REFERENCE, 0) + + def REF(self): + return self.getToken(Cobol85Parser.REF, 0) + + def RECEIVED(self): + return self.getToken(Cobol85Parser.RECEIVED, 0) + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataReceivedByClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataReceivedByClause" ): + listener.enterDataReceivedByClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataReceivedByClause" ): + listener.exitDataReceivedByClause(self) + + + + + def dataReceivedByClause(self): + + localctx = Cobol85Parser.DataReceivedByClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 472, self.RULE_dataReceivedByClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3324 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==376: + self.state = 3323 + self.match(Cobol85Parser.RECEIVED) + + + self.state = 3327 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==49: + self.state = 3326 + self.match(Cobol85Parser.BY) + + + self.state = 3329 + _la = self._input.LA(1) + if not(_la==95 or _la==383 or _la==384): + 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 DataRecordAreaClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RECORD(self): + return self.getToken(Cobol85Parser.RECORD, 0) + + def AREA(self): + return self.getToken(Cobol85Parser.AREA, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataRecordAreaClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataRecordAreaClause" ): + listener.enterDataRecordAreaClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataRecordAreaClause" ): + listener.exitDataRecordAreaClause(self) + + + + + def dataRecordAreaClause(self): + + localctx = Cobol85Parser.DataRecordAreaClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 474, self.RULE_dataRecordAreaClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3331 + self.match(Cobol85Parser.RECORD) + self.state = 3332 + self.match(Cobol85Parser.AREA) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataRedefinesClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REDEFINES(self): + return self.getToken(Cobol85Parser.REDEFINES, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataRedefinesClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataRedefinesClause" ): + listener.enterDataRedefinesClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataRedefinesClause" ): + listener.exitDataRedefinesClause(self) + + + + + def dataRedefinesClause(self): + + localctx = Cobol85Parser.DataRedefinesClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 476, self.RULE_dataRedefinesClause) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3334 + self.match(Cobol85Parser.REDEFINES) + self.state = 3335 + self.dataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataRenamesClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RENAMES(self): + return self.getToken(Cobol85Parser.RENAMES, 0) + + def qualifiedDataName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.QualifiedDataNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,i) + + + def THROUGH(self): + return self.getToken(Cobol85Parser.THROUGH, 0) + + def THRU(self): + return self.getToken(Cobol85Parser.THRU, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataRenamesClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataRenamesClause" ): + listener.enterDataRenamesClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataRenamesClause" ): + listener.exitDataRenamesClause(self) + + + + + def dataRenamesClause(self): + + localctx = Cobol85Parser.DataRenamesClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 478, self.RULE_dataRenamesClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3337 + self.match(Cobol85Parser.RENAMES) + self.state = 3338 + self.qualifiedDataName() + self.state = 3341 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==483 or _la==484: + self.state = 3339 + _la = self._input.LA(1) + if not(_la==483 or _la==484): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3340 + self.qualifiedDataName() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataSignClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LEADING(self): + return self.getToken(Cobol85Parser.LEADING, 0) + + def TRAILING(self): + return self.getToken(Cobol85Parser.TRAILING, 0) + + def SIGN(self): + return self.getToken(Cobol85Parser.SIGN, 0) + + def SEPARATE(self): + return self.getToken(Cobol85Parser.SEPARATE, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def CHARACTER(self): + return self.getToken(Cobol85Parser.CHARACTER, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataSignClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataSignClause" ): + listener.enterDataSignClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataSignClause" ): + listener.exitDataSignClause(self) + + + + + def dataSignClause(self): + + localctx = Cobol85Parser.DataSignClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 480, self.RULE_dataSignClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3347 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==438: + self.state = 3343 + self.match(Cobol85Parser.SIGN) + self.state = 3345 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3344 + self.match(Cobol85Parser.IS) + + + + + self.state = 3349 + _la = self._input.LA(1) + if not(_la==266 or _la==493): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3354 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==427: + self.state = 3350 + self.match(Cobol85Parser.SEPARATE) + self.state = 3352 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==62: + self.state = 3351 + self.match(Cobol85Parser.CHARACTER) + + + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataSynchronizedClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SYNCHRONIZED(self): + return self.getToken(Cobol85Parser.SYNCHRONIZED, 0) + + def SYNC(self): + return self.getToken(Cobol85Parser.SYNC, 0) + + def LEFT(self): + return self.getToken(Cobol85Parser.LEFT, 0) + + def RIGHT(self): + return self.getToken(Cobol85Parser.RIGHT, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataSynchronizedClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataSynchronizedClause" ): + listener.enterDataSynchronizedClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataSynchronizedClause" ): + listener.exitDataSynchronizedClause(self) + + + + + def dataSynchronizedClause(self): + + localctx = Cobol85Parser.DataSynchronizedClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 482, self.RULE_dataSynchronizedClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3356 + _la = self._input.LA(1) + if not(_la==468 or _la==469): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3358 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==267 or _la==411: + self.state = 3357 + _la = self._input.LA(1) + if not(_la==267 or _la==411): + 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 DataThreadLocalClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def THREAD_LOCAL(self): + return self.getToken(Cobol85Parser.THREAD_LOCAL, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataThreadLocalClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataThreadLocalClause" ): + listener.enterDataThreadLocalClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataThreadLocalClause" ): + listener.exitDataThreadLocalClause(self) + + + + + def dataThreadLocalClause(self): + + localctx = Cobol85Parser.DataThreadLocalClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 484, self.RULE_dataThreadLocalClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3361 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3360 + self.match(Cobol85Parser.IS) + + + self.state = 3363 + self.match(Cobol85Parser.THREAD_LOCAL) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataTypeClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TYPE(self): + return self.getToken(Cobol85Parser.TYPE, 0) + + def SHORT_DATE(self): + return self.getToken(Cobol85Parser.SHORT_DATE, 0) + + def LONG_DATE(self): + return self.getToken(Cobol85Parser.LONG_DATE, 0) + + def NUMERIC_DATE(self): + return self.getToken(Cobol85Parser.NUMERIC_DATE, 0) + + def NUMERIC_TIME(self): + return self.getToken(Cobol85Parser.NUMERIC_TIME, 0) + + def LONG_TIME(self): + return self.getToken(Cobol85Parser.LONG_TIME, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataTypeClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataTypeClause" ): + listener.enterDataTypeClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataTypeClause" ): + listener.exitDataTypeClause(self) + + + + + def dataTypeClause(self): + + localctx = Cobol85Parser.DataTypeClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 486, self.RULE_dataTypeClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3365 + self.match(Cobol85Parser.TYPE) + self.state = 3367 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3366 + self.match(Cobol85Parser.IS) + + + self.state = 3369 + _la = self._input.LA(1) + if not(((((_la - 287)) & ~0x3f) == 0 and ((1 << (_la - 287)) & 5368709123) != 0) or _la==437): + 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 DataTypeDefClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TYPEDEF(self): + return self.getToken(Cobol85Parser.TYPEDEF, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataTypeDefClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataTypeDefClause" ): + listener.enterDataTypeDefClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataTypeDefClause" ): + listener.exitDataTypeDefClause(self) + + + + + def dataTypeDefClause(self): + + localctx = Cobol85Parser.DataTypeDefClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 488, self.RULE_dataTypeDefClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3372 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3371 + self.match(Cobol85Parser.IS) + + + self.state = 3374 + self.match(Cobol85Parser.TYPEDEF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataUsageClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BINARY(self): + return self.getToken(Cobol85Parser.BINARY, 0) + + def BIT(self): + return self.getToken(Cobol85Parser.BIT, 0) + + def COMP(self): + return self.getToken(Cobol85Parser.COMP, 0) + + def COMP_1(self): + return self.getToken(Cobol85Parser.COMP_1, 0) + + def COMP_2(self): + return self.getToken(Cobol85Parser.COMP_2, 0) + + def COMP_3(self): + return self.getToken(Cobol85Parser.COMP_3, 0) + + def COMP_4(self): + return self.getToken(Cobol85Parser.COMP_4, 0) + + def COMP_5(self): + return self.getToken(Cobol85Parser.COMP_5, 0) + + def COMPUTATIONAL(self): + return self.getToken(Cobol85Parser.COMPUTATIONAL, 0) + + def COMPUTATIONAL_1(self): + return self.getToken(Cobol85Parser.COMPUTATIONAL_1, 0) + + def COMPUTATIONAL_2(self): + return self.getToken(Cobol85Parser.COMPUTATIONAL_2, 0) + + def COMPUTATIONAL_3(self): + return self.getToken(Cobol85Parser.COMPUTATIONAL_3, 0) + + def COMPUTATIONAL_4(self): + return self.getToken(Cobol85Parser.COMPUTATIONAL_4, 0) + + def COMPUTATIONAL_5(self): + return self.getToken(Cobol85Parser.COMPUTATIONAL_5, 0) + + def CONTROL_POINT(self): + return self.getToken(Cobol85Parser.CONTROL_POINT, 0) + + def DATE(self): + return self.getToken(Cobol85Parser.DATE, 0) + + def DISPLAY(self): + return self.getToken(Cobol85Parser.DISPLAY, 0) + + def DISPLAY_1(self): + return self.getToken(Cobol85Parser.DISPLAY_1, 0) + + def DOUBLE(self): + return self.getToken(Cobol85Parser.DOUBLE, 0) + + def EVENT(self): + return self.getToken(Cobol85Parser.EVENT, 0) + + def FUNCTION_POINTER(self): + return self.getToken(Cobol85Parser.FUNCTION_POINTER, 0) + + def INDEX(self): + return self.getToken(Cobol85Parser.INDEX, 0) + + def KANJI(self): + return self.getToken(Cobol85Parser.KANJI, 0) + + def LOCK(self): + return self.getToken(Cobol85Parser.LOCK, 0) + + def NATIONAL(self): + return self.getToken(Cobol85Parser.NATIONAL, 0) + + def PACKED_DECIMAL(self): + return self.getToken(Cobol85Parser.PACKED_DECIMAL, 0) + + def POINTER(self): + return self.getToken(Cobol85Parser.POINTER, 0) + + def PROCEDURE_POINTER(self): + return self.getToken(Cobol85Parser.PROCEDURE_POINTER, 0) + + def REAL(self): + return self.getToken(Cobol85Parser.REAL, 0) + + def TASK(self): + return self.getToken(Cobol85Parser.TASK, 0) + + def USAGE(self): + return self.getToken(Cobol85Parser.USAGE, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def TRUNCATED(self): + return self.getToken(Cobol85Parser.TRUNCATED, 0) + + def EXTENDED(self): + return self.getToken(Cobol85Parser.EXTENDED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataUsageClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataUsageClause" ): + listener.enterDataUsageClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataUsageClause" ): + listener.exitDataUsageClause(self) + + + + + def dataUsageClause(self): + + localctx = Cobol85Parser.DataUsageClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 490, self.RULE_dataUsageClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3380 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==504: + self.state = 3376 + self.match(Cobol85Parser.USAGE) + self.state = 3378 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3377 + self.match(Cobol85Parser.IS) + + + + + self.state = 3415 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [42]: + self.state = 3382 + self.match(Cobol85Parser.BINARY) + self.state = 3384 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,430,self._ctx) + if la_ == 1: + self.state = 3383 + _la = self._input.LA(1) + if not(_la==202 or _la==495): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + pass + elif token in [43]: + self.state = 3386 + self.match(Cobol85Parser.BIT) + pass + elif token in [80]: + self.state = 3387 + self.match(Cobol85Parser.COMP) + pass + elif token in [81]: + self.state = 3388 + self.match(Cobol85Parser.COMP_1) + pass + elif token in [82]: + self.state = 3389 + self.match(Cobol85Parser.COMP_2) + pass + elif token in [83]: + self.state = 3390 + self.match(Cobol85Parser.COMP_3) + pass + elif token in [84]: + self.state = 3391 + self.match(Cobol85Parser.COMP_4) + pass + elif token in [85]: + self.state = 3392 + self.match(Cobol85Parser.COMP_5) + pass + elif token in [86]: + self.state = 3393 + self.match(Cobol85Parser.COMPUTATIONAL) + pass + elif token in [87]: + self.state = 3394 + self.match(Cobol85Parser.COMPUTATIONAL_1) + pass + elif token in [88]: + self.state = 3395 + self.match(Cobol85Parser.COMPUTATIONAL_2) + pass + elif token in [89]: + self.state = 3396 + self.match(Cobol85Parser.COMPUTATIONAL_3) + pass + elif token in [90]: + self.state = 3397 + self.match(Cobol85Parser.COMPUTATIONAL_4) + pass + elif token in [91]: + self.state = 3398 + self.match(Cobol85Parser.COMPUTATIONAL_5) + pass + elif token in [98]: + self.state = 3399 + self.match(Cobol85Parser.CONTROL_POINT) + pass + elif token in [111]: + self.state = 3400 + self.match(Cobol85Parser.DATE) + pass + elif token in [142]: + self.state = 3401 + self.match(Cobol85Parser.DISPLAY) + pass + elif token in [143]: + self.state = 3402 + self.match(Cobol85Parser.DISPLAY_1) + pass + elif token in [147]: + self.state = 3403 + self.match(Cobol85Parser.DOUBLE) + pass + elif token in [194]: + self.state = 3404 + self.match(Cobol85Parser.EVENT) + pass + elif token in [219]: + self.state = 3405 + self.match(Cobol85Parser.FUNCTION_POINTER) + pass + elif token in [240]: + self.state = 3406 + self.match(Cobol85Parser.INDEX) + pass + elif token in [257]: + self.state = 3407 + self.match(Cobol85Parser.KANJI) + pass + elif token in [286]: + self.state = 3408 + self.match(Cobol85Parser.LOCK) + pass + elif token in [304]: + self.state = 3409 + self.match(Cobol85Parser.NATIONAL) + pass + elif token in [338]: + self.state = 3410 + self.match(Cobol85Parser.PACKED_DECIMAL) + pass + elif token in [349]: + self.state = 3411 + self.match(Cobol85Parser.POINTER) + pass + elif token in [357]: + self.state = 3412 + self.match(Cobol85Parser.PROCEDURE_POINTER) + pass + elif token in [373]: + self.state = 3413 + self.match(Cobol85Parser.REAL) + pass + elif token in [473]: + self.state = 3414 + self.match(Cobol85Parser.TASK) + 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 DataUsingClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def USING(self): + return self.getToken(Cobol85Parser.USING, 0) + + def LANGUAGE(self): + return self.getToken(Cobol85Parser.LANGUAGE, 0) + + def CONVENTION(self): + return self.getToken(Cobol85Parser.CONVENTION, 0) + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def OF(self): + return self.getToken(Cobol85Parser.OF, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataUsingClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataUsingClause" ): + listener.enterDataUsingClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataUsingClause" ): + listener.exitDataUsingClause(self) + + + + + def dataUsingClause(self): + + localctx = Cobol85Parser.DataUsingClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 492, self.RULE_dataUsingClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3417 + self.match(Cobol85Parser.USING) + self.state = 3418 + _la = self._input.LA(1) + if not(_la==100 or _la==262): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3420 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==323: + self.state = 3419 + self.match(Cobol85Parser.OF) + + + self.state = 3424 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,433,self._ctx) + if la_ == 1: + self.state = 3422 + self.cobolWord() + pass + + elif la_ == 2: + self.state = 3423 + self.dataName() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataValueClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def dataValueInterval(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DataValueIntervalContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DataValueIntervalContext,i) + + + def VALUE(self): + return self.getToken(Cobol85Parser.VALUE, 0) + + def VALUES(self): + return self.getToken(Cobol85Parser.VALUES, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def ARE(self): + return self.getToken(Cobol85Parser.ARE, 0) + + def COMMACHAR(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.COMMACHAR) + else: + return self.getToken(Cobol85Parser.COMMACHAR, i) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataValueClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataValueClause" ): + listener.enterDataValueClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataValueClause" ): + listener.exitDataValueClause(self) + + + + + def dataValueClause(self): + + localctx = Cobol85Parser.DataValueClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 494, self.RULE_dataValueClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3434 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [507]: + self.state = 3426 + self.match(Cobol85Parser.VALUE) + self.state = 3428 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 3427 + self.match(Cobol85Parser.IS) + + + pass + elif token in [508]: + self.state = 3430 + self.match(Cobol85Parser.VALUES) + self.state = 3432 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==21: + self.state = 3431 + self.match(Cobol85Parser.ARE) + + + pass + elif token in [1, 9, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 204, 213, 214, 216, 218, 219, 226, 229, 230, 231, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 291, 292, 296, 303, 304, 305, 308, 311, 313, 314, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 367, 368, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 450, 451, 466, 473, 481, 482, 486, 490, 491, 494, 495, 497, 498, 510, 511, 518, 519, 520, 521, 522, 523, 524, 551, 552, 553, 554, 555, 556, 557]: + pass + else: + pass + self.state = 3436 + self.dataValueInterval() + self.state = 3443 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,438,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 3438 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==529: + self.state = 3437 + self.match(Cobol85Parser.COMMACHAR) + + + self.state = 3440 + self.dataValueInterval() + self.state = 3445 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,438,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataValueIntervalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def dataValueIntervalFrom(self): + return self.getTypedRuleContext(Cobol85Parser.DataValueIntervalFromContext,0) + + + def dataValueIntervalTo(self): + return self.getTypedRuleContext(Cobol85Parser.DataValueIntervalToContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataValueInterval + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataValueInterval" ): + listener.enterDataValueInterval(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataValueInterval" ): + listener.exitDataValueInterval(self) + + + + + def dataValueInterval(self): + + localctx = Cobol85Parser.DataValueIntervalContext(self, self._ctx, self.state) + self.enterRule(localctx, 496, self.RULE_dataValueInterval) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3446 + self.dataValueIntervalFrom() + self.state = 3448 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==483 or _la==484: + self.state = 3447 + self.dataValueIntervalTo() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataValueIntervalFromContext(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(Cobol85Parser.LiteralContext,0) + + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataValueIntervalFrom + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataValueIntervalFrom" ): + listener.enterDataValueIntervalFrom(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataValueIntervalFrom" ): + listener.exitDataValueIntervalFrom(self) + + + + + def dataValueIntervalFrom(self): + + localctx = Cobol85Parser.DataValueIntervalFromContext(self, self._ctx, self.state) + self.enterRule(localctx, 498, self.RULE_dataValueIntervalFrom) + try: + self.state = 3452 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,440,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3450 + self.literal() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3451 + self.cobolWord() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataValueIntervalToContext(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(Cobol85Parser.LiteralContext,0) + + + def THROUGH(self): + return self.getToken(Cobol85Parser.THROUGH, 0) + + def THRU(self): + return self.getToken(Cobol85Parser.THRU, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataValueIntervalTo + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataValueIntervalTo" ): + listener.enterDataValueIntervalTo(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataValueIntervalTo" ): + listener.exitDataValueIntervalTo(self) + + + + + def dataValueIntervalTo(self): + + localctx = Cobol85Parser.DataValueIntervalToContext(self, self._ctx, self.state) + self.enterRule(localctx, 500, self.RULE_dataValueIntervalTo) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3454 + _la = self._input.LA(1) + if not(_la==483 or _la==484): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3455 + self.literal() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataWithLowerBoundsClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LOWER(self): + return self.getToken(Cobol85Parser.LOWER, 0) + + def BOUNDS(self): + return self.getToken(Cobol85Parser.BOUNDS, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataWithLowerBoundsClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataWithLowerBoundsClause" ): + listener.enterDataWithLowerBoundsClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataWithLowerBoundsClause" ): + listener.exitDataWithLowerBoundsClause(self) + + + + + def dataWithLowerBoundsClause(self): + + localctx = Cobol85Parser.DataWithLowerBoundsClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 502, self.RULE_dataWithLowerBoundsClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3458 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 3457 + self.match(Cobol85Parser.WITH) + + + self.state = 3460 + self.match(Cobol85Parser.LOWER) + self.state = 3461 + self.match(Cobol85Parser.BOUNDS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ProcedureDivisionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PROCEDURE(self): + return self.getToken(Cobol85Parser.PROCEDURE, 0) + + def DIVISION(self): + return self.getToken(Cobol85Parser.DIVISION, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def procedureDivisionBody(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureDivisionBodyContext,0) + + + def procedureDivisionUsingClause(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureDivisionUsingClauseContext,0) + + + def procedureDivisionGivingClause(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureDivisionGivingClauseContext,0) + + + def procedureDeclaratives(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureDeclarativesContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_procedureDivision + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProcedureDivision" ): + listener.enterProcedureDivision(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProcedureDivision" ): + listener.exitProcedureDivision(self) + + + + + def procedureDivision(self): + + localctx = Cobol85Parser.ProcedureDivisionContext(self, self._ctx, self.state) + self.enterRule(localctx, 504, self.RULE_procedureDivision) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3463 + self.match(Cobol85Parser.PROCEDURE) + self.state = 3464 + self.match(Cobol85Parser.DIVISION) + self.state = 3466 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==59 or _la==506: + self.state = 3465 + self.procedureDivisionUsingClause() + + + self.state = 3469 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==222 or _la==405: + self.state = 3468 + self.procedureDivisionGivingClause() + + + self.state = 3471 + self.match(Cobol85Parser.DOT_FS) + self.state = 3473 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==127: + self.state = 3472 + self.procedureDeclaratives() + + + self.state = 3475 + self.procedureDivisionBody() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ProcedureDivisionUsingClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def USING(self): + return self.getToken(Cobol85Parser.USING, 0) + + def CHAINING(self): + return self.getToken(Cobol85Parser.CHAINING, 0) + + def procedureDivisionUsingParameter(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ProcedureDivisionUsingParameterContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ProcedureDivisionUsingParameterContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_procedureDivisionUsingClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProcedureDivisionUsingClause" ): + listener.enterProcedureDivisionUsingClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProcedureDivisionUsingClause" ): + listener.exitProcedureDivisionUsingClause(self) + + + + + def procedureDivisionUsingClause(self): + + localctx = Cobol85Parser.ProcedureDivisionUsingClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 506, self.RULE_procedureDivisionUsingClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3477 + _la = self._input.LA(1) + if not(_la==59 or _la==506): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3479 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 3478 + self.procedureDivisionUsingParameter() + self.state = 3481 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3513562381090291746) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -8049611247572114313) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4648155908907139171) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103778511530590369) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 ProcedureDivisionGivingClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def GIVING(self): + return self.getToken(Cobol85Parser.GIVING, 0) + + def RETURNING(self): + return self.getToken(Cobol85Parser.RETURNING, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_procedureDivisionGivingClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProcedureDivisionGivingClause" ): + listener.enterProcedureDivisionGivingClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProcedureDivisionGivingClause" ): + listener.exitProcedureDivisionGivingClause(self) + + + + + def procedureDivisionGivingClause(self): + + localctx = Cobol85Parser.ProcedureDivisionGivingClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 508, self.RULE_procedureDivisionGivingClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3483 + _la = self._input.LA(1) + if not(_la==222 or _la==405): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3484 + self.dataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ProcedureDivisionUsingParameterContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def procedureDivisionByReferencePhrase(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureDivisionByReferencePhraseContext,0) + + + def procedureDivisionByValuePhrase(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureDivisionByValuePhraseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_procedureDivisionUsingParameter + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProcedureDivisionUsingParameter" ): + listener.enterProcedureDivisionUsingParameter(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProcedureDivisionUsingParameter" ): + listener.exitProcedureDivisionUsingParameter(self) + + + + + def procedureDivisionUsingParameter(self): + + localctx = Cobol85Parser.ProcedureDivisionUsingParameterContext(self, self._ctx, self.state) + self.enterRule(localctx, 510, self.RULE_procedureDivisionUsingParameter) + try: + self.state = 3488 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,446,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3486 + self.procedureDivisionByReferencePhrase() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3487 + self.procedureDivisionByValuePhrase() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ProcedureDivisionByReferencePhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REFERENCE(self): + return self.getToken(Cobol85Parser.REFERENCE, 0) + + def procedureDivisionByReference(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ProcedureDivisionByReferenceContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ProcedureDivisionByReferenceContext,i) + + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_procedureDivisionByReferencePhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProcedureDivisionByReferencePhrase" ): + listener.enterProcedureDivisionByReferencePhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProcedureDivisionByReferencePhrase" ): + listener.exitProcedureDivisionByReferencePhrase(self) + + + + + def procedureDivisionByReferencePhrase(self): + + localctx = Cobol85Parser.ProcedureDivisionByReferencePhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 512, self.RULE_procedureDivisionByReferencePhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3494 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==49 or _la==384: + self.state = 3491 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==49: + self.state = 3490 + self.match(Cobol85Parser.BY) + + + self.state = 3493 + self.match(Cobol85Parser.REFERENCE) + + + self.state = 3497 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 3496 + self.procedureDivisionByReference() + + else: + raise NoViableAltException(self) + self.state = 3499 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,449,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ProcedureDivisionByReferenceContext(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(Cobol85Parser.IdentifierContext,0) + + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def OPTIONAL(self): + return self.getToken(Cobol85Parser.OPTIONAL, 0) + + def ANY(self): + return self.getToken(Cobol85Parser.ANY, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_procedureDivisionByReference + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProcedureDivisionByReference" ): + listener.enterProcedureDivisionByReference(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProcedureDivisionByReference" ): + listener.exitProcedureDivisionByReference(self) + + + + + def procedureDivisionByReference(self): + + localctx = Cobol85Parser.ProcedureDivisionByReferenceContext(self, self._ctx, self.state) + self.enterRule(localctx, 514, self.RULE_procedureDivisionByReference) + self._la = 0 # Token type + try: + self.state = 3509 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [1, 5, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 111, 114, 115, 118, 119, 120, 121, 122, 123, 124, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 217, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 269, 270, 272, 273, 274, 278, 281, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 328, 331, 336, 337, 341, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 404, 415, 420, 431, 432, 433, 434, 435, 436, 437, 441, 442, 443, 445, 446, 447, 466, 471, 473, 481, 482, 485, 486, 490, 491, 495, 497, 498, 510, 511, 513, 518, 519, 520, 522, 552, 553, 554, 555, 557]: + self.enterOuterAlt(localctx, 1) + self.state = 3502 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==328: + self.state = 3501 + self.match(Cobol85Parser.OPTIONAL) + + + self.state = 3506 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,451,self._ctx) + if la_ == 1: + self.state = 3504 + self.identifier() + pass + + elif la_ == 2: + self.state = 3505 + self.fileName() + pass + + + pass + elif token in [20]: + self.enterOuterAlt(localctx, 2) + self.state = 3508 + self.match(Cobol85Parser.ANY) + 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 ProcedureDivisionByValuePhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def VALUE(self): + return self.getToken(Cobol85Parser.VALUE, 0) + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def procedureDivisionByValue(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ProcedureDivisionByValueContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ProcedureDivisionByValueContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_procedureDivisionByValuePhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProcedureDivisionByValuePhrase" ): + listener.enterProcedureDivisionByValuePhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProcedureDivisionByValuePhrase" ): + listener.exitProcedureDivisionByValuePhrase(self) + + + + + def procedureDivisionByValuePhrase(self): + + localctx = Cobol85Parser.ProcedureDivisionByValuePhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 516, self.RULE_procedureDivisionByValuePhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3512 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==49: + self.state = 3511 + self.match(Cobol85Parser.BY) + + + self.state = 3514 + self.match(Cobol85Parser.VALUE) + self.state = 3516 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 3515 + self.procedureDivisionByValue() + + else: + raise NoViableAltException(self) + self.state = 3518 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,454,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ProcedureDivisionByValueContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def ANY(self): + return self.getToken(Cobol85Parser.ANY, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_procedureDivisionByValue + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProcedureDivisionByValue" ): + listener.enterProcedureDivisionByValue(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProcedureDivisionByValue" ): + listener.exitProcedureDivisionByValue(self) + + + + + def procedureDivisionByValue(self): + + localctx = Cobol85Parser.ProcedureDivisionByValueContext(self, self._ctx, self.state) + self.enterRule(localctx, 518, self.RULE_procedureDivisionByValue) + try: + self.state = 3523 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,455,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3520 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3521 + self.literal() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3522 + self.match(Cobol85Parser.ANY) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ProcedureDeclarativesContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DECLARATIVES(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.DECLARATIVES) + else: + return self.getToken(Cobol85Parser.DECLARATIVES, i) + + def DOT_FS(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.DOT_FS) + else: + return self.getToken(Cobol85Parser.DOT_FS, i) + + def END(self): + return self.getToken(Cobol85Parser.END, 0) + + def procedureDeclarative(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ProcedureDeclarativeContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ProcedureDeclarativeContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_procedureDeclaratives + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProcedureDeclaratives" ): + listener.enterProcedureDeclaratives(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProcedureDeclaratives" ): + listener.exitProcedureDeclaratives(self) + + + + + def procedureDeclaratives(self): + + localctx = Cobol85Parser.ProcedureDeclarativesContext(self, self._ctx, self.state) + self.enterRule(localctx, 520, self.RULE_procedureDeclaratives) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3525 + self.match(Cobol85Parser.DECLARATIVES) + self.state = 3526 + self.match(Cobol85Parser.DOT_FS) + self.state = 3528 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 3527 + self.procedureDeclarative() + self.state = 3530 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 0)): + break + + self.state = 3532 + self.match(Cobol85Parser.END) + self.state = 3533 + self.match(Cobol85Parser.DECLARATIVES) + self.state = 3534 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ProcedureDeclarativeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def procedureSectionHeader(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureSectionHeaderContext,0) + + + def DOT_FS(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.DOT_FS) + else: + return self.getToken(Cobol85Parser.DOT_FS, i) + + def useStatement(self): + return self.getTypedRuleContext(Cobol85Parser.UseStatementContext,0) + + + def paragraphs(self): + return self.getTypedRuleContext(Cobol85Parser.ParagraphsContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_procedureDeclarative + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProcedureDeclarative" ): + listener.enterProcedureDeclarative(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProcedureDeclarative" ): + listener.exitProcedureDeclarative(self) + + + + + def procedureDeclarative(self): + + localctx = Cobol85Parser.ProcedureDeclarativeContext(self, self._ctx, self.state) + self.enterRule(localctx, 522, self.RULE_procedureDeclarative) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3536 + self.procedureSectionHeader() + self.state = 3537 + self.match(Cobol85Parser.DOT_FS) + self.state = 3538 + self.useStatement() + self.state = 3539 + self.match(Cobol85Parser.DOT_FS) + self.state = 3540 + self.paragraphs() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ProcedureSectionHeaderContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def sectionName(self): + return self.getTypedRuleContext(Cobol85Parser.SectionNameContext,0) + + + def SECTION(self): + return self.getToken(Cobol85Parser.SECTION, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_procedureSectionHeader + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProcedureSectionHeader" ): + listener.enterProcedureSectionHeader(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProcedureSectionHeader" ): + listener.exitProcedureSectionHeader(self) + + + + + def procedureSectionHeader(self): + + localctx = Cobol85Parser.ProcedureSectionHeaderContext(self, self._ctx, self.state) + self.enterRule(localctx, 524, self.RULE_procedureSectionHeader) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3542 + self.sectionName() + self.state = 3543 + self.match(Cobol85Parser.SECTION) + self.state = 3545 + self._errHandler.sync(self) + _la = self._input.LA(1) + if ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 15) != 0): + self.state = 3544 + self.integerLiteral() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ProcedureDivisionBodyContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def paragraphs(self): + return self.getTypedRuleContext(Cobol85Parser.ParagraphsContext,0) + + + def procedureSection(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ProcedureSectionContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ProcedureSectionContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_procedureDivisionBody + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProcedureDivisionBody" ): + listener.enterProcedureDivisionBody(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProcedureDivisionBody" ): + listener.exitProcedureDivisionBody(self) + + + + + def procedureDivisionBody(self): + + localctx = Cobol85Parser.ProcedureDivisionBodyContext(self, self._ctx, self.state) + self.enterRule(localctx, 526, self.RULE_procedureDivisionBody) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3547 + self.paragraphs() + self.state = 3551 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 0): + self.state = 3548 + self.procedureSection() + self.state = 3553 + 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 ProcedureSectionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def procedureSectionHeader(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureSectionHeaderContext,0) + + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def paragraphs(self): + return self.getTypedRuleContext(Cobol85Parser.ParagraphsContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_procedureSection + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProcedureSection" ): + listener.enterProcedureSection(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProcedureSection" ): + listener.exitProcedureSection(self) + + + + + def procedureSection(self): + + localctx = Cobol85Parser.ProcedureSectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 528, self.RULE_procedureSection) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3554 + self.procedureSectionHeader() + self.state = 3555 + self.match(Cobol85Parser.DOT_FS) + self.state = 3556 + self.paragraphs() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ParagraphsContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def sentence(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SentenceContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SentenceContext,i) + + + def paragraph(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ParagraphContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ParagraphContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_paragraphs + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterParagraphs" ): + listener.enterParagraphs(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitParagraphs" ): + listener.exitParagraphs(self) + + + + + def paragraphs(self): + + localctx = Cobol85Parser.ParagraphsContext(self, self._ctx, self.state) + self.enterRule(localctx, 530, self.RULE_paragraphs) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3561 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 13510798882242580) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & 570425345) != 0) or ((((_la - 131)) & ~0x3f) == 0 and ((1 << (_la - 131)) & 4613937818308192769) != 0) or ((((_la - 198)) & ~0x3f) == 0 and ((1 << (_la - 198)) & 1337281096974339) != 0) or ((((_la - 294)) & ~0x3f) == 0 and ((1 << (_la - 294)) & 562958543356225) != 0) or ((((_la - 365)) & ~0x3f) == 0 and ((1 << (_la - 365)) & 1161937774836712961) != 0) or ((((_la - 430)) & ~0x3f) == 0 and ((1 << (_la - 430)) & 70378206528513) != 0) or ((((_la - 500)) & ~0x3f) == 0 and ((1 << (_la - 500)) & 4035225283303964673) != 0): + self.state = 3558 + self.sentence() + self.state = 3563 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 3567 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,460,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 3564 + self.paragraph() + self.state = 3569 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,460,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ParagraphContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def paragraphName(self): + return self.getTypedRuleContext(Cobol85Parser.ParagraphNameContext,0) + + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def alteredGoTo(self): + return self.getTypedRuleContext(Cobol85Parser.AlteredGoToContext,0) + + + def sentence(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SentenceContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SentenceContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_paragraph + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterParagraph" ): + listener.enterParagraph(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitParagraph" ): + listener.exitParagraph(self) + + + + + def paragraph(self): + + localctx = Cobol85Parser.ParagraphContext(self, self._ctx, self.state) + self.enterRule(localctx, 532, self.RULE_paragraph) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3570 + self.paragraphName() + self.state = 3571 + self.match(Cobol85Parser.DOT_FS) + self.state = 3579 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,462,self._ctx) + if la_ == 1: + self.state = 3572 + self.alteredGoTo() + pass + + elif la_ == 2: + self.state = 3576 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 13510798882242580) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & 570425345) != 0) or ((((_la - 131)) & ~0x3f) == 0 and ((1 << (_la - 131)) & 4613937818308192769) != 0) or ((((_la - 198)) & ~0x3f) == 0 and ((1 << (_la - 198)) & 1337281096974339) != 0) or ((((_la - 294)) & ~0x3f) == 0 and ((1 << (_la - 294)) & 562958543356225) != 0) or ((((_la - 365)) & ~0x3f) == 0 and ((1 << (_la - 365)) & 1161937774836712961) != 0) or ((((_la - 430)) & ~0x3f) == 0 and ((1 << (_la - 430)) & 70378206528513) != 0) or ((((_la - 500)) & ~0x3f) == 0 and ((1 << (_la - 500)) & 4035225283303964673) != 0): + self.state = 3573 + self.sentence() + self.state = 3578 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SentenceContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_sentence + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSentence" ): + listener.enterSentence(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSentence" ): + listener.exitSentence(self) + + + + + def sentence(self): + + localctx = Cobol85Parser.SentenceContext(self, self._ctx, self.state) + self.enterRule(localctx, 534, self.RULE_sentence) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3584 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 13510798882242580) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & 570425345) != 0) or ((((_la - 131)) & ~0x3f) == 0 and ((1 << (_la - 131)) & 4613937818308192769) != 0) or ((((_la - 198)) & ~0x3f) == 0 and ((1 << (_la - 198)) & 1337281096974339) != 0) or ((((_la - 294)) & ~0x3f) == 0 and ((1 << (_la - 294)) & 562958543356225) != 0) or ((((_la - 365)) & ~0x3f) == 0 and ((1 << (_la - 365)) & 1161937774836712961) != 0) or ((((_la - 430)) & ~0x3f) == 0 and ((1 << (_la - 430)) & 70378206528513) != 0) or ((((_la - 500)) & ~0x3f) == 0 and ((1 << (_la - 500)) & 4035225266124095489) != 0): + self.state = 3581 + self.statement() + self.state = 3586 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 3587 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class StatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def acceptStatement(self): + return self.getTypedRuleContext(Cobol85Parser.AcceptStatementContext,0) + + + def addStatement(self): + return self.getTypedRuleContext(Cobol85Parser.AddStatementContext,0) + + + def alterStatement(self): + return self.getTypedRuleContext(Cobol85Parser.AlterStatementContext,0) + + + def callStatement(self): + return self.getTypedRuleContext(Cobol85Parser.CallStatementContext,0) + + + def cancelStatement(self): + return self.getTypedRuleContext(Cobol85Parser.CancelStatementContext,0) + + + def closeStatement(self): + return self.getTypedRuleContext(Cobol85Parser.CloseStatementContext,0) + + + def computeStatement(self): + return self.getTypedRuleContext(Cobol85Parser.ComputeStatementContext,0) + + + def continueStatement(self): + return self.getTypedRuleContext(Cobol85Parser.ContinueStatementContext,0) + + + def deleteStatement(self): + return self.getTypedRuleContext(Cobol85Parser.DeleteStatementContext,0) + + + def disableStatement(self): + return self.getTypedRuleContext(Cobol85Parser.DisableStatementContext,0) + + + def displayStatement(self): + return self.getTypedRuleContext(Cobol85Parser.DisplayStatementContext,0) + + + def divideStatement(self): + return self.getTypedRuleContext(Cobol85Parser.DivideStatementContext,0) + + + def enableStatement(self): + return self.getTypedRuleContext(Cobol85Parser.EnableStatementContext,0) + + + def entryStatement(self): + return self.getTypedRuleContext(Cobol85Parser.EntryStatementContext,0) + + + def evaluateStatement(self): + return self.getTypedRuleContext(Cobol85Parser.EvaluateStatementContext,0) + + + def exhibitStatement(self): + return self.getTypedRuleContext(Cobol85Parser.ExhibitStatementContext,0) + + + def execCicsStatement(self): + return self.getTypedRuleContext(Cobol85Parser.ExecCicsStatementContext,0) + + + def execSqlStatement(self): + return self.getTypedRuleContext(Cobol85Parser.ExecSqlStatementContext,0) + + + def execSqlImsStatement(self): + return self.getTypedRuleContext(Cobol85Parser.ExecSqlImsStatementContext,0) + + + def exitStatement(self): + return self.getTypedRuleContext(Cobol85Parser.ExitStatementContext,0) + + + def generateStatement(self): + return self.getTypedRuleContext(Cobol85Parser.GenerateStatementContext,0) + + + def gobackStatement(self): + return self.getTypedRuleContext(Cobol85Parser.GobackStatementContext,0) + + + def goToStatement(self): + return self.getTypedRuleContext(Cobol85Parser.GoToStatementContext,0) + + + def ifStatement(self): + return self.getTypedRuleContext(Cobol85Parser.IfStatementContext,0) + + + def initializeStatement(self): + return self.getTypedRuleContext(Cobol85Parser.InitializeStatementContext,0) + + + def initiateStatement(self): + return self.getTypedRuleContext(Cobol85Parser.InitiateStatementContext,0) + + + def inspectStatement(self): + return self.getTypedRuleContext(Cobol85Parser.InspectStatementContext,0) + + + def mergeStatement(self): + return self.getTypedRuleContext(Cobol85Parser.MergeStatementContext,0) + + + def moveStatement(self): + return self.getTypedRuleContext(Cobol85Parser.MoveStatementContext,0) + + + def multiplyStatement(self): + return self.getTypedRuleContext(Cobol85Parser.MultiplyStatementContext,0) + + + def openStatement(self): + return self.getTypedRuleContext(Cobol85Parser.OpenStatementContext,0) + + + def performStatement(self): + return self.getTypedRuleContext(Cobol85Parser.PerformStatementContext,0) + + + def purgeStatement(self): + return self.getTypedRuleContext(Cobol85Parser.PurgeStatementContext,0) + + + def readStatement(self): + return self.getTypedRuleContext(Cobol85Parser.ReadStatementContext,0) + + + def receiveStatement(self): + return self.getTypedRuleContext(Cobol85Parser.ReceiveStatementContext,0) + + + def releaseStatement(self): + return self.getTypedRuleContext(Cobol85Parser.ReleaseStatementContext,0) + + + def returnStatement(self): + return self.getTypedRuleContext(Cobol85Parser.ReturnStatementContext,0) + + + def rewriteStatement(self): + return self.getTypedRuleContext(Cobol85Parser.RewriteStatementContext,0) + + + def searchStatement(self): + return self.getTypedRuleContext(Cobol85Parser.SearchStatementContext,0) + + + def sendStatement(self): + return self.getTypedRuleContext(Cobol85Parser.SendStatementContext,0) + + + def setStatement(self): + return self.getTypedRuleContext(Cobol85Parser.SetStatementContext,0) + + + def sortStatement(self): + return self.getTypedRuleContext(Cobol85Parser.SortStatementContext,0) + + + def startStatement(self): + return self.getTypedRuleContext(Cobol85Parser.StartStatementContext,0) + + + def stopStatement(self): + return self.getTypedRuleContext(Cobol85Parser.StopStatementContext,0) + + + def stringStatement(self): + return self.getTypedRuleContext(Cobol85Parser.StringStatementContext,0) + + + def subtractStatement(self): + return self.getTypedRuleContext(Cobol85Parser.SubtractStatementContext,0) + + + def terminateStatement(self): + return self.getTypedRuleContext(Cobol85Parser.TerminateStatementContext,0) + + + def unstringStatement(self): + return self.getTypedRuleContext(Cobol85Parser.UnstringStatementContext,0) + + + def writeStatement(self): + return self.getTypedRuleContext(Cobol85Parser.WriteStatementContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_statement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStatement" ): + listener.enterStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStatement" ): + listener.exitStatement(self) + + + + + def statement(self): + + localctx = Cobol85Parser.StatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 536, self.RULE_statement) + try: + self.state = 3638 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [2]: + self.enterOuterAlt(localctx, 1) + self.state = 3589 + self.acceptStatement() + pass + elif token in [4]: + self.enterOuterAlt(localctx, 2) + self.state = 3590 + self.addStatement() + pass + elif token in [17]: + self.enterOuterAlt(localctx, 3) + self.state = 3591 + self.alterStatement() + pass + elif token in [52]: + self.enterOuterAlt(localctx, 4) + self.state = 3592 + self.callStatement() + pass + elif token in [53]: + self.enterOuterAlt(localctx, 5) + self.state = 3593 + self.cancelStatement() + pass + elif token in [67]: + self.enterOuterAlt(localctx, 6) + self.state = 3594 + self.closeStatement() + pass + elif token in [92]: + self.enterOuterAlt(localctx, 7) + self.state = 3595 + self.computeStatement() + pass + elif token in [96]: + self.enterOuterAlt(localctx, 8) + self.state = 3596 + self.continueStatement() + pass + elif token in [131]: + self.enterOuterAlt(localctx, 9) + self.state = 3597 + self.deleteStatement() + pass + elif token in [140]: + self.enterOuterAlt(localctx, 10) + self.state = 3598 + self.disableStatement() + pass + elif token in [142]: + self.enterOuterAlt(localctx, 11) + self.state = 3599 + self.displayStatement() + pass + elif token in [144]: + self.enterOuterAlt(localctx, 12) + self.state = 3600 + self.divideStatement() + pass + elif token in [157]: + self.enterOuterAlt(localctx, 13) + self.state = 3601 + self.enableStatement() + pass + elif token in [182]: + self.enterOuterAlt(localctx, 14) + self.state = 3602 + self.entryStatement() + pass + elif token in [193]: + self.enterOuterAlt(localctx, 15) + self.state = 3603 + self.evaluateStatement() + pass + elif token in [198]: + self.enterOuterAlt(localctx, 16) + self.state = 3604 + self.exhibitStatement() + pass + elif token in [559]: + self.enterOuterAlt(localctx, 17) + self.state = 3605 + self.execCicsStatement() + pass + elif token in [561]: + self.enterOuterAlt(localctx, 18) + self.state = 3606 + self.execSqlStatement() + pass + elif token in [560]: + self.enterOuterAlt(localctx, 19) + self.state = 3607 + self.execSqlImsStatement() + pass + elif token in [199]: + self.enterOuterAlt(localctx, 20) + self.state = 3608 + self.exitStatement() + pass + elif token in [220]: + self.enterOuterAlt(localctx, 21) + self.state = 3609 + self.generateStatement() + pass + elif token in [221]: + self.enterOuterAlt(localctx, 22) + self.state = 3610 + self.gobackStatement() + pass + elif token in [224]: + self.enterOuterAlt(localctx, 23) + self.state = 3611 + self.goToStatement() + pass + elif token in [236]: + self.enterOuterAlt(localctx, 24) + self.state = 3612 + self.ifStatement() + pass + elif token in [244]: + self.enterOuterAlt(localctx, 25) + self.state = 3613 + self.initializeStatement() + pass + elif token in [245]: + self.enterOuterAlt(localctx, 26) + self.state = 3614 + self.initiateStatement() + pass + elif token in [248]: + self.enterOuterAlt(localctx, 27) + self.state = 3615 + self.inspectStatement() + pass + elif token in [294]: + self.enterOuterAlt(localctx, 28) + self.state = 3616 + self.mergeStatement() + pass + elif token in [300]: + self.enterOuterAlt(localctx, 29) + self.state = 3617 + self.moveStatement() + pass + elif token in [302]: + self.enterOuterAlt(localctx, 30) + self.state = 3618 + self.multiplyStatement() + pass + elif token in [327]: + self.enterOuterAlt(localctx, 31) + self.state = 3619 + self.openStatement() + pass + elif token in [343]: + self.enterOuterAlt(localctx, 32) + self.state = 3620 + self.performStatement() + pass + elif token in [365]: + self.enterOuterAlt(localctx, 33) + self.state = 3621 + self.purgeStatement() + pass + elif token in [374]: + self.enterOuterAlt(localctx, 34) + self.state = 3622 + self.readStatement() + pass + elif token in [375]: + self.enterOuterAlt(localctx, 35) + self.state = 3623 + self.receiveStatement() + pass + elif token in [387]: + self.enterOuterAlt(localctx, 36) + self.state = 3624 + self.releaseStatement() + pass + elif token in [403]: + self.enterOuterAlt(localctx, 37) + self.state = 3625 + self.returnStatement() + pass + elif token in [408]: + self.enterOuterAlt(localctx, 38) + self.state = 3626 + self.rewriteStatement() + pass + elif token in [418]: + self.enterOuterAlt(localctx, 39) + self.state = 3627 + self.searchStatement() + pass + elif token in [425]: + self.enterOuterAlt(localctx, 40) + self.state = 3628 + self.sendStatement() + pass + elif token in [430]: + self.enterOuterAlt(localctx, 41) + self.state = 3629 + self.setStatement() + pass + elif token in [440]: + self.enterOuterAlt(localctx, 42) + self.state = 3630 + self.sortStatement() + pass + elif token in [456]: + self.enterOuterAlt(localctx, 43) + self.state = 3631 + self.startStatement() + pass + elif token in [458]: + self.enterOuterAlt(localctx, 44) + self.state = 3632 + self.stopStatement() + pass + elif token in [459]: + self.enterOuterAlt(localctx, 45) + self.state = 3633 + self.stringStatement() + pass + elif token in [463]: + self.enterOuterAlt(localctx, 46) + self.state = 3634 + self.subtractStatement() + pass + elif token in [476]: + self.enterOuterAlt(localctx, 47) + self.state = 3635 + self.terminateStatement() + pass + elif token in [500]: + self.enterOuterAlt(localctx, 48) + self.state = 3636 + self.unstringStatement() + pass + elif token in [517]: + self.enterOuterAlt(localctx, 49) + self.state = 3637 + self.writeStatement() + 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 AcceptStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ACCEPT(self): + return self.getToken(Cobol85Parser.ACCEPT, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def acceptFromDateStatement(self): + return self.getTypedRuleContext(Cobol85Parser.AcceptFromDateStatementContext,0) + + + def acceptFromEscapeKeyStatement(self): + return self.getTypedRuleContext(Cobol85Parser.AcceptFromEscapeKeyStatementContext,0) + + + def acceptFromMnemonicStatement(self): + return self.getTypedRuleContext(Cobol85Parser.AcceptFromMnemonicStatementContext,0) + + + def acceptMessageCountStatement(self): + return self.getTypedRuleContext(Cobol85Parser.AcceptMessageCountStatementContext,0) + + + def onExceptionClause(self): + return self.getTypedRuleContext(Cobol85Parser.OnExceptionClauseContext,0) + + + def notOnExceptionClause(self): + return self.getTypedRuleContext(Cobol85Parser.NotOnExceptionClauseContext,0) + + + def END_ACCEPT(self): + return self.getToken(Cobol85Parser.END_ACCEPT, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_acceptStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAcceptStatement" ): + listener.enterAcceptStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAcceptStatement" ): + listener.exitAcceptStatement(self) + + + + + def acceptStatement(self): + + localctx = Cobol85Parser.AcceptStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 538, self.RULE_acceptStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3640 + self.match(Cobol85Parser.ACCEPT) + self.state = 3641 + self.identifier() + self.state = 3646 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,465,self._ctx) + if la_ == 1: + self.state = 3642 + self.acceptFromDateStatement() + + elif la_ == 2: + self.state = 3643 + self.acceptFromEscapeKeyStatement() + + elif la_ == 3: + self.state = 3644 + self.acceptFromMnemonicStatement() + + elif la_ == 4: + self.state = 3645 + self.acceptMessageCountStatement() + + + self.state = 3649 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,466,self._ctx) + if la_ == 1: + self.state = 3648 + self.onExceptionClause() + + + self.state = 3652 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,467,self._ctx) + if la_ == 1: + self.state = 3651 + self.notOnExceptionClause() + + + self.state = 3655 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,468,self._ctx) + if la_ == 1: + self.state = 3654 + self.match(Cobol85Parser.END_ACCEPT) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AcceptFromDateStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FROM(self): + return self.getToken(Cobol85Parser.FROM, 0) + + def DATE(self): + return self.getToken(Cobol85Parser.DATE, 0) + + def DAY(self): + return self.getToken(Cobol85Parser.DAY, 0) + + def DAY_OF_WEEK(self): + return self.getToken(Cobol85Parser.DAY_OF_WEEK, 0) + + def TIME(self): + return self.getToken(Cobol85Parser.TIME, 0) + + def TIMER(self): + return self.getToken(Cobol85Parser.TIMER, 0) + + def TODAYS_DATE(self): + return self.getToken(Cobol85Parser.TODAYS_DATE, 0) + + def TODAYS_NAME(self): + return self.getToken(Cobol85Parser.TODAYS_NAME, 0) + + def YEAR(self): + return self.getToken(Cobol85Parser.YEAR, 0) + + def YYYYMMDD(self): + return self.getToken(Cobol85Parser.YYYYMMDD, 0) + + def YYYYDDD(self): + return self.getToken(Cobol85Parser.YYYYDDD, 0) + + def MMDDYYYY(self): + return self.getToken(Cobol85Parser.MMDDYYYY, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_acceptFromDateStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAcceptFromDateStatement" ): + listener.enterAcceptFromDateStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAcceptFromDateStatement" ): + listener.exitAcceptFromDateStatement(self) + + + + + def acceptFromDateStatement(self): + + localctx = Cobol85Parser.AcceptFromDateStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 540, self.RULE_acceptFromDateStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3657 + self.match(Cobol85Parser.FROM) + self.state = 3677 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [111]: + self.state = 3658 + self.match(Cobol85Parser.DATE) + self.state = 3660 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==519: + self.state = 3659 + self.match(Cobol85Parser.YYYYMMDD) + + + pass + elif token in [114]: + self.state = 3662 + self.match(Cobol85Parser.DAY) + self.state = 3664 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==520: + self.state = 3663 + self.match(Cobol85Parser.YYYYDDD) + + + pass + elif token in [115]: + self.state = 3666 + self.match(Cobol85Parser.DAY_OF_WEEK) + pass + elif token in [485]: + self.state = 3667 + self.match(Cobol85Parser.TIME) + pass + elif token in [486]: + self.state = 3668 + self.match(Cobol85Parser.TIMER) + pass + elif token in [490]: + self.state = 3669 + self.match(Cobol85Parser.TODAYS_DATE) + self.state = 3671 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==296: + self.state = 3670 + self.match(Cobol85Parser.MMDDYYYY) + + + pass + elif token in [491]: + self.state = 3673 + self.match(Cobol85Parser.TODAYS_NAME) + pass + elif token in [518]: + self.state = 3674 + self.match(Cobol85Parser.YEAR) + pass + elif token in [519]: + self.state = 3675 + self.match(Cobol85Parser.YYYYMMDD) + pass + elif token in [520]: + self.state = 3676 + self.match(Cobol85Parser.YYYYDDD) + 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 AcceptFromMnemonicStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FROM(self): + return self.getToken(Cobol85Parser.FROM, 0) + + def mnemonicName(self): + return self.getTypedRuleContext(Cobol85Parser.MnemonicNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_acceptFromMnemonicStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAcceptFromMnemonicStatement" ): + listener.enterAcceptFromMnemonicStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAcceptFromMnemonicStatement" ): + listener.exitAcceptFromMnemonicStatement(self) + + + + + def acceptFromMnemonicStatement(self): + + localctx = Cobol85Parser.AcceptFromMnemonicStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 542, self.RULE_acceptFromMnemonicStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3679 + self.match(Cobol85Parser.FROM) + self.state = 3680 + self.mnemonicName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AcceptFromEscapeKeyStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FROM(self): + return self.getToken(Cobol85Parser.FROM, 0) + + def ESCAPE(self): + return self.getToken(Cobol85Parser.ESCAPE, 0) + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_acceptFromEscapeKeyStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAcceptFromEscapeKeyStatement" ): + listener.enterAcceptFromEscapeKeyStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAcceptFromEscapeKeyStatement" ): + listener.exitAcceptFromEscapeKeyStatement(self) + + + + + def acceptFromEscapeKeyStatement(self): + + localctx = Cobol85Parser.AcceptFromEscapeKeyStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 544, self.RULE_acceptFromEscapeKeyStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3682 + self.match(Cobol85Parser.FROM) + self.state = 3683 + self.match(Cobol85Parser.ESCAPE) + self.state = 3684 + self.match(Cobol85Parser.KEY) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AcceptMessageCountStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def COUNT(self): + return self.getToken(Cobol85Parser.COUNT, 0) + + def MESSAGE(self): + return self.getToken(Cobol85Parser.MESSAGE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_acceptMessageCountStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAcceptMessageCountStatement" ): + listener.enterAcceptMessageCountStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAcceptMessageCountStatement" ): + listener.exitAcceptMessageCountStatement(self) + + + + + def acceptMessageCountStatement(self): + + localctx = Cobol85Parser.AcceptMessageCountStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 546, self.RULE_acceptMessageCountStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3687 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==295: + self.state = 3686 + self.match(Cobol85Parser.MESSAGE) + + + self.state = 3689 + self.match(Cobol85Parser.COUNT) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AddStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ADD(self): + return self.getToken(Cobol85Parser.ADD, 0) + + def addToStatement(self): + return self.getTypedRuleContext(Cobol85Parser.AddToStatementContext,0) + + + def addToGivingStatement(self): + return self.getTypedRuleContext(Cobol85Parser.AddToGivingStatementContext,0) + + + def addCorrespondingStatement(self): + return self.getTypedRuleContext(Cobol85Parser.AddCorrespondingStatementContext,0) + + + def onSizeErrorPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.OnSizeErrorPhraseContext,0) + + + def notOnSizeErrorPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.NotOnSizeErrorPhraseContext,0) + + + def END_ADD(self): + return self.getToken(Cobol85Parser.END_ADD, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_addStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAddStatement" ): + listener.enterAddStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAddStatement" ): + listener.exitAddStatement(self) + + + + + def addStatement(self): + + localctx = Cobol85Parser.AddStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 548, self.RULE_addStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3691 + self.match(Cobol85Parser.ADD) + self.state = 3695 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,474,self._ctx) + if la_ == 1: + self.state = 3692 + self.addToStatement() + pass + + elif la_ == 2: + self.state = 3693 + self.addToGivingStatement() + pass + + elif la_ == 3: + self.state = 3694 + self.addCorrespondingStatement() + pass + + + self.state = 3698 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,475,self._ctx) + if la_ == 1: + self.state = 3697 + self.onSizeErrorPhrase() + + + self.state = 3701 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,476,self._ctx) + if la_ == 1: + self.state = 3700 + self.notOnSizeErrorPhrase() + + + self.state = 3704 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,477,self._ctx) + if la_ == 1: + self.state = 3703 + self.match(Cobol85Parser.END_ADD) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AddToStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def addFrom(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.AddFromContext) + else: + return self.getTypedRuleContext(Cobol85Parser.AddFromContext,i) + + + def addTo(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.AddToContext) + else: + return self.getTypedRuleContext(Cobol85Parser.AddToContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_addToStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAddToStatement" ): + listener.enterAddToStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAddToStatement" ): + listener.exitAddToStatement(self) + + + + + def addToStatement(self): + + localctx = Cobol85Parser.AddToStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 550, self.RULE_addToStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3707 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 3706 + self.addFrom() + self.state = 3709 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822370) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194964618422267) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202427199037528969) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874440372879459) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 1819828109721609) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 572150674022301857) != 0) or ((((_la - 551)) & ~0x3f) == 0 and ((1 << (_la - 551)) & 127) != 0)): + break + + self.state = 3711 + self.match(Cobol85Parser.TO) + self.state = 3713 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 3712 + self.addTo() + self.state = 3715 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 AddToGivingStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GIVING(self): + return self.getToken(Cobol85Parser.GIVING, 0) + + def addFrom(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.AddFromContext) + else: + return self.getTypedRuleContext(Cobol85Parser.AddFromContext,i) + + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def addGiving(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.AddGivingContext) + else: + return self.getTypedRuleContext(Cobol85Parser.AddGivingContext,i) + + + def addToGiving(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.AddToGivingContext) + else: + return self.getTypedRuleContext(Cobol85Parser.AddToGivingContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_addToGivingStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAddToGivingStatement" ): + listener.enterAddToGivingStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAddToGivingStatement" ): + listener.exitAddToGivingStatement(self) + + + + + def addToGivingStatement(self): + + localctx = Cobol85Parser.AddToGivingStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 552, self.RULE_addToGivingStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3718 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 3717 + self.addFrom() + self.state = 3720 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822370) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194964618422267) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202427199037528969) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874440372879459) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 1819828109721609) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 572150674022301857) != 0) or ((((_la - 551)) & ~0x3f) == 0 and ((1 << (_la - 551)) & 127) != 0)): + break + + self.state = 3728 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==489: + self.state = 3722 + self.match(Cobol85Parser.TO) + self.state = 3724 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 3723 + self.addToGiving() + self.state = 3726 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822370) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194964618422267) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202427199037528969) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874440372879459) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 1819828109721609) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 572150674022301857) != 0) or ((((_la - 551)) & ~0x3f) == 0 and ((1 << (_la - 551)) & 127) != 0)): + break + + + + self.state = 3730 + self.match(Cobol85Parser.GIVING) + self.state = 3732 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 3731 + self.addGiving() + self.state = 3734 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 AddCorrespondingStatementContext(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(Cobol85Parser.IdentifierContext,0) + + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def addTo(self): + return self.getTypedRuleContext(Cobol85Parser.AddToContext,0) + + + def CORRESPONDING(self): + return self.getToken(Cobol85Parser.CORRESPONDING, 0) + + def CORR(self): + return self.getToken(Cobol85Parser.CORR, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_addCorrespondingStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAddCorrespondingStatement" ): + listener.enterAddCorrespondingStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAddCorrespondingStatement" ): + listener.exitAddCorrespondingStatement(self) + + + + + def addCorrespondingStatement(self): + + localctx = Cobol85Parser.AddCorrespondingStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 554, self.RULE_addCorrespondingStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3736 + _la = self._input.LA(1) + if not(_la==103 or _la==104): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3737 + self.identifier() + self.state = 3738 + self.match(Cobol85Parser.TO) + self.state = 3739 + self.addTo() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AddFromContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_addFrom + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAddFrom" ): + listener.enterAddFrom(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAddFrom" ): + listener.exitAddFrom(self) + + + + + def addFrom(self): + + localctx = Cobol85Parser.AddFromContext(self, self._ctx, self.state) + self.enterRule(localctx, 556, self.RULE_addFrom) + try: + self.state = 3743 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,484,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3741 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3742 + self.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 AddToContext(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(Cobol85Parser.IdentifierContext,0) + + + def ROUNDED(self): + return self.getToken(Cobol85Parser.ROUNDED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_addTo + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAddTo" ): + listener.enterAddTo(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAddTo" ): + listener.exitAddTo(self) + + + + + def addTo(self): + + localctx = Cobol85Parser.AddToContext(self, self._ctx, self.state) + self.enterRule(localctx, 558, self.RULE_addTo) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3745 + self.identifier() + self.state = 3747 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==412: + self.state = 3746 + self.match(Cobol85Parser.ROUNDED) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AddToGivingContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_addToGiving + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAddToGiving" ): + listener.enterAddToGiving(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAddToGiving" ): + listener.exitAddToGiving(self) + + + + + def addToGiving(self): + + localctx = Cobol85Parser.AddToGivingContext(self, self._ctx, self.state) + self.enterRule(localctx, 560, self.RULE_addToGiving) + try: + self.state = 3751 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,486,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3749 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3750 + self.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 AddGivingContext(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(Cobol85Parser.IdentifierContext,0) + + + def ROUNDED(self): + return self.getToken(Cobol85Parser.ROUNDED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_addGiving + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAddGiving" ): + listener.enterAddGiving(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAddGiving" ): + listener.exitAddGiving(self) + + + + + def addGiving(self): + + localctx = Cobol85Parser.AddGivingContext(self, self._ctx, self.state) + self.enterRule(localctx, 562, self.RULE_addGiving) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3753 + self.identifier() + self.state = 3755 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==412: + self.state = 3754 + self.match(Cobol85Parser.ROUNDED) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AlteredGoToContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GO(self): + return self.getToken(Cobol85Parser.GO, 0) + + def DOT_FS(self): + return self.getToken(Cobol85Parser.DOT_FS, 0) + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_alteredGoTo + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlteredGoTo" ): + listener.enterAlteredGoTo(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlteredGoTo" ): + listener.exitAlteredGoTo(self) + + + + + def alteredGoTo(self): + + localctx = Cobol85Parser.AlteredGoToContext(self, self._ctx, self.state) + self.enterRule(localctx, 564, self.RULE_alteredGoTo) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3757 + self.match(Cobol85Parser.GO) + self.state = 3759 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==489: + self.state = 3758 + self.match(Cobol85Parser.TO) + + + self.state = 3761 + self.match(Cobol85Parser.DOT_FS) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AlterStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALTER(self): + return self.getToken(Cobol85Parser.ALTER, 0) + + def alterProceedTo(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.AlterProceedToContext) + else: + return self.getTypedRuleContext(Cobol85Parser.AlterProceedToContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_alterStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlterStatement" ): + listener.enterAlterStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlterStatement" ): + listener.exitAlterStatement(self) + + + + + def alterStatement(self): + + localctx = Cobol85Parser.AlterStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 566, self.RULE_alterStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3763 + self.match(Cobol85Parser.ALTER) + self.state = 3765 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 3764 + self.alterProceedTo() + self.state = 3767 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 AlterProceedToContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def procedureName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ProcedureNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ProcedureNameContext,i) + + + def TO(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.TO) + else: + return self.getToken(Cobol85Parser.TO, i) + + def PROCEED(self): + return self.getToken(Cobol85Parser.PROCEED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_alterProceedTo + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlterProceedTo" ): + listener.enterAlterProceedTo(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlterProceedTo" ): + listener.exitAlterProceedTo(self) + + + + + def alterProceedTo(self): + + localctx = Cobol85Parser.AlterProceedToContext(self, self._ctx, self.state) + self.enterRule(localctx, 568, self.RULE_alterProceedTo) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3769 + self.procedureName() + self.state = 3770 + self.match(Cobol85Parser.TO) + self.state = 3773 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==359: + self.state = 3771 + self.match(Cobol85Parser.PROCEED) + self.state = 3772 + self.match(Cobol85Parser.TO) + + + self.state = 3775 + self.procedureName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CallStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CALL(self): + return self.getToken(Cobol85Parser.CALL, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def callUsingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.CallUsingPhraseContext,0) + + + def callGivingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.CallGivingPhraseContext,0) + + + def onOverflowPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.OnOverflowPhraseContext,0) + + + def onExceptionClause(self): + return self.getTypedRuleContext(Cobol85Parser.OnExceptionClauseContext,0) + + + def notOnExceptionClause(self): + return self.getTypedRuleContext(Cobol85Parser.NotOnExceptionClauseContext,0) + + + def END_CALL(self): + return self.getToken(Cobol85Parser.END_CALL, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_callStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCallStatement" ): + listener.enterCallStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCallStatement" ): + listener.exitCallStatement(self) + + + + + def callStatement(self): + + localctx = Cobol85Parser.CallStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 570, self.RULE_callStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3777 + self.match(Cobol85Parser.CALL) + self.state = 3780 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,491,self._ctx) + if la_ == 1: + self.state = 3778 + self.identifier() + pass + + elif la_ == 2: + self.state = 3779 + self.literal() + pass + + + self.state = 3783 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==506: + self.state = 3782 + self.callUsingPhrase() + + + self.state = 3786 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==222 or _la==405: + self.state = 3785 + self.callGivingPhrase() + + + self.state = 3789 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,494,self._ctx) + if la_ == 1: + self.state = 3788 + self.onOverflowPhrase() + + + self.state = 3792 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,495,self._ctx) + if la_ == 1: + self.state = 3791 + self.onExceptionClause() + + + self.state = 3795 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,496,self._ctx) + if la_ == 1: + self.state = 3794 + self.notOnExceptionClause() + + + self.state = 3798 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,497,self._ctx) + if la_ == 1: + self.state = 3797 + self.match(Cobol85Parser.END_CALL) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CallUsingPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def USING(self): + return self.getToken(Cobol85Parser.USING, 0) + + def callUsingParameter(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.CallUsingParameterContext) + else: + return self.getTypedRuleContext(Cobol85Parser.CallUsingParameterContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_callUsingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCallUsingPhrase" ): + listener.enterCallUsingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCallUsingPhrase" ): + listener.exitCallUsingPhrase(self) + + + + + def callUsingPhrase(self): + + localctx = Cobol85Parser.CallUsingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 572, self.RULE_callUsingPhrase) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3800 + self.match(Cobol85Parser.USING) + self.state = 3802 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 3801 + self.callUsingParameter() + + else: + raise NoViableAltException(self) + self.state = 3804 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,498,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CallUsingParameterContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def callByReferencePhrase(self): + return self.getTypedRuleContext(Cobol85Parser.CallByReferencePhraseContext,0) + + + def callByValuePhrase(self): + return self.getTypedRuleContext(Cobol85Parser.CallByValuePhraseContext,0) + + + def callByContentPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.CallByContentPhraseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_callUsingParameter + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCallUsingParameter" ): + listener.enterCallUsingParameter(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCallUsingParameter" ): + listener.exitCallUsingParameter(self) + + + + + def callUsingParameter(self): + + localctx = Cobol85Parser.CallUsingParameterContext(self, self._ctx, self.state) + self.enterRule(localctx, 574, self.RULE_callUsingParameter) + try: + self.state = 3809 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,499,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3806 + self.callByReferencePhrase() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3807 + self.callByValuePhrase() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3808 + self.callByContentPhrase() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CallByReferencePhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REFERENCE(self): + return self.getToken(Cobol85Parser.REFERENCE, 0) + + def callByReference(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.CallByReferenceContext) + else: + return self.getTypedRuleContext(Cobol85Parser.CallByReferenceContext,i) + + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_callByReferencePhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCallByReferencePhrase" ): + listener.enterCallByReferencePhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCallByReferencePhrase" ): + listener.exitCallByReferencePhrase(self) + + + + + def callByReferencePhrase(self): + + localctx = Cobol85Parser.CallByReferencePhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 576, self.RULE_callByReferencePhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3815 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==49 or _la==384: + self.state = 3812 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==49: + self.state = 3811 + self.match(Cobol85Parser.BY) + + + self.state = 3814 + self.match(Cobol85Parser.REFERENCE) + + + self.state = 3818 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 3817 + self.callByReference() + + else: + raise NoViableAltException(self) + self.state = 3820 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,502,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CallByReferenceContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def ADDRESS(self): + return self.getToken(Cobol85Parser.ADDRESS, 0) + + def OF(self): + return self.getToken(Cobol85Parser.OF, 0) + + def INTEGER(self): + return self.getToken(Cobol85Parser.INTEGER, 0) + + def STRING(self): + return self.getToken(Cobol85Parser.STRING, 0) + + def OMITTED(self): + return self.getToken(Cobol85Parser.OMITTED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_callByReference + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCallByReference" ): + listener.enterCallByReference(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCallByReference" ): + listener.exitCallByReference(self) + + + + + def callByReference(self): + + localctx = Cobol85Parser.CallByReferenceContext(self, self._ctx, self.state) + self.enterRule(localctx, 578, self.RULE_callByReference) + try: + self.state = 3834 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [1, 5, 9, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 111, 114, 115, 118, 119, 120, 121, 122, 123, 124, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 204, 213, 214, 216, 217, 218, 219, 226, 229, 230, 231, 237, 238, 250, 258, 260, 262, 264, 265, 268, 269, 270, 272, 273, 274, 278, 281, 283, 284, 287, 288, 289, 290, 291, 292, 296, 303, 304, 305, 308, 311, 313, 314, 317, 319, 322, 331, 336, 337, 341, 342, 352, 353, 355, 360, 361, 364, 367, 368, 370, 371, 373, 376, 380, 383, 391, 398, 401, 404, 415, 420, 431, 432, 433, 434, 435, 436, 437, 441, 442, 443, 445, 446, 447, 450, 451, 459, 466, 471, 473, 481, 482, 485, 486, 490, 491, 494, 495, 497, 498, 510, 511, 513, 518, 519, 520, 521, 522, 523, 524, 551, 552, 553, 554, 555, 556, 557]: + self.enterOuterAlt(localctx, 1) + self.state = 3831 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,504,self._ctx) + if la_ == 1: + self.state = 3826 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,503,self._ctx) + if la_ == 1: + self.state = 3822 + self.match(Cobol85Parser.ADDRESS) + self.state = 3823 + self.match(Cobol85Parser.OF) + + elif la_ == 2: + self.state = 3824 + self.match(Cobol85Parser.INTEGER) + + elif la_ == 3: + self.state = 3825 + self.match(Cobol85Parser.STRING) + + + self.state = 3828 + self.identifier() + pass + + elif la_ == 2: + self.state = 3829 + self.literal() + pass + + elif la_ == 3: + self.state = 3830 + self.fileName() + pass + + + pass + elif token in [325]: + self.enterOuterAlt(localctx, 2) + self.state = 3833 + self.match(Cobol85Parser.OMITTED) + 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 CallByValuePhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def VALUE(self): + return self.getToken(Cobol85Parser.VALUE, 0) + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def callByValue(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.CallByValueContext) + else: + return self.getTypedRuleContext(Cobol85Parser.CallByValueContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_callByValuePhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCallByValuePhrase" ): + listener.enterCallByValuePhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCallByValuePhrase" ): + listener.exitCallByValuePhrase(self) + + + + + def callByValuePhrase(self): + + localctx = Cobol85Parser.CallByValuePhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 580, self.RULE_callByValuePhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3837 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==49: + self.state = 3836 + self.match(Cobol85Parser.BY) + + + self.state = 3839 + self.match(Cobol85Parser.VALUE) + self.state = 3841 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 3840 + self.callByValue() + + else: + raise NoViableAltException(self) + self.state = 3843 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,507,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CallByValueContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def ADDRESS(self): + return self.getToken(Cobol85Parser.ADDRESS, 0) + + def OF(self): + return self.getToken(Cobol85Parser.OF, 0) + + def LENGTH(self): + return self.getToken(Cobol85Parser.LENGTH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_callByValue + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCallByValue" ): + listener.enterCallByValue(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCallByValue" ): + listener.exitCallByValue(self) + + + + + def callByValue(self): + + localctx = Cobol85Parser.CallByValueContext(self, self._ctx, self.state) + self.enterRule(localctx, 582, self.RULE_callByValue) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3851 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,509,self._ctx) + if la_ == 1: + self.state = 3845 + self.match(Cobol85Parser.ADDRESS) + self.state = 3846 + self.match(Cobol85Parser.OF) + + elif la_ == 2: + self.state = 3847 + self.match(Cobol85Parser.LENGTH) + self.state = 3849 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==323: + self.state = 3848 + self.match(Cobol85Parser.OF) + + + + + self.state = 3855 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,510,self._ctx) + if la_ == 1: + self.state = 3853 + self.identifier() + pass + + elif la_ == 2: + self.state = 3854 + self.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 CallByContentPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CONTENT(self): + return self.getToken(Cobol85Parser.CONTENT, 0) + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def callByContent(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.CallByContentContext) + else: + return self.getTypedRuleContext(Cobol85Parser.CallByContentContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_callByContentPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCallByContentPhrase" ): + listener.enterCallByContentPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCallByContentPhrase" ): + listener.exitCallByContentPhrase(self) + + + + + def callByContentPhrase(self): + + localctx = Cobol85Parser.CallByContentPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 584, self.RULE_callByContentPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3858 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==49: + self.state = 3857 + self.match(Cobol85Parser.BY) + + + self.state = 3860 + self.match(Cobol85Parser.CONTENT) + self.state = 3862 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 3861 + self.callByContent() + + else: + raise NoViableAltException(self) + self.state = 3864 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,512,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CallByContentContext(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(Cobol85Parser.IdentifierContext,0) + + + def ADDRESS(self): + return self.getToken(Cobol85Parser.ADDRESS, 0) + + def OF(self): + return self.getToken(Cobol85Parser.OF, 0) + + def LENGTH(self): + return self.getToken(Cobol85Parser.LENGTH, 0) + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def OMITTED(self): + return self.getToken(Cobol85Parser.OMITTED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_callByContent + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCallByContent" ): + listener.enterCallByContent(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCallByContent" ): + listener.exitCallByContent(self) + + + + + def callByContent(self): + + localctx = Cobol85Parser.CallByContentContext(self, self._ctx, self.state) + self.enterRule(localctx, 586, self.RULE_callByContent) + self._la = 0 # Token type + try: + self.state = 3877 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,515,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3872 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,514,self._ctx) + if la_ == 1: + self.state = 3866 + self.match(Cobol85Parser.ADDRESS) + self.state = 3867 + self.match(Cobol85Parser.OF) + + elif la_ == 2: + self.state = 3868 + self.match(Cobol85Parser.LENGTH) + self.state = 3870 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==323: + self.state = 3869 + self.match(Cobol85Parser.OF) + + + + + self.state = 3874 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3875 + self.literal() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3876 + self.match(Cobol85Parser.OMITTED) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CallGivingPhraseContext(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(Cobol85Parser.IdentifierContext,0) + + + def GIVING(self): + return self.getToken(Cobol85Parser.GIVING, 0) + + def RETURNING(self): + return self.getToken(Cobol85Parser.RETURNING, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_callGivingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCallGivingPhrase" ): + listener.enterCallGivingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCallGivingPhrase" ): + listener.exitCallGivingPhrase(self) + + + + + def callGivingPhrase(self): + + localctx = Cobol85Parser.CallGivingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 588, self.RULE_callGivingPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3879 + _la = self._input.LA(1) + if not(_la==222 or _la==405): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3880 + 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 CancelStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CANCEL(self): + return self.getToken(Cobol85Parser.CANCEL, 0) + + def cancelCall(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.CancelCallContext) + else: + return self.getTypedRuleContext(Cobol85Parser.CancelCallContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_cancelStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCancelStatement" ): + listener.enterCancelStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCancelStatement" ): + listener.exitCancelStatement(self) + + + + + def cancelStatement(self): + + localctx = Cobol85Parser.CancelStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 590, self.RULE_cancelStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3882 + self.match(Cobol85Parser.CANCEL) + self.state = 3884 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 3883 + self.cancelCall() + self.state = 3886 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822370) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194964618422267) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202427199037528969) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874440372879459) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 1819828109721609) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 572150674022301857) != 0) or ((((_la - 551)) & ~0x3f) == 0 and ((1 << (_la - 551)) & 127) != 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 CancelCallContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def libraryName(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryNameContext,0) + + + def BYTITLE(self): + return self.getToken(Cobol85Parser.BYTITLE, 0) + + def BYFUNCTION(self): + return self.getToken(Cobol85Parser.BYFUNCTION, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_cancelCall + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCancelCall" ): + listener.enterCancelCall(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCancelCall" ): + listener.exitCancelCall(self) + + + + + def cancelCall(self): + + localctx = Cobol85Parser.CancelCallContext(self, self._ctx, self.state) + self.enterRule(localctx, 592, self.RULE_cancelCall) + self._la = 0 # Token type + try: + self.state = 3893 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,517,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 3888 + self.libraryName() + self.state = 3889 + _la = self._input.LA(1) + if not(_la==50 or _la==51): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 3891 + self.identifier() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 3892 + self.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 CloseStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CLOSE(self): + return self.getToken(Cobol85Parser.CLOSE, 0) + + def closeFile(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.CloseFileContext) + else: + return self.getTypedRuleContext(Cobol85Parser.CloseFileContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_closeStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCloseStatement" ): + listener.enterCloseStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCloseStatement" ): + listener.exitCloseStatement(self) + + + + + def closeStatement(self): + + localctx = Cobol85Parser.CloseStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 594, self.RULE_closeStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3895 + self.match(Cobol85Parser.CLOSE) + self.state = 3897 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 3896 + self.closeFile() + self.state = 3899 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CloseFileContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def closeReelUnitStatement(self): + return self.getTypedRuleContext(Cobol85Parser.CloseReelUnitStatementContext,0) + + + def closeRelativeStatement(self): + return self.getTypedRuleContext(Cobol85Parser.CloseRelativeStatementContext,0) + + + def closePortFileIOStatement(self): + return self.getTypedRuleContext(Cobol85Parser.ClosePortFileIOStatementContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_closeFile + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCloseFile" ): + listener.enterCloseFile(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCloseFile" ): + listener.exitCloseFile(self) + + + + + def closeFile(self): + + localctx = Cobol85Parser.CloseFileContext(self, self._ctx, self.state) + self.enterRule(localctx, 596, self.RULE_closeFile) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3901 + self.fileName() + self.state = 3905 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,519,self._ctx) + if la_ == 1: + self.state = 3902 + self.closeReelUnitStatement() + + elif la_ == 2: + self.state = 3903 + self.closeRelativeStatement() + + elif la_ == 3: + self.state = 3904 + self.closePortFileIOStatement() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CloseReelUnitStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REEL(self): + return self.getToken(Cobol85Parser.REEL, 0) + + def UNIT(self): + return self.getToken(Cobol85Parser.UNIT, 0) + + def REMOVAL(self): + return self.getToken(Cobol85Parser.REMOVAL, 0) + + def NO(self): + return self.getToken(Cobol85Parser.NO, 0) + + def REWIND(self): + return self.getToken(Cobol85Parser.REWIND, 0) + + def LOCK(self): + return self.getToken(Cobol85Parser.LOCK, 0) + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_closeReelUnitStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCloseReelUnitStatement" ): + listener.enterCloseReelUnitStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCloseReelUnitStatement" ): + listener.exitCloseReelUnitStatement(self) + + + + + def closeReelUnitStatement(self): + + localctx = Cobol85Parser.CloseReelUnitStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 598, self.RULE_closeReelUnitStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3907 + _la = self._input.LA(1) + if not(_la==382 or _la==499): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3912 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212 or _la==390: + self.state = 3909 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 3908 + self.match(Cobol85Parser.FOR) + + + self.state = 3911 + self.match(Cobol85Parser.REMOVAL) + + + self.state = 3922 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,524,self._ctx) + if la_ == 1: + self.state = 3915 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 3914 + self.match(Cobol85Parser.WITH) + + + self.state = 3920 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [310]: + self.state = 3917 + self.match(Cobol85Parser.NO) + self.state = 3918 + self.match(Cobol85Parser.REWIND) + pass + elif token in [286]: + self.state = 3919 + self.match(Cobol85Parser.LOCK) + 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 CloseRelativeStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NO(self): + return self.getToken(Cobol85Parser.NO, 0) + + def REWIND(self): + return self.getToken(Cobol85Parser.REWIND, 0) + + def LOCK(self): + return self.getToken(Cobol85Parser.LOCK, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_closeRelativeStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCloseRelativeStatement" ): + listener.enterCloseRelativeStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCloseRelativeStatement" ): + listener.exitCloseRelativeStatement(self) + + + + + def closeRelativeStatement(self): + + localctx = Cobol85Parser.CloseRelativeStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 600, self.RULE_closeRelativeStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3925 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 3924 + self.match(Cobol85Parser.WITH) + + + self.state = 3930 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [310]: + self.state = 3927 + self.match(Cobol85Parser.NO) + self.state = 3928 + self.match(Cobol85Parser.REWIND) + pass + elif token in [286]: + self.state = 3929 + self.match(Cobol85Parser.LOCK) + 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 ClosePortFileIOStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NO(self): + return self.getToken(Cobol85Parser.NO, 0) + + def WAIT(self): + return self.getToken(Cobol85Parser.WAIT, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def USING(self): + return self.getToken(Cobol85Parser.USING, 0) + + def closePortFileIOUsing(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ClosePortFileIOUsingContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ClosePortFileIOUsingContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_closePortFileIOStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterClosePortFileIOStatement" ): + listener.enterClosePortFileIOStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitClosePortFileIOStatement" ): + listener.exitClosePortFileIOStatement(self) + + + + + def closePortFileIOStatement(self): + + localctx = Cobol85Parser.ClosePortFileIOStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 602, self.RULE_closePortFileIOStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3939 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,528,self._ctx) + if la_ == 1: + self.state = 3933 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 3932 + self.match(Cobol85Parser.WITH) + + + self.state = 3935 + self.match(Cobol85Parser.NO) + self.state = 3936 + self.match(Cobol85Parser.WAIT) + pass + + elif la_ == 2: + self.state = 3937 + self.match(Cobol85Parser.WITH) + self.state = 3938 + self.match(Cobol85Parser.WAIT) + pass + + + self.state = 3947 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==506: + self.state = 3941 + self.match(Cobol85Parser.USING) + self.state = 3943 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 3942 + self.closePortFileIOUsing() + + else: + raise NoViableAltException(self) + self.state = 3945 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,529,self._ctx) + + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ClosePortFileIOUsingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def closePortFileIOUsingCloseDisposition(self): + return self.getTypedRuleContext(Cobol85Parser.ClosePortFileIOUsingCloseDispositionContext,0) + + + def closePortFileIOUsingAssociatedData(self): + return self.getTypedRuleContext(Cobol85Parser.ClosePortFileIOUsingAssociatedDataContext,0) + + + def closePortFileIOUsingAssociatedDataLength(self): + return self.getTypedRuleContext(Cobol85Parser.ClosePortFileIOUsingAssociatedDataLengthContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_closePortFileIOUsing + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterClosePortFileIOUsing" ): + listener.enterClosePortFileIOUsing(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitClosePortFileIOUsing" ): + listener.exitClosePortFileIOUsing(self) + + + + + def closePortFileIOUsing(self): + + localctx = Cobol85Parser.ClosePortFileIOUsingContext(self, self._ctx, self.state) + self.enterRule(localctx, 604, self.RULE_closePortFileIOUsing) + try: + self.state = 3952 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [68]: + self.enterOuterAlt(localctx, 1) + self.state = 3949 + self.closePortFileIOUsingCloseDisposition() + pass + elif token in [28]: + self.enterOuterAlt(localctx, 2) + self.state = 3950 + self.closePortFileIOUsingAssociatedData() + pass + elif token in [29]: + self.enterOuterAlt(localctx, 3) + self.state = 3951 + self.closePortFileIOUsingAssociatedDataLength() + 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 ClosePortFileIOUsingCloseDispositionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CLOSE_DISPOSITION(self): + return self.getToken(Cobol85Parser.CLOSE_DISPOSITION, 0) + + def ABORT(self): + return self.getToken(Cobol85Parser.ABORT, 0) + + def ORDERLY(self): + return self.getToken(Cobol85Parser.ORDERLY, 0) + + def OF(self): + return self.getToken(Cobol85Parser.OF, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_closePortFileIOUsingCloseDisposition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterClosePortFileIOUsingCloseDisposition" ): + listener.enterClosePortFileIOUsingCloseDisposition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitClosePortFileIOUsingCloseDisposition" ): + listener.exitClosePortFileIOUsingCloseDisposition(self) + + + + + def closePortFileIOUsingCloseDisposition(self): + + localctx = Cobol85Parser.ClosePortFileIOUsingCloseDispositionContext(self, self._ctx, self.state) + self.enterRule(localctx, 606, self.RULE_closePortFileIOUsingCloseDisposition) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3954 + self.match(Cobol85Parser.CLOSE_DISPOSITION) + self.state = 3956 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==323: + self.state = 3955 + self.match(Cobol85Parser.OF) + + + self.state = 3958 + _la = self._input.LA(1) + if not(_la==1 or _la==331): + 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 ClosePortFileIOUsingAssociatedDataContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ASSOCIATED_DATA(self): + return self.getToken(Cobol85Parser.ASSOCIATED_DATA, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_closePortFileIOUsingAssociatedData + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterClosePortFileIOUsingAssociatedData" ): + listener.enterClosePortFileIOUsingAssociatedData(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitClosePortFileIOUsingAssociatedData" ): + listener.exitClosePortFileIOUsingAssociatedData(self) + + + + + def closePortFileIOUsingAssociatedData(self): + + localctx = Cobol85Parser.ClosePortFileIOUsingAssociatedDataContext(self, self._ctx, self.state) + self.enterRule(localctx, 608, self.RULE_closePortFileIOUsingAssociatedData) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3960 + self.match(Cobol85Parser.ASSOCIATED_DATA) + self.state = 3963 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,533,self._ctx) + if la_ == 1: + self.state = 3961 + self.identifier() + pass + + elif la_ == 2: + self.state = 3962 + self.integerLiteral() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ClosePortFileIOUsingAssociatedDataLengthContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ASSOCIATED_DATA_LENGTH(self): + return self.getToken(Cobol85Parser.ASSOCIATED_DATA_LENGTH, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def OF(self): + return self.getToken(Cobol85Parser.OF, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_closePortFileIOUsingAssociatedDataLength + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterClosePortFileIOUsingAssociatedDataLength" ): + listener.enterClosePortFileIOUsingAssociatedDataLength(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitClosePortFileIOUsingAssociatedDataLength" ): + listener.exitClosePortFileIOUsingAssociatedDataLength(self) + + + + + def closePortFileIOUsingAssociatedDataLength(self): + + localctx = Cobol85Parser.ClosePortFileIOUsingAssociatedDataLengthContext(self, self._ctx, self.state) + self.enterRule(localctx, 610, self.RULE_closePortFileIOUsingAssociatedDataLength) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3965 + self.match(Cobol85Parser.ASSOCIATED_DATA_LENGTH) + self.state = 3967 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==323: + self.state = 3966 + self.match(Cobol85Parser.OF) + + + self.state = 3971 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,535,self._ctx) + if la_ == 1: + self.state = 3969 + self.identifier() + pass + + elif la_ == 2: + self.state = 3970 + self.integerLiteral() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ComputeStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def COMPUTE(self): + return self.getToken(Cobol85Parser.COMPUTE, 0) + + def arithmeticExpression(self): + return self.getTypedRuleContext(Cobol85Parser.ArithmeticExpressionContext,0) + + + def EQUALCHAR(self): + return self.getToken(Cobol85Parser.EQUALCHAR, 0) + + def EQUAL(self): + return self.getToken(Cobol85Parser.EQUAL, 0) + + def computeStore(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ComputeStoreContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ComputeStoreContext,i) + + + def onSizeErrorPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.OnSizeErrorPhraseContext,0) + + + def notOnSizeErrorPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.NotOnSizeErrorPhraseContext,0) + + + def END_COMPUTE(self): + return self.getToken(Cobol85Parser.END_COMPUTE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_computeStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterComputeStatement" ): + listener.enterComputeStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitComputeStatement" ): + listener.exitComputeStatement(self) + + + + + def computeStatement(self): + + localctx = Cobol85Parser.ComputeStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 612, self.RULE_computeStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3973 + self.match(Cobol85Parser.COMPUTE) + self.state = 3975 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 3974 + self.computeStore() + self.state = 3977 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 0)): + break + + self.state = 3979 + _la = self._input.LA(1) + if not(_la==186 or _la==536): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 3980 + self.arithmeticExpression() + self.state = 3982 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,537,self._ctx) + if la_ == 1: + self.state = 3981 + self.onSizeErrorPhrase() + + + self.state = 3985 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,538,self._ctx) + if la_ == 1: + self.state = 3984 + self.notOnSizeErrorPhrase() + + + self.state = 3988 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,539,self._ctx) + if la_ == 1: + self.state = 3987 + self.match(Cobol85Parser.END_COMPUTE) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ComputeStoreContext(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(Cobol85Parser.IdentifierContext,0) + + + def ROUNDED(self): + return self.getToken(Cobol85Parser.ROUNDED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_computeStore + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterComputeStore" ): + listener.enterComputeStore(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitComputeStore" ): + listener.exitComputeStore(self) + + + + + def computeStore(self): + + localctx = Cobol85Parser.ComputeStoreContext(self, self._ctx, self.state) + self.enterRule(localctx, 614, self.RULE_computeStore) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3990 + self.identifier() + self.state = 3992 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==412: + self.state = 3991 + self.match(Cobol85Parser.ROUNDED) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ContinueStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CONTINUE(self): + return self.getToken(Cobol85Parser.CONTINUE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_continueStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterContinueStatement" ): + listener.enterContinueStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitContinueStatement" ): + listener.exitContinueStatement(self) + + + + + def continueStatement(self): + + localctx = Cobol85Parser.ContinueStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 616, self.RULE_continueStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 3994 + self.match(Cobol85Parser.CONTINUE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DeleteStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DELETE(self): + return self.getToken(Cobol85Parser.DELETE, 0) + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def RECORD(self): + return self.getToken(Cobol85Parser.RECORD, 0) + + def invalidKeyPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.InvalidKeyPhraseContext,0) + + + def notInvalidKeyPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.NotInvalidKeyPhraseContext,0) + + + def END_DELETE(self): + return self.getToken(Cobol85Parser.END_DELETE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_deleteStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDeleteStatement" ): + listener.enterDeleteStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDeleteStatement" ): + listener.exitDeleteStatement(self) + + + + + def deleteStatement(self): + + localctx = Cobol85Parser.DeleteStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 618, self.RULE_deleteStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 3996 + self.match(Cobol85Parser.DELETE) + self.state = 3997 + self.fileName() + self.state = 3999 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==377: + self.state = 3998 + self.match(Cobol85Parser.RECORD) + + + self.state = 4002 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,542,self._ctx) + if la_ == 1: + self.state = 4001 + self.invalidKeyPhrase() + + + self.state = 4005 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,543,self._ctx) + if la_ == 1: + self.state = 4004 + self.notInvalidKeyPhrase() + + + self.state = 4008 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,544,self._ctx) + if la_ == 1: + self.state = 4007 + self.match(Cobol85Parser.END_DELETE) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DisableStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DISABLE(self): + return self.getToken(Cobol85Parser.DISABLE, 0) + + def cdName(self): + return self.getTypedRuleContext(Cobol85Parser.CdNameContext,0) + + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def INPUT(self): + return self.getToken(Cobol85Parser.INPUT, 0) + + def I_O(self): + return self.getToken(Cobol85Parser.I_O, 0) + + def TERMINAL(self): + return self.getToken(Cobol85Parser.TERMINAL, 0) + + def OUTPUT(self): + return self.getToken(Cobol85Parser.OUTPUT, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_disableStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDisableStatement" ): + listener.enterDisableStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDisableStatement" ): + listener.exitDisableStatement(self) + + + + + def disableStatement(self): + + localctx = Cobol85Parser.DisableStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 620, self.RULE_disableStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4010 + self.match(Cobol85Parser.DISABLE) + self.state = 4018 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [246]: + self.state = 4011 + self.match(Cobol85Parser.INPUT) + self.state = 4013 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==475: + self.state = 4012 + self.match(Cobol85Parser.TERMINAL) + + + pass + elif token in [232]: + self.state = 4015 + self.match(Cobol85Parser.I_O) + self.state = 4016 + self.match(Cobol85Parser.TERMINAL) + pass + elif token in [334]: + self.state = 4017 + self.match(Cobol85Parser.OUTPUT) + pass + else: + raise NoViableAltException(self) + + self.state = 4020 + self.cdName() + self.state = 4022 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 4021 + self.match(Cobol85Parser.WITH) + + + self.state = 4024 + self.match(Cobol85Parser.KEY) + self.state = 4027 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,548,self._ctx) + if la_ == 1: + self.state = 4025 + self.identifier() + pass + + elif la_ == 2: + self.state = 4026 + self.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 DisplayStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DISPLAY(self): + return self.getToken(Cobol85Parser.DISPLAY, 0) + + def displayOperand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DisplayOperandContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DisplayOperandContext,i) + + + def displayAt(self): + return self.getTypedRuleContext(Cobol85Parser.DisplayAtContext,0) + + + def displayUpon(self): + return self.getTypedRuleContext(Cobol85Parser.DisplayUponContext,0) + + + def displayWith(self): + return self.getTypedRuleContext(Cobol85Parser.DisplayWithContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_displayStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDisplayStatement" ): + listener.enterDisplayStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDisplayStatement" ): + listener.exitDisplayStatement(self) + + + + + def displayStatement(self): + + localctx = Cobol85Parser.DisplayStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 622, self.RULE_displayStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4029 + self.match(Cobol85Parser.DISPLAY) + self.state = 4031 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4030 + self.displayOperand() + self.state = 4033 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822370) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194964618422267) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202427199037528969) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874440372879459) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 1819828109721609) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 572150674022301857) != 0) or ((((_la - 551)) & ~0x3f) == 0 and ((1 << (_la - 551)) & 127) != 0)): + break + + self.state = 4036 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,550,self._ctx) + if la_ == 1: + self.state = 4035 + self.displayAt() + + + self.state = 4039 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==503: + self.state = 4038 + self.displayUpon() + + + self.state = 4042 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,552,self._ctx) + if la_ == 1: + self.state = 4041 + self.displayWith() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DisplayOperandContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_displayOperand + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDisplayOperand" ): + listener.enterDisplayOperand(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDisplayOperand" ): + listener.exitDisplayOperand(self) + + + + + def displayOperand(self): + + localctx = Cobol85Parser.DisplayOperandContext(self, self._ctx, self.state) + self.enterRule(localctx, 624, self.RULE_displayOperand) + try: + self.state = 4046 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,553,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4044 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4045 + self.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 DisplayAtContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def AT(self): + return self.getToken(Cobol85Parser.AT, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_displayAt + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDisplayAt" ): + listener.enterDisplayAt(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDisplayAt" ): + listener.exitDisplayAt(self) + + + + + def displayAt(self): + + localctx = Cobol85Parser.DisplayAtContext(self, self._ctx, self.state) + self.enterRule(localctx, 626, self.RULE_displayAt) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4048 + self.match(Cobol85Parser.AT) + self.state = 4051 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,554,self._ctx) + if la_ == 1: + self.state = 4049 + self.identifier() + pass + + elif la_ == 2: + self.state = 4050 + self.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 DisplayUponContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def UPON(self): + return self.getToken(Cobol85Parser.UPON, 0) + + def mnemonicName(self): + return self.getTypedRuleContext(Cobol85Parser.MnemonicNameContext,0) + + + def environmentName(self): + return self.getTypedRuleContext(Cobol85Parser.EnvironmentNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_displayUpon + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDisplayUpon" ): + listener.enterDisplayUpon(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDisplayUpon" ): + listener.exitDisplayUpon(self) + + + + + def displayUpon(self): + + localctx = Cobol85Parser.DisplayUponContext(self, self._ctx, self.state) + self.enterRule(localctx, 628, self.RULE_displayUpon) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4053 + self.match(Cobol85Parser.UPON) + self.state = 4056 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,555,self._ctx) + if la_ == 1: + self.state = 4054 + self.mnemonicName() + pass + + elif la_ == 2: + self.state = 4055 + self.environmentName() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DisplayWithContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NO(self): + return self.getToken(Cobol85Parser.NO, 0) + + def ADVANCING(self): + return self.getToken(Cobol85Parser.ADVANCING, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_displayWith + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDisplayWith" ): + listener.enterDisplayWith(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDisplayWith" ): + listener.exitDisplayWith(self) + + + + + def displayWith(self): + + localctx = Cobol85Parser.DisplayWithContext(self, self._ctx, self.state) + self.enterRule(localctx, 630, self.RULE_displayWith) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4059 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 4058 + self.match(Cobol85Parser.WITH) + + + self.state = 4061 + self.match(Cobol85Parser.NO) + self.state = 4062 + self.match(Cobol85Parser.ADVANCING) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DivideStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DIVIDE(self): + return self.getToken(Cobol85Parser.DIVIDE, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def divideIntoStatement(self): + return self.getTypedRuleContext(Cobol85Parser.DivideIntoStatementContext,0) + + + def divideIntoGivingStatement(self): + return self.getTypedRuleContext(Cobol85Parser.DivideIntoGivingStatementContext,0) + + + def divideByGivingStatement(self): + return self.getTypedRuleContext(Cobol85Parser.DivideByGivingStatementContext,0) + + + def divideRemainder(self): + return self.getTypedRuleContext(Cobol85Parser.DivideRemainderContext,0) + + + def onSizeErrorPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.OnSizeErrorPhraseContext,0) + + + def notOnSizeErrorPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.NotOnSizeErrorPhraseContext,0) + + + def END_DIVIDE(self): + return self.getToken(Cobol85Parser.END_DIVIDE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_divideStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDivideStatement" ): + listener.enterDivideStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDivideStatement" ): + listener.exitDivideStatement(self) + + + + + def divideStatement(self): + + localctx = Cobol85Parser.DivideStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 632, self.RULE_divideStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4064 + self.match(Cobol85Parser.DIVIDE) + self.state = 4067 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,557,self._ctx) + if la_ == 1: + self.state = 4065 + self.identifier() + pass + + elif la_ == 2: + self.state = 4066 + self.literal() + pass + + + self.state = 4072 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,558,self._ctx) + if la_ == 1: + self.state = 4069 + self.divideIntoStatement() + pass + + elif la_ == 2: + self.state = 4070 + self.divideIntoGivingStatement() + pass + + elif la_ == 3: + self.state = 4071 + self.divideByGivingStatement() + pass + + + self.state = 4075 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==388: + self.state = 4074 + self.divideRemainder() + + + self.state = 4078 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,560,self._ctx) + if la_ == 1: + self.state = 4077 + self.onSizeErrorPhrase() + + + self.state = 4081 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,561,self._ctx) + if la_ == 1: + self.state = 4080 + self.notOnSizeErrorPhrase() + + + self.state = 4084 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,562,self._ctx) + if la_ == 1: + self.state = 4083 + self.match(Cobol85Parser.END_DIVIDE) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DivideIntoStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTO(self): + return self.getToken(Cobol85Parser.INTO, 0) + + def divideInto(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DivideIntoContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DivideIntoContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_divideIntoStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDivideIntoStatement" ): + listener.enterDivideIntoStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDivideIntoStatement" ): + listener.exitDivideIntoStatement(self) + + + + + def divideIntoStatement(self): + + localctx = Cobol85Parser.DivideIntoStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 634, self.RULE_divideIntoStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4086 + self.match(Cobol85Parser.INTO) + self.state = 4088 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4087 + self.divideInto() + self.state = 4090 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 DivideIntoGivingStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTO(self): + return self.getToken(Cobol85Parser.INTO, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def divideGivingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.DivideGivingPhraseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_divideIntoGivingStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDivideIntoGivingStatement" ): + listener.enterDivideIntoGivingStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDivideIntoGivingStatement" ): + listener.exitDivideIntoGivingStatement(self) + + + + + def divideIntoGivingStatement(self): + + localctx = Cobol85Parser.DivideIntoGivingStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 636, self.RULE_divideIntoGivingStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4092 + self.match(Cobol85Parser.INTO) + self.state = 4095 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,564,self._ctx) + if la_ == 1: + self.state = 4093 + self.identifier() + pass + + elif la_ == 2: + self.state = 4094 + self.literal() + pass + + + self.state = 4098 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==222: + self.state = 4097 + self.divideGivingPhrase() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DivideByGivingStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def divideGivingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.DivideGivingPhraseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_divideByGivingStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDivideByGivingStatement" ): + listener.enterDivideByGivingStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDivideByGivingStatement" ): + listener.exitDivideByGivingStatement(self) + + + + + def divideByGivingStatement(self): + + localctx = Cobol85Parser.DivideByGivingStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 638, self.RULE_divideByGivingStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4100 + self.match(Cobol85Parser.BY) + self.state = 4103 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,566,self._ctx) + if la_ == 1: + self.state = 4101 + self.identifier() + pass + + elif la_ == 2: + self.state = 4102 + self.literal() + pass + + + self.state = 4106 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==222: + self.state = 4105 + self.divideGivingPhrase() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DivideGivingPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GIVING(self): + return self.getToken(Cobol85Parser.GIVING, 0) + + def divideGiving(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.DivideGivingContext) + else: + return self.getTypedRuleContext(Cobol85Parser.DivideGivingContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_divideGivingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDivideGivingPhrase" ): + listener.enterDivideGivingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDivideGivingPhrase" ): + listener.exitDivideGivingPhrase(self) + + + + + def divideGivingPhrase(self): + + localctx = Cobol85Parser.DivideGivingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 640, self.RULE_divideGivingPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4108 + self.match(Cobol85Parser.GIVING) + self.state = 4110 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4109 + self.divideGiving() + self.state = 4112 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 DivideIntoContext(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(Cobol85Parser.IdentifierContext,0) + + + def ROUNDED(self): + return self.getToken(Cobol85Parser.ROUNDED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_divideInto + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDivideInto" ): + listener.enterDivideInto(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDivideInto" ): + listener.exitDivideInto(self) + + + + + def divideInto(self): + + localctx = Cobol85Parser.DivideIntoContext(self, self._ctx, self.state) + self.enterRule(localctx, 642, self.RULE_divideInto) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4114 + self.identifier() + self.state = 4116 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==412: + self.state = 4115 + self.match(Cobol85Parser.ROUNDED) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DivideGivingContext(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(Cobol85Parser.IdentifierContext,0) + + + def ROUNDED(self): + return self.getToken(Cobol85Parser.ROUNDED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_divideGiving + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDivideGiving" ): + listener.enterDivideGiving(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDivideGiving" ): + listener.exitDivideGiving(self) + + + + + def divideGiving(self): + + localctx = Cobol85Parser.DivideGivingContext(self, self._ctx, self.state) + self.enterRule(localctx, 644, self.RULE_divideGiving) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4118 + self.identifier() + self.state = 4120 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==412: + self.state = 4119 + self.match(Cobol85Parser.ROUNDED) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DivideRemainderContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REMAINDER(self): + return self.getToken(Cobol85Parser.REMAINDER, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_divideRemainder + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDivideRemainder" ): + listener.enterDivideRemainder(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDivideRemainder" ): + listener.exitDivideRemainder(self) + + + + + def divideRemainder(self): + + localctx = Cobol85Parser.DivideRemainderContext(self, self._ctx, self.state) + self.enterRule(localctx, 646, self.RULE_divideRemainder) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4122 + self.match(Cobol85Parser.REMAINDER) + self.state = 4123 + 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 EnableStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ENABLE(self): + return self.getToken(Cobol85Parser.ENABLE, 0) + + def cdName(self): + return self.getTypedRuleContext(Cobol85Parser.CdNameContext,0) + + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def INPUT(self): + return self.getToken(Cobol85Parser.INPUT, 0) + + def I_O(self): + return self.getToken(Cobol85Parser.I_O, 0) + + def TERMINAL(self): + return self.getToken(Cobol85Parser.TERMINAL, 0) + + def OUTPUT(self): + return self.getToken(Cobol85Parser.OUTPUT, 0) + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_enableStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEnableStatement" ): + listener.enterEnableStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEnableStatement" ): + listener.exitEnableStatement(self) + + + + + def enableStatement(self): + + localctx = Cobol85Parser.EnableStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 648, self.RULE_enableStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4125 + self.match(Cobol85Parser.ENABLE) + self.state = 4133 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [246]: + self.state = 4126 + self.match(Cobol85Parser.INPUT) + self.state = 4128 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==475: + self.state = 4127 + self.match(Cobol85Parser.TERMINAL) + + + pass + elif token in [232]: + self.state = 4130 + self.match(Cobol85Parser.I_O) + self.state = 4131 + self.match(Cobol85Parser.TERMINAL) + pass + elif token in [334]: + self.state = 4132 + self.match(Cobol85Parser.OUTPUT) + pass + else: + raise NoViableAltException(self) + + self.state = 4135 + self.cdName() + self.state = 4137 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 4136 + self.match(Cobol85Parser.WITH) + + + self.state = 4139 + self.match(Cobol85Parser.KEY) + self.state = 4142 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,574,self._ctx) + if la_ == 1: + self.state = 4140 + self.literal() + pass + + elif la_ == 2: + self.state = 4141 + self.identifier() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class EntryStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ENTRY(self): + return self.getToken(Cobol85Parser.ENTRY, 0) + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def USING(self): + return self.getToken(Cobol85Parser.USING, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.IdentifierContext) + else: + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_entryStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEntryStatement" ): + listener.enterEntryStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEntryStatement" ): + listener.exitEntryStatement(self) + + + + + def entryStatement(self): + + localctx = Cobol85Parser.EntryStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 650, self.RULE_entryStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4144 + self.match(Cobol85Parser.ENTRY) + self.state = 4145 + self.literal() + self.state = 4152 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==506: + self.state = 4146 + self.match(Cobol85Parser.USING) + self.state = 4148 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4147 + self.identifier() + self.state = 4150 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 EvaluateStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EVALUATE(self): + return self.getToken(Cobol85Parser.EVALUATE, 0) + + def evaluateSelect(self): + return self.getTypedRuleContext(Cobol85Parser.EvaluateSelectContext,0) + + + def evaluateAlsoSelect(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.EvaluateAlsoSelectContext) + else: + return self.getTypedRuleContext(Cobol85Parser.EvaluateAlsoSelectContext,i) + + + def evaluateWhenPhrase(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.EvaluateWhenPhraseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.EvaluateWhenPhraseContext,i) + + + def evaluateWhenOther(self): + return self.getTypedRuleContext(Cobol85Parser.EvaluateWhenOtherContext,0) + + + def END_EVALUATE(self): + return self.getToken(Cobol85Parser.END_EVALUATE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_evaluateStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEvaluateStatement" ): + listener.enterEvaluateStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEvaluateStatement" ): + listener.exitEvaluateStatement(self) + + + + + def evaluateStatement(self): + + localctx = Cobol85Parser.EvaluateStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 652, self.RULE_evaluateStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4154 + self.match(Cobol85Parser.EVALUATE) + self.state = 4155 + self.evaluateSelect() + self.state = 4159 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==16: + self.state = 4156 + self.evaluateAlsoSelect() + self.state = 4161 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 4163 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 4162 + self.evaluateWhenPhrase() + + else: + raise NoViableAltException(self) + self.state = 4165 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,578,self._ctx) + + self.state = 4168 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,579,self._ctx) + if la_ == 1: + self.state = 4167 + self.evaluateWhenOther() + + + self.state = 4171 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,580,self._ctx) + if la_ == 1: + self.state = 4170 + self.match(Cobol85Parser.END_EVALUATE) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class EvaluateSelectContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def arithmeticExpression(self): + return self.getTypedRuleContext(Cobol85Parser.ArithmeticExpressionContext,0) + + + def condition(self): + return self.getTypedRuleContext(Cobol85Parser.ConditionContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_evaluateSelect + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEvaluateSelect" ): + listener.enterEvaluateSelect(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEvaluateSelect" ): + listener.exitEvaluateSelect(self) + + + + + def evaluateSelect(self): + + localctx = Cobol85Parser.EvaluateSelectContext(self, self._ctx, self.state) + self.enterRule(localctx, 654, self.RULE_evaluateSelect) + try: + self.state = 4177 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,581,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4173 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4174 + self.literal() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 4175 + self.arithmeticExpression() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 4176 + self.condition() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class EvaluateAlsoSelectContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALSO(self): + return self.getToken(Cobol85Parser.ALSO, 0) + + def evaluateSelect(self): + return self.getTypedRuleContext(Cobol85Parser.EvaluateSelectContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_evaluateAlsoSelect + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEvaluateAlsoSelect" ): + listener.enterEvaluateAlsoSelect(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEvaluateAlsoSelect" ): + listener.exitEvaluateAlsoSelect(self) + + + + + def evaluateAlsoSelect(self): + + localctx = Cobol85Parser.EvaluateAlsoSelectContext(self, self._ctx, self.state) + self.enterRule(localctx, 656, self.RULE_evaluateAlsoSelect) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4179 + self.match(Cobol85Parser.ALSO) + self.state = 4180 + self.evaluateSelect() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class EvaluateWhenPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def evaluateWhen(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.EvaluateWhenContext) + else: + return self.getTypedRuleContext(Cobol85Parser.EvaluateWhenContext,i) + + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_evaluateWhenPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEvaluateWhenPhrase" ): + listener.enterEvaluateWhenPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEvaluateWhenPhrase" ): + listener.exitEvaluateWhenPhrase(self) + + + + + def evaluateWhenPhrase(self): + + localctx = Cobol85Parser.EvaluateWhenPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 658, self.RULE_evaluateWhenPhrase) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4183 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 4182 + self.evaluateWhen() + + else: + raise NoViableAltException(self) + self.state = 4185 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,582,self._ctx) + + self.state = 4190 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,583,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 4187 + self.statement() + self.state = 4192 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,583,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class EvaluateWhenContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def WHEN(self): + return self.getToken(Cobol85Parser.WHEN, 0) + + def evaluateCondition(self): + return self.getTypedRuleContext(Cobol85Parser.EvaluateConditionContext,0) + + + def evaluateAlsoCondition(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.EvaluateAlsoConditionContext) + else: + return self.getTypedRuleContext(Cobol85Parser.EvaluateAlsoConditionContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_evaluateWhen + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEvaluateWhen" ): + listener.enterEvaluateWhen(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEvaluateWhen" ): + listener.exitEvaluateWhen(self) + + + + + def evaluateWhen(self): + + localctx = Cobol85Parser.EvaluateWhenContext(self, self._ctx, self.state) + self.enterRule(localctx, 660, self.RULE_evaluateWhen) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4193 + self.match(Cobol85Parser.WHEN) + self.state = 4194 + self.evaluateCondition() + self.state = 4198 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==16: + self.state = 4195 + self.evaluateAlsoCondition() + self.state = 4200 + 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 EvaluateConditionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ANY(self): + return self.getToken(Cobol85Parser.ANY, 0) + + def evaluateValue(self): + return self.getTypedRuleContext(Cobol85Parser.EvaluateValueContext,0) + + + def NOT(self): + return self.getToken(Cobol85Parser.NOT, 0) + + def evaluateThrough(self): + return self.getTypedRuleContext(Cobol85Parser.EvaluateThroughContext,0) + + + def condition(self): + return self.getTypedRuleContext(Cobol85Parser.ConditionContext,0) + + + def booleanLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.BooleanLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_evaluateCondition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEvaluateCondition" ): + listener.enterEvaluateCondition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEvaluateCondition" ): + listener.exitEvaluateCondition(self) + + + + + def evaluateCondition(self): + + localctx = Cobol85Parser.EvaluateConditionContext(self, self._ctx, self.state) + self.enterRule(localctx, 662, self.RULE_evaluateCondition) + self._la = 0 # Token type + try: + self.state = 4211 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,587,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4201 + self.match(Cobol85Parser.ANY) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4203 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==312: + self.state = 4202 + self.match(Cobol85Parser.NOT) + + + self.state = 4205 + self.evaluateValue() + self.state = 4207 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==483 or _la==484: + self.state = 4206 + self.evaluateThrough() + + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 4209 + self.condition() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 4210 + self.booleanLiteral() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class EvaluateThroughContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def evaluateValue(self): + return self.getTypedRuleContext(Cobol85Parser.EvaluateValueContext,0) + + + def THROUGH(self): + return self.getToken(Cobol85Parser.THROUGH, 0) + + def THRU(self): + return self.getToken(Cobol85Parser.THRU, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_evaluateThrough + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEvaluateThrough" ): + listener.enterEvaluateThrough(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEvaluateThrough" ): + listener.exitEvaluateThrough(self) + + + + + def evaluateThrough(self): + + localctx = Cobol85Parser.EvaluateThroughContext(self, self._ctx, self.state) + self.enterRule(localctx, 664, self.RULE_evaluateThrough) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4213 + _la = self._input.LA(1) + if not(_la==483 or _la==484): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 4214 + self.evaluateValue() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class EvaluateAlsoConditionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALSO(self): + return self.getToken(Cobol85Parser.ALSO, 0) + + def evaluateCondition(self): + return self.getTypedRuleContext(Cobol85Parser.EvaluateConditionContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_evaluateAlsoCondition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEvaluateAlsoCondition" ): + listener.enterEvaluateAlsoCondition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEvaluateAlsoCondition" ): + listener.exitEvaluateAlsoCondition(self) + + + + + def evaluateAlsoCondition(self): + + localctx = Cobol85Parser.EvaluateAlsoConditionContext(self, self._ctx, self.state) + self.enterRule(localctx, 666, self.RULE_evaluateAlsoCondition) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4216 + self.match(Cobol85Parser.ALSO) + self.state = 4217 + self.evaluateCondition() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class EvaluateWhenOtherContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def WHEN(self): + return self.getToken(Cobol85Parser.WHEN, 0) + + def OTHER(self): + return self.getToken(Cobol85Parser.OTHER, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_evaluateWhenOther + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEvaluateWhenOther" ): + listener.enterEvaluateWhenOther(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEvaluateWhenOther" ): + listener.exitEvaluateWhenOther(self) + + + + + def evaluateWhenOther(self): + + localctx = Cobol85Parser.EvaluateWhenOtherContext(self, self._ctx, self.state) + self.enterRule(localctx, 668, self.RULE_evaluateWhenOther) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4219 + self.match(Cobol85Parser.WHEN) + self.state = 4220 + self.match(Cobol85Parser.OTHER) + self.state = 4224 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,588,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 4221 + self.statement() + self.state = 4226 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,588,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class EvaluateValueContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def arithmeticExpression(self): + return self.getTypedRuleContext(Cobol85Parser.ArithmeticExpressionContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_evaluateValue + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEvaluateValue" ): + listener.enterEvaluateValue(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEvaluateValue" ): + listener.exitEvaluateValue(self) + + + + + def evaluateValue(self): + + localctx = Cobol85Parser.EvaluateValueContext(self, self._ctx, self.state) + self.enterRule(localctx, 670, self.RULE_evaluateValue) + try: + self.state = 4230 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,589,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4227 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4228 + self.literal() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 4229 + self.arithmeticExpression() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ExecCicsStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXECCICSLINE(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.EXECCICSLINE) + else: + return self.getToken(Cobol85Parser.EXECCICSLINE, i) + + def getRuleIndex(self): + return Cobol85Parser.RULE_execCicsStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExecCicsStatement" ): + listener.enterExecCicsStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExecCicsStatement" ): + listener.exitExecCicsStatement(self) + + + + + def execCicsStatement(self): + + localctx = Cobol85Parser.ExecCicsStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 672, self.RULE_execCicsStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4233 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 4232 + self.match(Cobol85Parser.EXECCICSLINE) + + else: + raise NoViableAltException(self) + self.state = 4235 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,590,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ExecSqlStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXECSQLLINE(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.EXECSQLLINE) + else: + return self.getToken(Cobol85Parser.EXECSQLLINE, i) + + def getRuleIndex(self): + return Cobol85Parser.RULE_execSqlStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExecSqlStatement" ): + listener.enterExecSqlStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExecSqlStatement" ): + listener.exitExecSqlStatement(self) + + + + + def execSqlStatement(self): + + localctx = Cobol85Parser.ExecSqlStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 674, self.RULE_execSqlStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4238 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 4237 + self.match(Cobol85Parser.EXECSQLLINE) + + else: + raise NoViableAltException(self) + self.state = 4240 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,591,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ExecSqlImsStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXECSQLIMSLINE(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.EXECSQLIMSLINE) + else: + return self.getToken(Cobol85Parser.EXECSQLIMSLINE, i) + + def getRuleIndex(self): + return Cobol85Parser.RULE_execSqlImsStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExecSqlImsStatement" ): + listener.enterExecSqlImsStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExecSqlImsStatement" ): + listener.exitExecSqlImsStatement(self) + + + + + def execSqlImsStatement(self): + + localctx = Cobol85Parser.ExecSqlImsStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 676, self.RULE_execSqlImsStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4243 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 4242 + self.match(Cobol85Parser.EXECSQLIMSLINE) + + else: + raise NoViableAltException(self) + self.state = 4245 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,592,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ExhibitStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXHIBIT(self): + return self.getToken(Cobol85Parser.EXHIBIT, 0) + + def NAMED(self): + return self.getToken(Cobol85Parser.NAMED, 0) + + def CHANGED(self): + return self.getToken(Cobol85Parser.CHANGED, 0) + + def exhibitOperand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ExhibitOperandContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ExhibitOperandContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_exhibitStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExhibitStatement" ): + listener.enterExhibitStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExhibitStatement" ): + listener.exitExhibitStatement(self) + + + + + def exhibitStatement(self): + + localctx = Cobol85Parser.ExhibitStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 678, self.RULE_exhibitStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4247 + self.match(Cobol85Parser.EXHIBIT) + self.state = 4249 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,593,self._ctx) + if la_ == 1: + self.state = 4248 + self.match(Cobol85Parser.NAMED) + + + self.state = 4252 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,594,self._ctx) + if la_ == 1: + self.state = 4251 + self.match(Cobol85Parser.CHANGED) + + + self.state = 4255 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4254 + self.exhibitOperand() + self.state = 4257 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822370) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194964618422267) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202427199037528969) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874440372879459) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 1819828109721609) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 572150674022301857) != 0) or ((((_la - 551)) & ~0x3f) == 0 and ((1 << (_la - 551)) & 127) != 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 ExhibitOperandContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_exhibitOperand + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExhibitOperand" ): + listener.enterExhibitOperand(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExhibitOperand" ): + listener.exitExhibitOperand(self) + + + + + def exhibitOperand(self): + + localctx = Cobol85Parser.ExhibitOperandContext(self, self._ctx, self.state) + self.enterRule(localctx, 680, self.RULE_exhibitOperand) + try: + self.state = 4261 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,596,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4259 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4260 + self.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 ExitStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXIT(self): + return self.getToken(Cobol85Parser.EXIT, 0) + + def PROGRAM(self): + return self.getToken(Cobol85Parser.PROGRAM, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_exitStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExitStatement" ): + listener.enterExitStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExitStatement" ): + listener.exitExitStatement(self) + + + + + def exitStatement(self): + + localctx = Cobol85Parser.ExitStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 682, self.RULE_exitStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4263 + self.match(Cobol85Parser.EXIT) + self.state = 4265 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==361: + self.state = 4264 + self.match(Cobol85Parser.PROGRAM) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class GenerateStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GENERATE(self): + return self.getToken(Cobol85Parser.GENERATE, 0) + + def reportName(self): + return self.getTypedRuleContext(Cobol85Parser.ReportNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_generateStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGenerateStatement" ): + listener.enterGenerateStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGenerateStatement" ): + listener.exitGenerateStatement(self) + + + + + def generateStatement(self): + + localctx = Cobol85Parser.GenerateStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 684, self.RULE_generateStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4267 + self.match(Cobol85Parser.GENERATE) + self.state = 4268 + self.reportName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class GobackStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GOBACK(self): + return self.getToken(Cobol85Parser.GOBACK, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_gobackStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGobackStatement" ): + listener.enterGobackStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGobackStatement" ): + listener.exitGobackStatement(self) + + + + + def gobackStatement(self): + + localctx = Cobol85Parser.GobackStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 686, self.RULE_gobackStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4270 + self.match(Cobol85Parser.GOBACK) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class GoToStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GO(self): + return self.getToken(Cobol85Parser.GO, 0) + + def goToStatementSimple(self): + return self.getTypedRuleContext(Cobol85Parser.GoToStatementSimpleContext,0) + + + def goToDependingOnStatement(self): + return self.getTypedRuleContext(Cobol85Parser.GoToDependingOnStatementContext,0) + + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_goToStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGoToStatement" ): + listener.enterGoToStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGoToStatement" ): + listener.exitGoToStatement(self) + + + + + def goToStatement(self): + + localctx = Cobol85Parser.GoToStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 688, self.RULE_goToStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4272 + self.match(Cobol85Parser.GO) + self.state = 4274 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==489: + self.state = 4273 + self.match(Cobol85Parser.TO) + + + self.state = 4278 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,599,self._ctx) + if la_ == 1: + self.state = 4276 + self.goToStatementSimple() + pass + + elif la_ == 2: + self.state = 4277 + self.goToDependingOnStatement() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class GoToStatementSimpleContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def procedureName(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_goToStatementSimple + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGoToStatementSimple" ): + listener.enterGoToStatementSimple(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGoToStatementSimple" ): + listener.exitGoToStatementSimple(self) + + + + + def goToStatementSimple(self): + + localctx = Cobol85Parser.GoToStatementSimpleContext(self, self._ctx, self.state) + self.enterRule(localctx, 690, self.RULE_goToStatementSimple) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4280 + self.procedureName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class GoToDependingOnStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def MORE_LABELS(self): + return self.getToken(Cobol85Parser.MORE_LABELS, 0) + + def procedureName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ProcedureNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ProcedureNameContext,i) + + + def DEPENDING(self): + return self.getToken(Cobol85Parser.DEPENDING, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_goToDependingOnStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGoToDependingOnStatement" ): + listener.enterGoToDependingOnStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGoToDependingOnStatement" ): + listener.exitGoToDependingOnStatement(self) + + + + + def goToDependingOnStatement(self): + + localctx = Cobol85Parser.GoToDependingOnStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 692, self.RULE_goToDependingOnStatement) + self._la = 0 # Token type + try: + self.state = 4295 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [299]: + self.enterOuterAlt(localctx, 1) + self.state = 4282 + self.match(Cobol85Parser.MORE_LABELS) + pass + elif token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 552, 553, 554, 555, 557]: + self.enterOuterAlt(localctx, 2) + self.state = 4284 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4283 + self.procedureName() + self.state = 4286 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 0)): + break + + self.state = 4293 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==134: + self.state = 4288 + self.match(Cobol85Parser.DEPENDING) + self.state = 4290 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 4289 + self.match(Cobol85Parser.ON) + + + self.state = 4292 + 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 IfStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def IF(self): + return self.getToken(Cobol85Parser.IF, 0) + + def condition(self): + return self.getTypedRuleContext(Cobol85Parser.ConditionContext,0) + + + def ifThen(self): + return self.getTypedRuleContext(Cobol85Parser.IfThenContext,0) + + + def ifElse(self): + return self.getTypedRuleContext(Cobol85Parser.IfElseContext,0) + + + def END_IF(self): + return self.getToken(Cobol85Parser.END_IF, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_ifStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIfStatement" ): + listener.enterIfStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIfStatement" ): + listener.exitIfStatement(self) + + + + + def ifStatement(self): + + localctx = Cobol85Parser.IfStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 694, self.RULE_ifStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4297 + self.match(Cobol85Parser.IF) + self.state = 4298 + self.condition() + self.state = 4299 + self.ifThen() + self.state = 4301 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,604,self._ctx) + if la_ == 1: + self.state = 4300 + self.ifElse() + + + self.state = 4304 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,605,self._ctx) + if la_ == 1: + self.state = 4303 + self.match(Cobol85Parser.END_IF) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IfThenContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NEXT(self): + return self.getToken(Cobol85Parser.NEXT, 0) + + def SENTENCE(self): + return self.getToken(Cobol85Parser.SENTENCE, 0) + + def THEN(self): + return self.getToken(Cobol85Parser.THEN, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_ifThen + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIfThen" ): + listener.enterIfThen(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIfThen" ): + listener.exitIfThen(self) + + + + + def ifThen(self): + + localctx = Cobol85Parser.IfThenContext(self, self._ctx, self.state) + self.enterRule(localctx, 696, self.RULE_ifThen) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4307 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==480: + self.state = 4306 + self.match(Cobol85Parser.THEN) + + + self.state = 4317 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [309]: + self.state = 4309 + self.match(Cobol85Parser.NEXT) + self.state = 4310 + self.match(Cobol85Parser.SENTENCE) + pass + elif token in [2, 4, 17, 30, 52, 53, 67, 92, 96, 131, 140, 142, 144, 154, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 182, 193, 196, 198, 199, 220, 221, 224, 236, 244, 245, 248, 252, 294, 300, 302, 312, 326, 327, 343, 365, 374, 375, 387, 403, 408, 418, 425, 430, 440, 456, 458, 459, 463, 476, 500, 512, 514, 517, 534, 559, 560, 561]: + self.state = 4314 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,607,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 4311 + self.statement() + self.state = 4316 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,607,self._ctx) + + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IfElseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ELSE(self): + return self.getToken(Cobol85Parser.ELSE, 0) + + def NEXT(self): + return self.getToken(Cobol85Parser.NEXT, 0) + + def SENTENCE(self): + return self.getToken(Cobol85Parser.SENTENCE, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_ifElse + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIfElse" ): + listener.enterIfElse(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIfElse" ): + listener.exitIfElse(self) + + + + + def ifElse(self): + + localctx = Cobol85Parser.IfElseContext(self, self._ctx, self.state) + self.enterRule(localctx, 698, self.RULE_ifElse) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4319 + self.match(Cobol85Parser.ELSE) + self.state = 4328 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [309]: + self.state = 4320 + self.match(Cobol85Parser.NEXT) + self.state = 4321 + self.match(Cobol85Parser.SENTENCE) + pass + elif token in [2, 4, 17, 30, 52, 53, 67, 92, 96, 131, 140, 142, 144, 154, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 182, 193, 196, 198, 199, 220, 221, 224, 236, 244, 245, 248, 252, 294, 300, 302, 312, 326, 327, 343, 365, 374, 375, 387, 403, 408, 418, 425, 430, 440, 456, 458, 459, 463, 476, 500, 512, 514, 517, 534, 559, 560, 561]: + self.state = 4325 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,609,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 4322 + self.statement() + self.state = 4327 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,609,self._ctx) + + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InitializeStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INITIALIZE(self): + return self.getToken(Cobol85Parser.INITIALIZE, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.IdentifierContext) + else: + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,i) + + + def initializeReplacingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.InitializeReplacingPhraseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_initializeStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInitializeStatement" ): + listener.enterInitializeStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInitializeStatement" ): + listener.exitInitializeStatement(self) + + + + + def initializeStatement(self): + + localctx = Cobol85Parser.InitializeStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 700, self.RULE_initializeStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4330 + self.match(Cobol85Parser.INITIALIZE) + self.state = 4332 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4331 + self.identifier() + self.state = 4334 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 0)): + break + + self.state = 4337 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==394: + self.state = 4336 + self.initializeReplacingPhrase() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InitializeReplacingPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REPLACING(self): + return self.getToken(Cobol85Parser.REPLACING, 0) + + def initializeReplacingBy(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InitializeReplacingByContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InitializeReplacingByContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_initializeReplacingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInitializeReplacingPhrase" ): + listener.enterInitializeReplacingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInitializeReplacingPhrase" ): + listener.exitInitializeReplacingPhrase(self) + + + + + def initializeReplacingPhrase(self): + + localctx = Cobol85Parser.InitializeReplacingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 702, self.RULE_initializeReplacingPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4339 + self.match(Cobol85Parser.REPLACING) + self.state = 4341 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4340 + self.initializeReplacingBy() + self.state = 4343 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 51200) != 0) or _la==116 or _la==152 or ((((_la - 304)) & ~0x3f) == 0 and ((1 << (_la - 304)) & 20483) != 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 InitializeReplacingByContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def ALPHABETIC(self): + return self.getToken(Cobol85Parser.ALPHABETIC, 0) + + def ALPHANUMERIC(self): + return self.getToken(Cobol85Parser.ALPHANUMERIC, 0) + + def ALPHANUMERIC_EDITED(self): + return self.getToken(Cobol85Parser.ALPHANUMERIC_EDITED, 0) + + def NATIONAL(self): + return self.getToken(Cobol85Parser.NATIONAL, 0) + + def NATIONAL_EDITED(self): + return self.getToken(Cobol85Parser.NATIONAL_EDITED, 0) + + def NUMERIC(self): + return self.getToken(Cobol85Parser.NUMERIC, 0) + + def NUMERIC_EDITED(self): + return self.getToken(Cobol85Parser.NUMERIC_EDITED, 0) + + def DBCS(self): + return self.getToken(Cobol85Parser.DBCS, 0) + + def EGCS(self): + return self.getToken(Cobol85Parser.EGCS, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def DATA(self): + return self.getToken(Cobol85Parser.DATA, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_initializeReplacingBy + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInitializeReplacingBy" ): + listener.enterInitializeReplacingBy(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInitializeReplacingBy" ): + listener.exitInitializeReplacingBy(self) + + + + + def initializeReplacingBy(self): + + localctx = Cobol85Parser.InitializeReplacingByContext(self, self._ctx, self.state) + self.enterRule(localctx, 704, self.RULE_initializeReplacingBy) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4345 + _la = self._input.LA(1) + if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 51200) != 0) or _la==116 or _la==152 or ((((_la - 304)) & ~0x3f) == 0 and ((1 << (_la - 304)) & 20483) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 4347 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==109: + self.state = 4346 + self.match(Cobol85Parser.DATA) + + + self.state = 4349 + self.match(Cobol85Parser.BY) + self.state = 4352 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,615,self._ctx) + if la_ == 1: + self.state = 4350 + self.identifier() + pass + + elif la_ == 2: + self.state = 4351 + self.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 InitiateStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INITIATE(self): + return self.getToken(Cobol85Parser.INITIATE, 0) + + def reportName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReportNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReportNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_initiateStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInitiateStatement" ): + listener.enterInitiateStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInitiateStatement" ): + listener.exitInitiateStatement(self) + + + + + def initiateStatement(self): + + localctx = Cobol85Parser.InitiateStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 706, self.RULE_initiateStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4354 + self.match(Cobol85Parser.INITIATE) + self.state = 4356 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4355 + self.reportName() + self.state = 4358 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178969483) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 InspectStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INSPECT(self): + return self.getToken(Cobol85Parser.INSPECT, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def inspectTallyingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.InspectTallyingPhraseContext,0) + + + def inspectReplacingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.InspectReplacingPhraseContext,0) + + + def inspectTallyingReplacingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.InspectTallyingReplacingPhraseContext,0) + + + def inspectConvertingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.InspectConvertingPhraseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inspectStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInspectStatement" ): + listener.enterInspectStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInspectStatement" ): + listener.exitInspectStatement(self) + + + + + def inspectStatement(self): + + localctx = Cobol85Parser.InspectStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 708, self.RULE_inspectStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4360 + self.match(Cobol85Parser.INSPECT) + self.state = 4361 + self.identifier() + self.state = 4366 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,617,self._ctx) + if la_ == 1: + self.state = 4362 + self.inspectTallyingPhrase() + pass + + elif la_ == 2: + self.state = 4363 + self.inspectReplacingPhrase() + pass + + elif la_ == 3: + self.state = 4364 + self.inspectTallyingReplacingPhrase() + pass + + elif la_ == 4: + self.state = 4365 + self.inspectConvertingPhrase() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InspectTallyingPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TALLYING(self): + return self.getToken(Cobol85Parser.TALLYING, 0) + + def inspectFor(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InspectForContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InspectForContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inspectTallyingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInspectTallyingPhrase" ): + listener.enterInspectTallyingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInspectTallyingPhrase" ): + listener.exitInspectTallyingPhrase(self) + + + + + def inspectTallyingPhrase(self): + + localctx = Cobol85Parser.InspectTallyingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 710, self.RULE_inspectTallyingPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4368 + self.match(Cobol85Parser.TALLYING) + self.state = 4370 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4369 + self.inspectFor() + self.state = 4372 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 InspectReplacingPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REPLACING(self): + return self.getToken(Cobol85Parser.REPLACING, 0) + + def inspectReplacingCharacters(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InspectReplacingCharactersContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InspectReplacingCharactersContext,i) + + + def inspectReplacingAllLeadings(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InspectReplacingAllLeadingsContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InspectReplacingAllLeadingsContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inspectReplacingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInspectReplacingPhrase" ): + listener.enterInspectReplacingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInspectReplacingPhrase" ): + listener.exitInspectReplacingPhrase(self) + + + + + def inspectReplacingPhrase(self): + + localctx = Cobol85Parser.InspectReplacingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 712, self.RULE_inspectReplacingPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4374 + self.match(Cobol85Parser.REPLACING) + self.state = 4377 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4377 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [63]: + self.state = 4375 + self.inspectReplacingCharacters() + pass + elif token in [9, 210, 266]: + self.state = 4376 + self.inspectReplacingAllLeadings() + pass + else: + raise NoViableAltException(self) + + self.state = 4379 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==9 or _la==63 or _la==210 or _la==266): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InspectTallyingReplacingPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TALLYING(self): + return self.getToken(Cobol85Parser.TALLYING, 0) + + def inspectFor(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InspectForContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InspectForContext,i) + + + def inspectReplacingPhrase(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InspectReplacingPhraseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InspectReplacingPhraseContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inspectTallyingReplacingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInspectTallyingReplacingPhrase" ): + listener.enterInspectTallyingReplacingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInspectTallyingReplacingPhrase" ): + listener.exitInspectTallyingReplacingPhrase(self) + + + + + def inspectTallyingReplacingPhrase(self): + + localctx = Cobol85Parser.InspectTallyingReplacingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 714, self.RULE_inspectTallyingReplacingPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4381 + self.match(Cobol85Parser.TALLYING) + self.state = 4383 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4382 + self.inspectFor() + self.state = 4385 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 0)): + break + + self.state = 4388 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4387 + self.inspectReplacingPhrase() + self.state = 4390 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==394): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InspectConvertingPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CONVERTING(self): + return self.getToken(Cobol85Parser.CONVERTING, 0) + + def inspectTo(self): + return self.getTypedRuleContext(Cobol85Parser.InspectToContext,0) + + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def inspectBeforeAfter(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InspectBeforeAfterContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InspectBeforeAfterContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inspectConvertingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInspectConvertingPhrase" ): + listener.enterInspectConvertingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInspectConvertingPhrase" ): + listener.exitInspectConvertingPhrase(self) + + + + + def inspectConvertingPhrase(self): + + localctx = Cobol85Parser.InspectConvertingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 716, self.RULE_inspectConvertingPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4392 + self.match(Cobol85Parser.CONVERTING) + self.state = 4395 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,623,self._ctx) + if la_ == 1: + self.state = 4393 + self.identifier() + pass + + elif la_ == 2: + self.state = 4394 + self.literal() + pass + + + self.state = 4397 + self.inspectTo() + self.state = 4401 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==7 or _la==39: + self.state = 4398 + self.inspectBeforeAfter() + self.state = 4403 + 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 InspectForContext(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(Cobol85Parser.IdentifierContext,0) + + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def inspectCharacters(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InspectCharactersContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InspectCharactersContext,i) + + + def inspectAllLeadings(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InspectAllLeadingsContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InspectAllLeadingsContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inspectFor + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInspectFor" ): + listener.enterInspectFor(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInspectFor" ): + listener.exitInspectFor(self) + + + + + def inspectFor(self): + + localctx = Cobol85Parser.InspectForContext(self, self._ctx, self.state) + self.enterRule(localctx, 718, self.RULE_inspectFor) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4404 + self.identifier() + self.state = 4405 + self.match(Cobol85Parser.FOR) + self.state = 4408 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4408 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [63]: + self.state = 4406 + self.inspectCharacters() + pass + elif token in [9, 266]: + self.state = 4407 + self.inspectAllLeadings() + pass + else: + raise NoViableAltException(self) + + self.state = 4410 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==9 or _la==63 or _la==266): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InspectCharactersContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CHARACTERS(self): + return self.getToken(Cobol85Parser.CHARACTERS, 0) + + def inspectBeforeAfter(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InspectBeforeAfterContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InspectBeforeAfterContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inspectCharacters + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInspectCharacters" ): + listener.enterInspectCharacters(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInspectCharacters" ): + listener.exitInspectCharacters(self) + + + + + def inspectCharacters(self): + + localctx = Cobol85Parser.InspectCharactersContext(self, self._ctx, self.state) + self.enterRule(localctx, 720, self.RULE_inspectCharacters) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4412 + self.match(Cobol85Parser.CHARACTERS) + self.state = 4416 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==7 or _la==39: + self.state = 4413 + self.inspectBeforeAfter() + self.state = 4418 + 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 InspectReplacingCharactersContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def CHARACTERS(self): + return self.getToken(Cobol85Parser.CHARACTERS, 0) + + def inspectBy(self): + return self.getTypedRuleContext(Cobol85Parser.InspectByContext,0) + + + def inspectBeforeAfter(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InspectBeforeAfterContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InspectBeforeAfterContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inspectReplacingCharacters + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInspectReplacingCharacters" ): + listener.enterInspectReplacingCharacters(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInspectReplacingCharacters" ): + listener.exitInspectReplacingCharacters(self) + + + + + def inspectReplacingCharacters(self): + + localctx = Cobol85Parser.InspectReplacingCharactersContext(self, self._ctx, self.state) + self.enterRule(localctx, 722, self.RULE_inspectReplacingCharacters) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4419 + self.match(Cobol85Parser.CHARACTERS) + self.state = 4420 + self.inspectBy() + self.state = 4424 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==7 or _la==39: + self.state = 4421 + self.inspectBeforeAfter() + self.state = 4426 + 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 InspectAllLeadingsContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALL(self): + return self.getToken(Cobol85Parser.ALL, 0) + + def LEADING(self): + return self.getToken(Cobol85Parser.LEADING, 0) + + def inspectAllLeading(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InspectAllLeadingContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InspectAllLeadingContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inspectAllLeadings + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInspectAllLeadings" ): + listener.enterInspectAllLeadings(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInspectAllLeadings" ): + listener.exitInspectAllLeadings(self) + + + + + def inspectAllLeadings(self): + + localctx = Cobol85Parser.InspectAllLeadingsContext(self, self._ctx, self.state) + self.enterRule(localctx, 724, self.RULE_inspectAllLeadings) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4427 + _la = self._input.LA(1) + if not(_la==9 or _la==266): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 4429 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 4428 + self.inspectAllLeading() + + else: + raise NoViableAltException(self) + self.state = 4431 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,629,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InspectReplacingAllLeadingsContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALL(self): + return self.getToken(Cobol85Parser.ALL, 0) + + def LEADING(self): + return self.getToken(Cobol85Parser.LEADING, 0) + + def FIRST(self): + return self.getToken(Cobol85Parser.FIRST, 0) + + def inspectReplacingAllLeading(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InspectReplacingAllLeadingContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InspectReplacingAllLeadingContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inspectReplacingAllLeadings + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInspectReplacingAllLeadings" ): + listener.enterInspectReplacingAllLeadings(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInspectReplacingAllLeadings" ): + listener.exitInspectReplacingAllLeadings(self) + + + + + def inspectReplacingAllLeadings(self): + + localctx = Cobol85Parser.InspectReplacingAllLeadingsContext(self, self._ctx, self.state) + self.enterRule(localctx, 726, self.RULE_inspectReplacingAllLeadings) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4433 + _la = self._input.LA(1) + if not(_la==9 or _la==210 or _la==266): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 4435 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 4434 + self.inspectReplacingAllLeading() + + else: + raise NoViableAltException(self) + self.state = 4437 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,630,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InspectAllLeadingContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def inspectBeforeAfter(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InspectBeforeAfterContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InspectBeforeAfterContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inspectAllLeading + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInspectAllLeading" ): + listener.enterInspectAllLeading(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInspectAllLeading" ): + listener.exitInspectAllLeading(self) + + + + + def inspectAllLeading(self): + + localctx = Cobol85Parser.InspectAllLeadingContext(self, self._ctx, self.state) + self.enterRule(localctx, 728, self.RULE_inspectAllLeading) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4441 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,631,self._ctx) + if la_ == 1: + self.state = 4439 + self.identifier() + pass + + elif la_ == 2: + self.state = 4440 + self.literal() + pass + + + self.state = 4446 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==7 or _la==39: + self.state = 4443 + self.inspectBeforeAfter() + self.state = 4448 + 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 InspectReplacingAllLeadingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def inspectBy(self): + return self.getTypedRuleContext(Cobol85Parser.InspectByContext,0) + + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def inspectBeforeAfter(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InspectBeforeAfterContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InspectBeforeAfterContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inspectReplacingAllLeading + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInspectReplacingAllLeading" ): + listener.enterInspectReplacingAllLeading(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInspectReplacingAllLeading" ): + listener.exitInspectReplacingAllLeading(self) + + + + + def inspectReplacingAllLeading(self): + + localctx = Cobol85Parser.InspectReplacingAllLeadingContext(self, self._ctx, self.state) + self.enterRule(localctx, 730, self.RULE_inspectReplacingAllLeading) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4451 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,633,self._ctx) + if la_ == 1: + self.state = 4449 + self.identifier() + pass + + elif la_ == 2: + self.state = 4450 + self.literal() + pass + + + self.state = 4453 + self.inspectBy() + self.state = 4457 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==7 or _la==39: + self.state = 4454 + self.inspectBeforeAfter() + self.state = 4459 + 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 InspectByContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inspectBy + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInspectBy" ): + listener.enterInspectBy(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInspectBy" ): + listener.exitInspectBy(self) + + + + + def inspectBy(self): + + localctx = Cobol85Parser.InspectByContext(self, self._ctx, self.state) + self.enterRule(localctx, 732, self.RULE_inspectBy) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4460 + self.match(Cobol85Parser.BY) + self.state = 4463 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,635,self._ctx) + if la_ == 1: + self.state = 4461 + self.identifier() + pass + + elif la_ == 2: + self.state = 4462 + self.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 InspectToContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_inspectTo + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInspectTo" ): + listener.enterInspectTo(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInspectTo" ): + listener.exitInspectTo(self) + + + + + def inspectTo(self): + + localctx = Cobol85Parser.InspectToContext(self, self._ctx, self.state) + self.enterRule(localctx, 734, self.RULE_inspectTo) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4465 + self.match(Cobol85Parser.TO) + self.state = 4468 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,636,self._ctx) + if la_ == 1: + self.state = 4466 + self.identifier() + pass + + elif la_ == 2: + self.state = 4467 + self.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 InspectBeforeAfterContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BEFORE(self): + return self.getToken(Cobol85Parser.BEFORE, 0) + + def AFTER(self): + return self.getToken(Cobol85Parser.AFTER, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def INITIAL(self): + return self.getToken(Cobol85Parser.INITIAL, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_inspectBeforeAfter + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInspectBeforeAfter" ): + listener.enterInspectBeforeAfter(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInspectBeforeAfter" ): + listener.exitInspectBeforeAfter(self) + + + + + def inspectBeforeAfter(self): + + localctx = Cobol85Parser.InspectBeforeAfterContext(self, self._ctx, self.state) + self.enterRule(localctx, 736, self.RULE_inspectBeforeAfter) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4470 + _la = self._input.LA(1) + if not(_la==7 or _la==39): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 4472 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==243: + self.state = 4471 + self.match(Cobol85Parser.INITIAL) + + + self.state = 4476 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,638,self._ctx) + if la_ == 1: + self.state = 4474 + self.identifier() + pass + + elif la_ == 2: + self.state = 4475 + self.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 MergeStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def MERGE(self): + return self.getToken(Cobol85Parser.MERGE, 0) + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def mergeOnKeyClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.MergeOnKeyClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.MergeOnKeyClauseContext,i) + + + def mergeCollatingSequencePhrase(self): + return self.getTypedRuleContext(Cobol85Parser.MergeCollatingSequencePhraseContext,0) + + + def mergeUsing(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.MergeUsingContext) + else: + return self.getTypedRuleContext(Cobol85Parser.MergeUsingContext,i) + + + def mergeOutputProcedurePhrase(self): + return self.getTypedRuleContext(Cobol85Parser.MergeOutputProcedurePhraseContext,0) + + + def mergeGivingPhrase(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.MergeGivingPhraseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.MergeGivingPhraseContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_mergeStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMergeStatement" ): + listener.enterMergeStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMergeStatement" ): + listener.exitMergeStatement(self) + + + + + def mergeStatement(self): + + localctx = Cobol85Parser.MergeStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 738, self.RULE_mergeStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4478 + self.match(Cobol85Parser.MERGE) + self.state = 4479 + self.fileName() + self.state = 4481 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 4480 + self.mergeOnKeyClause() + + else: + raise NoViableAltException(self) + self.state = 4483 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,639,self._ctx) + + self.state = 4486 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==72 or _la==428: + self.state = 4485 + self.mergeCollatingSequencePhrase() + + + self.state = 4491 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==506: + self.state = 4488 + self.mergeUsing() + self.state = 4493 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 4495 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==334: + self.state = 4494 + self.mergeOutputProcedurePhrase() + + + self.state = 4500 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==222: + self.state = 4497 + self.mergeGivingPhrase() + self.state = 4502 + 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 MergeOnKeyClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ASCENDING(self): + return self.getToken(Cobol85Parser.ASCENDING, 0) + + def DESCENDING(self): + return self.getToken(Cobol85Parser.DESCENDING, 0) + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def qualifiedDataName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.QualifiedDataNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_mergeOnKeyClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMergeOnKeyClause" ): + listener.enterMergeOnKeyClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMergeOnKeyClause" ): + listener.exitMergeOnKeyClause(self) + + + + + def mergeOnKeyClause(self): + + localctx = Cobol85Parser.MergeOnKeyClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 740, self.RULE_mergeOnKeyClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4504 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 4503 + self.match(Cobol85Parser.ON) + + + self.state = 4506 + _la = self._input.LA(1) + if not(_la==25 or _la==135): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 4508 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==259: + self.state = 4507 + self.match(Cobol85Parser.KEY) + + + self.state = 4511 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4510 + self.qualifiedDataName() + self.state = 4513 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178969483) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 MergeCollatingSequencePhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SEQUENCE(self): + return self.getToken(Cobol85Parser.SEQUENCE, 0) + + def COLLATING(self): + return self.getToken(Cobol85Parser.COLLATING, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def alphabetName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.AlphabetNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.AlphabetNameContext,i) + + + def mergeCollatingAlphanumeric(self): + return self.getTypedRuleContext(Cobol85Parser.MergeCollatingAlphanumericContext,0) + + + def mergeCollatingNational(self): + return self.getTypedRuleContext(Cobol85Parser.MergeCollatingNationalContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_mergeCollatingSequencePhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMergeCollatingSequencePhrase" ): + listener.enterMergeCollatingSequencePhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMergeCollatingSequencePhrase" ): + listener.exitMergeCollatingSequencePhrase(self) + + + + + def mergeCollatingSequencePhrase(self): + + localctx = Cobol85Parser.MergeCollatingSequencePhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 742, self.RULE_mergeCollatingSequencePhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4516 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==72: + self.state = 4515 + self.match(Cobol85Parser.COLLATING) + + + self.state = 4518 + self.match(Cobol85Parser.SEQUENCE) + self.state = 4520 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 4519 + self.match(Cobol85Parser.IS) + + + self.state = 4523 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 4522 + self.alphabetName() + + else: + raise NoViableAltException(self) + self.state = 4525 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,649,self._ctx) + + self.state = 4528 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,650,self._ctx) + if la_ == 1: + self.state = 4527 + self.mergeCollatingAlphanumeric() + + + self.state = 4531 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212 or _la==304: + self.state = 4530 + self.mergeCollatingNational() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MergeCollatingAlphanumericContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALPHANUMERIC(self): + return self.getToken(Cobol85Parser.ALPHANUMERIC, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def alphabetName(self): + return self.getTypedRuleContext(Cobol85Parser.AlphabetNameContext,0) + + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_mergeCollatingAlphanumeric + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMergeCollatingAlphanumeric" ): + listener.enterMergeCollatingAlphanumeric(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMergeCollatingAlphanumeric" ): + listener.exitMergeCollatingAlphanumeric(self) + + + + + def mergeCollatingAlphanumeric(self): + + localctx = Cobol85Parser.MergeCollatingAlphanumericContext(self, self._ctx, self.state) + self.enterRule(localctx, 744, self.RULE_mergeCollatingAlphanumeric) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4534 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 4533 + self.match(Cobol85Parser.FOR) + + + self.state = 4536 + self.match(Cobol85Parser.ALPHANUMERIC) + self.state = 4537 + self.match(Cobol85Parser.IS) + self.state = 4538 + self.alphabetName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MergeCollatingNationalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NATIONAL(self): + return self.getToken(Cobol85Parser.NATIONAL, 0) + + def alphabetName(self): + return self.getTypedRuleContext(Cobol85Parser.AlphabetNameContext,0) + + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_mergeCollatingNational + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMergeCollatingNational" ): + listener.enterMergeCollatingNational(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMergeCollatingNational" ): + listener.exitMergeCollatingNational(self) + + + + + def mergeCollatingNational(self): + + localctx = Cobol85Parser.MergeCollatingNationalContext(self, self._ctx, self.state) + self.enterRule(localctx, 746, self.RULE_mergeCollatingNational) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4541 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 4540 + self.match(Cobol85Parser.FOR) + + + self.state = 4543 + self.match(Cobol85Parser.NATIONAL) + self.state = 4545 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 4544 + self.match(Cobol85Parser.IS) + + + self.state = 4547 + self.alphabetName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MergeUsingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def USING(self): + return self.getToken(Cobol85Parser.USING, 0) + + def fileName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.FileNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_mergeUsing + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMergeUsing" ): + listener.enterMergeUsing(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMergeUsing" ): + listener.exitMergeUsing(self) + + + + + def mergeUsing(self): + + localctx = Cobol85Parser.MergeUsingContext(self, self._ctx, self.state) + self.enterRule(localctx, 748, self.RULE_mergeUsing) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4549 + self.match(Cobol85Parser.USING) + self.state = 4551 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4550 + self.fileName() + self.state = 4553 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MergeOutputProcedurePhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OUTPUT(self): + return self.getToken(Cobol85Parser.OUTPUT, 0) + + def PROCEDURE(self): + return self.getToken(Cobol85Parser.PROCEDURE, 0) + + def procedureName(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def mergeOutputThrough(self): + return self.getTypedRuleContext(Cobol85Parser.MergeOutputThroughContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_mergeOutputProcedurePhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMergeOutputProcedurePhrase" ): + listener.enterMergeOutputProcedurePhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMergeOutputProcedurePhrase" ): + listener.exitMergeOutputProcedurePhrase(self) + + + + + def mergeOutputProcedurePhrase(self): + + localctx = Cobol85Parser.MergeOutputProcedurePhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 750, self.RULE_mergeOutputProcedurePhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4555 + self.match(Cobol85Parser.OUTPUT) + self.state = 4556 + self.match(Cobol85Parser.PROCEDURE) + self.state = 4558 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 4557 + self.match(Cobol85Parser.IS) + + + self.state = 4560 + self.procedureName() + self.state = 4562 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==483 or _la==484: + self.state = 4561 + self.mergeOutputThrough() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MergeOutputThroughContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def procedureName(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureNameContext,0) + + + def THROUGH(self): + return self.getToken(Cobol85Parser.THROUGH, 0) + + def THRU(self): + return self.getToken(Cobol85Parser.THRU, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_mergeOutputThrough + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMergeOutputThrough" ): + listener.enterMergeOutputThrough(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMergeOutputThrough" ): + listener.exitMergeOutputThrough(self) + + + + + def mergeOutputThrough(self): + + localctx = Cobol85Parser.MergeOutputThroughContext(self, self._ctx, self.state) + self.enterRule(localctx, 752, self.RULE_mergeOutputThrough) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4564 + _la = self._input.LA(1) + if not(_la==483 or _la==484): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 4565 + self.procedureName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MergeGivingPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GIVING(self): + return self.getToken(Cobol85Parser.GIVING, 0) + + def mergeGiving(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.MergeGivingContext) + else: + return self.getTypedRuleContext(Cobol85Parser.MergeGivingContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_mergeGivingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMergeGivingPhrase" ): + listener.enterMergeGivingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMergeGivingPhrase" ): + listener.exitMergeGivingPhrase(self) + + + + + def mergeGivingPhrase(self): + + localctx = Cobol85Parser.MergeGivingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 754, self.RULE_mergeGivingPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4567 + self.match(Cobol85Parser.GIVING) + self.state = 4569 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4568 + self.mergeGiving() + self.state = 4571 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MergeGivingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def LOCK(self): + return self.getToken(Cobol85Parser.LOCK, 0) + + def SAVE(self): + return self.getToken(Cobol85Parser.SAVE, 0) + + def NO(self): + return self.getToken(Cobol85Parser.NO, 0) + + def REWIND(self): + return self.getToken(Cobol85Parser.REWIND, 0) + + def CRUNCH(self): + return self.getToken(Cobol85Parser.CRUNCH, 0) + + def RELEASE(self): + return self.getToken(Cobol85Parser.RELEASE, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def REMOVE(self): + return self.getToken(Cobol85Parser.REMOVE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_mergeGiving + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMergeGiving" ): + listener.enterMergeGiving(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMergeGiving" ): + listener.exitMergeGiving(self) + + + + + def mergeGiving(self): + + localctx = Cobol85Parser.MergeGivingContext(self, self._ctx, self.state) + self.enterRule(localctx, 756, self.RULE_mergeGiving) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4573 + self.fileName() + self.state = 4583 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,659,self._ctx) + if la_ == 1: + self.state = 4574 + self.match(Cobol85Parser.LOCK) + + elif la_ == 2: + self.state = 4575 + self.match(Cobol85Parser.SAVE) + + elif la_ == 3: + self.state = 4576 + self.match(Cobol85Parser.NO) + self.state = 4577 + self.match(Cobol85Parser.REWIND) + + elif la_ == 4: + self.state = 4578 + self.match(Cobol85Parser.CRUNCH) + + elif la_ == 5: + self.state = 4579 + self.match(Cobol85Parser.RELEASE) + + elif la_ == 6: + self.state = 4580 + self.match(Cobol85Parser.WITH) + self.state = 4581 + self.match(Cobol85Parser.REMOVE) + self.state = 4582 + self.match(Cobol85Parser.CRUNCH) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MoveStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def MOVE(self): + return self.getToken(Cobol85Parser.MOVE, 0) + + def moveToStatement(self): + return self.getTypedRuleContext(Cobol85Parser.MoveToStatementContext,0) + + + def moveCorrespondingToStatement(self): + return self.getTypedRuleContext(Cobol85Parser.MoveCorrespondingToStatementContext,0) + + + def ALL(self): + return self.getToken(Cobol85Parser.ALL, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_moveStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMoveStatement" ): + listener.enterMoveStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMoveStatement" ): + listener.exitMoveStatement(self) + + + + + def moveStatement(self): + + localctx = Cobol85Parser.MoveStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 758, self.RULE_moveStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4585 + self.match(Cobol85Parser.MOVE) + self.state = 4587 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,660,self._ctx) + if la_ == 1: + self.state = 4586 + self.match(Cobol85Parser.ALL) + + + self.state = 4591 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [1, 5, 9, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 111, 114, 115, 118, 119, 120, 121, 122, 123, 124, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 204, 213, 214, 216, 217, 218, 219, 226, 229, 230, 231, 237, 238, 250, 258, 260, 262, 264, 265, 268, 269, 270, 272, 273, 274, 278, 281, 283, 284, 287, 288, 289, 290, 291, 292, 296, 303, 304, 305, 308, 311, 313, 314, 317, 319, 322, 331, 336, 337, 341, 342, 352, 353, 355, 360, 361, 364, 367, 368, 370, 371, 373, 376, 380, 383, 391, 398, 401, 404, 415, 420, 431, 432, 433, 434, 435, 436, 437, 441, 442, 443, 445, 446, 447, 450, 451, 466, 471, 473, 481, 482, 485, 486, 490, 491, 494, 495, 497, 498, 510, 511, 513, 518, 519, 520, 521, 522, 523, 524, 551, 552, 553, 554, 555, 556, 557]: + self.state = 4589 + self.moveToStatement() + pass + elif token in [103, 104]: + self.state = 4590 + self.moveCorrespondingToStatement() + 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 MoveToStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def moveToSendingArea(self): + return self.getTypedRuleContext(Cobol85Parser.MoveToSendingAreaContext,0) + + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.IdentifierContext) + else: + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_moveToStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMoveToStatement" ): + listener.enterMoveToStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMoveToStatement" ): + listener.exitMoveToStatement(self) + + + + + def moveToStatement(self): + + localctx = Cobol85Parser.MoveToStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 760, self.RULE_moveToStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4593 + self.moveToSendingArea() + self.state = 4594 + self.match(Cobol85Parser.TO) + self.state = 4596 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4595 + self.identifier() + self.state = 4598 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 MoveToSendingAreaContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_moveToSendingArea + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMoveToSendingArea" ): + listener.enterMoveToSendingArea(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMoveToSendingArea" ): + listener.exitMoveToSendingArea(self) + + + + + def moveToSendingArea(self): + + localctx = Cobol85Parser.MoveToSendingAreaContext(self, self._ctx, self.state) + self.enterRule(localctx, 762, self.RULE_moveToSendingArea) + try: + self.state = 4602 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,663,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4600 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4601 + self.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 MoveCorrespondingToStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def moveCorrespondingToSendingArea(self): + return self.getTypedRuleContext(Cobol85Parser.MoveCorrespondingToSendingAreaContext,0) + + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def CORRESPONDING(self): + return self.getToken(Cobol85Parser.CORRESPONDING, 0) + + def CORR(self): + return self.getToken(Cobol85Parser.CORR, 0) + + def identifier(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.IdentifierContext) + else: + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_moveCorrespondingToStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMoveCorrespondingToStatement" ): + listener.enterMoveCorrespondingToStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMoveCorrespondingToStatement" ): + listener.exitMoveCorrespondingToStatement(self) + + + + + def moveCorrespondingToStatement(self): + + localctx = Cobol85Parser.MoveCorrespondingToStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 764, self.RULE_moveCorrespondingToStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4604 + _la = self._input.LA(1) + if not(_la==103 or _la==104): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 4605 + self.moveCorrespondingToSendingArea() + self.state = 4606 + self.match(Cobol85Parser.TO) + self.state = 4608 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4607 + self.identifier() + self.state = 4610 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 MoveCorrespondingToSendingAreaContext(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(Cobol85Parser.IdentifierContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_moveCorrespondingToSendingArea + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMoveCorrespondingToSendingArea" ): + listener.enterMoveCorrespondingToSendingArea(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMoveCorrespondingToSendingArea" ): + listener.exitMoveCorrespondingToSendingArea(self) + + + + + def moveCorrespondingToSendingArea(self): + + localctx = Cobol85Parser.MoveCorrespondingToSendingAreaContext(self, self._ctx, self.state) + self.enterRule(localctx, 766, self.RULE_moveCorrespondingToSendingArea) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4612 + 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 MultiplyStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def MULTIPLY(self): + return self.getToken(Cobol85Parser.MULTIPLY, 0) + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def multiplyRegular(self): + return self.getTypedRuleContext(Cobol85Parser.MultiplyRegularContext,0) + + + def multiplyGiving(self): + return self.getTypedRuleContext(Cobol85Parser.MultiplyGivingContext,0) + + + def onSizeErrorPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.OnSizeErrorPhraseContext,0) + + + def notOnSizeErrorPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.NotOnSizeErrorPhraseContext,0) + + + def END_MULTIPLY(self): + return self.getToken(Cobol85Parser.END_MULTIPLY, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_multiplyStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMultiplyStatement" ): + listener.enterMultiplyStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMultiplyStatement" ): + listener.exitMultiplyStatement(self) + + + + + def multiplyStatement(self): + + localctx = Cobol85Parser.MultiplyStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 768, self.RULE_multiplyStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4614 + self.match(Cobol85Parser.MULTIPLY) + self.state = 4617 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,665,self._ctx) + if la_ == 1: + self.state = 4615 + self.identifier() + pass + + elif la_ == 2: + self.state = 4616 + self.literal() + pass + + + self.state = 4619 + self.match(Cobol85Parser.BY) + self.state = 4622 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,666,self._ctx) + if la_ == 1: + self.state = 4620 + self.multiplyRegular() + pass + + elif la_ == 2: + self.state = 4621 + self.multiplyGiving() + pass + + + self.state = 4625 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,667,self._ctx) + if la_ == 1: + self.state = 4624 + self.onSizeErrorPhrase() + + + self.state = 4628 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,668,self._ctx) + if la_ == 1: + self.state = 4627 + self.notOnSizeErrorPhrase() + + + self.state = 4631 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,669,self._ctx) + if la_ == 1: + self.state = 4630 + self.match(Cobol85Parser.END_MULTIPLY) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MultiplyRegularContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def multiplyRegularOperand(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.MultiplyRegularOperandContext) + else: + return self.getTypedRuleContext(Cobol85Parser.MultiplyRegularOperandContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_multiplyRegular + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMultiplyRegular" ): + listener.enterMultiplyRegular(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMultiplyRegular" ): + listener.exitMultiplyRegular(self) + + + + + def multiplyRegular(self): + + localctx = Cobol85Parser.MultiplyRegularContext(self, self._ctx, self.state) + self.enterRule(localctx, 770, self.RULE_multiplyRegular) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4634 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4633 + self.multiplyRegularOperand() + self.state = 4636 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 MultiplyRegularOperandContext(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(Cobol85Parser.IdentifierContext,0) + + + def ROUNDED(self): + return self.getToken(Cobol85Parser.ROUNDED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_multiplyRegularOperand + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMultiplyRegularOperand" ): + listener.enterMultiplyRegularOperand(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMultiplyRegularOperand" ): + listener.exitMultiplyRegularOperand(self) + + + + + def multiplyRegularOperand(self): + + localctx = Cobol85Parser.MultiplyRegularOperandContext(self, self._ctx, self.state) + self.enterRule(localctx, 772, self.RULE_multiplyRegularOperand) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4638 + self.identifier() + self.state = 4640 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==412: + self.state = 4639 + self.match(Cobol85Parser.ROUNDED) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MultiplyGivingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def multiplyGivingOperand(self): + return self.getTypedRuleContext(Cobol85Parser.MultiplyGivingOperandContext,0) + + + def GIVING(self): + return self.getToken(Cobol85Parser.GIVING, 0) + + def multiplyGivingResult(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.MultiplyGivingResultContext) + else: + return self.getTypedRuleContext(Cobol85Parser.MultiplyGivingResultContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_multiplyGiving + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMultiplyGiving" ): + listener.enterMultiplyGiving(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMultiplyGiving" ): + listener.exitMultiplyGiving(self) + + + + + def multiplyGiving(self): + + localctx = Cobol85Parser.MultiplyGivingContext(self, self._ctx, self.state) + self.enterRule(localctx, 774, self.RULE_multiplyGiving) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4642 + self.multiplyGivingOperand() + self.state = 4643 + self.match(Cobol85Parser.GIVING) + self.state = 4645 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4644 + self.multiplyGivingResult() + self.state = 4647 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 MultiplyGivingOperandContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_multiplyGivingOperand + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMultiplyGivingOperand" ): + listener.enterMultiplyGivingOperand(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMultiplyGivingOperand" ): + listener.exitMultiplyGivingOperand(self) + + + + + def multiplyGivingOperand(self): + + localctx = Cobol85Parser.MultiplyGivingOperandContext(self, self._ctx, self.state) + self.enterRule(localctx, 776, self.RULE_multiplyGivingOperand) + try: + self.state = 4651 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,673,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4649 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4650 + self.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 MultiplyGivingResultContext(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(Cobol85Parser.IdentifierContext,0) + + + def ROUNDED(self): + return self.getToken(Cobol85Parser.ROUNDED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_multiplyGivingResult + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMultiplyGivingResult" ): + listener.enterMultiplyGivingResult(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMultiplyGivingResult" ): + listener.exitMultiplyGivingResult(self) + + + + + def multiplyGivingResult(self): + + localctx = Cobol85Parser.MultiplyGivingResultContext(self, self._ctx, self.state) + self.enterRule(localctx, 778, self.RULE_multiplyGivingResult) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4653 + self.identifier() + self.state = 4655 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==412: + self.state = 4654 + self.match(Cobol85Parser.ROUNDED) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class OpenStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OPEN(self): + return self.getToken(Cobol85Parser.OPEN, 0) + + def openInputStatement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.OpenInputStatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.OpenInputStatementContext,i) + + + def openOutputStatement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.OpenOutputStatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.OpenOutputStatementContext,i) + + + def openIOStatement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.OpenIOStatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.OpenIOStatementContext,i) + + + def openExtendStatement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.OpenExtendStatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.OpenExtendStatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_openStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOpenStatement" ): + listener.enterOpenStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOpenStatement" ): + listener.exitOpenStatement(self) + + + + + def openStatement(self): + + localctx = Cobol85Parser.OpenStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 780, self.RULE_openStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4657 + self.match(Cobol85Parser.OPEN) + self.state = 4662 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4662 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [246]: + self.state = 4658 + self.openInputStatement() + pass + elif token in [334]: + self.state = 4659 + self.openOutputStatement() + pass + elif token in [232]: + self.state = 4660 + self.openIOStatement() + pass + elif token in [201]: + self.state = 4661 + self.openExtendStatement() + pass + else: + raise NoViableAltException(self) + + self.state = 4664 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (((((_la - 201)) & ~0x3f) == 0 and ((1 << (_la - 201)) & 35186519572481) != 0) or _la==334): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class OpenInputStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INPUT(self): + return self.getToken(Cobol85Parser.INPUT, 0) + + def openInput(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.OpenInputContext) + else: + return self.getTypedRuleContext(Cobol85Parser.OpenInputContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_openInputStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOpenInputStatement" ): + listener.enterOpenInputStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOpenInputStatement" ): + listener.exitOpenInputStatement(self) + + + + + def openInputStatement(self): + + localctx = Cobol85Parser.OpenInputStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 782, self.RULE_openInputStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4666 + self.match(Cobol85Parser.INPUT) + self.state = 4668 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4667 + self.openInput() + self.state = 4670 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class OpenInputContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def REVERSED(self): + return self.getToken(Cobol85Parser.REVERSED, 0) + + def NO(self): + return self.getToken(Cobol85Parser.NO, 0) + + def REWIND(self): + return self.getToken(Cobol85Parser.REWIND, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_openInput + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOpenInput" ): + listener.enterOpenInput(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOpenInput" ): + listener.exitOpenInput(self) + + + + + def openInput(self): + + localctx = Cobol85Parser.OpenInputContext(self, self._ctx, self.state) + self.enterRule(localctx, 784, self.RULE_openInput) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4672 + self.fileName() + self.state = 4679 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,679,self._ctx) + if la_ == 1: + self.state = 4673 + self.match(Cobol85Parser.REVERSED) + + elif la_ == 2: + self.state = 4675 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 4674 + self.match(Cobol85Parser.WITH) + + + self.state = 4677 + self.match(Cobol85Parser.NO) + self.state = 4678 + self.match(Cobol85Parser.REWIND) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class OpenOutputStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OUTPUT(self): + return self.getToken(Cobol85Parser.OUTPUT, 0) + + def openOutput(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.OpenOutputContext) + else: + return self.getTypedRuleContext(Cobol85Parser.OpenOutputContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_openOutputStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOpenOutputStatement" ): + listener.enterOpenOutputStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOpenOutputStatement" ): + listener.exitOpenOutputStatement(self) + + + + + def openOutputStatement(self): + + localctx = Cobol85Parser.OpenOutputStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 786, self.RULE_openOutputStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4681 + self.match(Cobol85Parser.OUTPUT) + self.state = 4683 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4682 + self.openOutput() + self.state = 4685 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class OpenOutputContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def NO(self): + return self.getToken(Cobol85Parser.NO, 0) + + def REWIND(self): + return self.getToken(Cobol85Parser.REWIND, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_openOutput + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOpenOutput" ): + listener.enterOpenOutput(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOpenOutput" ): + listener.exitOpenOutput(self) + + + + + def openOutput(self): + + localctx = Cobol85Parser.OpenOutputContext(self, self._ctx, self.state) + self.enterRule(localctx, 788, self.RULE_openOutput) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4687 + self.fileName() + self.state = 4693 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,682,self._ctx) + if la_ == 1: + self.state = 4689 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 4688 + self.match(Cobol85Parser.WITH) + + + self.state = 4691 + self.match(Cobol85Parser.NO) + self.state = 4692 + self.match(Cobol85Parser.REWIND) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class OpenIOStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def I_O(self): + return self.getToken(Cobol85Parser.I_O, 0) + + def fileName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.FileNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_openIOStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOpenIOStatement" ): + listener.enterOpenIOStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOpenIOStatement" ): + listener.exitOpenIOStatement(self) + + + + + def openIOStatement(self): + + localctx = Cobol85Parser.OpenIOStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 790, self.RULE_openIOStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4695 + self.match(Cobol85Parser.I_O) + self.state = 4697 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4696 + self.fileName() + self.state = 4699 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class OpenExtendStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXTEND(self): + return self.getToken(Cobol85Parser.EXTEND, 0) + + def fileName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.FileNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_openExtendStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOpenExtendStatement" ): + listener.enterOpenExtendStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOpenExtendStatement" ): + listener.exitOpenExtendStatement(self) + + + + + def openExtendStatement(self): + + localctx = Cobol85Parser.OpenExtendStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 792, self.RULE_openExtendStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4701 + self.match(Cobol85Parser.EXTEND) + self.state = 4703 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4702 + self.fileName() + self.state = 4705 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PerformStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PERFORM(self): + return self.getToken(Cobol85Parser.PERFORM, 0) + + def performInlineStatement(self): + return self.getTypedRuleContext(Cobol85Parser.PerformInlineStatementContext,0) + + + def performProcedureStatement(self): + return self.getTypedRuleContext(Cobol85Parser.PerformProcedureStatementContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_performStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPerformStatement" ): + listener.enterPerformStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPerformStatement" ): + listener.exitPerformStatement(self) + + + + + def performStatement(self): + + localctx = Cobol85Parser.PerformStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 794, self.RULE_performStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4707 + self.match(Cobol85Parser.PERFORM) + self.state = 4710 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,685,self._ctx) + if la_ == 1: + self.state = 4708 + self.performInlineStatement() + pass + + elif la_ == 2: + self.state = 4709 + self.performProcedureStatement() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PerformInlineStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def END_PERFORM(self): + return self.getToken(Cobol85Parser.END_PERFORM, 0) + + def performType(self): + return self.getTypedRuleContext(Cobol85Parser.PerformTypeContext,0) + + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_performInlineStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPerformInlineStatement" ): + listener.enterPerformInlineStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPerformInlineStatement" ): + listener.exitPerformInlineStatement(self) + + + + + def performInlineStatement(self): + + localctx = Cobol85Parser.PerformInlineStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 796, self.RULE_performInlineStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4713 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 104066617936808097) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 0): + self.state = 4712 + self.performType() + + + self.state = 4718 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 13510798882242580) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & 570425345) != 0) or ((((_la - 131)) & ~0x3f) == 0 and ((1 << (_la - 131)) & 4613937818308192769) != 0) or ((((_la - 198)) & ~0x3f) == 0 and ((1 << (_la - 198)) & 1337281096974339) != 0) or ((((_la - 294)) & ~0x3f) == 0 and ((1 << (_la - 294)) & 562958543356225) != 0) or ((((_la - 365)) & ~0x3f) == 0 and ((1 << (_la - 365)) & 1161937774836712961) != 0) or ((((_la - 430)) & ~0x3f) == 0 and ((1 << (_la - 430)) & 70378206528513) != 0) or ((((_la - 500)) & ~0x3f) == 0 and ((1 << (_la - 500)) & 4035225266124095489) != 0): + self.state = 4715 + self.statement() + self.state = 4720 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 4721 + self.match(Cobol85Parser.END_PERFORM) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PerformProcedureStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def procedureName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ProcedureNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ProcedureNameContext,i) + + + def performType(self): + return self.getTypedRuleContext(Cobol85Parser.PerformTypeContext,0) + + + def THROUGH(self): + return self.getToken(Cobol85Parser.THROUGH, 0) + + def THRU(self): + return self.getToken(Cobol85Parser.THRU, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_performProcedureStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPerformProcedureStatement" ): + listener.enterPerformProcedureStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPerformProcedureStatement" ): + listener.exitPerformProcedureStatement(self) + + + + + def performProcedureStatement(self): + + localctx = Cobol85Parser.PerformProcedureStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 798, self.RULE_performProcedureStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4723 + self.procedureName() + self.state = 4726 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==483 or _la==484: + self.state = 4724 + _la = self._input.LA(1) + if not(_la==483 or _la==484): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 4725 + self.procedureName() + + + self.state = 4729 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,689,self._ctx) + if la_ == 1: + self.state = 4728 + self.performType() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PerformTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def performTimes(self): + return self.getTypedRuleContext(Cobol85Parser.PerformTimesContext,0) + + + def performUntil(self): + return self.getTypedRuleContext(Cobol85Parser.PerformUntilContext,0) + + + def performVarying(self): + return self.getTypedRuleContext(Cobol85Parser.PerformVaryingContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_performType + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPerformType" ): + listener.enterPerformType(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPerformType" ): + listener.exitPerformType(self) + + + + + def performType(self): + + localctx = Cobol85Parser.PerformTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 800, self.RULE_performType) + try: + self.state = 4734 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,690,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 4731 + self.performTimes() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 4732 + self.performUntil() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 4733 + self.performVarying() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PerformTimesContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TIMES(self): + return self.getToken(Cobol85Parser.TIMES, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_performTimes + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPerformTimes" ): + listener.enterPerformTimes(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPerformTimes" ): + listener.exitPerformTimes(self) + + + + + def performTimes(self): + + localctx = Cobol85Parser.PerformTimesContext(self, self._ctx, self.state) + self.enterRule(localctx, 802, self.RULE_performTimes) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4738 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,691,self._ctx) + if la_ == 1: + self.state = 4736 + self.identifier() + pass + + elif la_ == 2: + self.state = 4737 + self.integerLiteral() + pass + + + self.state = 4740 + self.match(Cobol85Parser.TIMES) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PerformUntilContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def UNTIL(self): + return self.getToken(Cobol85Parser.UNTIL, 0) + + def condition(self): + return self.getTypedRuleContext(Cobol85Parser.ConditionContext,0) + + + def performTestClause(self): + return self.getTypedRuleContext(Cobol85Parser.PerformTestClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_performUntil + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPerformUntil" ): + listener.enterPerformUntil(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPerformUntil" ): + listener.exitPerformUntil(self) + + + + + def performUntil(self): + + localctx = Cobol85Parser.PerformUntilContext(self, self._ctx, self.state) + self.enterRule(localctx, 804, self.RULE_performUntil) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4743 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==477 or _la==514: + self.state = 4742 + self.performTestClause() + + + self.state = 4745 + self.match(Cobol85Parser.UNTIL) + self.state = 4746 + self.condition() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PerformVaryingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def performTestClause(self): + return self.getTypedRuleContext(Cobol85Parser.PerformTestClauseContext,0) + + + def performVaryingClause(self): + return self.getTypedRuleContext(Cobol85Parser.PerformVaryingClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_performVarying + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPerformVarying" ): + listener.enterPerformVarying(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPerformVarying" ): + listener.exitPerformVarying(self) + + + + + def performVarying(self): + + localctx = Cobol85Parser.PerformVaryingContext(self, self._ctx, self.state) + self.enterRule(localctx, 806, self.RULE_performVarying) + try: + self.state = 4755 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [477, 514]: + self.enterOuterAlt(localctx, 1) + self.state = 4748 + self.performTestClause() + self.state = 4749 + self.performVaryingClause() + pass + elif token in [509]: + self.enterOuterAlt(localctx, 2) + self.state = 4751 + self.performVaryingClause() + self.state = 4753 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,693,self._ctx) + if la_ == 1: + self.state = 4752 + self.performTestClause() + + + 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 PerformVaryingClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def VARYING(self): + return self.getToken(Cobol85Parser.VARYING, 0) + + def performVaryingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.PerformVaryingPhraseContext,0) + + + def performAfter(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.PerformAfterContext) + else: + return self.getTypedRuleContext(Cobol85Parser.PerformAfterContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_performVaryingClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPerformVaryingClause" ): + listener.enterPerformVaryingClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPerformVaryingClause" ): + listener.exitPerformVaryingClause(self) + + + + + def performVaryingClause(self): + + localctx = Cobol85Parser.PerformVaryingClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 808, self.RULE_performVaryingClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4757 + self.match(Cobol85Parser.VARYING) + self.state = 4758 + self.performVaryingPhrase() + self.state = 4762 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==7: + self.state = 4759 + self.performAfter() + self.state = 4764 + 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 PerformVaryingPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def performFrom(self): + return self.getTypedRuleContext(Cobol85Parser.PerformFromContext,0) + + + def performBy(self): + return self.getTypedRuleContext(Cobol85Parser.PerformByContext,0) + + + def performUntil(self): + return self.getTypedRuleContext(Cobol85Parser.PerformUntilContext,0) + + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_performVaryingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPerformVaryingPhrase" ): + listener.enterPerformVaryingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPerformVaryingPhrase" ): + listener.exitPerformVaryingPhrase(self) + + + + + def performVaryingPhrase(self): + + localctx = Cobol85Parser.PerformVaryingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 810, self.RULE_performVaryingPhrase) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4767 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,696,self._ctx) + if la_ == 1: + self.state = 4765 + self.identifier() + pass + + elif la_ == 2: + self.state = 4766 + self.literal() + pass + + + self.state = 4769 + self.performFrom() + self.state = 4770 + self.performBy() + self.state = 4771 + self.performUntil() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PerformAfterContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def AFTER(self): + return self.getToken(Cobol85Parser.AFTER, 0) + + def performVaryingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.PerformVaryingPhraseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_performAfter + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPerformAfter" ): + listener.enterPerformAfter(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPerformAfter" ): + listener.exitPerformAfter(self) + + + + + def performAfter(self): + + localctx = Cobol85Parser.PerformAfterContext(self, self._ctx, self.state) + self.enterRule(localctx, 812, self.RULE_performAfter) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4773 + self.match(Cobol85Parser.AFTER) + self.state = 4774 + self.performVaryingPhrase() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PerformFromContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FROM(self): + return self.getToken(Cobol85Parser.FROM, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def arithmeticExpression(self): + return self.getTypedRuleContext(Cobol85Parser.ArithmeticExpressionContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_performFrom + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPerformFrom" ): + listener.enterPerformFrom(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPerformFrom" ): + listener.exitPerformFrom(self) + + + + + def performFrom(self): + + localctx = Cobol85Parser.PerformFromContext(self, self._ctx, self.state) + self.enterRule(localctx, 814, self.RULE_performFrom) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4776 + self.match(Cobol85Parser.FROM) + self.state = 4780 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,697,self._ctx) + if la_ == 1: + self.state = 4777 + self.identifier() + pass + + elif la_ == 2: + self.state = 4778 + self.literal() + pass + + elif la_ == 3: + self.state = 4779 + self.arithmeticExpression() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PerformByContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def arithmeticExpression(self): + return self.getTypedRuleContext(Cobol85Parser.ArithmeticExpressionContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_performBy + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPerformBy" ): + listener.enterPerformBy(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPerformBy" ): + listener.exitPerformBy(self) + + + + + def performBy(self): + + localctx = Cobol85Parser.PerformByContext(self, self._ctx, self.state) + self.enterRule(localctx, 816, self.RULE_performBy) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4782 + self.match(Cobol85Parser.BY) + self.state = 4786 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,698,self._ctx) + if la_ == 1: + self.state = 4783 + self.identifier() + pass + + elif la_ == 2: + self.state = 4784 + self.literal() + pass + + elif la_ == 3: + self.state = 4785 + self.arithmeticExpression() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PerformTestClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TEST(self): + return self.getToken(Cobol85Parser.TEST, 0) + + def BEFORE(self): + return self.getToken(Cobol85Parser.BEFORE, 0) + + def AFTER(self): + return self.getToken(Cobol85Parser.AFTER, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_performTestClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPerformTestClause" ): + listener.enterPerformTestClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPerformTestClause" ): + listener.exitPerformTestClause(self) + + + + + def performTestClause(self): + + localctx = Cobol85Parser.PerformTestClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 818, self.RULE_performTestClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4789 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 4788 + self.match(Cobol85Parser.WITH) + + + self.state = 4791 + self.match(Cobol85Parser.TEST) + self.state = 4792 + _la = self._input.LA(1) + if not(_la==7 or _la==39): + 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 PurgeStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PURGE(self): + return self.getToken(Cobol85Parser.PURGE, 0) + + def cdName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.CdNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.CdNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_purgeStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPurgeStatement" ): + listener.enterPurgeStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPurgeStatement" ): + listener.exitPurgeStatement(self) + + + + + def purgeStatement(self): + + localctx = Cobol85Parser.PurgeStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 820, self.RULE_purgeStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4794 + self.match(Cobol85Parser.PURGE) + self.state = 4796 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 4795 + self.cdName() + self.state = 4798 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReadStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def READ(self): + return self.getToken(Cobol85Parser.READ, 0) + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def NEXT(self): + return self.getToken(Cobol85Parser.NEXT, 0) + + def RECORD(self): + return self.getToken(Cobol85Parser.RECORD, 0) + + def readInto(self): + return self.getTypedRuleContext(Cobol85Parser.ReadIntoContext,0) + + + def readWith(self): + return self.getTypedRuleContext(Cobol85Parser.ReadWithContext,0) + + + def readKey(self): + return self.getTypedRuleContext(Cobol85Parser.ReadKeyContext,0) + + + def invalidKeyPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.InvalidKeyPhraseContext,0) + + + def notInvalidKeyPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.NotInvalidKeyPhraseContext,0) + + + def atEndPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.AtEndPhraseContext,0) + + + def notAtEndPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.NotAtEndPhraseContext,0) + + + def END_READ(self): + return self.getToken(Cobol85Parser.END_READ, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_readStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReadStatement" ): + listener.enterReadStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReadStatement" ): + listener.exitReadStatement(self) + + + + + def readStatement(self): + + localctx = Cobol85Parser.ReadStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 822, self.RULE_readStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4800 + self.match(Cobol85Parser.READ) + self.state = 4801 + self.fileName() + self.state = 4803 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==309: + self.state = 4802 + self.match(Cobol85Parser.NEXT) + + + self.state = 4806 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==377: + self.state = 4805 + self.match(Cobol85Parser.RECORD) + + + self.state = 4809 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==251: + self.state = 4808 + self.readInto() + + + self.state = 4812 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,704,self._ctx) + if la_ == 1: + self.state = 4811 + self.readWith() + + + self.state = 4815 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==259: + self.state = 4814 + self.readKey() + + + self.state = 4818 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,706,self._ctx) + if la_ == 1: + self.state = 4817 + self.invalidKeyPhrase() + + + self.state = 4821 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,707,self._ctx) + if la_ == 1: + self.state = 4820 + self.notInvalidKeyPhrase() + + + self.state = 4824 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,708,self._ctx) + if la_ == 1: + self.state = 4823 + self.atEndPhrase() + + + self.state = 4827 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,709,self._ctx) + if la_ == 1: + self.state = 4826 + self.notAtEndPhrase() + + + self.state = 4830 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,710,self._ctx) + if la_ == 1: + self.state = 4829 + self.match(Cobol85Parser.END_READ) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReadIntoContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTO(self): + return self.getToken(Cobol85Parser.INTO, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_readInto + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReadInto" ): + listener.enterReadInto(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReadInto" ): + listener.exitReadInto(self) + + + + + def readInto(self): + + localctx = Cobol85Parser.ReadIntoContext(self, self._ctx, self.state) + self.enterRule(localctx, 824, self.RULE_readInto) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4832 + self.match(Cobol85Parser.INTO) + self.state = 4833 + 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 ReadWithContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LOCK(self): + return self.getToken(Cobol85Parser.LOCK, 0) + + def WAIT(self): + return self.getToken(Cobol85Parser.WAIT, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def KEPT(self): + return self.getToken(Cobol85Parser.KEPT, 0) + + def NO(self): + return self.getToken(Cobol85Parser.NO, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_readWith + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReadWith" ): + listener.enterReadWith(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReadWith" ): + listener.exitReadWith(self) + + + + + def readWith(self): + + localctx = Cobol85Parser.ReadWithContext(self, self._ctx, self.state) + self.enterRule(localctx, 826, self.RULE_readWith) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4836 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 4835 + self.match(Cobol85Parser.WITH) + + + self.state = 4841 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [258, 310]: + self.state = 4838 + _la = self._input.LA(1) + if not(_la==258 or _la==310): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 4839 + self.match(Cobol85Parser.LOCK) + pass + elif token in [511]: + self.state = 4840 + self.match(Cobol85Parser.WAIT) + 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 ReadKeyContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_readKey + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReadKey" ): + listener.enterReadKey(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReadKey" ): + listener.exitReadKey(self) + + + + + def readKey(self): + + localctx = Cobol85Parser.ReadKeyContext(self, self._ctx, self.state) + self.enterRule(localctx, 828, self.RULE_readKey) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4843 + self.match(Cobol85Parser.KEY) + self.state = 4845 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 4844 + self.match(Cobol85Parser.IS) + + + self.state = 4847 + self.qualifiedDataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReceiveStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RECEIVE(self): + return self.getToken(Cobol85Parser.RECEIVE, 0) + + def receiveFromStatement(self): + return self.getTypedRuleContext(Cobol85Parser.ReceiveFromStatementContext,0) + + + def receiveIntoStatement(self): + return self.getTypedRuleContext(Cobol85Parser.ReceiveIntoStatementContext,0) + + + def onExceptionClause(self): + return self.getTypedRuleContext(Cobol85Parser.OnExceptionClauseContext,0) + + + def notOnExceptionClause(self): + return self.getTypedRuleContext(Cobol85Parser.NotOnExceptionClauseContext,0) + + + def END_RECEIVE(self): + return self.getToken(Cobol85Parser.END_RECEIVE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_receiveStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReceiveStatement" ): + listener.enterReceiveStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReceiveStatement" ): + listener.exitReceiveStatement(self) + + + + + def receiveStatement(self): + + localctx = Cobol85Parser.ReceiveStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 830, self.RULE_receiveStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4849 + self.match(Cobol85Parser.RECEIVE) + self.state = 4852 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,714,self._ctx) + if la_ == 1: + self.state = 4850 + self.receiveFromStatement() + pass + + elif la_ == 2: + self.state = 4851 + self.receiveIntoStatement() + pass + + + self.state = 4855 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,715,self._ctx) + if la_ == 1: + self.state = 4854 + self.onExceptionClause() + + + self.state = 4858 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,716,self._ctx) + if la_ == 1: + self.state = 4857 + self.notOnExceptionClause() + + + self.state = 4861 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,717,self._ctx) + if la_ == 1: + self.state = 4860 + self.match(Cobol85Parser.END_RECEIVE) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReceiveFromStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def FROM(self): + return self.getToken(Cobol85Parser.FROM, 0) + + def receiveFrom(self): + return self.getTypedRuleContext(Cobol85Parser.ReceiveFromContext,0) + + + def receiveBefore(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReceiveBeforeContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReceiveBeforeContext,i) + + + def receiveWith(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReceiveWithContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReceiveWithContext,i) + + + def receiveThread(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReceiveThreadContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReceiveThreadContext,i) + + + def receiveSize(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReceiveSizeContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReceiveSizeContext,i) + + + def receiveStatus(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ReceiveStatusContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ReceiveStatusContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_receiveFromStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReceiveFromStatement" ): + listener.enterReceiveFromStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReceiveFromStatement" ): + listener.exitReceiveFromStatement(self) + + + + + def receiveFromStatement(self): + + localctx = Cobol85Parser.ReceiveFromStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 832, self.RULE_receiveFromStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4863 + self.dataName() + self.state = 4864 + self.match(Cobol85Parser.FROM) + self.state = 4865 + self.receiveFrom() + self.state = 4873 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,719,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 4871 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [39]: + self.state = 4866 + self.receiveBefore() + pass + elif token in [310, 514]: + self.state = 4867 + self.receiveWith() + pass + elif token in [481]: + self.state = 4868 + self.receiveThread() + pass + elif token in [439]: + self.state = 4869 + self.receiveSize() + pass + elif token in [457]: + self.state = 4870 + self.receiveStatus() + pass + else: + raise NoViableAltException(self) + + self.state = 4875 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,719,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReceiveFromContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def THREAD(self): + return self.getToken(Cobol85Parser.THREAD, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def LAST(self): + return self.getToken(Cobol85Parser.LAST, 0) + + def ANY(self): + return self.getToken(Cobol85Parser.ANY, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_receiveFrom + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReceiveFrom" ): + listener.enterReceiveFrom(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReceiveFrom" ): + listener.exitReceiveFrom(self) + + + + + def receiveFrom(self): + + localctx = Cobol85Parser.ReceiveFromContext(self, self._ctx, self.state) + self.enterRule(localctx, 834, self.RULE_receiveFrom) + try: + self.state = 4882 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [481]: + self.enterOuterAlt(localctx, 1) + self.state = 4876 + self.match(Cobol85Parser.THREAD) + self.state = 4877 + self.dataName() + pass + elif token in [263]: + self.enterOuterAlt(localctx, 2) + self.state = 4878 + self.match(Cobol85Parser.LAST) + self.state = 4879 + self.match(Cobol85Parser.THREAD) + pass + elif token in [20]: + self.enterOuterAlt(localctx, 3) + self.state = 4880 + self.match(Cobol85Parser.ANY) + self.state = 4881 + self.match(Cobol85Parser.THREAD) + 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 ReceiveIntoStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cdName(self): + return self.getTypedRuleContext(Cobol85Parser.CdNameContext,0) + + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def MESSAGE(self): + return self.getToken(Cobol85Parser.MESSAGE, 0) + + def SEGMENT(self): + return self.getToken(Cobol85Parser.SEGMENT, 0) + + def INTO(self): + return self.getToken(Cobol85Parser.INTO, 0) + + def receiveNoData(self): + return self.getTypedRuleContext(Cobol85Parser.ReceiveNoDataContext,0) + + + def receiveWithData(self): + return self.getTypedRuleContext(Cobol85Parser.ReceiveWithDataContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_receiveIntoStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReceiveIntoStatement" ): + listener.enterReceiveIntoStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReceiveIntoStatement" ): + listener.exitReceiveIntoStatement(self) + + + + + def receiveIntoStatement(self): + + localctx = Cobol85Parser.ReceiveIntoStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 836, self.RULE_receiveIntoStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4884 + self.cdName() + self.state = 4885 + _la = self._input.LA(1) + if not(_la==295 or _la==422): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 4887 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==251: + self.state = 4886 + self.match(Cobol85Parser.INTO) + + + self.state = 4889 + self.identifier() + self.state = 4891 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==310: + self.state = 4890 + self.receiveNoData() + + + self.state = 4894 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,723,self._ctx) + if la_ == 1: + self.state = 4893 + self.receiveWithData() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReceiveNoDataContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NO(self): + return self.getToken(Cobol85Parser.NO, 0) + + def DATA(self): + return self.getToken(Cobol85Parser.DATA, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_receiveNoData + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReceiveNoData" ): + listener.enterReceiveNoData(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReceiveNoData" ): + listener.exitReceiveNoData(self) + + + + + def receiveNoData(self): + + localctx = Cobol85Parser.ReceiveNoDataContext(self, self._ctx, self.state) + self.enterRule(localctx, 838, self.RULE_receiveNoData) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4896 + self.match(Cobol85Parser.NO) + self.state = 4897 + self.match(Cobol85Parser.DATA) + self.state = 4901 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,724,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 4898 + self.statement() + self.state = 4903 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,724,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReceiveWithDataContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def DATA(self): + return self.getToken(Cobol85Parser.DATA, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_receiveWithData + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReceiveWithData" ): + listener.enterReceiveWithData(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReceiveWithData" ): + listener.exitReceiveWithData(self) + + + + + def receiveWithData(self): + + localctx = Cobol85Parser.ReceiveWithDataContext(self, self._ctx, self.state) + self.enterRule(localctx, 840, self.RULE_receiveWithData) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4904 + self.match(Cobol85Parser.WITH) + self.state = 4905 + self.match(Cobol85Parser.DATA) + self.state = 4909 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,725,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 4906 + self.statement() + self.state = 4911 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,725,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReceiveBeforeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BEFORE(self): + return self.getToken(Cobol85Parser.BEFORE, 0) + + def numericLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.NumericLiteralContext,0) + + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def TIME(self): + return self.getToken(Cobol85Parser.TIME, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_receiveBefore + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReceiveBefore" ): + listener.enterReceiveBefore(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReceiveBefore" ): + listener.exitReceiveBefore(self) + + + + + def receiveBefore(self): + + localctx = Cobol85Parser.ReceiveBeforeContext(self, self._ctx, self.state) + self.enterRule(localctx, 842, self.RULE_receiveBefore) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4912 + self.match(Cobol85Parser.BEFORE) + self.state = 4914 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,726,self._ctx) + if la_ == 1: + self.state = 4913 + self.match(Cobol85Parser.TIME) + + + self.state = 4918 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,727,self._ctx) + if la_ == 1: + self.state = 4916 + self.numericLiteral() + pass + + elif la_ == 2: + self.state = 4917 + self.identifier() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReceiveWithContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NO(self): + return self.getToken(Cobol85Parser.NO, 0) + + def WAIT(self): + return self.getToken(Cobol85Parser.WAIT, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_receiveWith + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReceiveWith" ): + listener.enterReceiveWith(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReceiveWith" ): + listener.exitReceiveWith(self) + + + + + def receiveWith(self): + + localctx = Cobol85Parser.ReceiveWithContext(self, self._ctx, self.state) + self.enterRule(localctx, 844, self.RULE_receiveWith) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4921 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 4920 + self.match(Cobol85Parser.WITH) + + + self.state = 4923 + self.match(Cobol85Parser.NO) + self.state = 4924 + self.match(Cobol85Parser.WAIT) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReceiveThreadContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def THREAD(self): + return self.getToken(Cobol85Parser.THREAD, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def IN(self): + return self.getToken(Cobol85Parser.IN, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_receiveThread + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReceiveThread" ): + listener.enterReceiveThread(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReceiveThread" ): + listener.exitReceiveThread(self) + + + + + def receiveThread(self): + + localctx = Cobol85Parser.ReceiveThreadContext(self, self._ctx, self.state) + self.enterRule(localctx, 846, self.RULE_receiveThread) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4926 + self.match(Cobol85Parser.THREAD) + self.state = 4928 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==239: + self.state = 4927 + self.match(Cobol85Parser.IN) + + + self.state = 4930 + self.dataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReceiveSizeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SIZE(self): + return self.getToken(Cobol85Parser.SIZE, 0) + + def numericLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.NumericLiteralContext,0) + + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def IN(self): + return self.getToken(Cobol85Parser.IN, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_receiveSize + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReceiveSize" ): + listener.enterReceiveSize(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReceiveSize" ): + listener.exitReceiveSize(self) + + + + + def receiveSize(self): + + localctx = Cobol85Parser.ReceiveSizeContext(self, self._ctx, self.state) + self.enterRule(localctx, 848, self.RULE_receiveSize) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4932 + self.match(Cobol85Parser.SIZE) + self.state = 4934 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==239: + self.state = 4933 + self.match(Cobol85Parser.IN) + + + self.state = 4938 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,731,self._ctx) + if la_ == 1: + self.state = 4936 + self.numericLiteral() + pass + + elif la_ == 2: + self.state = 4937 + self.identifier() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReceiveStatusContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def STATUS(self): + return self.getToken(Cobol85Parser.STATUS, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def IN(self): + return self.getToken(Cobol85Parser.IN, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_receiveStatus + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReceiveStatus" ): + listener.enterReceiveStatus(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReceiveStatus" ): + listener.exitReceiveStatus(self) + + + + + def receiveStatus(self): + + localctx = Cobol85Parser.ReceiveStatusContext(self, self._ctx, self.state) + self.enterRule(localctx, 850, self.RULE_receiveStatus) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4940 + self.match(Cobol85Parser.STATUS) + self.state = 4942 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==239: + self.state = 4941 + self.match(Cobol85Parser.IN) + + + self.state = 4944 + 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 ReleaseStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RELEASE(self): + return self.getToken(Cobol85Parser.RELEASE, 0) + + def recordName(self): + return self.getTypedRuleContext(Cobol85Parser.RecordNameContext,0) + + + def FROM(self): + return self.getToken(Cobol85Parser.FROM, 0) + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_releaseStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReleaseStatement" ): + listener.enterReleaseStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReleaseStatement" ): + listener.exitReleaseStatement(self) + + + + + def releaseStatement(self): + + localctx = Cobol85Parser.ReleaseStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 852, self.RULE_releaseStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4946 + self.match(Cobol85Parser.RELEASE) + self.state = 4947 + self.recordName() + self.state = 4950 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==215: + self.state = 4948 + self.match(Cobol85Parser.FROM) + self.state = 4949 + self.qualifiedDataName() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReturnStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RETURN(self): + return self.getToken(Cobol85Parser.RETURN, 0) + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def atEndPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.AtEndPhraseContext,0) + + + def RECORD(self): + return self.getToken(Cobol85Parser.RECORD, 0) + + def returnInto(self): + return self.getTypedRuleContext(Cobol85Parser.ReturnIntoContext,0) + + + def notAtEndPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.NotAtEndPhraseContext,0) + + + def END_RETURN(self): + return self.getToken(Cobol85Parser.END_RETURN, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_returnStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReturnStatement" ): + listener.enterReturnStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReturnStatement" ): + listener.exitReturnStatement(self) + + + + + def returnStatement(self): + + localctx = Cobol85Parser.ReturnStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 854, self.RULE_returnStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4952 + self.match(Cobol85Parser.RETURN) + self.state = 4953 + self.fileName() + self.state = 4955 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==377: + self.state = 4954 + self.match(Cobol85Parser.RECORD) + + + self.state = 4958 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==251: + self.state = 4957 + self.returnInto() + + + self.state = 4960 + self.atEndPhrase() + self.state = 4962 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,736,self._ctx) + if la_ == 1: + self.state = 4961 + self.notAtEndPhrase() + + + self.state = 4965 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,737,self._ctx) + if la_ == 1: + self.state = 4964 + self.match(Cobol85Parser.END_RETURN) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReturnIntoContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTO(self): + return self.getToken(Cobol85Parser.INTO, 0) + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_returnInto + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReturnInto" ): + listener.enterReturnInto(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReturnInto" ): + listener.exitReturnInto(self) + + + + + def returnInto(self): + + localctx = Cobol85Parser.ReturnIntoContext(self, self._ctx, self.state) + self.enterRule(localctx, 856, self.RULE_returnInto) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4967 + self.match(Cobol85Parser.INTO) + self.state = 4968 + self.qualifiedDataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RewriteStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REWRITE(self): + return self.getToken(Cobol85Parser.REWRITE, 0) + + def recordName(self): + return self.getTypedRuleContext(Cobol85Parser.RecordNameContext,0) + + + def rewriteFrom(self): + return self.getTypedRuleContext(Cobol85Parser.RewriteFromContext,0) + + + def invalidKeyPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.InvalidKeyPhraseContext,0) + + + def notInvalidKeyPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.NotInvalidKeyPhraseContext,0) + + + def END_REWRITE(self): + return self.getToken(Cobol85Parser.END_REWRITE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_rewriteStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRewriteStatement" ): + listener.enterRewriteStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRewriteStatement" ): + listener.exitRewriteStatement(self) + + + + + def rewriteStatement(self): + + localctx = Cobol85Parser.RewriteStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 858, self.RULE_rewriteStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4970 + self.match(Cobol85Parser.REWRITE) + self.state = 4971 + self.recordName() + self.state = 4973 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==215: + self.state = 4972 + self.rewriteFrom() + + + self.state = 4976 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,739,self._ctx) + if la_ == 1: + self.state = 4975 + self.invalidKeyPhrase() + + + self.state = 4979 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,740,self._ctx) + if la_ == 1: + self.state = 4978 + self.notInvalidKeyPhrase() + + + self.state = 4982 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,741,self._ctx) + if la_ == 1: + self.state = 4981 + self.match(Cobol85Parser.END_REWRITE) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RewriteFromContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FROM(self): + return self.getToken(Cobol85Parser.FROM, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_rewriteFrom + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRewriteFrom" ): + listener.enterRewriteFrom(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRewriteFrom" ): + listener.exitRewriteFrom(self) + + + + + def rewriteFrom(self): + + localctx = Cobol85Parser.RewriteFromContext(self, self._ctx, self.state) + self.enterRule(localctx, 860, self.RULE_rewriteFrom) + try: + self.enterOuterAlt(localctx, 1) + self.state = 4984 + self.match(Cobol85Parser.FROM) + self.state = 4985 + 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 SearchStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SEARCH(self): + return self.getToken(Cobol85Parser.SEARCH, 0) + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def ALL(self): + return self.getToken(Cobol85Parser.ALL, 0) + + def searchVarying(self): + return self.getTypedRuleContext(Cobol85Parser.SearchVaryingContext,0) + + + def atEndPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.AtEndPhraseContext,0) + + + def searchWhen(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SearchWhenContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SearchWhenContext,i) + + + def END_SEARCH(self): + return self.getToken(Cobol85Parser.END_SEARCH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_searchStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSearchStatement" ): + listener.enterSearchStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSearchStatement" ): + listener.exitSearchStatement(self) + + + + + def searchStatement(self): + + localctx = Cobol85Parser.SearchStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 862, self.RULE_searchStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 4987 + self.match(Cobol85Parser.SEARCH) + self.state = 4989 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==9: + self.state = 4988 + self.match(Cobol85Parser.ALL) + + + self.state = 4991 + self.qualifiedDataName() + self.state = 4993 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==509: + self.state = 4992 + self.searchVarying() + + + self.state = 4996 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==30 or _la==158: + self.state = 4995 + self.atEndPhrase() + + + self.state = 4999 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 4998 + self.searchWhen() + + else: + raise NoViableAltException(self) + self.state = 5001 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,745,self._ctx) + + self.state = 5004 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,746,self._ctx) + if la_ == 1: + self.state = 5003 + self.match(Cobol85Parser.END_SEARCH) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SearchVaryingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def VARYING(self): + return self.getToken(Cobol85Parser.VARYING, 0) + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_searchVarying + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSearchVarying" ): + listener.enterSearchVarying(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSearchVarying" ): + listener.exitSearchVarying(self) + + + + + def searchVarying(self): + + localctx = Cobol85Parser.SearchVaryingContext(self, self._ctx, self.state) + self.enterRule(localctx, 864, self.RULE_searchVarying) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5006 + self.match(Cobol85Parser.VARYING) + self.state = 5007 + self.qualifiedDataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SearchWhenContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def WHEN(self): + return self.getToken(Cobol85Parser.WHEN, 0) + + def condition(self): + return self.getTypedRuleContext(Cobol85Parser.ConditionContext,0) + + + def NEXT(self): + return self.getToken(Cobol85Parser.NEXT, 0) + + def SENTENCE(self): + return self.getToken(Cobol85Parser.SENTENCE, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_searchWhen + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSearchWhen" ): + listener.enterSearchWhen(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSearchWhen" ): + listener.exitSearchWhen(self) + + + + + def searchWhen(self): + + localctx = Cobol85Parser.SearchWhenContext(self, self._ctx, self.state) + self.enterRule(localctx, 866, self.RULE_searchWhen) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5009 + self.match(Cobol85Parser.WHEN) + self.state = 5010 + self.condition() + self.state = 5019 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [309]: + self.state = 5011 + self.match(Cobol85Parser.NEXT) + self.state = 5012 + self.match(Cobol85Parser.SENTENCE) + pass + elif token in [2, 4, 17, 30, 52, 53, 67, 92, 96, 131, 140, 142, 144, 154, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 182, 193, 196, 198, 199, 220, 221, 224, 236, 244, 245, 248, 252, 294, 300, 302, 312, 326, 327, 343, 365, 374, 375, 387, 403, 408, 418, 425, 430, 440, 456, 458, 459, 463, 476, 500, 512, 514, 517, 534, 559, 560, 561]: + self.state = 5016 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,747,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5013 + self.statement() + self.state = 5018 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,747,self._ctx) + + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SendStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SEND(self): + return self.getToken(Cobol85Parser.SEND, 0) + + def sendStatementSync(self): + return self.getTypedRuleContext(Cobol85Parser.SendStatementSyncContext,0) + + + def sendStatementAsync(self): + return self.getTypedRuleContext(Cobol85Parser.SendStatementAsyncContext,0) + + + def onExceptionClause(self): + return self.getTypedRuleContext(Cobol85Parser.OnExceptionClauseContext,0) + + + def notOnExceptionClause(self): + return self.getTypedRuleContext(Cobol85Parser.NotOnExceptionClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_sendStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSendStatement" ): + listener.enterSendStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSendStatement" ): + listener.exitSendStatement(self) + + + + + def sendStatement(self): + + localctx = Cobol85Parser.SendStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 868, self.RULE_sendStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5021 + self.match(Cobol85Parser.SEND) + self.state = 5024 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [1, 5, 9, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 111, 114, 115, 118, 119, 120, 121, 122, 123, 124, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 204, 213, 214, 216, 217, 218, 219, 226, 229, 230, 231, 237, 238, 250, 258, 260, 262, 264, 265, 268, 269, 270, 272, 273, 274, 278, 281, 283, 284, 287, 288, 289, 290, 291, 292, 296, 303, 304, 305, 308, 311, 313, 314, 317, 319, 322, 331, 336, 337, 341, 342, 352, 353, 355, 360, 361, 364, 367, 368, 370, 371, 373, 376, 380, 383, 391, 398, 401, 404, 415, 420, 431, 432, 433, 434, 435, 436, 437, 441, 442, 443, 445, 446, 447, 450, 451, 466, 471, 473, 481, 482, 485, 486, 490, 491, 494, 495, 497, 498, 510, 511, 513, 518, 519, 520, 521, 522, 523, 524, 551, 552, 553, 554, 555, 556, 557]: + self.state = 5022 + self.sendStatementSync() + pass + elif token in [489]: + self.state = 5023 + self.sendStatementAsync() + pass + else: + raise NoViableAltException(self) + + self.state = 5027 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,750,self._ctx) + if la_ == 1: + self.state = 5026 + self.onExceptionClause() + + + self.state = 5030 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,751,self._ctx) + if la_ == 1: + self.state = 5029 + self.notOnExceptionClause() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SendStatementSyncContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def sendFromPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.SendFromPhraseContext,0) + + + def sendWithPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.SendWithPhraseContext,0) + + + def sendReplacingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.SendReplacingPhraseContext,0) + + + def sendAdvancingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.SendAdvancingPhraseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_sendStatementSync + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSendStatementSync" ): + listener.enterSendStatementSync(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSendStatementSync" ): + listener.exitSendStatementSync(self) + + + + + def sendStatementSync(self): + + localctx = Cobol85Parser.SendStatementSyncContext(self, self._ctx, self.state) + self.enterRule(localctx, 870, self.RULE_sendStatementSync) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5034 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,752,self._ctx) + if la_ == 1: + self.state = 5032 + self.identifier() + pass + + elif la_ == 2: + self.state = 5033 + self.literal() + pass + + + self.state = 5037 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==215: + self.state = 5036 + self.sendFromPhrase() + + + self.state = 5040 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,754,self._ctx) + if la_ == 1: + self.state = 5039 + self.sendWithPhrase() + + + self.state = 5043 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==394: + self.state = 5042 + self.sendReplacingPhrase() + + + self.state = 5046 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==7 or _la==39: + self.state = 5045 + self.sendAdvancingPhrase() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SendStatementAsyncContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def TOP(self): + return self.getToken(Cobol85Parser.TOP, 0) + + def BOTTOM(self): + return self.getToken(Cobol85Parser.BOTTOM, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_sendStatementAsync + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSendStatementAsync" ): + listener.enterSendStatementAsync(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSendStatementAsync" ): + listener.exitSendStatementAsync(self) + + + + + def sendStatementAsync(self): + + localctx = Cobol85Parser.SendStatementAsyncContext(self, self._ctx, self.state) + self.enterRule(localctx, 872, self.RULE_sendStatementAsync) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5048 + self.match(Cobol85Parser.TO) + self.state = 5049 + _la = self._input.LA(1) + if not(_la==48 or _la==492): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5050 + 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 SendFromPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FROM(self): + return self.getToken(Cobol85Parser.FROM, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_sendFromPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSendFromPhrase" ): + listener.enterSendFromPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSendFromPhrase" ): + listener.exitSendFromPhrase(self) + + + + + def sendFromPhrase(self): + + localctx = Cobol85Parser.SendFromPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 874, self.RULE_sendFromPhrase) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5052 + self.match(Cobol85Parser.FROM) + self.state = 5053 + 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 SendWithPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def EGI(self): + return self.getToken(Cobol85Parser.EGI, 0) + + def EMI(self): + return self.getToken(Cobol85Parser.EMI, 0) + + def ESI(self): + return self.getToken(Cobol85Parser.ESI, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_sendWithPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSendWithPhrase" ): + listener.enterSendWithPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSendWithPhrase" ): + listener.exitSendWithPhrase(self) + + + + + def sendWithPhrase(self): + + localctx = Cobol85Parser.SendWithPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 876, self.RULE_sendWithPhrase) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5055 + self.match(Cobol85Parser.WITH) + self.state = 5060 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [153]: + self.state = 5056 + self.match(Cobol85Parser.EGI) + pass + elif token in [155]: + self.state = 5057 + self.match(Cobol85Parser.EMI) + pass + elif token in [192]: + self.state = 5058 + self.match(Cobol85Parser.ESI) + pass + elif token in [1, 5, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 111, 114, 115, 118, 119, 120, 121, 122, 123, 124, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 217, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 269, 270, 272, 273, 274, 278, 281, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 341, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 404, 415, 420, 431, 432, 433, 434, 435, 436, 437, 441, 442, 443, 445, 446, 447, 466, 471, 473, 481, 482, 485, 486, 490, 491, 495, 497, 498, 510, 511, 513, 518, 519, 520, 522, 552, 553, 554, 555, 557]: + self.state = 5059 + 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 SendReplacingPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def REPLACING(self): + return self.getToken(Cobol85Parser.REPLACING, 0) + + def LINE(self): + return self.getToken(Cobol85Parser.LINE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_sendReplacingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSendReplacingPhrase" ): + listener.enterSendReplacingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSendReplacingPhrase" ): + listener.exitSendReplacingPhrase(self) + + + + + def sendReplacingPhrase(self): + + localctx = Cobol85Parser.SendReplacingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 878, self.RULE_sendReplacingPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5062 + self.match(Cobol85Parser.REPLACING) + self.state = 5064 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==279: + self.state = 5063 + self.match(Cobol85Parser.LINE) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SendAdvancingPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BEFORE(self): + return self.getToken(Cobol85Parser.BEFORE, 0) + + def AFTER(self): + return self.getToken(Cobol85Parser.AFTER, 0) + + def sendAdvancingPage(self): + return self.getTypedRuleContext(Cobol85Parser.SendAdvancingPageContext,0) + + + def sendAdvancingLines(self): + return self.getTypedRuleContext(Cobol85Parser.SendAdvancingLinesContext,0) + + + def sendAdvancingMnemonic(self): + return self.getTypedRuleContext(Cobol85Parser.SendAdvancingMnemonicContext,0) + + + def ADVANCING(self): + return self.getToken(Cobol85Parser.ADVANCING, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_sendAdvancingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSendAdvancingPhrase" ): + listener.enterSendAdvancingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSendAdvancingPhrase" ): + listener.exitSendAdvancingPhrase(self) + + + + + def sendAdvancingPhrase(self): + + localctx = Cobol85Parser.SendAdvancingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 880, self.RULE_sendAdvancingPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5066 + _la = self._input.LA(1) + if not(_la==7 or _la==39): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5068 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==6: + self.state = 5067 + self.match(Cobol85Parser.ADVANCING) + + + self.state = 5073 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,760,self._ctx) + if la_ == 1: + self.state = 5070 + self.sendAdvancingPage() + pass + + elif la_ == 2: + self.state = 5071 + self.sendAdvancingLines() + pass + + elif la_ == 3: + self.state = 5072 + self.sendAdvancingMnemonic() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SendAdvancingPageContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PAGE(self): + return self.getToken(Cobol85Parser.PAGE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_sendAdvancingPage + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSendAdvancingPage" ): + listener.enterSendAdvancingPage(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSendAdvancingPage" ): + listener.exitSendAdvancingPage(self) + + + + + def sendAdvancingPage(self): + + localctx = Cobol85Parser.SendAdvancingPageContext(self, self._ctx, self.state) + self.enterRule(localctx, 882, self.RULE_sendAdvancingPage) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5075 + self.match(Cobol85Parser.PAGE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SendAdvancingLinesContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def LINE(self): + return self.getToken(Cobol85Parser.LINE, 0) + + def LINES(self): + return self.getToken(Cobol85Parser.LINES, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_sendAdvancingLines + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSendAdvancingLines" ): + listener.enterSendAdvancingLines(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSendAdvancingLines" ): + listener.exitSendAdvancingLines(self) + + + + + def sendAdvancingLines(self): + + localctx = Cobol85Parser.SendAdvancingLinesContext(self, self._ctx, self.state) + self.enterRule(localctx, 884, self.RULE_sendAdvancingLines) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5079 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,761,self._ctx) + if la_ == 1: + self.state = 5077 + self.identifier() + pass + + elif la_ == 2: + self.state = 5078 + self.literal() + pass + + + self.state = 5082 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==279 or _la==280: + self.state = 5081 + _la = self._input.LA(1) + if not(_la==279 or _la==280): + 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 SendAdvancingMnemonicContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def mnemonicName(self): + return self.getTypedRuleContext(Cobol85Parser.MnemonicNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_sendAdvancingMnemonic + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSendAdvancingMnemonic" ): + listener.enterSendAdvancingMnemonic(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSendAdvancingMnemonic" ): + listener.exitSendAdvancingMnemonic(self) + + + + + def sendAdvancingMnemonic(self): + + localctx = Cobol85Parser.SendAdvancingMnemonicContext(self, self._ctx, self.state) + self.enterRule(localctx, 886, self.RULE_sendAdvancingMnemonic) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5084 + self.mnemonicName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SetStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SET(self): + return self.getToken(Cobol85Parser.SET, 0) + + def setUpDownByStatement(self): + return self.getTypedRuleContext(Cobol85Parser.SetUpDownByStatementContext,0) + + + def setToStatement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SetToStatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SetToStatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_setStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSetStatement" ): + listener.enterSetStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSetStatement" ): + listener.exitSetStatement(self) + + + + + def setStatement(self): + + localctx = Cobol85Parser.SetStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 888, self.RULE_setStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5086 + self.match(Cobol85Parser.SET) + self.state = 5093 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,764,self._ctx) + if la_ == 1: + self.state = 5088 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5087 + self.setToStatement() + self.state = 5090 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 0)): + break + + pass + + elif la_ == 2: + self.state = 5092 + self.setUpDownByStatement() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SetToStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def setTo(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SetToContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SetToContext,i) + + + def setToValue(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SetToValueContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SetToValueContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_setToStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSetToStatement" ): + listener.enterSetToStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSetToStatement" ): + listener.exitSetToStatement(self) + + + + + def setToStatement(self): + + localctx = Cobol85Parser.SetToStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 890, self.RULE_setToStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5096 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5095 + self.setTo() + self.state = 5098 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 0)): + break + + self.state = 5100 + self.match(Cobol85Parser.TO) + self.state = 5102 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 5101 + self.setToValue() + + else: + raise NoViableAltException(self) + self.state = 5104 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,766,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SetUpDownByStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def setByValue(self): + return self.getTypedRuleContext(Cobol85Parser.SetByValueContext,0) + + + def UP(self): + return self.getToken(Cobol85Parser.UP, 0) + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def DOWN(self): + return self.getToken(Cobol85Parser.DOWN, 0) + + def setTo(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SetToContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SetToContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_setUpDownByStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSetUpDownByStatement" ): + listener.enterSetUpDownByStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSetUpDownByStatement" ): + listener.exitSetUpDownByStatement(self) + + + + + def setUpDownByStatement(self): + + localctx = Cobol85Parser.SetUpDownByStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 892, self.RULE_setUpDownByStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5107 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5106 + self.setTo() + self.state = 5109 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 0)): + break + + self.state = 5115 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [502]: + self.state = 5111 + self.match(Cobol85Parser.UP) + self.state = 5112 + self.match(Cobol85Parser.BY) + pass + elif token in [148]: + self.state = 5113 + self.match(Cobol85Parser.DOWN) + self.state = 5114 + self.match(Cobol85Parser.BY) + pass + else: + raise NoViableAltException(self) + + self.state = 5117 + self.setByValue() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SetToContext(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(Cobol85Parser.IdentifierContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_setTo + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSetTo" ): + listener.enterSetTo(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSetTo" ): + listener.exitSetTo(self) + + + + + def setTo(self): + + localctx = Cobol85Parser.SetToContext(self, self._ctx, self.state) + self.enterRule(localctx, 894, self.RULE_setTo) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5119 + 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 SetToValueContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def OFF(self): + return self.getToken(Cobol85Parser.OFF, 0) + + def ENTRY(self): + return self.getToken(Cobol85Parser.ENTRY, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_setToValue + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSetToValue" ): + listener.enterSetToValue(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSetToValue" ): + listener.exitSetToValue(self) + + + + + def setToValue(self): + + localctx = Cobol85Parser.SetToValueContext(self, self._ctx, self.state) + self.enterRule(localctx, 896, self.RULE_setToValue) + try: + self.state = 5130 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,770,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5121 + self.match(Cobol85Parser.ON) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5122 + self.match(Cobol85Parser.OFF) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 5123 + self.match(Cobol85Parser.ENTRY) + self.state = 5126 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,769,self._ctx) + if la_ == 1: + self.state = 5124 + self.identifier() + pass + + elif la_ == 2: + self.state = 5125 + self.literal() + pass + + + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 5128 + self.identifier() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 5129 + self.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 SetByValueContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_setByValue + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSetByValue" ): + listener.enterSetByValue(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSetByValue" ): + listener.exitSetByValue(self) + + + + + def setByValue(self): + + localctx = Cobol85Parser.SetByValueContext(self, self._ctx, self.state) + self.enterRule(localctx, 898, self.RULE_setByValue) + try: + self.state = 5134 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,771,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5132 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5133 + self.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 SortStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SORT(self): + return self.getToken(Cobol85Parser.SORT, 0) + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def sortOnKeyClause(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SortOnKeyClauseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SortOnKeyClauseContext,i) + + + def sortDuplicatesPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.SortDuplicatesPhraseContext,0) + + + def sortCollatingSequencePhrase(self): + return self.getTypedRuleContext(Cobol85Parser.SortCollatingSequencePhraseContext,0) + + + def sortInputProcedurePhrase(self): + return self.getTypedRuleContext(Cobol85Parser.SortInputProcedurePhraseContext,0) + + + def sortUsing(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SortUsingContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SortUsingContext,i) + + + def sortOutputProcedurePhrase(self): + return self.getTypedRuleContext(Cobol85Parser.SortOutputProcedurePhraseContext,0) + + + def sortGivingPhrase(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SortGivingPhraseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SortGivingPhraseContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_sortStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSortStatement" ): + listener.enterSortStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSortStatement" ): + listener.exitSortStatement(self) + + + + + def sortStatement(self): + + localctx = Cobol85Parser.SortStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 900, self.RULE_sortStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5136 + self.match(Cobol85Parser.SORT) + self.state = 5137 + self.fileName() + self.state = 5139 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 5138 + self.sortOnKeyClause() + + else: + raise NoViableAltException(self) + self.state = 5141 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,772,self._ctx) + + self.state = 5144 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,773,self._ctx) + if la_ == 1: + self.state = 5143 + self.sortDuplicatesPhrase() + + + self.state = 5147 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==72 or _la==428: + self.state = 5146 + self.sortCollatingSequencePhrase() + + + self.state = 5150 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==246: + self.state = 5149 + self.sortInputProcedurePhrase() + + + self.state = 5155 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==506: + self.state = 5152 + self.sortUsing() + self.state = 5157 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 5159 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==334: + self.state = 5158 + self.sortOutputProcedurePhrase() + + + self.state = 5164 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==222: + self.state = 5161 + self.sortGivingPhrase() + self.state = 5166 + 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 SortOnKeyClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ASCENDING(self): + return self.getToken(Cobol85Parser.ASCENDING, 0) + + def DESCENDING(self): + return self.getToken(Cobol85Parser.DESCENDING, 0) + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def qualifiedDataName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.QualifiedDataNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_sortOnKeyClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSortOnKeyClause" ): + listener.enterSortOnKeyClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSortOnKeyClause" ): + listener.exitSortOnKeyClause(self) + + + + + def sortOnKeyClause(self): + + localctx = Cobol85Parser.SortOnKeyClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 902, self.RULE_sortOnKeyClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5168 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 5167 + self.match(Cobol85Parser.ON) + + + self.state = 5170 + _la = self._input.LA(1) + if not(_la==25 or _la==135): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5172 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==259: + self.state = 5171 + self.match(Cobol85Parser.KEY) + + + self.state = 5175 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5174 + self.qualifiedDataName() + self.state = 5177 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178969483) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 SortDuplicatesPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DUPLICATES(self): + return self.getToken(Cobol85Parser.DUPLICATES, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def IN(self): + return self.getToken(Cobol85Parser.IN, 0) + + def ORDER(self): + return self.getToken(Cobol85Parser.ORDER, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_sortDuplicatesPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSortDuplicatesPhrase" ): + listener.enterSortDuplicatesPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSortDuplicatesPhrase" ): + listener.exitSortDuplicatesPhrase(self) + + + + + def sortDuplicatesPhrase(self): + + localctx = Cobol85Parser.SortDuplicatesPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 904, self.RULE_sortDuplicatesPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5180 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 5179 + self.match(Cobol85Parser.WITH) + + + self.state = 5182 + self.match(Cobol85Parser.DUPLICATES) + self.state = 5184 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==239: + self.state = 5183 + self.match(Cobol85Parser.IN) + + + self.state = 5187 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==330: + self.state = 5186 + self.match(Cobol85Parser.ORDER) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SortCollatingSequencePhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SEQUENCE(self): + return self.getToken(Cobol85Parser.SEQUENCE, 0) + + def COLLATING(self): + return self.getToken(Cobol85Parser.COLLATING, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def alphabetName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.AlphabetNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.AlphabetNameContext,i) + + + def sortCollatingAlphanumeric(self): + return self.getTypedRuleContext(Cobol85Parser.SortCollatingAlphanumericContext,0) + + + def sortCollatingNational(self): + return self.getTypedRuleContext(Cobol85Parser.SortCollatingNationalContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_sortCollatingSequencePhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSortCollatingSequencePhrase" ): + listener.enterSortCollatingSequencePhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSortCollatingSequencePhrase" ): + listener.exitSortCollatingSequencePhrase(self) + + + + + def sortCollatingSequencePhrase(self): + + localctx = Cobol85Parser.SortCollatingSequencePhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 906, self.RULE_sortCollatingSequencePhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5190 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==72: + self.state = 5189 + self.match(Cobol85Parser.COLLATING) + + + self.state = 5192 + self.match(Cobol85Parser.SEQUENCE) + self.state = 5194 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 5193 + self.match(Cobol85Parser.IS) + + + self.state = 5197 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 5196 + self.alphabetName() + + else: + raise NoViableAltException(self) + self.state = 5199 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,787,self._ctx) + + self.state = 5202 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,788,self._ctx) + if la_ == 1: + self.state = 5201 + self.sortCollatingAlphanumeric() + + + self.state = 5205 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212 or _la==304: + self.state = 5204 + self.sortCollatingNational() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SortCollatingAlphanumericContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALPHANUMERIC(self): + return self.getToken(Cobol85Parser.ALPHANUMERIC, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def alphabetName(self): + return self.getTypedRuleContext(Cobol85Parser.AlphabetNameContext,0) + + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_sortCollatingAlphanumeric + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSortCollatingAlphanumeric" ): + listener.enterSortCollatingAlphanumeric(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSortCollatingAlphanumeric" ): + listener.exitSortCollatingAlphanumeric(self) + + + + + def sortCollatingAlphanumeric(self): + + localctx = Cobol85Parser.SortCollatingAlphanumericContext(self, self._ctx, self.state) + self.enterRule(localctx, 908, self.RULE_sortCollatingAlphanumeric) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5208 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 5207 + self.match(Cobol85Parser.FOR) + + + self.state = 5210 + self.match(Cobol85Parser.ALPHANUMERIC) + self.state = 5211 + self.match(Cobol85Parser.IS) + self.state = 5212 + self.alphabetName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SortCollatingNationalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NATIONAL(self): + return self.getToken(Cobol85Parser.NATIONAL, 0) + + def alphabetName(self): + return self.getTypedRuleContext(Cobol85Parser.AlphabetNameContext,0) + + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_sortCollatingNational + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSortCollatingNational" ): + listener.enterSortCollatingNational(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSortCollatingNational" ): + listener.exitSortCollatingNational(self) + + + + + def sortCollatingNational(self): + + localctx = Cobol85Parser.SortCollatingNationalContext(self, self._ctx, self.state) + self.enterRule(localctx, 910, self.RULE_sortCollatingNational) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5215 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 5214 + self.match(Cobol85Parser.FOR) + + + self.state = 5217 + self.match(Cobol85Parser.NATIONAL) + self.state = 5219 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 5218 + self.match(Cobol85Parser.IS) + + + self.state = 5221 + self.alphabetName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SortInputProcedurePhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INPUT(self): + return self.getToken(Cobol85Parser.INPUT, 0) + + def PROCEDURE(self): + return self.getToken(Cobol85Parser.PROCEDURE, 0) + + def procedureName(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def sortInputThrough(self): + return self.getTypedRuleContext(Cobol85Parser.SortInputThroughContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_sortInputProcedurePhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSortInputProcedurePhrase" ): + listener.enterSortInputProcedurePhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSortInputProcedurePhrase" ): + listener.exitSortInputProcedurePhrase(self) + + + + + def sortInputProcedurePhrase(self): + + localctx = Cobol85Parser.SortInputProcedurePhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 912, self.RULE_sortInputProcedurePhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5223 + self.match(Cobol85Parser.INPUT) + self.state = 5224 + self.match(Cobol85Parser.PROCEDURE) + self.state = 5226 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 5225 + self.match(Cobol85Parser.IS) + + + self.state = 5228 + self.procedureName() + self.state = 5230 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==483 or _la==484: + self.state = 5229 + self.sortInputThrough() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SortInputThroughContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def procedureName(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureNameContext,0) + + + def THROUGH(self): + return self.getToken(Cobol85Parser.THROUGH, 0) + + def THRU(self): + return self.getToken(Cobol85Parser.THRU, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_sortInputThrough + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSortInputThrough" ): + listener.enterSortInputThrough(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSortInputThrough" ): + listener.exitSortInputThrough(self) + + + + + def sortInputThrough(self): + + localctx = Cobol85Parser.SortInputThroughContext(self, self._ctx, self.state) + self.enterRule(localctx, 914, self.RULE_sortInputThrough) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5232 + _la = self._input.LA(1) + if not(_la==483 or _la==484): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5233 + self.procedureName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SortUsingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def USING(self): + return self.getToken(Cobol85Parser.USING, 0) + + def fileName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.FileNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_sortUsing + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSortUsing" ): + listener.enterSortUsing(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSortUsing" ): + listener.exitSortUsing(self) + + + + + def sortUsing(self): + + localctx = Cobol85Parser.SortUsingContext(self, self._ctx, self.state) + self.enterRule(localctx, 916, self.RULE_sortUsing) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5235 + self.match(Cobol85Parser.USING) + self.state = 5237 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5236 + self.fileName() + self.state = 5239 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SortOutputProcedurePhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OUTPUT(self): + return self.getToken(Cobol85Parser.OUTPUT, 0) + + def PROCEDURE(self): + return self.getToken(Cobol85Parser.PROCEDURE, 0) + + def procedureName(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def sortOutputThrough(self): + return self.getTypedRuleContext(Cobol85Parser.SortOutputThroughContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_sortOutputProcedurePhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSortOutputProcedurePhrase" ): + listener.enterSortOutputProcedurePhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSortOutputProcedurePhrase" ): + listener.exitSortOutputProcedurePhrase(self) + + + + + def sortOutputProcedurePhrase(self): + + localctx = Cobol85Parser.SortOutputProcedurePhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 918, self.RULE_sortOutputProcedurePhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5241 + self.match(Cobol85Parser.OUTPUT) + self.state = 5242 + self.match(Cobol85Parser.PROCEDURE) + self.state = 5244 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 5243 + self.match(Cobol85Parser.IS) + + + self.state = 5246 + self.procedureName() + self.state = 5248 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==483 or _la==484: + self.state = 5247 + self.sortOutputThrough() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SortOutputThroughContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def procedureName(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureNameContext,0) + + + def THROUGH(self): + return self.getToken(Cobol85Parser.THROUGH, 0) + + def THRU(self): + return self.getToken(Cobol85Parser.THRU, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_sortOutputThrough + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSortOutputThrough" ): + listener.enterSortOutputThrough(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSortOutputThrough" ): + listener.exitSortOutputThrough(self) + + + + + def sortOutputThrough(self): + + localctx = Cobol85Parser.SortOutputThroughContext(self, self._ctx, self.state) + self.enterRule(localctx, 920, self.RULE_sortOutputThrough) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5250 + _la = self._input.LA(1) + if not(_la==483 or _la==484): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5251 + self.procedureName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SortGivingPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def GIVING(self): + return self.getToken(Cobol85Parser.GIVING, 0) + + def sortGiving(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SortGivingContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SortGivingContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_sortGivingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSortGivingPhrase" ): + listener.enterSortGivingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSortGivingPhrase" ): + listener.exitSortGivingPhrase(self) + + + + + def sortGivingPhrase(self): + + localctx = Cobol85Parser.SortGivingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 922, self.RULE_sortGivingPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5253 + self.match(Cobol85Parser.GIVING) + self.state = 5255 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5254 + self.sortGiving() + self.state = 5257 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SortGivingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def LOCK(self): + return self.getToken(Cobol85Parser.LOCK, 0) + + def SAVE(self): + return self.getToken(Cobol85Parser.SAVE, 0) + + def NO(self): + return self.getToken(Cobol85Parser.NO, 0) + + def REWIND(self): + return self.getToken(Cobol85Parser.REWIND, 0) + + def CRUNCH(self): + return self.getToken(Cobol85Parser.CRUNCH, 0) + + def RELEASE(self): + return self.getToken(Cobol85Parser.RELEASE, 0) + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def REMOVE(self): + return self.getToken(Cobol85Parser.REMOVE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_sortGiving + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSortGiving" ): + listener.enterSortGiving(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSortGiving" ): + listener.exitSortGiving(self) + + + + + def sortGiving(self): + + localctx = Cobol85Parser.SortGivingContext(self, self._ctx, self.state) + self.enterRule(localctx, 924, self.RULE_sortGiving) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5259 + self.fileName() + self.state = 5269 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,799,self._ctx) + if la_ == 1: + self.state = 5260 + self.match(Cobol85Parser.LOCK) + + elif la_ == 2: + self.state = 5261 + self.match(Cobol85Parser.SAVE) + + elif la_ == 3: + self.state = 5262 + self.match(Cobol85Parser.NO) + self.state = 5263 + self.match(Cobol85Parser.REWIND) + + elif la_ == 4: + self.state = 5264 + self.match(Cobol85Parser.CRUNCH) + + elif la_ == 5: + self.state = 5265 + self.match(Cobol85Parser.RELEASE) + + elif la_ == 6: + self.state = 5266 + self.match(Cobol85Parser.WITH) + self.state = 5267 + self.match(Cobol85Parser.REMOVE) + self.state = 5268 + self.match(Cobol85Parser.CRUNCH) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class StartStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def START(self): + return self.getToken(Cobol85Parser.START, 0) + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def startKey(self): + return self.getTypedRuleContext(Cobol85Parser.StartKeyContext,0) + + + def invalidKeyPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.InvalidKeyPhraseContext,0) + + + def notInvalidKeyPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.NotInvalidKeyPhraseContext,0) + + + def END_START(self): + return self.getToken(Cobol85Parser.END_START, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_startStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStartStatement" ): + listener.enterStartStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStartStatement" ): + listener.exitStartStatement(self) + + + + + def startStatement(self): + + localctx = Cobol85Parser.StartStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 926, self.RULE_startStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5271 + self.match(Cobol85Parser.START) + self.state = 5272 + self.fileName() + self.state = 5274 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==259: + self.state = 5273 + self.startKey() + + + self.state = 5277 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,801,self._ctx) + if la_ == 1: + self.state = 5276 + self.invalidKeyPhrase() + + + self.state = 5280 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,802,self._ctx) + if la_ == 1: + self.state = 5279 + self.notInvalidKeyPhrase() + + + self.state = 5283 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,803,self._ctx) + if la_ == 1: + self.state = 5282 + self.match(Cobol85Parser.END_START) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class StartKeyContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def EQUAL(self): + return self.getToken(Cobol85Parser.EQUAL, 0) + + def EQUALCHAR(self): + return self.getToken(Cobol85Parser.EQUALCHAR, 0) + + def GREATER(self): + return self.getToken(Cobol85Parser.GREATER, 0) + + def MORETHANCHAR(self): + return self.getToken(Cobol85Parser.MORETHANCHAR, 0) + + def NOT(self): + return self.getToken(Cobol85Parser.NOT, 0) + + def LESS(self): + return self.getToken(Cobol85Parser.LESS, 0) + + def LESSTHANCHAR(self): + return self.getToken(Cobol85Parser.LESSTHANCHAR, 0) + + def OR(self): + return self.getToken(Cobol85Parser.OR, 0) + + def MORETHANOREQUAL(self): + return self.getToken(Cobol85Parser.MORETHANOREQUAL, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def THAN(self): + return self.getToken(Cobol85Parser.THAN, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_startKey + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStartKey" ): + listener.enterStartKey(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStartKey" ): + listener.exitStartKey(self) + + + + + def startKey(self): + + localctx = Cobol85Parser.StartKeyContext(self, self._ctx, self.state) + self.enterRule(localctx, 928, self.RULE_startKey) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5285 + self.match(Cobol85Parser.KEY) + self.state = 5287 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 5286 + self.match(Cobol85Parser.IS) + + + self.state = 5316 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,810,self._ctx) + if la_ == 1: + self.state = 5289 + self.match(Cobol85Parser.EQUAL) + self.state = 5291 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==489: + self.state = 5290 + self.match(Cobol85Parser.TO) + + + pass + + elif la_ == 2: + self.state = 5293 + self.match(Cobol85Parser.EQUALCHAR) + pass + + elif la_ == 3: + self.state = 5294 + self.match(Cobol85Parser.GREATER) + self.state = 5296 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==479: + self.state = 5295 + self.match(Cobol85Parser.THAN) + + + pass + + elif la_ == 4: + self.state = 5298 + self.match(Cobol85Parser.MORETHANCHAR) + pass + + elif la_ == 5: + self.state = 5299 + self.match(Cobol85Parser.NOT) + self.state = 5300 + self.match(Cobol85Parser.LESS) + self.state = 5302 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==479: + self.state = 5301 + self.match(Cobol85Parser.THAN) + + + pass + + elif la_ == 6: + self.state = 5304 + self.match(Cobol85Parser.NOT) + self.state = 5305 + self.match(Cobol85Parser.LESSTHANCHAR) + pass + + elif la_ == 7: + self.state = 5306 + self.match(Cobol85Parser.GREATER) + self.state = 5308 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==479: + self.state = 5307 + self.match(Cobol85Parser.THAN) + + + self.state = 5310 + self.match(Cobol85Parser.OR) + self.state = 5311 + self.match(Cobol85Parser.EQUAL) + self.state = 5313 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==489: + self.state = 5312 + self.match(Cobol85Parser.TO) + + + pass + + elif la_ == 8: + self.state = 5315 + self.match(Cobol85Parser.MORETHANOREQUAL) + pass + + + self.state = 5318 + self.qualifiedDataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class StopStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def STOP(self): + return self.getToken(Cobol85Parser.STOP, 0) + + def RUN(self): + return self.getToken(Cobol85Parser.RUN, 0) + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_stopStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStopStatement" ): + listener.enterStopStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStopStatement" ): + listener.exitStopStatement(self) + + + + + def stopStatement(self): + + localctx = Cobol85Parser.StopStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 930, self.RULE_stopStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5320 + self.match(Cobol85Parser.STOP) + self.state = 5323 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [413]: + self.state = 5321 + self.match(Cobol85Parser.RUN) + pass + elif token in [9, 138, 139, 204, 230, 231, 291, 292, 313, 314, 367, 368, 450, 451, 494, 521, 523, 524, 551, 552, 553, 554, 555, 556]: + self.state = 5322 + self.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 StringStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def STRING(self): + return self.getToken(Cobol85Parser.STRING, 0) + + def stringIntoPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.StringIntoPhraseContext,0) + + + def stringSendingPhrase(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StringSendingPhraseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StringSendingPhraseContext,i) + + + def stringWithPointerPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.StringWithPointerPhraseContext,0) + + + def onOverflowPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.OnOverflowPhraseContext,0) + + + def notOnOverflowPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.NotOnOverflowPhraseContext,0) + + + def END_STRING(self): + return self.getToken(Cobol85Parser.END_STRING, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_stringStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStringStatement" ): + listener.enterStringStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStringStatement" ): + listener.exitStringStatement(self) + + + + + def stringStatement(self): + + localctx = Cobol85Parser.StringStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 932, self.RULE_stringStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5325 + self.match(Cobol85Parser.STRING) + self.state = 5327 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5326 + self.stringSendingPhrase() + self.state = 5329 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822370) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194964618422267) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202427199037528969) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874440372879459) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 1819828109721609) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 572150674022301857) != 0) or ((((_la - 551)) & ~0x3f) == 0 and ((1 << (_la - 551)) & 127) != 0)): + break + + self.state = 5331 + self.stringIntoPhrase() + self.state = 5333 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,813,self._ctx) + if la_ == 1: + self.state = 5332 + self.stringWithPointerPhrase() + + + self.state = 5336 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,814,self._ctx) + if la_ == 1: + self.state = 5335 + self.onOverflowPhrase() + + + self.state = 5339 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,815,self._ctx) + if la_ == 1: + self.state = 5338 + self.notOnOverflowPhrase() + + + self.state = 5342 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,816,self._ctx) + if la_ == 1: + self.state = 5341 + self.match(Cobol85Parser.END_STRING) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class StringSendingPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def stringDelimitedByPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.StringDelimitedByPhraseContext,0) + + + def stringForPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.StringForPhraseContext,0) + + + def stringSending(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StringSendingContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StringSendingContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_stringSendingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStringSendingPhrase" ): + listener.enterStringSendingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStringSendingPhrase" ): + listener.exitStringSendingPhrase(self) + + + + + def stringSendingPhrase(self): + + localctx = Cobol85Parser.StringSendingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 934, self.RULE_stringSendingPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5345 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5344 + self.stringSending() + self.state = 5347 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822370) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194964618422267) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202427199037528969) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874440372879459) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 1819828109721609) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 572150674022301857) != 0) or ((((_la - 551)) & ~0x3f) == 0 and ((1 << (_la - 551)) & 127) != 0)): + break + + self.state = 5351 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [132]: + self.state = 5349 + self.stringDelimitedByPhrase() + pass + elif token in [212]: + self.state = 5350 + self.stringForPhrase() + 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 StringSendingContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_stringSending + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStringSending" ): + listener.enterStringSending(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStringSending" ): + listener.exitStringSending(self) + + + + + def stringSending(self): + + localctx = Cobol85Parser.StringSendingContext(self, self._ctx, self.state) + self.enterRule(localctx, 936, self.RULE_stringSending) + try: + self.state = 5355 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,819,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5353 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5354 + self.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 StringDelimitedByPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DELIMITED(self): + return self.getToken(Cobol85Parser.DELIMITED, 0) + + def SIZE(self): + return self.getToken(Cobol85Parser.SIZE, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_stringDelimitedByPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStringDelimitedByPhrase" ): + listener.enterStringDelimitedByPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStringDelimitedByPhrase" ): + listener.exitStringDelimitedByPhrase(self) + + + + + def stringDelimitedByPhrase(self): + + localctx = Cobol85Parser.StringDelimitedByPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 938, self.RULE_stringDelimitedByPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5357 + self.match(Cobol85Parser.DELIMITED) + self.state = 5359 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==49: + self.state = 5358 + self.match(Cobol85Parser.BY) + + + self.state = 5364 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,821,self._ctx) + if la_ == 1: + self.state = 5361 + self.match(Cobol85Parser.SIZE) + pass + + elif la_ == 2: + self.state = 5362 + self.identifier() + pass + + elif la_ == 3: + self.state = 5363 + self.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 StringForPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_stringForPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStringForPhrase" ): + listener.enterStringForPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStringForPhrase" ): + listener.exitStringForPhrase(self) + + + + + def stringForPhrase(self): + + localctx = Cobol85Parser.StringForPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 940, self.RULE_stringForPhrase) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5366 + self.match(Cobol85Parser.FOR) + self.state = 5369 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,822,self._ctx) + if la_ == 1: + self.state = 5367 + self.identifier() + pass + + elif la_ == 2: + self.state = 5368 + self.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 StringIntoPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTO(self): + return self.getToken(Cobol85Parser.INTO, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_stringIntoPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStringIntoPhrase" ): + listener.enterStringIntoPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStringIntoPhrase" ): + listener.exitStringIntoPhrase(self) + + + + + def stringIntoPhrase(self): + + localctx = Cobol85Parser.StringIntoPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 942, self.RULE_stringIntoPhrase) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5371 + self.match(Cobol85Parser.INTO) + self.state = 5372 + 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 StringWithPointerPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def POINTER(self): + return self.getToken(Cobol85Parser.POINTER, 0) + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_stringWithPointerPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStringWithPointerPhrase" ): + listener.enterStringWithPointerPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStringWithPointerPhrase" ): + listener.exitStringWithPointerPhrase(self) + + + + + def stringWithPointerPhrase(self): + + localctx = Cobol85Parser.StringWithPointerPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 944, self.RULE_stringWithPointerPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5375 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 5374 + self.match(Cobol85Parser.WITH) + + + self.state = 5377 + self.match(Cobol85Parser.POINTER) + self.state = 5378 + self.qualifiedDataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SubtractStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SUBTRACT(self): + return self.getToken(Cobol85Parser.SUBTRACT, 0) + + def subtractFromStatement(self): + return self.getTypedRuleContext(Cobol85Parser.SubtractFromStatementContext,0) + + + def subtractFromGivingStatement(self): + return self.getTypedRuleContext(Cobol85Parser.SubtractFromGivingStatementContext,0) + + + def subtractCorrespondingStatement(self): + return self.getTypedRuleContext(Cobol85Parser.SubtractCorrespondingStatementContext,0) + + + def onSizeErrorPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.OnSizeErrorPhraseContext,0) + + + def notOnSizeErrorPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.NotOnSizeErrorPhraseContext,0) + + + def END_SUBTRACT(self): + return self.getToken(Cobol85Parser.END_SUBTRACT, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_subtractStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubtractStatement" ): + listener.enterSubtractStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubtractStatement" ): + listener.exitSubtractStatement(self) + + + + + def subtractStatement(self): + + localctx = Cobol85Parser.SubtractStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 946, self.RULE_subtractStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5380 + self.match(Cobol85Parser.SUBTRACT) + self.state = 5384 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,824,self._ctx) + if la_ == 1: + self.state = 5381 + self.subtractFromStatement() + pass + + elif la_ == 2: + self.state = 5382 + self.subtractFromGivingStatement() + pass + + elif la_ == 3: + self.state = 5383 + self.subtractCorrespondingStatement() + pass + + + self.state = 5387 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,825,self._ctx) + if la_ == 1: + self.state = 5386 + self.onSizeErrorPhrase() + + + self.state = 5390 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,826,self._ctx) + if la_ == 1: + self.state = 5389 + self.notOnSizeErrorPhrase() + + + self.state = 5393 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,827,self._ctx) + if la_ == 1: + self.state = 5392 + self.match(Cobol85Parser.END_SUBTRACT) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SubtractFromStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FROM(self): + return self.getToken(Cobol85Parser.FROM, 0) + + def subtractSubtrahend(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SubtractSubtrahendContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SubtractSubtrahendContext,i) + + + def subtractMinuend(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SubtractMinuendContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SubtractMinuendContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_subtractFromStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubtractFromStatement" ): + listener.enterSubtractFromStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubtractFromStatement" ): + listener.exitSubtractFromStatement(self) + + + + + def subtractFromStatement(self): + + localctx = Cobol85Parser.SubtractFromStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 948, self.RULE_subtractFromStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5396 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5395 + self.subtractSubtrahend() + self.state = 5398 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822370) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194964618422267) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202427199037528969) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874440372879459) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 1819828109721609) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 572150674022301857) != 0) or ((((_la - 551)) & ~0x3f) == 0 and ((1 << (_la - 551)) & 127) != 0)): + break + + self.state = 5400 + self.match(Cobol85Parser.FROM) + self.state = 5402 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5401 + self.subtractMinuend() + self.state = 5404 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 SubtractFromGivingStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FROM(self): + return self.getToken(Cobol85Parser.FROM, 0) + + def subtractMinuendGiving(self): + return self.getTypedRuleContext(Cobol85Parser.SubtractMinuendGivingContext,0) + + + def GIVING(self): + return self.getToken(Cobol85Parser.GIVING, 0) + + def subtractSubtrahend(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SubtractSubtrahendContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SubtractSubtrahendContext,i) + + + def subtractGiving(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.SubtractGivingContext) + else: + return self.getTypedRuleContext(Cobol85Parser.SubtractGivingContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_subtractFromGivingStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubtractFromGivingStatement" ): + listener.enterSubtractFromGivingStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubtractFromGivingStatement" ): + listener.exitSubtractFromGivingStatement(self) + + + + + def subtractFromGivingStatement(self): + + localctx = Cobol85Parser.SubtractFromGivingStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 950, self.RULE_subtractFromGivingStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5407 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5406 + self.subtractSubtrahend() + self.state = 5409 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822370) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194964618422267) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202427199037528969) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874440372879459) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 1819828109721609) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 572150674022301857) != 0) or ((((_la - 551)) & ~0x3f) == 0 and ((1 << (_la - 551)) & 127) != 0)): + break + + self.state = 5411 + self.match(Cobol85Parser.FROM) + self.state = 5412 + self.subtractMinuendGiving() + self.state = 5413 + self.match(Cobol85Parser.GIVING) + self.state = 5415 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5414 + self.subtractGiving() + self.state = 5417 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 SubtractCorrespondingStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def FROM(self): + return self.getToken(Cobol85Parser.FROM, 0) + + def subtractMinuendCorresponding(self): + return self.getTypedRuleContext(Cobol85Parser.SubtractMinuendCorrespondingContext,0) + + + def CORRESPONDING(self): + return self.getToken(Cobol85Parser.CORRESPONDING, 0) + + def CORR(self): + return self.getToken(Cobol85Parser.CORR, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_subtractCorrespondingStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubtractCorrespondingStatement" ): + listener.enterSubtractCorrespondingStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubtractCorrespondingStatement" ): + listener.exitSubtractCorrespondingStatement(self) + + + + + def subtractCorrespondingStatement(self): + + localctx = Cobol85Parser.SubtractCorrespondingStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 952, self.RULE_subtractCorrespondingStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5419 + _la = self._input.LA(1) + if not(_la==103 or _la==104): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5420 + self.qualifiedDataName() + self.state = 5421 + self.match(Cobol85Parser.FROM) + self.state = 5422 + self.subtractMinuendCorresponding() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SubtractSubtrahendContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_subtractSubtrahend + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubtractSubtrahend" ): + listener.enterSubtractSubtrahend(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubtractSubtrahend" ): + listener.exitSubtractSubtrahend(self) + + + + + def subtractSubtrahend(self): + + localctx = Cobol85Parser.SubtractSubtrahendContext(self, self._ctx, self.state) + self.enterRule(localctx, 954, self.RULE_subtractSubtrahend) + try: + self.state = 5426 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,832,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5424 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5425 + self.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 SubtractMinuendContext(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(Cobol85Parser.IdentifierContext,0) + + + def ROUNDED(self): + return self.getToken(Cobol85Parser.ROUNDED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_subtractMinuend + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubtractMinuend" ): + listener.enterSubtractMinuend(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubtractMinuend" ): + listener.exitSubtractMinuend(self) + + + + + def subtractMinuend(self): + + localctx = Cobol85Parser.SubtractMinuendContext(self, self._ctx, self.state) + self.enterRule(localctx, 956, self.RULE_subtractMinuend) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5428 + self.identifier() + self.state = 5430 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==412: + self.state = 5429 + self.match(Cobol85Parser.ROUNDED) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SubtractMinuendGivingContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_subtractMinuendGiving + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubtractMinuendGiving" ): + listener.enterSubtractMinuendGiving(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubtractMinuendGiving" ): + listener.exitSubtractMinuendGiving(self) + + + + + def subtractMinuendGiving(self): + + localctx = Cobol85Parser.SubtractMinuendGivingContext(self, self._ctx, self.state) + self.enterRule(localctx, 958, self.RULE_subtractMinuendGiving) + try: + self.state = 5434 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,834,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5432 + self.identifier() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5433 + self.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 SubtractGivingContext(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(Cobol85Parser.IdentifierContext,0) + + + def ROUNDED(self): + return self.getToken(Cobol85Parser.ROUNDED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_subtractGiving + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubtractGiving" ): + listener.enterSubtractGiving(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubtractGiving" ): + listener.exitSubtractGiving(self) + + + + + def subtractGiving(self): + + localctx = Cobol85Parser.SubtractGivingContext(self, self._ctx, self.state) + self.enterRule(localctx, 960, self.RULE_subtractGiving) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5436 + self.identifier() + self.state = 5438 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==412: + self.state = 5437 + self.match(Cobol85Parser.ROUNDED) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SubtractMinuendCorrespondingContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def ROUNDED(self): + return self.getToken(Cobol85Parser.ROUNDED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_subtractMinuendCorresponding + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubtractMinuendCorresponding" ): + listener.enterSubtractMinuendCorresponding(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubtractMinuendCorresponding" ): + listener.exitSubtractMinuendCorresponding(self) + + + + + def subtractMinuendCorresponding(self): + + localctx = Cobol85Parser.SubtractMinuendCorrespondingContext(self, self._ctx, self.state) + self.enterRule(localctx, 962, self.RULE_subtractMinuendCorresponding) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5440 + self.qualifiedDataName() + self.state = 5442 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==412: + self.state = 5441 + self.match(Cobol85Parser.ROUNDED) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TerminateStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TERMINATE(self): + return self.getToken(Cobol85Parser.TERMINATE, 0) + + def reportName(self): + return self.getTypedRuleContext(Cobol85Parser.ReportNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_terminateStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTerminateStatement" ): + listener.enterTerminateStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTerminateStatement" ): + listener.exitTerminateStatement(self) + + + + + def terminateStatement(self): + + localctx = Cobol85Parser.TerminateStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 964, self.RULE_terminateStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5444 + self.match(Cobol85Parser.TERMINATE) + self.state = 5445 + self.reportName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class UnstringStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def UNSTRING(self): + return self.getToken(Cobol85Parser.UNSTRING, 0) + + def unstringSendingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.UnstringSendingPhraseContext,0) + + + def unstringIntoPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.UnstringIntoPhraseContext,0) + + + def unstringWithPointerPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.UnstringWithPointerPhraseContext,0) + + + def unstringTallyingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.UnstringTallyingPhraseContext,0) + + + def onOverflowPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.OnOverflowPhraseContext,0) + + + def notOnOverflowPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.NotOnOverflowPhraseContext,0) + + + def END_UNSTRING(self): + return self.getToken(Cobol85Parser.END_UNSTRING, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_unstringStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnstringStatement" ): + listener.enterUnstringStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnstringStatement" ): + listener.exitUnstringStatement(self) + + + + + def unstringStatement(self): + + localctx = Cobol85Parser.UnstringStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 966, self.RULE_unstringStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5447 + self.match(Cobol85Parser.UNSTRING) + self.state = 5448 + self.unstringSendingPhrase() + self.state = 5449 + self.unstringIntoPhrase() + self.state = 5451 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,837,self._ctx) + if la_ == 1: + self.state = 5450 + self.unstringWithPointerPhrase() + + + self.state = 5454 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==472: + self.state = 5453 + self.unstringTallyingPhrase() + + + self.state = 5457 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,839,self._ctx) + if la_ == 1: + self.state = 5456 + self.onOverflowPhrase() + + + self.state = 5460 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,840,self._ctx) + if la_ == 1: + self.state = 5459 + self.notOnOverflowPhrase() + + + self.state = 5463 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,841,self._ctx) + if la_ == 1: + self.state = 5462 + self.match(Cobol85Parser.END_UNSTRING) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class UnstringSendingPhraseContext(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(Cobol85Parser.IdentifierContext,0) + + + def unstringDelimitedByPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.UnstringDelimitedByPhraseContext,0) + + + def unstringOrAllPhrase(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.UnstringOrAllPhraseContext) + else: + return self.getTypedRuleContext(Cobol85Parser.UnstringOrAllPhraseContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_unstringSendingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnstringSendingPhrase" ): + listener.enterUnstringSendingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnstringSendingPhrase" ): + listener.exitUnstringSendingPhrase(self) + + + + + def unstringSendingPhrase(self): + + localctx = Cobol85Parser.UnstringSendingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 968, self.RULE_unstringSendingPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5465 + self.identifier() + self.state = 5473 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==132: + self.state = 5466 + self.unstringDelimitedByPhrase() + self.state = 5470 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==329: + self.state = 5467 + self.unstringOrAllPhrase() + self.state = 5472 + 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 UnstringDelimitedByPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DELIMITED(self): + return self.getToken(Cobol85Parser.DELIMITED, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def BY(self): + return self.getToken(Cobol85Parser.BY, 0) + + def ALL(self): + return self.getToken(Cobol85Parser.ALL, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_unstringDelimitedByPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnstringDelimitedByPhrase" ): + listener.enterUnstringDelimitedByPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnstringDelimitedByPhrase" ): + listener.exitUnstringDelimitedByPhrase(self) + + + + + def unstringDelimitedByPhrase(self): + + localctx = Cobol85Parser.UnstringDelimitedByPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 970, self.RULE_unstringDelimitedByPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5475 + self.match(Cobol85Parser.DELIMITED) + self.state = 5477 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==49: + self.state = 5476 + self.match(Cobol85Parser.BY) + + + self.state = 5480 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,845,self._ctx) + if la_ == 1: + self.state = 5479 + self.match(Cobol85Parser.ALL) + + + self.state = 5484 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,846,self._ctx) + if la_ == 1: + self.state = 5482 + self.identifier() + pass + + elif la_ == 2: + self.state = 5483 + self.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 UnstringOrAllPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OR(self): + return self.getToken(Cobol85Parser.OR, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def ALL(self): + return self.getToken(Cobol85Parser.ALL, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_unstringOrAllPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnstringOrAllPhrase" ): + listener.enterUnstringOrAllPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnstringOrAllPhrase" ): + listener.exitUnstringOrAllPhrase(self) + + + + + def unstringOrAllPhrase(self): + + localctx = Cobol85Parser.UnstringOrAllPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 972, self.RULE_unstringOrAllPhrase) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5486 + self.match(Cobol85Parser.OR) + self.state = 5488 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,847,self._ctx) + if la_ == 1: + self.state = 5487 + self.match(Cobol85Parser.ALL) + + + self.state = 5492 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,848,self._ctx) + if la_ == 1: + self.state = 5490 + self.identifier() + pass + + elif la_ == 2: + self.state = 5491 + self.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 UnstringIntoPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTO(self): + return self.getToken(Cobol85Parser.INTO, 0) + + def unstringInto(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.UnstringIntoContext) + else: + return self.getTypedRuleContext(Cobol85Parser.UnstringIntoContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_unstringIntoPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnstringIntoPhrase" ): + listener.enterUnstringIntoPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnstringIntoPhrase" ): + listener.exitUnstringIntoPhrase(self) + + + + + def unstringIntoPhrase(self): + + localctx = Cobol85Parser.UnstringIntoPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 974, self.RULE_unstringIntoPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5494 + self.match(Cobol85Parser.INTO) + self.state = 5496 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5495 + self.unstringInto() + self.state = 5498 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821858) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423728639) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178961289) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428515) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 130978249457673) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103776312507334817) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 UnstringIntoContext(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(Cobol85Parser.IdentifierContext,0) + + + def unstringDelimiterIn(self): + return self.getTypedRuleContext(Cobol85Parser.UnstringDelimiterInContext,0) + + + def unstringCountIn(self): + return self.getTypedRuleContext(Cobol85Parser.UnstringCountInContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_unstringInto + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnstringInto" ): + listener.enterUnstringInto(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnstringInto" ): + listener.exitUnstringInto(self) + + + + + def unstringInto(self): + + localctx = Cobol85Parser.UnstringIntoContext(self, self._ctx, self.state) + self.enterRule(localctx, 976, self.RULE_unstringInto) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5500 + self.identifier() + self.state = 5502 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==133: + self.state = 5501 + self.unstringDelimiterIn() + + + self.state = 5505 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==105: + self.state = 5504 + self.unstringCountIn() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class UnstringDelimiterInContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DELIMITER(self): + return self.getToken(Cobol85Parser.DELIMITER, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def IN(self): + return self.getToken(Cobol85Parser.IN, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_unstringDelimiterIn + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnstringDelimiterIn" ): + listener.enterUnstringDelimiterIn(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnstringDelimiterIn" ): + listener.exitUnstringDelimiterIn(self) + + + + + def unstringDelimiterIn(self): + + localctx = Cobol85Parser.UnstringDelimiterInContext(self, self._ctx, self.state) + self.enterRule(localctx, 978, self.RULE_unstringDelimiterIn) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5507 + self.match(Cobol85Parser.DELIMITER) + self.state = 5509 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==239: + self.state = 5508 + self.match(Cobol85Parser.IN) + + + self.state = 5511 + 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 UnstringCountInContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def COUNT(self): + return self.getToken(Cobol85Parser.COUNT, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def IN(self): + return self.getToken(Cobol85Parser.IN, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_unstringCountIn + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnstringCountIn" ): + listener.enterUnstringCountIn(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnstringCountIn" ): + listener.exitUnstringCountIn(self) + + + + + def unstringCountIn(self): + + localctx = Cobol85Parser.UnstringCountInContext(self, self._ctx, self.state) + self.enterRule(localctx, 980, self.RULE_unstringCountIn) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5513 + self.match(Cobol85Parser.COUNT) + self.state = 5515 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==239: + self.state = 5514 + self.match(Cobol85Parser.IN) + + + self.state = 5517 + 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 UnstringWithPointerPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def POINTER(self): + return self.getToken(Cobol85Parser.POINTER, 0) + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def WITH(self): + return self.getToken(Cobol85Parser.WITH, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_unstringWithPointerPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnstringWithPointerPhrase" ): + listener.enterUnstringWithPointerPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnstringWithPointerPhrase" ): + listener.exitUnstringWithPointerPhrase(self) + + + + + def unstringWithPointerPhrase(self): + + localctx = Cobol85Parser.UnstringWithPointerPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 982, self.RULE_unstringWithPointerPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5520 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==514: + self.state = 5519 + self.match(Cobol85Parser.WITH) + + + self.state = 5522 + self.match(Cobol85Parser.POINTER) + self.state = 5523 + self.qualifiedDataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class UnstringTallyingPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TALLYING(self): + return self.getToken(Cobol85Parser.TALLYING, 0) + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def IN(self): + return self.getToken(Cobol85Parser.IN, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_unstringTallyingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnstringTallyingPhrase" ): + listener.enterUnstringTallyingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnstringTallyingPhrase" ): + listener.exitUnstringTallyingPhrase(self) + + + + + def unstringTallyingPhrase(self): + + localctx = Cobol85Parser.UnstringTallyingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 984, self.RULE_unstringTallyingPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5525 + self.match(Cobol85Parser.TALLYING) + self.state = 5527 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==239: + self.state = 5526 + self.match(Cobol85Parser.IN) + + + self.state = 5529 + self.qualifiedDataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class UseStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def USE(self): + return self.getToken(Cobol85Parser.USE, 0) + + def useAfterClause(self): + return self.getTypedRuleContext(Cobol85Parser.UseAfterClauseContext,0) + + + def useDebugClause(self): + return self.getTypedRuleContext(Cobol85Parser.UseDebugClauseContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_useStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUseStatement" ): + listener.enterUseStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUseStatement" ): + listener.exitUseStatement(self) + + + + + def useStatement(self): + + localctx = Cobol85Parser.UseStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 986, self.RULE_useStatement) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5531 + self.match(Cobol85Parser.USE) + self.state = 5534 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [7, 223]: + self.state = 5532 + self.useAfterClause() + pass + elif token in [125, 212]: + self.state = 5533 + self.useDebugClause() + 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 UseAfterClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def AFTER(self): + return self.getToken(Cobol85Parser.AFTER, 0) + + def PROCEDURE(self): + return self.getToken(Cobol85Parser.PROCEDURE, 0) + + def useAfterOn(self): + return self.getTypedRuleContext(Cobol85Parser.UseAfterOnContext,0) + + + def EXCEPTION(self): + return self.getToken(Cobol85Parser.EXCEPTION, 0) + + def ERROR(self): + return self.getToken(Cobol85Parser.ERROR, 0) + + def GLOBAL(self): + return self.getToken(Cobol85Parser.GLOBAL, 0) + + def STANDARD(self): + return self.getToken(Cobol85Parser.STANDARD, 0) + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_useAfterClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUseAfterClause" ): + listener.enterUseAfterClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUseAfterClause" ): + listener.exitUseAfterClause(self) + + + + + def useAfterClause(self): + + localctx = Cobol85Parser.UseAfterClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 988, self.RULE_useAfterClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5537 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==223: + self.state = 5536 + self.match(Cobol85Parser.GLOBAL) + + + self.state = 5539 + self.match(Cobol85Parser.AFTER) + self.state = 5541 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==453: + self.state = 5540 + self.match(Cobol85Parser.STANDARD) + + + self.state = 5543 + _la = self._input.LA(1) + if not(_la==188 or _la==196): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5544 + self.match(Cobol85Parser.PROCEDURE) + self.state = 5546 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 5545 + self.match(Cobol85Parser.ON) + + + self.state = 5548 + self.useAfterOn() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class UseAfterOnContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INPUT(self): + return self.getToken(Cobol85Parser.INPUT, 0) + + def OUTPUT(self): + return self.getToken(Cobol85Parser.OUTPUT, 0) + + def I_O(self): + return self.getToken(Cobol85Parser.I_O, 0) + + def EXTEND(self): + return self.getToken(Cobol85Parser.EXTEND, 0) + + def fileName(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.FileNameContext) + else: + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_useAfterOn + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUseAfterOn" ): + listener.enterUseAfterOn(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUseAfterOn" ): + listener.exitUseAfterOn(self) + + + + + def useAfterOn(self): + + localctx = Cobol85Parser.UseAfterOnContext(self, self._ctx, self.state) + self.enterRule(localctx, 990, self.RULE_useAfterOn) + self._la = 0 # Token type + try: + self.state = 5559 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [246]: + self.enterOuterAlt(localctx, 1) + self.state = 5550 + self.match(Cobol85Parser.INPUT) + pass + elif token in [334]: + self.enterOuterAlt(localctx, 2) + self.state = 5551 + self.match(Cobol85Parser.OUTPUT) + pass + elif token in [232]: + self.enterOuterAlt(localctx, 3) + self.state = 5552 + self.match(Cobol85Parser.I_O) + pass + elif token in [201]: + self.enterOuterAlt(localctx, 4) + self.state = 5553 + self.match(Cobol85Parser.EXTEND) + pass + elif token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.enterOuterAlt(localctx, 5) + self.state = 5555 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5554 + self.fileName() + self.state = 5557 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + break + + 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 UseDebugClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DEBUGGING(self): + return self.getToken(Cobol85Parser.DEBUGGING, 0) + + def FOR(self): + return self.getToken(Cobol85Parser.FOR, 0) + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def useDebugOn(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.UseDebugOnContext) + else: + return self.getTypedRuleContext(Cobol85Parser.UseDebugOnContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_useDebugClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUseDebugClause" ): + listener.enterUseDebugClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUseDebugClause" ): + listener.exitUseDebugClause(self) + + + + + def useDebugClause(self): + + localctx = Cobol85Parser.UseDebugClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 992, self.RULE_useDebugClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5562 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==212: + self.state = 5561 + self.match(Cobol85Parser.FOR) + + + self.state = 5564 + self.match(Cobol85Parser.DEBUGGING) + self.state = 5566 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 5565 + self.match(Cobol85Parser.ON) + + + self.state = 5569 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5568 + self.useDebugOn() + self.state = 5571 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822338) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or ((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 47) != 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 UseDebugOnContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALL(self): + return self.getToken(Cobol85Parser.ALL, 0) + + def PROCEDURES(self): + return self.getToken(Cobol85Parser.PROCEDURES, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def REFERENCES(self): + return self.getToken(Cobol85Parser.REFERENCES, 0) + + def OF(self): + return self.getToken(Cobol85Parser.OF, 0) + + def procedureName(self): + return self.getTypedRuleContext(Cobol85Parser.ProcedureNameContext,0) + + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_useDebugOn + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUseDebugOn" ): + listener.enterUseDebugOn(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUseDebugOn" ): + listener.exitUseDebugOn(self) + + + + + def useDebugOn(self): + + localctx = Cobol85Parser.UseDebugOnContext(self, self._ctx, self.state) + self.enterRule(localctx, 994, self.RULE_useDebugOn) + self._la = 0 # Token type + try: + self.state = 5585 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,867,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5573 + self.match(Cobol85Parser.ALL) + self.state = 5574 + self.match(Cobol85Parser.PROCEDURES) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5575 + self.match(Cobol85Parser.ALL) + self.state = 5577 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==385: + self.state = 5576 + self.match(Cobol85Parser.REFERENCES) + + + self.state = 5580 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==323: + self.state = 5579 + self.match(Cobol85Parser.OF) + + + self.state = 5582 + self.identifier() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 5583 + self.procedureName() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 5584 + self.fileName() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class WriteStatementContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def WRITE(self): + return self.getToken(Cobol85Parser.WRITE, 0) + + def recordName(self): + return self.getTypedRuleContext(Cobol85Parser.RecordNameContext,0) + + + def writeFromPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.WriteFromPhraseContext,0) + + + def writeAdvancingPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.WriteAdvancingPhraseContext,0) + + + def writeAtEndOfPagePhrase(self): + return self.getTypedRuleContext(Cobol85Parser.WriteAtEndOfPagePhraseContext,0) + + + def writeNotAtEndOfPagePhrase(self): + return self.getTypedRuleContext(Cobol85Parser.WriteNotAtEndOfPagePhraseContext,0) + + + def invalidKeyPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.InvalidKeyPhraseContext,0) + + + def notInvalidKeyPhrase(self): + return self.getTypedRuleContext(Cobol85Parser.NotInvalidKeyPhraseContext,0) + + + def END_WRITE(self): + return self.getToken(Cobol85Parser.END_WRITE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_writeStatement + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWriteStatement" ): + listener.enterWriteStatement(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWriteStatement" ): + listener.exitWriteStatement(self) + + + + + def writeStatement(self): + + localctx = Cobol85Parser.WriteStatementContext(self, self._ctx, self.state) + self.enterRule(localctx, 996, self.RULE_writeStatement) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5587 + self.match(Cobol85Parser.WRITE) + self.state = 5588 + self.recordName() + self.state = 5590 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==215: + self.state = 5589 + self.writeFromPhrase() + + + self.state = 5593 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==7 or _la==39: + self.state = 5592 + self.writeAdvancingPhrase() + + + self.state = 5596 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,870,self._ctx) + if la_ == 1: + self.state = 5595 + self.writeAtEndOfPagePhrase() + + + self.state = 5599 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,871,self._ctx) + if la_ == 1: + self.state = 5598 + self.writeNotAtEndOfPagePhrase() + + + self.state = 5602 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,872,self._ctx) + if la_ == 1: + self.state = 5601 + self.invalidKeyPhrase() + + + self.state = 5605 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,873,self._ctx) + if la_ == 1: + self.state = 5604 + self.notInvalidKeyPhrase() + + + self.state = 5608 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,874,self._ctx) + if la_ == 1: + self.state = 5607 + self.match(Cobol85Parser.END_WRITE) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class WriteFromPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FROM(self): + return self.getToken(Cobol85Parser.FROM, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_writeFromPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWriteFromPhrase" ): + listener.enterWriteFromPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWriteFromPhrase" ): + listener.exitWriteFromPhrase(self) + + + + + def writeFromPhrase(self): + + localctx = Cobol85Parser.WriteFromPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 998, self.RULE_writeFromPhrase) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5610 + self.match(Cobol85Parser.FROM) + self.state = 5613 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,875,self._ctx) + if la_ == 1: + self.state = 5611 + self.identifier() + pass + + elif la_ == 2: + self.state = 5612 + self.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 WriteAdvancingPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BEFORE(self): + return self.getToken(Cobol85Parser.BEFORE, 0) + + def AFTER(self): + return self.getToken(Cobol85Parser.AFTER, 0) + + def writeAdvancingPage(self): + return self.getTypedRuleContext(Cobol85Parser.WriteAdvancingPageContext,0) + + + def writeAdvancingLines(self): + return self.getTypedRuleContext(Cobol85Parser.WriteAdvancingLinesContext,0) + + + def writeAdvancingMnemonic(self): + return self.getTypedRuleContext(Cobol85Parser.WriteAdvancingMnemonicContext,0) + + + def ADVANCING(self): + return self.getToken(Cobol85Parser.ADVANCING, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_writeAdvancingPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWriteAdvancingPhrase" ): + listener.enterWriteAdvancingPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWriteAdvancingPhrase" ): + listener.exitWriteAdvancingPhrase(self) + + + + + def writeAdvancingPhrase(self): + + localctx = Cobol85Parser.WriteAdvancingPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 1000, self.RULE_writeAdvancingPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5615 + _la = self._input.LA(1) + if not(_la==7 or _la==39): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5617 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==6: + self.state = 5616 + self.match(Cobol85Parser.ADVANCING) + + + self.state = 5622 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,877,self._ctx) + if la_ == 1: + self.state = 5619 + self.writeAdvancingPage() + pass + + elif la_ == 2: + self.state = 5620 + self.writeAdvancingLines() + pass + + elif la_ == 3: + self.state = 5621 + self.writeAdvancingMnemonic() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class WriteAdvancingPageContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def PAGE(self): + return self.getToken(Cobol85Parser.PAGE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_writeAdvancingPage + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWriteAdvancingPage" ): + listener.enterWriteAdvancingPage(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWriteAdvancingPage" ): + listener.exitWriteAdvancingPage(self) + + + + + def writeAdvancingPage(self): + + localctx = Cobol85Parser.WriteAdvancingPageContext(self, self._ctx, self.state) + self.enterRule(localctx, 1002, self.RULE_writeAdvancingPage) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5624 + self.match(Cobol85Parser.PAGE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class WriteAdvancingLinesContext(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(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def LINE(self): + return self.getToken(Cobol85Parser.LINE, 0) + + def LINES(self): + return self.getToken(Cobol85Parser.LINES, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_writeAdvancingLines + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWriteAdvancingLines" ): + listener.enterWriteAdvancingLines(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWriteAdvancingLines" ): + listener.exitWriteAdvancingLines(self) + + + + + def writeAdvancingLines(self): + + localctx = Cobol85Parser.WriteAdvancingLinesContext(self, self._ctx, self.state) + self.enterRule(localctx, 1004, self.RULE_writeAdvancingLines) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5628 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,878,self._ctx) + if la_ == 1: + self.state = 5626 + self.identifier() + pass + + elif la_ == 2: + self.state = 5627 + self.literal() + pass + + + self.state = 5631 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==279 or _la==280: + self.state = 5630 + _la = self._input.LA(1) + if not(_la==279 or _la==280): + 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 WriteAdvancingMnemonicContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def mnemonicName(self): + return self.getTypedRuleContext(Cobol85Parser.MnemonicNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_writeAdvancingMnemonic + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWriteAdvancingMnemonic" ): + listener.enterWriteAdvancingMnemonic(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWriteAdvancingMnemonic" ): + listener.exitWriteAdvancingMnemonic(self) + + + + + def writeAdvancingMnemonic(self): + + localctx = Cobol85Parser.WriteAdvancingMnemonicContext(self, self._ctx, self.state) + self.enterRule(localctx, 1006, self.RULE_writeAdvancingMnemonic) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5633 + self.mnemonicName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class WriteAtEndOfPagePhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def END_OF_PAGE(self): + return self.getToken(Cobol85Parser.END_OF_PAGE, 0) + + def EOP(self): + return self.getToken(Cobol85Parser.EOP, 0) + + def AT(self): + return self.getToken(Cobol85Parser.AT, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_writeAtEndOfPagePhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWriteAtEndOfPagePhrase" ): + listener.enterWriteAtEndOfPagePhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWriteAtEndOfPagePhrase" ): + listener.exitWriteAtEndOfPagePhrase(self) + + + + + def writeAtEndOfPagePhrase(self): + + localctx = Cobol85Parser.WriteAtEndOfPagePhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 1008, self.RULE_writeAtEndOfPagePhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5636 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==30: + self.state = 5635 + self.match(Cobol85Parser.AT) + + + self.state = 5638 + _la = self._input.LA(1) + if not(_la==168 or _la==185): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5642 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,881,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5639 + self.statement() + self.state = 5644 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,881,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class WriteNotAtEndOfPagePhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NOT(self): + return self.getToken(Cobol85Parser.NOT, 0) + + def END_OF_PAGE(self): + return self.getToken(Cobol85Parser.END_OF_PAGE, 0) + + def EOP(self): + return self.getToken(Cobol85Parser.EOP, 0) + + def AT(self): + return self.getToken(Cobol85Parser.AT, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_writeNotAtEndOfPagePhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterWriteNotAtEndOfPagePhrase" ): + listener.enterWriteNotAtEndOfPagePhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitWriteNotAtEndOfPagePhrase" ): + listener.exitWriteNotAtEndOfPagePhrase(self) + + + + + def writeNotAtEndOfPagePhrase(self): + + localctx = Cobol85Parser.WriteNotAtEndOfPagePhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 1010, self.RULE_writeNotAtEndOfPagePhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5645 + self.match(Cobol85Parser.NOT) + self.state = 5647 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==30: + self.state = 5646 + self.match(Cobol85Parser.AT) + + + self.state = 5649 + _la = self._input.LA(1) + if not(_la==168 or _la==185): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5653 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,883,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5650 + self.statement() + self.state = 5655 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,883,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AtEndPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def END(self): + return self.getToken(Cobol85Parser.END, 0) + + def AT(self): + return self.getToken(Cobol85Parser.AT, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_atEndPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAtEndPhrase" ): + listener.enterAtEndPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAtEndPhrase" ): + listener.exitAtEndPhrase(self) + + + + + def atEndPhrase(self): + + localctx = Cobol85Parser.AtEndPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 1012, self.RULE_atEndPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5657 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==30: + self.state = 5656 + self.match(Cobol85Parser.AT) + + + self.state = 5659 + self.match(Cobol85Parser.END) + self.state = 5663 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,885,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5660 + self.statement() + self.state = 5665 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,885,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class NotAtEndPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NOT(self): + return self.getToken(Cobol85Parser.NOT, 0) + + def END(self): + return self.getToken(Cobol85Parser.END, 0) + + def AT(self): + return self.getToken(Cobol85Parser.AT, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_notAtEndPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNotAtEndPhrase" ): + listener.enterNotAtEndPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNotAtEndPhrase" ): + listener.exitNotAtEndPhrase(self) + + + + + def notAtEndPhrase(self): + + localctx = Cobol85Parser.NotAtEndPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 1014, self.RULE_notAtEndPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5666 + self.match(Cobol85Parser.NOT) + self.state = 5668 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==30: + self.state = 5667 + self.match(Cobol85Parser.AT) + + + self.state = 5670 + self.match(Cobol85Parser.END) + self.state = 5674 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,887,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5671 + self.statement() + self.state = 5676 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,887,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InvalidKeyPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INVALID(self): + return self.getToken(Cobol85Parser.INVALID, 0) + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_invalidKeyPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInvalidKeyPhrase" ): + listener.enterInvalidKeyPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInvalidKeyPhrase" ): + listener.exitInvalidKeyPhrase(self) + + + + + def invalidKeyPhrase(self): + + localctx = Cobol85Parser.InvalidKeyPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 1016, self.RULE_invalidKeyPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5677 + self.match(Cobol85Parser.INVALID) + self.state = 5679 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==259: + self.state = 5678 + self.match(Cobol85Parser.KEY) + + + self.state = 5684 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,889,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5681 + self.statement() + self.state = 5686 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,889,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class NotInvalidKeyPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NOT(self): + return self.getToken(Cobol85Parser.NOT, 0) + + def INVALID(self): + return self.getToken(Cobol85Parser.INVALID, 0) + + def KEY(self): + return self.getToken(Cobol85Parser.KEY, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_notInvalidKeyPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNotInvalidKeyPhrase" ): + listener.enterNotInvalidKeyPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNotInvalidKeyPhrase" ): + listener.exitNotInvalidKeyPhrase(self) + + + + + def notInvalidKeyPhrase(self): + + localctx = Cobol85Parser.NotInvalidKeyPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 1018, self.RULE_notInvalidKeyPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5687 + self.match(Cobol85Parser.NOT) + self.state = 5688 + self.match(Cobol85Parser.INVALID) + self.state = 5690 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==259: + self.state = 5689 + self.match(Cobol85Parser.KEY) + + + self.state = 5695 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,891,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5692 + self.statement() + self.state = 5697 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,891,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class OnOverflowPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OVERFLOW(self): + return self.getToken(Cobol85Parser.OVERFLOW, 0) + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_onOverflowPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOnOverflowPhrase" ): + listener.enterOnOverflowPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOnOverflowPhrase" ): + listener.exitOnOverflowPhrase(self) + + + + + def onOverflowPhrase(self): + + localctx = Cobol85Parser.OnOverflowPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 1020, self.RULE_onOverflowPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5699 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 5698 + self.match(Cobol85Parser.ON) + + + self.state = 5701 + self.match(Cobol85Parser.OVERFLOW) + self.state = 5705 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,893,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5702 + self.statement() + self.state = 5707 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,893,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class NotOnOverflowPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NOT(self): + return self.getToken(Cobol85Parser.NOT, 0) + + def OVERFLOW(self): + return self.getToken(Cobol85Parser.OVERFLOW, 0) + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_notOnOverflowPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNotOnOverflowPhrase" ): + listener.enterNotOnOverflowPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNotOnOverflowPhrase" ): + listener.exitNotOnOverflowPhrase(self) + + + + + def notOnOverflowPhrase(self): + + localctx = Cobol85Parser.NotOnOverflowPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 1022, self.RULE_notOnOverflowPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5708 + self.match(Cobol85Parser.NOT) + self.state = 5710 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 5709 + self.match(Cobol85Parser.ON) + + + self.state = 5712 + self.match(Cobol85Parser.OVERFLOW) + self.state = 5716 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,895,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5713 + self.statement() + self.state = 5718 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,895,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class OnSizeErrorPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SIZE(self): + return self.getToken(Cobol85Parser.SIZE, 0) + + def ERROR(self): + return self.getToken(Cobol85Parser.ERROR, 0) + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_onSizeErrorPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOnSizeErrorPhrase" ): + listener.enterOnSizeErrorPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOnSizeErrorPhrase" ): + listener.exitOnSizeErrorPhrase(self) + + + + + def onSizeErrorPhrase(self): + + localctx = Cobol85Parser.OnSizeErrorPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 1024, self.RULE_onSizeErrorPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5720 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 5719 + self.match(Cobol85Parser.ON) + + + self.state = 5722 + self.match(Cobol85Parser.SIZE) + self.state = 5723 + self.match(Cobol85Parser.ERROR) + self.state = 5727 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,897,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5724 + self.statement() + self.state = 5729 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,897,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class NotOnSizeErrorPhraseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NOT(self): + return self.getToken(Cobol85Parser.NOT, 0) + + def SIZE(self): + return self.getToken(Cobol85Parser.SIZE, 0) + + def ERROR(self): + return self.getToken(Cobol85Parser.ERROR, 0) + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_notOnSizeErrorPhrase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNotOnSizeErrorPhrase" ): + listener.enterNotOnSizeErrorPhrase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNotOnSizeErrorPhrase" ): + listener.exitNotOnSizeErrorPhrase(self) + + + + + def notOnSizeErrorPhrase(self): + + localctx = Cobol85Parser.NotOnSizeErrorPhraseContext(self, self._ctx, self.state) + self.enterRule(localctx, 1026, self.RULE_notOnSizeErrorPhrase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5730 + self.match(Cobol85Parser.NOT) + self.state = 5732 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 5731 + self.match(Cobol85Parser.ON) + + + self.state = 5734 + self.match(Cobol85Parser.SIZE) + self.state = 5735 + self.match(Cobol85Parser.ERROR) + self.state = 5739 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,899,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5736 + self.statement() + self.state = 5741 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,899,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class OnExceptionClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def EXCEPTION(self): + return self.getToken(Cobol85Parser.EXCEPTION, 0) + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_onExceptionClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOnExceptionClause" ): + listener.enterOnExceptionClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOnExceptionClause" ): + listener.exitOnExceptionClause(self) + + + + + def onExceptionClause(self): + + localctx = Cobol85Parser.OnExceptionClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 1028, self.RULE_onExceptionClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5743 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 5742 + self.match(Cobol85Parser.ON) + + + self.state = 5745 + self.match(Cobol85Parser.EXCEPTION) + self.state = 5749 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,901,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5746 + self.statement() + self.state = 5751 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,901,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class NotOnExceptionClauseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NOT(self): + return self.getToken(Cobol85Parser.NOT, 0) + + def EXCEPTION(self): + return self.getToken(Cobol85Parser.EXCEPTION, 0) + + def ON(self): + return self.getToken(Cobol85Parser.ON, 0) + + def statement(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.StatementContext) + else: + return self.getTypedRuleContext(Cobol85Parser.StatementContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_notOnExceptionClause + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNotOnExceptionClause" ): + listener.enterNotOnExceptionClause(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNotOnExceptionClause" ): + listener.exitNotOnExceptionClause(self) + + + + + def notOnExceptionClause(self): + + localctx = Cobol85Parser.NotOnExceptionClauseContext(self, self._ctx, self.state) + self.enterRule(localctx, 1030, self.RULE_notOnExceptionClause) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5752 + self.match(Cobol85Parser.NOT) + self.state = 5754 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==326: + self.state = 5753 + self.match(Cobol85Parser.ON) + + + self.state = 5756 + self.match(Cobol85Parser.EXCEPTION) + self.state = 5760 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,903,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5757 + self.statement() + self.state = 5762 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,903,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ArithmeticExpressionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def multDivs(self): + return self.getTypedRuleContext(Cobol85Parser.MultDivsContext,0) + + + def plusMinus(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.PlusMinusContext) + else: + return self.getTypedRuleContext(Cobol85Parser.PlusMinusContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_arithmeticExpression + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArithmeticExpression" ): + listener.enterArithmeticExpression(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArithmeticExpression" ): + listener.exitArithmeticExpression(self) + + + + + def arithmeticExpression(self): + + localctx = Cobol85Parser.ArithmeticExpressionContext(self, self._ctx, self.state) + self.enterRule(localctx, 1032, self.RULE_arithmeticExpression) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5763 + self.multDivs() + self.state = 5767 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,904,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5764 + self.plusMinus() + self.state = 5769 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,904,self._ctx) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PlusMinusContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def multDivs(self): + return self.getTypedRuleContext(Cobol85Parser.MultDivsContext,0) + + + def PLUSCHAR(self): + return self.getToken(Cobol85Parser.PLUSCHAR, 0) + + def MINUSCHAR(self): + return self.getToken(Cobol85Parser.MINUSCHAR, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_plusMinus + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPlusMinus" ): + listener.enterPlusMinus(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPlusMinus" ): + listener.exitPlusMinus(self) + + + + + def plusMinus(self): + + localctx = Cobol85Parser.PlusMinusContext(self, self._ctx, self.state) + self.enterRule(localctx, 1034, self.RULE_plusMinus) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5770 + _la = self._input.LA(1) + if not(_la==543 or _la==547): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5771 + self.multDivs() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MultDivsContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def powers(self): + return self.getTypedRuleContext(Cobol85Parser.PowersContext,0) + + + def multDiv(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.MultDivContext) + else: + return self.getTypedRuleContext(Cobol85Parser.MultDivContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_multDivs + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMultDivs" ): + listener.enterMultDivs(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMultDivs" ): + listener.exitMultDivs(self) + + + + + def multDivs(self): + + localctx = Cobol85Parser.MultDivsContext(self, self._ctx, self.state) + self.enterRule(localctx, 1036, self.RULE_multDivs) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5773 + self.powers() + self.state = 5777 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==526 or _la==550: + self.state = 5774 + self.multDiv() + self.state = 5779 + 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 MultDivContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def powers(self): + return self.getTypedRuleContext(Cobol85Parser.PowersContext,0) + + + def ASTERISKCHAR(self): + return self.getToken(Cobol85Parser.ASTERISKCHAR, 0) + + def SLASHCHAR(self): + return self.getToken(Cobol85Parser.SLASHCHAR, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_multDiv + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMultDiv" ): + listener.enterMultDiv(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMultDiv" ): + listener.exitMultDiv(self) + + + + + def multDiv(self): + + localctx = Cobol85Parser.MultDivContext(self, self._ctx, self.state) + self.enterRule(localctx, 1038, self.RULE_multDiv) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5780 + _la = self._input.LA(1) + if not(_la==526 or _la==550): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5781 + self.powers() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PowersContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def basis(self): + return self.getTypedRuleContext(Cobol85Parser.BasisContext,0) + + + def power(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.PowerContext) + else: + return self.getTypedRuleContext(Cobol85Parser.PowerContext,i) + + + def PLUSCHAR(self): + return self.getToken(Cobol85Parser.PLUSCHAR, 0) + + def MINUSCHAR(self): + return self.getToken(Cobol85Parser.MINUSCHAR, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_powers + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPowers" ): + listener.enterPowers(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPowers" ): + listener.exitPowers(self) + + + + + def powers(self): + + localctx = Cobol85Parser.PowersContext(self, self._ctx, self.state) + self.enterRule(localctx, 1040, self.RULE_powers) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5784 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==543 or _la==547: + self.state = 5783 + _la = self._input.LA(1) + if not(_la==543 or _la==547): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 5786 + self.basis() + self.state = 5790 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==527: + self.state = 5787 + self.power() + self.state = 5792 + 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 PowerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DOUBLEASTERISKCHAR(self): + return self.getToken(Cobol85Parser.DOUBLEASTERISKCHAR, 0) + + def basis(self): + return self.getTypedRuleContext(Cobol85Parser.BasisContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_power + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPower" ): + listener.enterPower(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPower" ): + listener.exitPower(self) + + + + + def power(self): + + localctx = Cobol85Parser.PowerContext(self, self._ctx, self.state) + self.enterRule(localctx, 1042, self.RULE_power) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5793 + self.match(Cobol85Parser.DOUBLEASTERISKCHAR) + self.state = 5794 + self.basis() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class BasisContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPARENCHAR(self): + return self.getToken(Cobol85Parser.LPARENCHAR, 0) + + def arithmeticExpression(self): + return self.getTypedRuleContext(Cobol85Parser.ArithmeticExpressionContext,0) + + + def RPARENCHAR(self): + return self.getToken(Cobol85Parser.RPARENCHAR, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_basis + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBasis" ): + listener.enterBasis(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBasis" ): + listener.exitBasis(self) + + + + + def basis(self): + + localctx = Cobol85Parser.BasisContext(self, self._ctx, self.state) + self.enterRule(localctx, 1044, self.RULE_basis) + try: + self.state = 5802 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,908,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5796 + self.match(Cobol85Parser.LPARENCHAR) + self.state = 5797 + self.arithmeticExpression() + self.state = 5798 + self.match(Cobol85Parser.RPARENCHAR) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5800 + self.identifier() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 5801 + self.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 ConditionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def combinableCondition(self): + return self.getTypedRuleContext(Cobol85Parser.CombinableConditionContext,0) + + + def andOrCondition(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.AndOrConditionContext) + else: + return self.getTypedRuleContext(Cobol85Parser.AndOrConditionContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_condition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCondition" ): + listener.enterCondition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCondition" ): + listener.exitCondition(self) + + + + + def condition(self): + + localctx = Cobol85Parser.ConditionContext(self, self._ctx, self.state) + self.enterRule(localctx, 1046, self.RULE_condition) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5804 + self.combinableCondition() + self.state = 5808 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==19 or _la==329: + self.state = 5805 + self.andOrCondition() + self.state = 5810 + 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 AndOrConditionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def AND(self): + return self.getToken(Cobol85Parser.AND, 0) + + def OR(self): + return self.getToken(Cobol85Parser.OR, 0) + + def combinableCondition(self): + return self.getTypedRuleContext(Cobol85Parser.CombinableConditionContext,0) + + + def abbreviation(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.AbbreviationContext) + else: + return self.getTypedRuleContext(Cobol85Parser.AbbreviationContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_andOrCondition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAndOrCondition" ): + listener.enterAndOrCondition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAndOrCondition" ): + listener.exitAndOrCondition(self) + + + + + def andOrCondition(self): + + localctx = Cobol85Parser.AndOrConditionContext(self, self._ctx, self.state) + self.enterRule(localctx, 1048, self.RULE_andOrCondition) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5811 + _la = self._input.LA(1) + if not(_la==19 or _la==329): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5818 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,911,self._ctx) + if la_ == 1: + self.state = 5812 + self.combinableCondition() + pass + + elif la_ == 2: + self.state = 5814 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 5813 + self.abbreviation() + + else: + raise NoViableAltException(self) + self.state = 5816 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,910,self._ctx) + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CombinableConditionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def simpleCondition(self): + return self.getTypedRuleContext(Cobol85Parser.SimpleConditionContext,0) + + + def NOT(self): + return self.getToken(Cobol85Parser.NOT, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_combinableCondition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCombinableCondition" ): + listener.enterCombinableCondition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCombinableCondition" ): + listener.exitCombinableCondition(self) + + + + + def combinableCondition(self): + + localctx = Cobol85Parser.CombinableConditionContext(self, self._ctx, self.state) + self.enterRule(localctx, 1050, self.RULE_combinableCondition) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5821 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==312: + self.state = 5820 + self.match(Cobol85Parser.NOT) + + + self.state = 5823 + self.simpleCondition() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SimpleConditionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPARENCHAR(self): + return self.getToken(Cobol85Parser.LPARENCHAR, 0) + + def condition(self): + return self.getTypedRuleContext(Cobol85Parser.ConditionContext,0) + + + def RPARENCHAR(self): + return self.getToken(Cobol85Parser.RPARENCHAR, 0) + + def relationCondition(self): + return self.getTypedRuleContext(Cobol85Parser.RelationConditionContext,0) + + + def classCondition(self): + return self.getTypedRuleContext(Cobol85Parser.ClassConditionContext,0) + + + def conditionNameReference(self): + return self.getTypedRuleContext(Cobol85Parser.ConditionNameReferenceContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_simpleCondition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSimpleCondition" ): + listener.enterSimpleCondition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSimpleCondition" ): + listener.exitSimpleCondition(self) + + + + + def simpleCondition(self): + + localctx = Cobol85Parser.SimpleConditionContext(self, self._ctx, self.state) + self.enterRule(localctx, 1052, self.RULE_simpleCondition) + try: + self.state = 5832 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,913,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5825 + self.match(Cobol85Parser.LPARENCHAR) + self.state = 5826 + self.condition() + self.state = 5827 + self.match(Cobol85Parser.RPARENCHAR) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5829 + self.relationCondition() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 5830 + self.classCondition() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 5831 + self.conditionNameReference() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ClassConditionContext(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(Cobol85Parser.IdentifierContext,0) + + + def NUMERIC(self): + return self.getToken(Cobol85Parser.NUMERIC, 0) + + def ALPHABETIC(self): + return self.getToken(Cobol85Parser.ALPHABETIC, 0) + + def ALPHABETIC_LOWER(self): + return self.getToken(Cobol85Parser.ALPHABETIC_LOWER, 0) + + def ALPHABETIC_UPPER(self): + return self.getToken(Cobol85Parser.ALPHABETIC_UPPER, 0) + + def DBCS(self): + return self.getToken(Cobol85Parser.DBCS, 0) + + def KANJI(self): + return self.getToken(Cobol85Parser.KANJI, 0) + + def className(self): + return self.getTypedRuleContext(Cobol85Parser.ClassNameContext,0) + + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def NOT(self): + return self.getToken(Cobol85Parser.NOT, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_classCondition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterClassCondition" ): + listener.enterClassCondition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitClassCondition" ): + listener.exitClassCondition(self) + + + + + def classCondition(self): + + localctx = Cobol85Parser.ClassConditionContext(self, self._ctx, self.state) + self.enterRule(localctx, 1054, self.RULE_classCondition) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5834 + self.identifier() + self.state = 5836 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 5835 + self.match(Cobol85Parser.IS) + + + self.state = 5839 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==312: + self.state = 5838 + self.match(Cobol85Parser.NOT) + + + self.state = 5848 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [316]: + self.state = 5841 + self.match(Cobol85Parser.NUMERIC) + pass + elif token in [11]: + self.state = 5842 + self.match(Cobol85Parser.ALPHABETIC) + pass + elif token in [12]: + self.state = 5843 + self.match(Cobol85Parser.ALPHABETIC_LOWER) + pass + elif token in [13]: + self.state = 5844 + self.match(Cobol85Parser.ALPHABETIC_UPPER) + pass + elif token in [116]: + self.state = 5845 + self.match(Cobol85Parser.DBCS) + pass + elif token in [257]: + self.state = 5846 + self.match(Cobol85Parser.KANJI) + pass + elif token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.state = 5847 + self.className() + 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 ConditionNameReferenceContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def conditionName(self): + return self.getTypedRuleContext(Cobol85Parser.ConditionNameContext,0) + + + def inData(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InDataContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InDataContext,i) + + + def inFile(self): + return self.getTypedRuleContext(Cobol85Parser.InFileContext,0) + + + def conditionNameSubscriptReference(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ConditionNameSubscriptReferenceContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ConditionNameSubscriptReferenceContext,i) + + + def inMnemonic(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.InMnemonicContext) + else: + return self.getTypedRuleContext(Cobol85Parser.InMnemonicContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_conditionNameReference + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConditionNameReference" ): + listener.enterConditionNameReference(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConditionNameReference" ): + listener.exitConditionNameReference(self) + + + + + def conditionNameReference(self): + + localctx = Cobol85Parser.ConditionNameReferenceContext(self, self._ctx, self.state) + self.enterRule(localctx, 1056, self.RULE_conditionNameReference) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5850 + self.conditionName() + self.state = 5872 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,921,self._ctx) + if la_ == 1: + self.state = 5854 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,917,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5851 + self.inData() + self.state = 5856 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,917,self._ctx) + + self.state = 5858 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==239 or _la==323: + self.state = 5857 + self.inFile() + + + self.state = 5863 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==542: + self.state = 5860 + self.conditionNameSubscriptReference() + self.state = 5865 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + elif la_ == 2: + self.state = 5869 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==239 or _la==323: + self.state = 5866 + self.inMnemonic() + self.state = 5871 + self._errHandler.sync(self) + _la = self._input.LA(1) + + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ConditionNameSubscriptReferenceContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPARENCHAR(self): + return self.getToken(Cobol85Parser.LPARENCHAR, 0) + + def subscript_(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.Subscript_Context) + else: + return self.getTypedRuleContext(Cobol85Parser.Subscript_Context,i) + + + def RPARENCHAR(self): + return self.getToken(Cobol85Parser.RPARENCHAR, 0) + + def COMMACHAR(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.COMMACHAR) + else: + return self.getToken(Cobol85Parser.COMMACHAR, i) + + def getRuleIndex(self): + return Cobol85Parser.RULE_conditionNameSubscriptReference + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConditionNameSubscriptReference" ): + listener.enterConditionNameSubscriptReference(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConditionNameSubscriptReference" ): + listener.exitConditionNameSubscriptReference(self) + + + + + def conditionNameSubscriptReference(self): + + localctx = Cobol85Parser.ConditionNameSubscriptReferenceContext(self, self._ctx, self.state) + self.enterRule(localctx, 1058, self.RULE_conditionNameSubscriptReference) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5874 + self.match(Cobol85Parser.LPARENCHAR) + self.state = 5875 + self.subscript_() + self.state = 5882 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822370) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194964618422267) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202427199037528969) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874440372879459) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 1819828109721609) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & -8651221362832473951) != 0) or ((((_la - 542)) & ~0x3f) == 0 and ((1 << (_la - 542)) & 65059) != 0): + self.state = 5877 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==529: + self.state = 5876 + self.match(Cobol85Parser.COMMACHAR) + + + self.state = 5879 + self.subscript_() + self.state = 5884 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 5885 + self.match(Cobol85Parser.RPARENCHAR) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RelationConditionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def relationSignCondition(self): + return self.getTypedRuleContext(Cobol85Parser.RelationSignConditionContext,0) + + + def relationArithmeticComparison(self): + return self.getTypedRuleContext(Cobol85Parser.RelationArithmeticComparisonContext,0) + + + def relationCombinedComparison(self): + return self.getTypedRuleContext(Cobol85Parser.RelationCombinedComparisonContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_relationCondition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRelationCondition" ): + listener.enterRelationCondition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRelationCondition" ): + listener.exitRelationCondition(self) + + + + + def relationCondition(self): + + localctx = Cobol85Parser.RelationConditionContext(self, self._ctx, self.state) + self.enterRule(localctx, 1060, self.RULE_relationCondition) + try: + self.state = 5890 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,924,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5887 + self.relationSignCondition() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5888 + self.relationArithmeticComparison() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 5889 + self.relationCombinedComparison() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RelationSignConditionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def arithmeticExpression(self): + return self.getTypedRuleContext(Cobol85Parser.ArithmeticExpressionContext,0) + + + def POSITIVE(self): + return self.getToken(Cobol85Parser.POSITIVE, 0) + + def NEGATIVE(self): + return self.getToken(Cobol85Parser.NEGATIVE, 0) + + def ZERO(self): + return self.getToken(Cobol85Parser.ZERO, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def NOT(self): + return self.getToken(Cobol85Parser.NOT, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_relationSignCondition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRelationSignCondition" ): + listener.enterRelationSignCondition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRelationSignCondition" ): + listener.exitRelationSignCondition(self) + + + + + def relationSignCondition(self): + + localctx = Cobol85Parser.RelationSignConditionContext(self, self._ctx, self.state) + self.enterRule(localctx, 1062, self.RULE_relationSignCondition) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5892 + self.arithmeticExpression() + self.state = 5894 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==254: + self.state = 5893 + self.match(Cobol85Parser.IS) + + + self.state = 5897 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==312: + self.state = 5896 + self.match(Cobol85Parser.NOT) + + + self.state = 5899 + _la = self._input.LA(1) + if not(_la==307 or _la==351 or _la==521): + 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 RelationArithmeticComparisonContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def arithmeticExpression(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ArithmeticExpressionContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ArithmeticExpressionContext,i) + + + def relationalOperator(self): + return self.getTypedRuleContext(Cobol85Parser.RelationalOperatorContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_relationArithmeticComparison + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRelationArithmeticComparison" ): + listener.enterRelationArithmeticComparison(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRelationArithmeticComparison" ): + listener.exitRelationArithmeticComparison(self) + + + + + def relationArithmeticComparison(self): + + localctx = Cobol85Parser.RelationArithmeticComparisonContext(self, self._ctx, self.state) + self.enterRule(localctx, 1064, self.RULE_relationArithmeticComparison) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5901 + self.arithmeticExpression() + self.state = 5902 + self.relationalOperator() + self.state = 5903 + self.arithmeticExpression() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RelationCombinedComparisonContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def arithmeticExpression(self): + return self.getTypedRuleContext(Cobol85Parser.ArithmeticExpressionContext,0) + + + def relationalOperator(self): + return self.getTypedRuleContext(Cobol85Parser.RelationalOperatorContext,0) + + + def LPARENCHAR(self): + return self.getToken(Cobol85Parser.LPARENCHAR, 0) + + def relationCombinedCondition(self): + return self.getTypedRuleContext(Cobol85Parser.RelationCombinedConditionContext,0) + + + def RPARENCHAR(self): + return self.getToken(Cobol85Parser.RPARENCHAR, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_relationCombinedComparison + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRelationCombinedComparison" ): + listener.enterRelationCombinedComparison(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRelationCombinedComparison" ): + listener.exitRelationCombinedComparison(self) + + + + + def relationCombinedComparison(self): + + localctx = Cobol85Parser.RelationCombinedComparisonContext(self, self._ctx, self.state) + self.enterRule(localctx, 1066, self.RULE_relationCombinedComparison) + try: + self.enterOuterAlt(localctx, 1) + self.state = 5905 + self.arithmeticExpression() + self.state = 5906 + self.relationalOperator() + self.state = 5907 + self.match(Cobol85Parser.LPARENCHAR) + self.state = 5908 + self.relationCombinedCondition() + self.state = 5909 + self.match(Cobol85Parser.RPARENCHAR) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RelationCombinedConditionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def arithmeticExpression(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ArithmeticExpressionContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ArithmeticExpressionContext,i) + + + def AND(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.AND) + else: + return self.getToken(Cobol85Parser.AND, i) + + def OR(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.OR) + else: + return self.getToken(Cobol85Parser.OR, i) + + def getRuleIndex(self): + return Cobol85Parser.RULE_relationCombinedCondition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRelationCombinedCondition" ): + listener.enterRelationCombinedCondition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRelationCombinedCondition" ): + listener.exitRelationCombinedCondition(self) + + + + + def relationCombinedCondition(self): + + localctx = Cobol85Parser.RelationCombinedConditionContext(self, self._ctx, self.state) + self.enterRule(localctx, 1068, self.RULE_relationCombinedCondition) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5911 + self.arithmeticExpression() + self.state = 5914 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 5912 + _la = self._input.LA(1) + if not(_la==19 or _la==329): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 5913 + self.arithmeticExpression() + self.state = 5916 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==19 or _la==329): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RelationalOperatorContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NOTEQUALCHAR(self): + return self.getToken(Cobol85Parser.NOTEQUALCHAR, 0) + + def GREATER(self): + return self.getToken(Cobol85Parser.GREATER, 0) + + def OR(self): + return self.getToken(Cobol85Parser.OR, 0) + + def EQUAL(self): + return self.getToken(Cobol85Parser.EQUAL, 0) + + def MORETHANOREQUAL(self): + return self.getToken(Cobol85Parser.MORETHANOREQUAL, 0) + + def LESS(self): + return self.getToken(Cobol85Parser.LESS, 0) + + def LESSTHANOREQUAL(self): + return self.getToken(Cobol85Parser.LESSTHANOREQUAL, 0) + + def IS(self): + return self.getToken(Cobol85Parser.IS, 0) + + def ARE(self): + return self.getToken(Cobol85Parser.ARE, 0) + + def MORETHANCHAR(self): + return self.getToken(Cobol85Parser.MORETHANCHAR, 0) + + def LESSTHANCHAR(self): + return self.getToken(Cobol85Parser.LESSTHANCHAR, 0) + + def EQUALCHAR(self): + return self.getToken(Cobol85Parser.EQUALCHAR, 0) + + def NOT(self): + return self.getToken(Cobol85Parser.NOT, 0) + + def THAN(self): + return self.getToken(Cobol85Parser.THAN, 0) + + def TO(self): + return self.getToken(Cobol85Parser.TO, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_relationalOperator + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRelationalOperator" ): + listener.enterRelationalOperator(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRelationalOperator" ): + listener.exitRelationalOperator(self) + + + + + def relationalOperator(self): + + localctx = Cobol85Parser.RelationalOperatorContext(self, self._ctx, self.state) + self.enterRule(localctx, 1070, self.RULE_relationalOperator) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5919 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==21 or _la==254: + self.state = 5918 + _la = self._input.LA(1) + if not(_la==21 or _la==254): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + + + self.state = 5962 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,938,self._ctx) + if la_ == 1: + self.state = 5922 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==312: + self.state = 5921 + self.match(Cobol85Parser.NOT) + + + self.state = 5939 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [225]: + self.state = 5924 + self.match(Cobol85Parser.GREATER) + self.state = 5926 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==479: + self.state = 5925 + self.match(Cobol85Parser.THAN) + + + pass + elif token in [544]: + self.state = 5928 + self.match(Cobol85Parser.MORETHANCHAR) + pass + elif token in [271]: + self.state = 5929 + self.match(Cobol85Parser.LESS) + self.state = 5931 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==479: + self.state = 5930 + self.match(Cobol85Parser.THAN) + + + pass + elif token in [540]: + self.state = 5933 + self.match(Cobol85Parser.LESSTHANCHAR) + pass + elif token in [186]: + self.state = 5934 + self.match(Cobol85Parser.EQUAL) + self.state = 5936 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==489: + self.state = 5935 + self.match(Cobol85Parser.TO) + + + pass + elif token in [536]: + self.state = 5938 + self.match(Cobol85Parser.EQUALCHAR) + pass + else: + raise NoViableAltException(self) + + pass + + elif la_ == 2: + self.state = 5941 + self.match(Cobol85Parser.NOTEQUALCHAR) + pass + + elif la_ == 3: + self.state = 5942 + self.match(Cobol85Parser.GREATER) + self.state = 5944 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==479: + self.state = 5943 + self.match(Cobol85Parser.THAN) + + + self.state = 5946 + self.match(Cobol85Parser.OR) + self.state = 5947 + self.match(Cobol85Parser.EQUAL) + self.state = 5949 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==489: + self.state = 5948 + self.match(Cobol85Parser.TO) + + + pass + + elif la_ == 4: + self.state = 5951 + self.match(Cobol85Parser.MORETHANOREQUAL) + pass + + elif la_ == 5: + self.state = 5952 + self.match(Cobol85Parser.LESS) + self.state = 5954 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==479: + self.state = 5953 + self.match(Cobol85Parser.THAN) + + + self.state = 5956 + self.match(Cobol85Parser.OR) + self.state = 5957 + self.match(Cobol85Parser.EQUAL) + self.state = 5959 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==489: + self.state = 5958 + self.match(Cobol85Parser.TO) + + + pass + + elif la_ == 6: + self.state = 5961 + self.match(Cobol85Parser.LESSTHANOREQUAL) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AbbreviationContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def arithmeticExpression(self): + return self.getTypedRuleContext(Cobol85Parser.ArithmeticExpressionContext,0) + + + def LPARENCHAR(self): + return self.getToken(Cobol85Parser.LPARENCHAR, 0) + + def abbreviation(self): + return self.getTypedRuleContext(Cobol85Parser.AbbreviationContext,0) + + + def RPARENCHAR(self): + return self.getToken(Cobol85Parser.RPARENCHAR, 0) + + def NOT(self): + return self.getToken(Cobol85Parser.NOT, 0) + + def relationalOperator(self): + return self.getTypedRuleContext(Cobol85Parser.RelationalOperatorContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_abbreviation + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAbbreviation" ): + listener.enterAbbreviation(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAbbreviation" ): + listener.exitAbbreviation(self) + + + + + def abbreviation(self): + + localctx = Cobol85Parser.AbbreviationContext(self, self._ctx, self.state) + self.enterRule(localctx, 1072, self.RULE_abbreviation) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5965 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,939,self._ctx) + if la_ == 1: + self.state = 5964 + self.match(Cobol85Parser.NOT) + + + self.state = 5968 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==21 or _la==186 or _la==225 or ((((_la - 254)) & ~0x3f) == 0 and ((1 << (_la - 254)) & 288230376151842817) != 0) or ((((_la - 536)) & ~0x3f) == 0 and ((1 << (_la - 536)) & 1841) != 0): + self.state = 5967 + self.relationalOperator() + + + self.state = 5976 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,941,self._ctx) + if la_ == 1: + self.state = 5970 + self.arithmeticExpression() + pass + + elif la_ == 2: + self.state = 5971 + self.match(Cobol85Parser.LPARENCHAR) + self.state = 5972 + self.arithmeticExpression() + self.state = 5973 + self.abbreviation() + self.state = 5974 + self.match(Cobol85Parser.RPARENCHAR) + pass + + + 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 qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def tableCall(self): + return self.getTypedRuleContext(Cobol85Parser.TableCallContext,0) + + + def functionCall(self): + return self.getTypedRuleContext(Cobol85Parser.FunctionCallContext,0) + + + def specialRegister(self): + return self.getTypedRuleContext(Cobol85Parser.SpecialRegisterContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.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 = Cobol85Parser.IdentifierContext(self, self._ctx, self.state) + self.enterRule(localctx, 1074, self.RULE_identifier) + try: + self.state = 5982 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,942,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 5978 + self.qualifiedDataName() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 5979 + self.tableCall() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 5980 + self.functionCall() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 5981 + self.specialRegister() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TableCallContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def LPARENCHAR(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.LPARENCHAR) + else: + return self.getToken(Cobol85Parser.LPARENCHAR, i) + + def subscript_(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.Subscript_Context) + else: + return self.getTypedRuleContext(Cobol85Parser.Subscript_Context,i) + + + def RPARENCHAR(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.RPARENCHAR) + else: + return self.getToken(Cobol85Parser.RPARENCHAR, i) + + def referenceModifier(self): + return self.getTypedRuleContext(Cobol85Parser.ReferenceModifierContext,0) + + + def COMMACHAR(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.COMMACHAR) + else: + return self.getToken(Cobol85Parser.COMMACHAR, i) + + def getRuleIndex(self): + return Cobol85Parser.RULE_tableCall + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTableCall" ): + listener.enterTableCall(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTableCall" ): + listener.exitTableCall(self) + + + + + def tableCall(self): + + localctx = Cobol85Parser.TableCallContext(self, self._ctx, self.state) + self.enterRule(localctx, 1076, self.RULE_tableCall) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 5984 + self.qualifiedDataName() + self.state = 6000 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,945,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 5985 + self.match(Cobol85Parser.LPARENCHAR) + self.state = 5986 + self.subscript_() + self.state = 5993 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822370) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194964618422267) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202427199037528969) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874440372879459) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 1819828109721609) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & -8651221362832473951) != 0) or ((((_la - 542)) & ~0x3f) == 0 and ((1 << (_la - 542)) & 65059) != 0): + self.state = 5988 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==529: + self.state = 5987 + self.match(Cobol85Parser.COMMACHAR) + + + self.state = 5990 + self.subscript_() + self.state = 5995 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 5996 + self.match(Cobol85Parser.RPARENCHAR) + self.state = 6002 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,945,self._ctx) + + self.state = 6004 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,946,self._ctx) + if la_ == 1: + self.state = 6003 + self.referenceModifier() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class FunctionCallContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FUNCTION(self): + return self.getToken(Cobol85Parser.FUNCTION, 0) + + def functionName(self): + return self.getTypedRuleContext(Cobol85Parser.FunctionNameContext,0) + + + def LPARENCHAR(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.LPARENCHAR) + else: + return self.getToken(Cobol85Parser.LPARENCHAR, i) + + def argument(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.ArgumentContext) + else: + return self.getTypedRuleContext(Cobol85Parser.ArgumentContext,i) + + + def RPARENCHAR(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.RPARENCHAR) + else: + return self.getToken(Cobol85Parser.RPARENCHAR, i) + + def referenceModifier(self): + return self.getTypedRuleContext(Cobol85Parser.ReferenceModifierContext,0) + + + def COMMACHAR(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.COMMACHAR) + else: + return self.getToken(Cobol85Parser.COMMACHAR, i) + + def getRuleIndex(self): + return Cobol85Parser.RULE_functionCall + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunctionCall" ): + listener.enterFunctionCall(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunctionCall" ): + listener.exitFunctionCall(self) + + + + + def functionCall(self): + + localctx = Cobol85Parser.FunctionCallContext(self, self._ctx, self.state) + self.enterRule(localctx, 1078, self.RULE_functionCall) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6006 + self.match(Cobol85Parser.FUNCTION) + self.state = 6007 + self.functionName() + self.state = 6023 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,949,self._ctx) + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt==1: + self.state = 6008 + self.match(Cobol85Parser.LPARENCHAR) + self.state = 6009 + self.argument() + self.state = 6016 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822370) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194964618422267) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202427199037528969) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874440372879459) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 1819828109721609) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & -8651221362832473951) != 0) or ((((_la - 542)) & ~0x3f) == 0 and ((1 << (_la - 542)) & 65059) != 0): + self.state = 6011 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==529: + self.state = 6010 + self.match(Cobol85Parser.COMMACHAR) + + + self.state = 6013 + self.argument() + self.state = 6018 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 6019 + self.match(Cobol85Parser.RPARENCHAR) + self.state = 6025 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,949,self._ctx) + + self.state = 6027 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,950,self._ctx) + if la_ == 1: + self.state = 6026 + self.referenceModifier() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReferenceModifierContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LPARENCHAR(self): + return self.getToken(Cobol85Parser.LPARENCHAR, 0) + + def characterPosition(self): + return self.getTypedRuleContext(Cobol85Parser.CharacterPositionContext,0) + + + def COLONCHAR(self): + return self.getToken(Cobol85Parser.COLONCHAR, 0) + + def RPARENCHAR(self): + return self.getToken(Cobol85Parser.RPARENCHAR, 0) + + def length(self): + return self.getTypedRuleContext(Cobol85Parser.LengthContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_referenceModifier + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReferenceModifier" ): + listener.enterReferenceModifier(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReferenceModifier" ): + listener.exitReferenceModifier(self) + + + + + def referenceModifier(self): + + localctx = Cobol85Parser.ReferenceModifierContext(self, self._ctx, self.state) + self.enterRule(localctx, 1080, self.RULE_referenceModifier) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6029 + self.match(Cobol85Parser.LPARENCHAR) + self.state = 6030 + self.characterPosition() + self.state = 6031 + self.match(Cobol85Parser.COLONCHAR) + self.state = 6033 + self._errHandler.sync(self) + _la = self._input.LA(1) + if (((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135822370) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8213661102500741635) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194964618422267) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202427199037528969) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874440372879459) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 1819828109721609) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 572150674022301857) != 0) or ((((_la - 542)) & ~0x3f) == 0 and ((1 << (_la - 542)) & 65059) != 0): + self.state = 6032 + self.length() + + + self.state = 6035 + self.match(Cobol85Parser.RPARENCHAR) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CharacterPositionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def arithmeticExpression(self): + return self.getTypedRuleContext(Cobol85Parser.ArithmeticExpressionContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_characterPosition + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCharacterPosition" ): + listener.enterCharacterPosition(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCharacterPosition" ): + listener.exitCharacterPosition(self) + + + + + def characterPosition(self): + + localctx = Cobol85Parser.CharacterPositionContext(self, self._ctx, self.state) + self.enterRule(localctx, 1082, self.RULE_characterPosition) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6037 + self.arithmeticExpression() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LengthContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def arithmeticExpression(self): + return self.getTypedRuleContext(Cobol85Parser.ArithmeticExpressionContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_length + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLength" ): + listener.enterLength(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLength" ): + listener.exitLength(self) + + + + + def length(self): + + localctx = Cobol85Parser.LengthContext(self, self._ctx, self.state) + self.enterRule(localctx, 1084, self.RULE_length) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6039 + self.arithmeticExpression() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Subscript_Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALL(self): + return self.getToken(Cobol85Parser.ALL, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def indexName(self): + return self.getTypedRuleContext(Cobol85Parser.IndexNameContext,0) + + + def arithmeticExpression(self): + return self.getTypedRuleContext(Cobol85Parser.ArithmeticExpressionContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_subscript_ + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubscript_" ): + listener.enterSubscript_(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubscript_" ): + listener.exitSubscript_(self) + + + + + def subscript_(self): + + localctx = Cobol85Parser.Subscript_Context(self, self._ctx, self.state) + self.enterRule(localctx, 1086, self.RULE_subscript_) + try: + self.state = 6052 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,954,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 6041 + self.match(Cobol85Parser.ALL) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 6042 + self.integerLiteral() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 6043 + self.qualifiedDataName() + self.state = 6045 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,952,self._ctx) + if la_ == 1: + self.state = 6044 + self.integerLiteral() + + + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 6047 + self.indexName() + self.state = 6049 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,953,self._ctx) + if la_ == 1: + self.state = 6048 + self.integerLiteral() + + + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 6051 + self.arithmeticExpression() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ArgumentContext(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(Cobol85Parser.LiteralContext,0) + + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def indexName(self): + return self.getTypedRuleContext(Cobol85Parser.IndexNameContext,0) + + + def arithmeticExpression(self): + return self.getTypedRuleContext(Cobol85Parser.ArithmeticExpressionContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_argument + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArgument" ): + listener.enterArgument(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArgument" ): + listener.exitArgument(self) + + + + + def argument(self): + + localctx = Cobol85Parser.ArgumentContext(self, self._ctx, self.state) + self.enterRule(localctx, 1088, self.RULE_argument) + try: + self.state = 6065 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,957,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 6054 + self.literal() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 6055 + self.identifier() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 6056 + self.qualifiedDataName() + self.state = 6058 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,955,self._ctx) + if la_ == 1: + self.state = 6057 + self.integerLiteral() + + + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 6060 + self.indexName() + self.state = 6062 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,956,self._ctx) + if la_ == 1: + self.state = 6061 + self.integerLiteral() + + + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 6064 + self.arithmeticExpression() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class QualifiedDataNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def qualifiedDataNameFormat1(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameFormat1Context,0) + + + def qualifiedDataNameFormat2(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameFormat2Context,0) + + + def qualifiedDataNameFormat3(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameFormat3Context,0) + + + def qualifiedDataNameFormat4(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameFormat4Context,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_qualifiedDataName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterQualifiedDataName" ): + listener.enterQualifiedDataName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitQualifiedDataName" ): + listener.exitQualifiedDataName(self) + + + + + def qualifiedDataName(self): + + localctx = Cobol85Parser.QualifiedDataNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1090, self.RULE_qualifiedDataName) + try: + self.state = 6071 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,958,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 6067 + self.qualifiedDataNameFormat1() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 6068 + self.qualifiedDataNameFormat2() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 6069 + self.qualifiedDataNameFormat3() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 6070 + self.qualifiedDataNameFormat4() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class QualifiedDataNameFormat1Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def conditionName(self): + return self.getTypedRuleContext(Cobol85Parser.ConditionNameContext,0) + + + def inFile(self): + return self.getTypedRuleContext(Cobol85Parser.InFileContext,0) + + + def qualifiedInData(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(Cobol85Parser.QualifiedInDataContext) + else: + return self.getTypedRuleContext(Cobol85Parser.QualifiedInDataContext,i) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_qualifiedDataNameFormat1 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterQualifiedDataNameFormat1" ): + listener.enterQualifiedDataNameFormat1(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitQualifiedDataNameFormat1" ): + listener.exitQualifiedDataNameFormat1(self) + + + + + def qualifiedDataNameFormat1(self): + + localctx = Cobol85Parser.QualifiedDataNameFormat1Context(self, self._ctx, self.state) + self.enterRule(localctx, 1092, self.RULE_qualifiedDataNameFormat1) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6075 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,959,self._ctx) + if la_ == 1: + self.state = 6073 + self.dataName() + pass + + elif la_ == 2: + self.state = 6074 + self.conditionName() + pass + + + self.state = 6086 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,962,self._ctx) + if la_ == 1: + self.state = 6078 + self._errHandler.sync(self) + _alt = 1 + while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER: + if _alt == 1: + self.state = 6077 + self.qualifiedInData() + + else: + raise NoViableAltException(self) + self.state = 6080 + self._errHandler.sync(self) + _alt = self._interp.adaptivePredict(self._input,960,self._ctx) + + self.state = 6083 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,961,self._ctx) + if la_ == 1: + self.state = 6082 + self.inFile() + + + + elif la_ == 2: + self.state = 6085 + self.inFile() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class QualifiedDataNameFormat2Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def paragraphName(self): + return self.getTypedRuleContext(Cobol85Parser.ParagraphNameContext,0) + + + def inSection(self): + return self.getTypedRuleContext(Cobol85Parser.InSectionContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_qualifiedDataNameFormat2 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterQualifiedDataNameFormat2" ): + listener.enterQualifiedDataNameFormat2(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitQualifiedDataNameFormat2" ): + listener.exitQualifiedDataNameFormat2(self) + + + + + def qualifiedDataNameFormat2(self): + + localctx = Cobol85Parser.QualifiedDataNameFormat2Context(self, self._ctx, self.state) + self.enterRule(localctx, 1094, self.RULE_qualifiedDataNameFormat2) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6088 + self.paragraphName() + self.state = 6089 + self.inSection() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class QualifiedDataNameFormat3Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def textName(self): + return self.getTypedRuleContext(Cobol85Parser.TextNameContext,0) + + + def inLibrary(self): + return self.getTypedRuleContext(Cobol85Parser.InLibraryContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_qualifiedDataNameFormat3 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterQualifiedDataNameFormat3" ): + listener.enterQualifiedDataNameFormat3(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitQualifiedDataNameFormat3" ): + listener.exitQualifiedDataNameFormat3(self) + + + + + def qualifiedDataNameFormat3(self): + + localctx = Cobol85Parser.QualifiedDataNameFormat3Context(self, self._ctx, self.state) + self.enterRule(localctx, 1096, self.RULE_qualifiedDataNameFormat3) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6091 + self.textName() + self.state = 6092 + self.inLibrary() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class QualifiedDataNameFormat4Context(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def LINAGE_COUNTER(self): + return self.getToken(Cobol85Parser.LINAGE_COUNTER, 0) + + def inFile(self): + return self.getTypedRuleContext(Cobol85Parser.InFileContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_qualifiedDataNameFormat4 + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterQualifiedDataNameFormat4" ): + listener.enterQualifiedDataNameFormat4(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitQualifiedDataNameFormat4" ): + listener.exitQualifiedDataNameFormat4(self) + + + + + def qualifiedDataNameFormat4(self): + + localctx = Cobol85Parser.QualifiedDataNameFormat4Context(self, self._ctx, self.state) + self.enterRule(localctx, 1098, self.RULE_qualifiedDataNameFormat4) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6094 + self.match(Cobol85Parser.LINAGE_COUNTER) + self.state = 6095 + self.inFile() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class QualifiedInDataContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def inData(self): + return self.getTypedRuleContext(Cobol85Parser.InDataContext,0) + + + def inTable(self): + return self.getTypedRuleContext(Cobol85Parser.InTableContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_qualifiedInData + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterQualifiedInData" ): + listener.enterQualifiedInData(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitQualifiedInData" ): + listener.exitQualifiedInData(self) + + + + + def qualifiedInData(self): + + localctx = Cobol85Parser.QualifiedInDataContext(self, self._ctx, self.state) + self.enterRule(localctx, 1100, self.RULE_qualifiedInData) + try: + self.state = 6099 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,963,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 6097 + self.inData() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 6098 + self.inTable() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InDataContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def IN(self): + return self.getToken(Cobol85Parser.IN, 0) + + def OF(self): + return self.getToken(Cobol85Parser.OF, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_inData + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInData" ): + listener.enterInData(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInData" ): + listener.exitInData(self) + + + + + def inData(self): + + localctx = Cobol85Parser.InDataContext(self, self._ctx, self.state) + self.enterRule(localctx, 1102, self.RULE_inData) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6101 + _la = self._input.LA(1) + if not(_la==239 or _la==323): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6102 + self.dataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InFileContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def fileName(self): + return self.getTypedRuleContext(Cobol85Parser.FileNameContext,0) + + + def IN(self): + return self.getToken(Cobol85Parser.IN, 0) + + def OF(self): + return self.getToken(Cobol85Parser.OF, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_inFile + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInFile" ): + listener.enterInFile(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInFile" ): + listener.exitInFile(self) + + + + + def inFile(self): + + localctx = Cobol85Parser.InFileContext(self, self._ctx, self.state) + self.enterRule(localctx, 1104, self.RULE_inFile) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6104 + _la = self._input.LA(1) + if not(_la==239 or _la==323): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6105 + self.fileName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InMnemonicContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def mnemonicName(self): + return self.getTypedRuleContext(Cobol85Parser.MnemonicNameContext,0) + + + def IN(self): + return self.getToken(Cobol85Parser.IN, 0) + + def OF(self): + return self.getToken(Cobol85Parser.OF, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_inMnemonic + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInMnemonic" ): + listener.enterInMnemonic(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInMnemonic" ): + listener.exitInMnemonic(self) + + + + + def inMnemonic(self): + + localctx = Cobol85Parser.InMnemonicContext(self, self._ctx, self.state) + self.enterRule(localctx, 1106, self.RULE_inMnemonic) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6107 + _la = self._input.LA(1) + if not(_la==239 or _la==323): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6108 + self.mnemonicName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InSectionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def sectionName(self): + return self.getTypedRuleContext(Cobol85Parser.SectionNameContext,0) + + + def IN(self): + return self.getToken(Cobol85Parser.IN, 0) + + def OF(self): + return self.getToken(Cobol85Parser.OF, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_inSection + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInSection" ): + listener.enterInSection(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInSection" ): + listener.exitInSection(self) + + + + + def inSection(self): + + localctx = Cobol85Parser.InSectionContext(self, self._ctx, self.state) + self.enterRule(localctx, 1108, self.RULE_inSection) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6110 + _la = self._input.LA(1) + if not(_la==239 or _la==323): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6111 + self.sectionName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InLibraryContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def libraryName(self): + return self.getTypedRuleContext(Cobol85Parser.LibraryNameContext,0) + + + def IN(self): + return self.getToken(Cobol85Parser.IN, 0) + + def OF(self): + return self.getToken(Cobol85Parser.OF, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_inLibrary + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInLibrary" ): + listener.enterInLibrary(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInLibrary" ): + listener.exitInLibrary(self) + + + + + def inLibrary(self): + + localctx = Cobol85Parser.InLibraryContext(self, self._ctx, self.state) + self.enterRule(localctx, 1110, self.RULE_inLibrary) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6113 + _la = self._input.LA(1) + if not(_la==239 or _la==323): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6114 + self.libraryName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class InTableContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def tableCall(self): + return self.getTypedRuleContext(Cobol85Parser.TableCallContext,0) + + + def IN(self): + return self.getToken(Cobol85Parser.IN, 0) + + def OF(self): + return self.getToken(Cobol85Parser.OF, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_inTable + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInTable" ): + listener.enterInTable(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInTable" ): + listener.exitInTable(self) + + + + + def inTable(self): + + localctx = Cobol85Parser.InTableContext(self, self._ctx, self.state) + self.enterRule(localctx, 1112, self.RULE_inTable) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6116 + _la = self._input.LA(1) + if not(_la==239 or _la==323): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + self.state = 6117 + self.tableCall() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AlphabetNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_alphabetName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAlphabetName" ): + listener.enterAlphabetName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAlphabetName" ): + listener.exitAlphabetName(self) + + + + + def alphabetName(self): + + localctx = Cobol85Parser.AlphabetNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1114, self.RULE_alphabetName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6119 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class AssignmentNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def systemName(self): + return self.getTypedRuleContext(Cobol85Parser.SystemNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_assignmentName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAssignmentName" ): + listener.enterAssignmentName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAssignmentName" ): + listener.exitAssignmentName(self) + + + + + def assignmentName(self): + + localctx = Cobol85Parser.AssignmentNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1116, self.RULE_assignmentName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6121 + self.systemName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class BasisNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def programName(self): + return self.getTypedRuleContext(Cobol85Parser.ProgramNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_basisName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBasisName" ): + listener.enterBasisName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBasisName" ): + listener.exitBasisName(self) + + + + + def basisName(self): + + localctx = Cobol85Parser.BasisNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1118, self.RULE_basisName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6123 + self.programName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CdNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_cdName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCdName" ): + listener.enterCdName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCdName" ): + listener.exitCdName(self) + + + + + def cdName(self): + + localctx = Cobol85Parser.CdNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1120, self.RULE_cdName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6125 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ClassNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_className + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterClassName" ): + listener.enterClassName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitClassName" ): + listener.exitClassName(self) + + + + + def className(self): + + localctx = Cobol85Parser.ClassNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1122, self.RULE_className) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6127 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ComputerNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def systemName(self): + return self.getTypedRuleContext(Cobol85Parser.SystemNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_computerName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterComputerName" ): + listener.enterComputerName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitComputerName" ): + listener.exitComputerName(self) + + + + + def computerName(self): + + localctx = Cobol85Parser.ComputerNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1124, self.RULE_computerName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6129 + self.systemName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ConditionNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_conditionName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterConditionName" ): + listener.enterConditionName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitConditionName" ): + listener.exitConditionName(self) + + + + + def conditionName(self): + + localctx = Cobol85Parser.ConditionNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1126, self.RULE_conditionName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6131 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataName" ): + listener.enterDataName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataName" ): + listener.exitDataName(self) + + + + + def dataName(self): + + localctx = Cobol85Parser.DataNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1128, self.RULE_dataName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6133 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DataDescNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def FILLER(self): + return self.getToken(Cobol85Parser.FILLER, 0) + + def CURSOR(self): + return self.getToken(Cobol85Parser.CURSOR, 0) + + def dataName(self): + return self.getTypedRuleContext(Cobol85Parser.DataNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_dataDescName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDataDescName" ): + listener.enterDataDescName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDataDescName" ): + listener.exitDataDescName(self) + + + + + def dataDescName(self): + + localctx = Cobol85Parser.DataDescNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1130, self.RULE_dataDescName) + try: + self.state = 6138 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,964,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 6135 + self.match(Cobol85Parser.FILLER) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 6136 + self.match(Cobol85Parser.CURSOR) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 6137 + self.dataName() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class EnvironmentNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def systemName(self): + return self.getTypedRuleContext(Cobol85Parser.SystemNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_environmentName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEnvironmentName" ): + listener.enterEnvironmentName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEnvironmentName" ): + listener.exitEnvironmentName(self) + + + + + def environmentName(self): + + localctx = Cobol85Parser.EnvironmentNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1132, self.RULE_environmentName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6140 + self.systemName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class FileNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_fileName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFileName" ): + listener.enterFileName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFileName" ): + listener.exitFileName(self) + + + + + def fileName(self): + + localctx = Cobol85Parser.FileNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1134, self.RULE_fileName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6142 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class FunctionNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTEGER(self): + return self.getToken(Cobol85Parser.INTEGER, 0) + + def LENGTH(self): + return self.getToken(Cobol85Parser.LENGTH, 0) + + def RANDOM(self): + return self.getToken(Cobol85Parser.RANDOM, 0) + + def SUM(self): + return self.getToken(Cobol85Parser.SUM, 0) + + def WHEN_COMPILED(self): + return self.getToken(Cobol85Parser.WHEN_COMPILED, 0) + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_functionName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunctionName" ): + listener.enterFunctionName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunctionName" ): + listener.exitFunctionName(self) + + + + + def functionName(self): + + localctx = Cobol85Parser.FunctionNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1136, self.RULE_functionName) + try: + self.state = 6150 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,965,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 6144 + self.match(Cobol85Parser.INTEGER) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 6145 + self.match(Cobol85Parser.LENGTH) + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 6146 + self.match(Cobol85Parser.RANDOM) + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 6147 + self.match(Cobol85Parser.SUM) + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 6148 + self.match(Cobol85Parser.WHEN_COMPILED) + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 6149 + self.cobolWord() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IndexNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_indexName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIndexName" ): + listener.enterIndexName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIndexName" ): + listener.exitIndexName(self) + + + + + def indexName(self): + + localctx = Cobol85Parser.IndexNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1138, self.RULE_indexName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6152 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LanguageNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def systemName(self): + return self.getTypedRuleContext(Cobol85Parser.SystemNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_languageName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLanguageName" ): + listener.enterLanguageName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLanguageName" ): + listener.exitLanguageName(self) + + + + + def languageName(self): + + localctx = Cobol85Parser.LanguageNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1140, self.RULE_languageName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6154 + self.systemName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LibraryNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_libraryName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLibraryName" ): + listener.enterLibraryName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLibraryName" ): + listener.exitLibraryName(self) + + + + + def libraryName(self): + + localctx = Cobol85Parser.LibraryNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1142, self.RULE_libraryName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6156 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class LocalNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_localName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterLocalName" ): + listener.enterLocalName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitLocalName" ): + listener.exitLocalName(self) + + + + + def localName(self): + + localctx = Cobol85Parser.LocalNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1144, self.RULE_localName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6158 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class MnemonicNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_mnemonicName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMnemonicName" ): + listener.enterMnemonicName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMnemonicName" ): + listener.exitMnemonicName(self) + + + + + def mnemonicName(self): + + localctx = Cobol85Parser.MnemonicNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1146, self.RULE_mnemonicName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6160 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ParagraphNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_paragraphName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterParagraphName" ): + listener.enterParagraphName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitParagraphName" ): + listener.exitParagraphName(self) + + + + + def paragraphName(self): + + localctx = Cobol85Parser.ParagraphNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1148, self.RULE_paragraphName) + try: + self.state = 6164 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.enterOuterAlt(localctx, 1) + self.state = 6162 + self.cobolWord() + pass + elif token in [552, 553, 554, 555]: + self.enterOuterAlt(localctx, 2) + self.state = 6163 + self.integerLiteral() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ProcedureNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def paragraphName(self): + return self.getTypedRuleContext(Cobol85Parser.ParagraphNameContext,0) + + + def inSection(self): + return self.getTypedRuleContext(Cobol85Parser.InSectionContext,0) + + + def sectionName(self): + return self.getTypedRuleContext(Cobol85Parser.SectionNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_procedureName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProcedureName" ): + listener.enterProcedureName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProcedureName" ): + listener.exitProcedureName(self) + + + + + def procedureName(self): + + localctx = Cobol85Parser.ProcedureNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1150, self.RULE_procedureName) + self._la = 0 # Token type + try: + self.state = 6171 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,968,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 6166 + self.paragraphName() + self.state = 6168 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==239 or _la==323: + self.state = 6167 + self.inSection() + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 6170 + self.sectionName() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ProgramNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NONNUMERICLITERAL(self): + return self.getToken(Cobol85Parser.NONNUMERICLITERAL, 0) + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_programName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterProgramName" ): + listener.enterProgramName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitProgramName" ): + listener.exitProgramName(self) + + + + + def programName(self): + + localctx = Cobol85Parser.ProgramNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1152, self.RULE_programName) + try: + self.state = 6175 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [551]: + self.enterOuterAlt(localctx, 1) + self.state = 6173 + self.match(Cobol85Parser.NONNUMERICLITERAL) + pass + elif token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.enterOuterAlt(localctx, 2) + self.state = 6174 + self.cobolWord() + 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 RecordNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_recordName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRecordName" ): + listener.enterRecordName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRecordName" ): + listener.exitRecordName(self) + + + + + def recordName(self): + + localctx = Cobol85Parser.RecordNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1154, self.RULE_recordName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6177 + self.qualifiedDataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ReportNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def qualifiedDataName(self): + return self.getTypedRuleContext(Cobol85Parser.QualifiedDataNameContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_reportName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterReportName" ): + listener.enterReportName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitReportName" ): + listener.exitReportName(self) + + + + + def reportName(self): + + localctx = Cobol85Parser.ReportNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1156, self.RULE_reportName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6179 + self.qualifiedDataName() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class RoutineNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_routineName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRoutineName" ): + listener.enterRoutineName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRoutineName" ): + listener.exitRoutineName(self) + + + + + def routineName(self): + + localctx = Cobol85Parser.RoutineNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1158, self.RULE_routineName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6181 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScreenNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_screenName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScreenName" ): + listener.enterScreenName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScreenName" ): + listener.exitScreenName(self) + + + + + def screenName(self): + + localctx = Cobol85Parser.ScreenNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1160, self.RULE_screenName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6183 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SectionNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_sectionName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSectionName" ): + listener.enterSectionName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSectionName" ): + listener.exitSectionName(self) + + + + + def sectionName(self): + + localctx = Cobol85Parser.SectionNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1162, self.RULE_sectionName) + try: + self.state = 6187 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [1, 24, 26, 28, 29, 31, 33, 34, 35, 36, 38, 41, 42, 43, 45, 47, 54, 55, 60, 61, 68, 69, 77, 98, 100, 106, 108, 128, 129, 130, 138, 139, 141, 146, 147, 151, 156, 181, 183, 187, 189, 190, 191, 194, 197, 200, 202, 213, 214, 216, 218, 219, 226, 229, 237, 238, 250, 258, 260, 262, 264, 265, 268, 270, 272, 273, 274, 283, 284, 287, 288, 289, 290, 296, 303, 304, 305, 308, 311, 317, 319, 322, 331, 336, 337, 342, 352, 353, 355, 360, 361, 364, 370, 371, 373, 376, 380, 383, 391, 398, 401, 415, 420, 431, 432, 433, 434, 437, 466, 473, 481, 482, 486, 490, 491, 495, 497, 498, 510, 511, 518, 519, 520, 522, 557]: + self.enterOuterAlt(localctx, 1) + self.state = 6185 + self.cobolWord() + pass + elif token in [552, 553, 554, 555]: + self.enterOuterAlt(localctx, 2) + self.state = 6186 + self.integerLiteral() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SystemNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_systemName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSystemName" ): + listener.enterSystemName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSystemName" ): + listener.exitSystemName(self) + + + + + def systemName(self): + + localctx = Cobol85Parser.SystemNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1164, self.RULE_systemName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6189 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SymbolicCharacterContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_symbolicCharacter + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSymbolicCharacter" ): + listener.enterSymbolicCharacter(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSymbolicCharacter" ): + listener.exitSymbolicCharacter(self) + + + + + def symbolicCharacter(self): + + localctx = Cobol85Parser.SymbolicCharacterContext(self, self._ctx, self.state) + self.enterRule(localctx, 1166, self.RULE_symbolicCharacter) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6191 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TextNameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_textName + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTextName" ): + listener.enterTextName(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTextName" ): + listener.exitTextName(self) + + + + + def textName(self): + + localctx = Cobol85Parser.TextNameContext(self, self._ctx, self.state) + self.enterRule(localctx, 1168, self.RULE_textName) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6193 + self.cobolWord() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CobolWordContext(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(Cobol85Parser.IDENTIFIER, 0) + + def COBOL(self): + return self.getToken(Cobol85Parser.COBOL, 0) + + def PROGRAM(self): + return self.getToken(Cobol85Parser.PROGRAM, 0) + + def ABORT(self): + return self.getToken(Cobol85Parser.ABORT, 0) + + def AS(self): + return self.getToken(Cobol85Parser.AS, 0) + + def ASCII(self): + return self.getToken(Cobol85Parser.ASCII, 0) + + def ASSOCIATED_DATA(self): + return self.getToken(Cobol85Parser.ASSOCIATED_DATA, 0) + + def ASSOCIATED_DATA_LENGTH(self): + return self.getToken(Cobol85Parser.ASSOCIATED_DATA_LENGTH, 0) + + def ATTRIBUTE(self): + return self.getToken(Cobol85Parser.ATTRIBUTE, 0) + + def AUTO(self): + return self.getToken(Cobol85Parser.AUTO, 0) + + def AUTO_SKIP(self): + return self.getToken(Cobol85Parser.AUTO_SKIP, 0) + + def BACKGROUND_COLOR(self): + return self.getToken(Cobol85Parser.BACKGROUND_COLOR, 0) + + def BACKGROUND_COLOUR(self): + return self.getToken(Cobol85Parser.BACKGROUND_COLOUR, 0) + + def BEEP(self): + return self.getToken(Cobol85Parser.BEEP, 0) + + def BELL(self): + return self.getToken(Cobol85Parser.BELL, 0) + + def BINARY(self): + return self.getToken(Cobol85Parser.BINARY, 0) + + def BIT(self): + return self.getToken(Cobol85Parser.BIT, 0) + + def BLINK(self): + return self.getToken(Cobol85Parser.BLINK, 0) + + def BOUNDS(self): + return self.getToken(Cobol85Parser.BOUNDS, 0) + + def CAPABLE(self): + return self.getToken(Cobol85Parser.CAPABLE, 0) + + def CCSVERSION(self): + return self.getToken(Cobol85Parser.CCSVERSION, 0) + + def CHANGED(self): + return self.getToken(Cobol85Parser.CHANGED, 0) + + def CHANNEL(self): + return self.getToken(Cobol85Parser.CHANNEL, 0) + + def CLOSE_DISPOSITION(self): + return self.getToken(Cobol85Parser.CLOSE_DISPOSITION, 0) + + def COMMITMENT(self): + return self.getToken(Cobol85Parser.COMMITMENT, 0) + + def CONTROL_POINT(self): + return self.getToken(Cobol85Parser.CONTROL_POINT, 0) + + def CONVENTION(self): + return self.getToken(Cobol85Parser.CONVENTION, 0) + + def CRUNCH(self): + return self.getToken(Cobol85Parser.CRUNCH, 0) + + def CURSOR(self): + return self.getToken(Cobol85Parser.CURSOR, 0) + + def DEFAULT(self): + return self.getToken(Cobol85Parser.DEFAULT, 0) + + def DEFAULT_DISPLAY(self): + return self.getToken(Cobol85Parser.DEFAULT_DISPLAY, 0) + + def DEFINITION(self): + return self.getToken(Cobol85Parser.DEFINITION, 0) + + def DFHRESP(self): + return self.getToken(Cobol85Parser.DFHRESP, 0) + + def DFHVALUE(self): + return self.getToken(Cobol85Parser.DFHVALUE, 0) + + def DISK(self): + return self.getToken(Cobol85Parser.DISK, 0) + + def DONTCARE(self): + return self.getToken(Cobol85Parser.DONTCARE, 0) + + def DOUBLE(self): + return self.getToken(Cobol85Parser.DOUBLE, 0) + + def EBCDIC(self): + return self.getToken(Cobol85Parser.EBCDIC, 0) + + def EMPTY_CHECK(self): + return self.getToken(Cobol85Parser.EMPTY_CHECK, 0) + + def ENTER(self): + return self.getToken(Cobol85Parser.ENTER, 0) + + def ENTRY_PROCEDURE(self): + return self.getToken(Cobol85Parser.ENTRY_PROCEDURE, 0) + + def EOL(self): + return self.getToken(Cobol85Parser.EOL, 0) + + def EOS(self): + return self.getToken(Cobol85Parser.EOS, 0) + + def ERASE(self): + return self.getToken(Cobol85Parser.ERASE, 0) + + def ESCAPE(self): + return self.getToken(Cobol85Parser.ESCAPE, 0) + + def EVENT(self): + return self.getToken(Cobol85Parser.EVENT, 0) + + def EXCLUSIVE(self): + return self.getToken(Cobol85Parser.EXCLUSIVE, 0) + + def EXPORT(self): + return self.getToken(Cobol85Parser.EXPORT, 0) + + def EXTENDED(self): + return self.getToken(Cobol85Parser.EXTENDED, 0) + + def FOREGROUND_COLOR(self): + return self.getToken(Cobol85Parser.FOREGROUND_COLOR, 0) + + def FOREGROUND_COLOUR(self): + return self.getToken(Cobol85Parser.FOREGROUND_COLOUR, 0) + + def FULL(self): + return self.getToken(Cobol85Parser.FULL, 0) + + def FUNCTIONNAME(self): + return self.getToken(Cobol85Parser.FUNCTIONNAME, 0) + + def FUNCTION_POINTER(self): + return self.getToken(Cobol85Parser.FUNCTION_POINTER, 0) + + def GRID(self): + return self.getToken(Cobol85Parser.GRID, 0) + + def HIGHLIGHT(self): + return self.getToken(Cobol85Parser.HIGHLIGHT, 0) + + def IMPLICIT(self): + return self.getToken(Cobol85Parser.IMPLICIT, 0) + + def IMPORT(self): + return self.getToken(Cobol85Parser.IMPORT, 0) + + def INTEGER(self): + return self.getToken(Cobol85Parser.INTEGER, 0) + + def KEPT(self): + return self.getToken(Cobol85Parser.KEPT, 0) + + def KEYBOARD(self): + return self.getToken(Cobol85Parser.KEYBOARD, 0) + + def LANGUAGE(self): + return self.getToken(Cobol85Parser.LANGUAGE, 0) + + def LB(self): + return self.getToken(Cobol85Parser.LB, 0) + + def LD(self): + return self.getToken(Cobol85Parser.LD, 0) + + def LEFTLINE(self): + return self.getToken(Cobol85Parser.LEFTLINE, 0) + + def LENGTH_CHECK(self): + return self.getToken(Cobol85Parser.LENGTH_CHECK, 0) + + def LIBACCESS(self): + return self.getToken(Cobol85Parser.LIBACCESS, 0) + + def LIBPARAMETER(self): + return self.getToken(Cobol85Parser.LIBPARAMETER, 0) + + def LIBRARY(self): + return self.getToken(Cobol85Parser.LIBRARY, 0) + + def LIST(self): + return self.getToken(Cobol85Parser.LIST, 0) + + def LOCAL(self): + return self.getToken(Cobol85Parser.LOCAL, 0) + + def LONG_DATE(self): + return self.getToken(Cobol85Parser.LONG_DATE, 0) + + def LONG_TIME(self): + return self.getToken(Cobol85Parser.LONG_TIME, 0) + + def LOWER(self): + return self.getToken(Cobol85Parser.LOWER, 0) + + def LOWLIGHT(self): + return self.getToken(Cobol85Parser.LOWLIGHT, 0) + + def MMDDYYYY(self): + return self.getToken(Cobol85Parser.MMDDYYYY, 0) + + def NAMED(self): + return self.getToken(Cobol85Parser.NAMED, 0) + + def NATIONAL(self): + return self.getToken(Cobol85Parser.NATIONAL, 0) + + def NATIONAL_EDITED(self): + return self.getToken(Cobol85Parser.NATIONAL_EDITED, 0) + + def NETWORK(self): + return self.getToken(Cobol85Parser.NETWORK, 0) + + def NO_ECHO(self): + return self.getToken(Cobol85Parser.NO_ECHO, 0) + + def NUMERIC_DATE(self): + return self.getToken(Cobol85Parser.NUMERIC_DATE, 0) + + def NUMERIC_TIME(self): + return self.getToken(Cobol85Parser.NUMERIC_TIME, 0) + + def ODT(self): + return self.getToken(Cobol85Parser.ODT, 0) + + def ORDERLY(self): + return self.getToken(Cobol85Parser.ORDERLY, 0) + + def OVERLINE(self): + return self.getToken(Cobol85Parser.OVERLINE, 0) + + def OWN(self): + return self.getToken(Cobol85Parser.OWN, 0) + + def PASSWORD(self): + return self.getToken(Cobol85Parser.PASSWORD, 0) + + def PORT(self): + return self.getToken(Cobol85Parser.PORT, 0) + + def PRINTER(self): + return self.getToken(Cobol85Parser.PRINTER, 0) + + def PRIVATE(self): + return self.getToken(Cobol85Parser.PRIVATE, 0) + + def PROCESS(self): + return self.getToken(Cobol85Parser.PROCESS, 0) + + def PROMPT(self): + return self.getToken(Cobol85Parser.PROMPT, 0) + + def READER(self): + return self.getToken(Cobol85Parser.READER, 0) + + def REAL(self): + return self.getToken(Cobol85Parser.REAL, 0) + + def RECEIVED(self): + return self.getToken(Cobol85Parser.RECEIVED, 0) + + def RECURSIVE(self): + return self.getToken(Cobol85Parser.RECURSIVE, 0) + + def REF(self): + return self.getToken(Cobol85Parser.REF, 0) + + def REMOTE(self): + return self.getToken(Cobol85Parser.REMOTE, 0) + + def REMOVE(self): + return self.getToken(Cobol85Parser.REMOVE, 0) + + def REQUIRED(self): + return self.getToken(Cobol85Parser.REQUIRED, 0) + + def REVERSE_VIDEO(self): + return self.getToken(Cobol85Parser.REVERSE_VIDEO, 0) + + def SAVE(self): + return self.getToken(Cobol85Parser.SAVE, 0) + + def SECURE(self): + return self.getToken(Cobol85Parser.SECURE, 0) + + def SHARED(self): + return self.getToken(Cobol85Parser.SHARED, 0) + + def SHAREDBYALL(self): + return self.getToken(Cobol85Parser.SHAREDBYALL, 0) + + def SHAREDBYRUNUNIT(self): + return self.getToken(Cobol85Parser.SHAREDBYRUNUNIT, 0) + + def SHARING(self): + return self.getToken(Cobol85Parser.SHARING, 0) + + def SHORT_DATE(self): + return self.getToken(Cobol85Parser.SHORT_DATE, 0) + + def SYMBOL(self): + return self.getToken(Cobol85Parser.SYMBOL, 0) + + def TASK(self): + return self.getToken(Cobol85Parser.TASK, 0) + + def THREAD(self): + return self.getToken(Cobol85Parser.THREAD, 0) + + def THREAD_LOCAL(self): + return self.getToken(Cobol85Parser.THREAD_LOCAL, 0) + + def TIMER(self): + return self.getToken(Cobol85Parser.TIMER, 0) + + def TODAYS_DATE(self): + return self.getToken(Cobol85Parser.TODAYS_DATE, 0) + + def TODAYS_NAME(self): + return self.getToken(Cobol85Parser.TODAYS_NAME, 0) + + def TRUNCATED(self): + return self.getToken(Cobol85Parser.TRUNCATED, 0) + + def TYPEDEF(self): + return self.getToken(Cobol85Parser.TYPEDEF, 0) + + def UNDERLINE(self): + return self.getToken(Cobol85Parser.UNDERLINE, 0) + + def VIRTUAL(self): + return self.getToken(Cobol85Parser.VIRTUAL, 0) + + def WAIT(self): + return self.getToken(Cobol85Parser.WAIT, 0) + + def YEAR(self): + return self.getToken(Cobol85Parser.YEAR, 0) + + def YYYYMMDD(self): + return self.getToken(Cobol85Parser.YYYYMMDD, 0) + + def YYYYDDD(self): + return self.getToken(Cobol85Parser.YYYYDDD, 0) + + def ZERO_FILL(self): + return self.getToken(Cobol85Parser.ZERO_FILL, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_cobolWord + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCobolWord" ): + listener.enterCobolWord(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCobolWord" ): + listener.exitCobolWord(self) + + + + + def cobolWord(self): + + localctx = Cobol85Parser.CobolWordContext(self, self._ctx, self.state) + self.enterRule(localctx, 1170, self.RULE_cobolWord) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6195 + _la = self._input.LA(1) + if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 3512999431135821826) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & 8070451912006173187) != 0) or ((((_la - 138)) & ~0x3f) == 0 and ((1 << (_la - 138)) & 5276573893883339531) != 0) or ((((_la - 202)) & ~0x3f) == 0 and ((1 << (_la - 202)) & -3098194965423761407) != 0) or ((((_la - 268)) & ~0x3f) == 0 and ((1 << (_la - 268)) & -9202532752178970507) != 0) or ((((_la - 336)) & ~0x3f) == 0 and ((1 << (_la - 336)) & 4647874433930428483) != 0) or ((((_la - 401)) & ~0x3f) == 0 and ((1 << (_la - 401)) & 84826144769) != 0) or ((((_la - 466)) & ~0x3f) == 0 and ((1 << (_la - 466)) & 103635575018455169) != 0) or _la==557): + 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 LiteralContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NONNUMERICLITERAL(self): + return self.getToken(Cobol85Parser.NONNUMERICLITERAL, 0) + + def figurativeConstant(self): + return self.getTypedRuleContext(Cobol85Parser.FigurativeConstantContext,0) + + + def numericLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.NumericLiteralContext,0) + + + def booleanLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.BooleanLiteralContext,0) + + + def cicsDfhRespLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.CicsDfhRespLiteralContext,0) + + + def cicsDfhValueLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.CicsDfhValueLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.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 = Cobol85Parser.LiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 1172, self.RULE_literal) + try: + self.state = 6203 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,971,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 6197 + self.match(Cobol85Parser.NONNUMERICLITERAL) + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 6198 + self.figurativeConstant() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 6199 + self.numericLiteral() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 6200 + self.booleanLiteral() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 6201 + self.cicsDfhRespLiteral() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 6202 + self.cicsDfhValueLiteral() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class BooleanLiteralContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TRUE(self): + return self.getToken(Cobol85Parser.TRUE, 0) + + def FALSE(self): + return self.getToken(Cobol85Parser.FALSE, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_booleanLiteral + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBooleanLiteral" ): + listener.enterBooleanLiteral(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBooleanLiteral" ): + listener.exitBooleanLiteral(self) + + + + + def booleanLiteral(self): + + localctx = Cobol85Parser.BooleanLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 1174, self.RULE_booleanLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6205 + _la = self._input.LA(1) + if not(_la==204 or _la==494): + 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 NumericLiteralContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NUMERICLITERAL(self): + return self.getToken(Cobol85Parser.NUMERICLITERAL, 0) + + def ZERO(self): + return self.getToken(Cobol85Parser.ZERO, 0) + + def integerLiteral(self): + return self.getTypedRuleContext(Cobol85Parser.IntegerLiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_numericLiteral + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNumericLiteral" ): + listener.enterNumericLiteral(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNumericLiteral" ): + listener.exitNumericLiteral(self) + + + + + def numericLiteral(self): + + localctx = Cobol85Parser.NumericLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 1176, self.RULE_numericLiteral) + try: + self.state = 6210 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [556]: + self.enterOuterAlt(localctx, 1) + self.state = 6207 + self.match(Cobol85Parser.NUMERICLITERAL) + pass + elif token in [521]: + self.enterOuterAlt(localctx, 2) + self.state = 6208 + self.match(Cobol85Parser.ZERO) + pass + elif token in [552, 553, 554, 555]: + self.enterOuterAlt(localctx, 3) + self.state = 6209 + self.integerLiteral() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IntegerLiteralContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTEGERLITERAL(self): + return self.getToken(Cobol85Parser.INTEGERLITERAL, 0) + + def LEVEL_NUMBER_66(self): + return self.getToken(Cobol85Parser.LEVEL_NUMBER_66, 0) + + def LEVEL_NUMBER_77(self): + return self.getToken(Cobol85Parser.LEVEL_NUMBER_77, 0) + + def LEVEL_NUMBER_88(self): + return self.getToken(Cobol85Parser.LEVEL_NUMBER_88, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_integerLiteral + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntegerLiteral" ): + listener.enterIntegerLiteral(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntegerLiteral" ): + listener.exitIntegerLiteral(self) + + + + + def integerLiteral(self): + + localctx = Cobol85Parser.IntegerLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 1178, self.RULE_integerLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6212 + _la = self._input.LA(1) + if not(((((_la - 552)) & ~0x3f) == 0 and ((1 << (_la - 552)) & 15) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CicsDfhRespLiteralContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DFHRESP(self): + return self.getToken(Cobol85Parser.DFHRESP, 0) + + def LPARENCHAR(self): + return self.getToken(Cobol85Parser.LPARENCHAR, 0) + + def RPARENCHAR(self): + return self.getToken(Cobol85Parser.RPARENCHAR, 0) + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_cicsDfhRespLiteral + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCicsDfhRespLiteral" ): + listener.enterCicsDfhRespLiteral(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCicsDfhRespLiteral" ): + listener.exitCicsDfhRespLiteral(self) + + + + + def cicsDfhRespLiteral(self): + + localctx = Cobol85Parser.CicsDfhRespLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 1180, self.RULE_cicsDfhRespLiteral) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6214 + self.match(Cobol85Parser.DFHRESP) + self.state = 6215 + self.match(Cobol85Parser.LPARENCHAR) + self.state = 6218 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,973,self._ctx) + if la_ == 1: + self.state = 6216 + self.cobolWord() + pass + + elif la_ == 2: + self.state = 6217 + self.literal() + pass + + + self.state = 6220 + self.match(Cobol85Parser.RPARENCHAR) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class CicsDfhValueLiteralContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DFHVALUE(self): + return self.getToken(Cobol85Parser.DFHVALUE, 0) + + def LPARENCHAR(self): + return self.getToken(Cobol85Parser.LPARENCHAR, 0) + + def RPARENCHAR(self): + return self.getToken(Cobol85Parser.RPARENCHAR, 0) + + def cobolWord(self): + return self.getTypedRuleContext(Cobol85Parser.CobolWordContext,0) + + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def getRuleIndex(self): + return Cobol85Parser.RULE_cicsDfhValueLiteral + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCicsDfhValueLiteral" ): + listener.enterCicsDfhValueLiteral(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCicsDfhValueLiteral" ): + listener.exitCicsDfhValueLiteral(self) + + + + + def cicsDfhValueLiteral(self): + + localctx = Cobol85Parser.CicsDfhValueLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 1182, self.RULE_cicsDfhValueLiteral) + try: + self.enterOuterAlt(localctx, 1) + self.state = 6222 + self.match(Cobol85Parser.DFHVALUE) + self.state = 6223 + self.match(Cobol85Parser.LPARENCHAR) + self.state = 6226 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,974,self._ctx) + if la_ == 1: + self.state = 6224 + self.cobolWord() + pass + + elif la_ == 2: + self.state = 6225 + self.literal() + pass + + + self.state = 6228 + self.match(Cobol85Parser.RPARENCHAR) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class FigurativeConstantContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ALL(self): + return self.getToken(Cobol85Parser.ALL, 0) + + def literal(self): + return self.getTypedRuleContext(Cobol85Parser.LiteralContext,0) + + + def HIGH_VALUE(self): + return self.getToken(Cobol85Parser.HIGH_VALUE, 0) + + def HIGH_VALUES(self): + return self.getToken(Cobol85Parser.HIGH_VALUES, 0) + + def LOW_VALUE(self): + return self.getToken(Cobol85Parser.LOW_VALUE, 0) + + def LOW_VALUES(self): + return self.getToken(Cobol85Parser.LOW_VALUES, 0) + + def NULL_(self): + return self.getToken(Cobol85Parser.NULL_, 0) + + def NULLS(self): + return self.getToken(Cobol85Parser.NULLS, 0) + + def QUOTE(self): + return self.getToken(Cobol85Parser.QUOTE, 0) + + def QUOTES(self): + return self.getToken(Cobol85Parser.QUOTES, 0) + + def SPACE(self): + return self.getToken(Cobol85Parser.SPACE, 0) + + def SPACES(self): + return self.getToken(Cobol85Parser.SPACES, 0) + + def ZERO(self): + return self.getToken(Cobol85Parser.ZERO, 0) + + def ZEROS(self): + return self.getToken(Cobol85Parser.ZEROS, 0) + + def ZEROES(self): + return self.getToken(Cobol85Parser.ZEROES, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_figurativeConstant + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFigurativeConstant" ): + listener.enterFigurativeConstant(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFigurativeConstant" ): + listener.exitFigurativeConstant(self) + + + + + def figurativeConstant(self): + + localctx = Cobol85Parser.FigurativeConstantContext(self, self._ctx, self.state) + self.enterRule(localctx, 1184, self.RULE_figurativeConstant) + try: + self.state = 6245 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [9]: + self.enterOuterAlt(localctx, 1) + self.state = 6230 + self.match(Cobol85Parser.ALL) + self.state = 6231 + self.literal() + pass + elif token in [230]: + self.enterOuterAlt(localctx, 2) + self.state = 6232 + self.match(Cobol85Parser.HIGH_VALUE) + pass + elif token in [231]: + self.enterOuterAlt(localctx, 3) + self.state = 6233 + self.match(Cobol85Parser.HIGH_VALUES) + pass + elif token in [291]: + self.enterOuterAlt(localctx, 4) + self.state = 6234 + self.match(Cobol85Parser.LOW_VALUE) + pass + elif token in [292]: + self.enterOuterAlt(localctx, 5) + self.state = 6235 + self.match(Cobol85Parser.LOW_VALUES) + pass + elif token in [313]: + self.enterOuterAlt(localctx, 6) + self.state = 6236 + self.match(Cobol85Parser.NULL_) + pass + elif token in [314]: + self.enterOuterAlt(localctx, 7) + self.state = 6237 + self.match(Cobol85Parser.NULLS) + pass + elif token in [367]: + self.enterOuterAlt(localctx, 8) + self.state = 6238 + self.match(Cobol85Parser.QUOTE) + pass + elif token in [368]: + self.enterOuterAlt(localctx, 9) + self.state = 6239 + self.match(Cobol85Parser.QUOTES) + pass + elif token in [450]: + self.enterOuterAlt(localctx, 10) + self.state = 6240 + self.match(Cobol85Parser.SPACE) + pass + elif token in [451]: + self.enterOuterAlt(localctx, 11) + self.state = 6241 + self.match(Cobol85Parser.SPACES) + pass + elif token in [521]: + self.enterOuterAlt(localctx, 12) + self.state = 6242 + self.match(Cobol85Parser.ZERO) + pass + elif token in [523]: + self.enterOuterAlt(localctx, 13) + self.state = 6243 + self.match(Cobol85Parser.ZEROS) + pass + elif token in [524]: + self.enterOuterAlt(localctx, 14) + self.state = 6244 + self.match(Cobol85Parser.ZEROES) + 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 SpecialRegisterContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ADDRESS(self): + return self.getToken(Cobol85Parser.ADDRESS, 0) + + def OF(self): + return self.getToken(Cobol85Parser.OF, 0) + + def identifier(self): + return self.getTypedRuleContext(Cobol85Parser.IdentifierContext,0) + + + def DATE(self): + return self.getToken(Cobol85Parser.DATE, 0) + + def DAY(self): + return self.getToken(Cobol85Parser.DAY, 0) + + def DAY_OF_WEEK(self): + return self.getToken(Cobol85Parser.DAY_OF_WEEK, 0) + + def DEBUG_CONTENTS(self): + return self.getToken(Cobol85Parser.DEBUG_CONTENTS, 0) + + def DEBUG_ITEM(self): + return self.getToken(Cobol85Parser.DEBUG_ITEM, 0) + + def DEBUG_LINE(self): + return self.getToken(Cobol85Parser.DEBUG_LINE, 0) + + def DEBUG_NAME(self): + return self.getToken(Cobol85Parser.DEBUG_NAME, 0) + + def DEBUG_SUB_1(self): + return self.getToken(Cobol85Parser.DEBUG_SUB_1, 0) + + def DEBUG_SUB_2(self): + return self.getToken(Cobol85Parser.DEBUG_SUB_2, 0) + + def DEBUG_SUB_3(self): + return self.getToken(Cobol85Parser.DEBUG_SUB_3, 0) + + def LENGTH(self): + return self.getToken(Cobol85Parser.LENGTH, 0) + + def LINAGE_COUNTER(self): + return self.getToken(Cobol85Parser.LINAGE_COUNTER, 0) + + def LINE_COUNTER(self): + return self.getToken(Cobol85Parser.LINE_COUNTER, 0) + + def PAGE_COUNTER(self): + return self.getToken(Cobol85Parser.PAGE_COUNTER, 0) + + def RETURN_CODE(self): + return self.getToken(Cobol85Parser.RETURN_CODE, 0) + + def SHIFT_IN(self): + return self.getToken(Cobol85Parser.SHIFT_IN, 0) + + def SHIFT_OUT(self): + return self.getToken(Cobol85Parser.SHIFT_OUT, 0) + + def SORT_CONTROL(self): + return self.getToken(Cobol85Parser.SORT_CONTROL, 0) + + def SORT_CORE_SIZE(self): + return self.getToken(Cobol85Parser.SORT_CORE_SIZE, 0) + + def SORT_FILE_SIZE(self): + return self.getToken(Cobol85Parser.SORT_FILE_SIZE, 0) + + def SORT_MESSAGE(self): + return self.getToken(Cobol85Parser.SORT_MESSAGE, 0) + + def SORT_MODE_SIZE(self): + return self.getToken(Cobol85Parser.SORT_MODE_SIZE, 0) + + def SORT_RETURN(self): + return self.getToken(Cobol85Parser.SORT_RETURN, 0) + + def TALLY(self): + return self.getToken(Cobol85Parser.TALLY, 0) + + def TIME(self): + return self.getToken(Cobol85Parser.TIME, 0) + + def WHEN_COMPILED(self): + return self.getToken(Cobol85Parser.WHEN_COMPILED, 0) + + def getRuleIndex(self): + return Cobol85Parser.RULE_specialRegister + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSpecialRegister" ): + listener.enterSpecialRegister(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSpecialRegister" ): + listener.exitSpecialRegister(self) + + + + + def specialRegister(self): + + localctx = Cobol85Parser.SpecialRegisterContext(self, self._ctx, self.state) + self.enterRule(localctx, 1186, self.RULE_specialRegister) + self._la = 0 # Token type + try: + self.state = 6280 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [5]: + self.enterOuterAlt(localctx, 1) + self.state = 6247 + self.match(Cobol85Parser.ADDRESS) + self.state = 6248 + self.match(Cobol85Parser.OF) + self.state = 6249 + self.identifier() + pass + elif token in [111]: + self.enterOuterAlt(localctx, 2) + self.state = 6250 + self.match(Cobol85Parser.DATE) + pass + elif token in [114]: + self.enterOuterAlt(localctx, 3) + self.state = 6251 + self.match(Cobol85Parser.DAY) + pass + elif token in [115]: + self.enterOuterAlt(localctx, 4) + self.state = 6252 + self.match(Cobol85Parser.DAY_OF_WEEK) + pass + elif token in [118]: + self.enterOuterAlt(localctx, 5) + self.state = 6253 + self.match(Cobol85Parser.DEBUG_CONTENTS) + pass + elif token in [119]: + self.enterOuterAlt(localctx, 6) + self.state = 6254 + self.match(Cobol85Parser.DEBUG_ITEM) + pass + elif token in [120]: + self.enterOuterAlt(localctx, 7) + self.state = 6255 + self.match(Cobol85Parser.DEBUG_LINE) + pass + elif token in [121]: + self.enterOuterAlt(localctx, 8) + self.state = 6256 + self.match(Cobol85Parser.DEBUG_NAME) + pass + elif token in [122]: + self.enterOuterAlt(localctx, 9) + self.state = 6257 + self.match(Cobol85Parser.DEBUG_SUB_1) + pass + elif token in [123]: + self.enterOuterAlt(localctx, 10) + self.state = 6258 + self.match(Cobol85Parser.DEBUG_SUB_2) + pass + elif token in [124]: + self.enterOuterAlt(localctx, 11) + self.state = 6259 + self.match(Cobol85Parser.DEBUG_SUB_3) + pass + elif token in [269]: + self.enterOuterAlt(localctx, 12) + self.state = 6260 + self.match(Cobol85Parser.LENGTH) + self.state = 6262 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==323: + self.state = 6261 + self.match(Cobol85Parser.OF) + + + self.state = 6264 + self.identifier() + pass + elif token in [278]: + self.enterOuterAlt(localctx, 13) + self.state = 6265 + self.match(Cobol85Parser.LINAGE_COUNTER) + pass + elif token in [281]: + self.enterOuterAlt(localctx, 14) + self.state = 6266 + self.match(Cobol85Parser.LINE_COUNTER) + pass + elif token in [341]: + self.enterOuterAlt(localctx, 15) + self.state = 6267 + self.match(Cobol85Parser.PAGE_COUNTER) + pass + elif token in [404]: + self.enterOuterAlt(localctx, 16) + self.state = 6268 + self.match(Cobol85Parser.RETURN_CODE) + pass + elif token in [435]: + self.enterOuterAlt(localctx, 17) + self.state = 6269 + self.match(Cobol85Parser.SHIFT_IN) + pass + elif token in [436]: + self.enterOuterAlt(localctx, 18) + self.state = 6270 + self.match(Cobol85Parser.SHIFT_OUT) + pass + elif token in [441]: + self.enterOuterAlt(localctx, 19) + self.state = 6271 + self.match(Cobol85Parser.SORT_CONTROL) + pass + elif token in [442]: + self.enterOuterAlt(localctx, 20) + self.state = 6272 + self.match(Cobol85Parser.SORT_CORE_SIZE) + pass + elif token in [443]: + self.enterOuterAlt(localctx, 21) + self.state = 6273 + self.match(Cobol85Parser.SORT_FILE_SIZE) + pass + elif token in [445]: + self.enterOuterAlt(localctx, 22) + self.state = 6274 + self.match(Cobol85Parser.SORT_MESSAGE) + pass + elif token in [446]: + self.enterOuterAlt(localctx, 23) + self.state = 6275 + self.match(Cobol85Parser.SORT_MODE_SIZE) + pass + elif token in [447]: + self.enterOuterAlt(localctx, 24) + self.state = 6276 + self.match(Cobol85Parser.SORT_RETURN) + pass + elif token in [471]: + self.enterOuterAlt(localctx, 25) + self.state = 6277 + self.match(Cobol85Parser.TALLY) + pass + elif token in [485]: + self.enterOuterAlt(localctx, 26) + self.state = 6278 + self.match(Cobol85Parser.TIME) + pass + elif token in [513]: + self.enterOuterAlt(localctx, 27) + self.state = 6279 + self.match(Cobol85Parser.WHEN_COMPILED) + 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 CommentEntryContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def COMMENTENTRYLINE(self, i:int=None): + if i is None: + return self.getTokens(Cobol85Parser.COMMENTENTRYLINE) + else: + return self.getToken(Cobol85Parser.COMMENTENTRYLINE, i) + + def getRuleIndex(self): + return Cobol85Parser.RULE_commentEntry + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterCommentEntry" ): + listener.enterCommentEntry(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitCommentEntry" ): + listener.exitCommentEntry(self) + + + + + def commentEntry(self): + + localctx = Cobol85Parser.CommentEntryContext(self, self._ctx, self.state) + self.enterRule(localctx, 1188, self.RULE_commentEntry) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 6283 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 6282 + self.match(Cobol85Parser.COMMENTENTRYLINE) + self.state = 6285 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==562): + break + + 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/src/DataDivisionCobol85Listener.py b/src/DataDivisionCobol85Listener.py new file mode 100644 index 0000000..010e703 --- /dev/null +++ b/src/DataDivisionCobol85Listener.py @@ -0,0 +1,303 @@ +''' + +The purpose of this program is to build a data structure that we can use to generate +the proper python reader code for the Cobol File section being parsed. + +''' + +from antlr4 import ParseTreeListener, ParserRuleContext +from Cobol85Listener import Cobol85Listener +from Cobol85Parser import Cobol85Parser +from Symbol import Symbol, SymbolTable + +# We will build the symbol table, with a row for each Level 01 set of symbols. +''' +current_symbol will be a dict and will represent the current symbol being built for the symbol table. +when the code has all it needs for a valid symbol, it will add the current_symbol dict to the symbol_table + +current_symbol keys: + "symbol_name", the name of the cobol variable + "picture", the type of the cobol variable. e.g. '9', '99', 'X' 'S9', 'V99' + "cardinality", the cardinality (optional) + "redefines", the field being redefined (optional) + "occurs", the number of times the field definition occurs + + Example of redefines and occurs: + + Level:03 Name:COUNTY Type: PIC 9 Cardinality 18 + Level:03 Name:COUNTIES Type: PIC 9 Cardinality 3 Redefines: REDEFINES COUNTY Occurs OCCURS 6 + + So COUNTIES is "like" an array with 6 elements 3-bytes long each for a total byte-length of 18 + and COUNTIES redefines the COUNTY variable + +So a readable version of the COBOL parsed is as follows. +Repeated Level 01's within the same file definition act as a "union" (as in C) of the byte structure. + +Level:01 Name:FIELD-MAST + Level:02 Name:OIL-CODES + Level:03 Name:TYPE-REC Type: PIC 9 + Level:03 Name:DIST Type: PIC 999 + Level:03 Name:FIELD Type: PIC 9 Cardinality 8 + Level:03 Name:OPR Type: PIC 9 Cardinality 6 + Level:03 Name:LEASE Type: PIC 9 Cardinality 5 + Level:03 Name:LSE-FILLER Type: PIC 99 + Level:03 Name:OFFSHORE Type: PIC 9 + Level:02 Name:FIELD-DATA + Level:03 Name:F-NAME Type: PIC X Cardinality 32 + Level:03 Name:COUNTY Type: PIC 9 Cardinality 18 + Level:03 Name:COUNTIES Type: PIC 9 Cardinality 3 Redefines: REDEFINES COUNTY Occurs OCCURS 6 + Level:03 Name:DISC-DATE Type: PIC 9 Cardinality 8 + Level:03 Name:D-DATE Redefines: REDEFINES DISC-DATE + Level:05 Name:DSC-CCYY Type: PIC 9 Cardinality 4 + Level:05 Name:DSC-CCYY-REDF Redefines: REDEFINES DSC-CCYY + Level:07 Name:DSC-CC Type: PIC 99 + Level:07 Name:DSC-YR Type: PIC 99 + Level:05 Name:DSC-MO Type: PIC 99 + Level:05 Name:DSC-DAY Type: PIC 99 + Level:03 Name:F-DEPTH Type: PIC 9 Cardinality 5 + Level:03 Name:O-GRAV Type: PIC 999 + + + +''' + +current_symbol = Symbol() +global_symbol_table = SymbolTable() + +def visit_to_generate_symbol_table(ctx:ParserRuleContext): + + numChildren = ctx.getChildCount() + + if numChildren == 0: + # terminal, and we don't care about them b/c they will have been processed below + return + + elif 'DataDescriptionEntryFormat1Context' in str(type(ctx)): + + ''' + Process tree like this (this is a tree structure from grun: + + (fileSection FILE SECTION .\n + (fileDescriptionEntry FD + (fileName + (cobolWord TXOilLedgerFile)) .\n + (dataDescriptionEntry + (dataDescriptionEntryFormat1 01 <<<<----- we care about these. + (dataName + (cobolWord FIELD-MAST)) .\n )) + (dataDescriptionEntry + (dataDescriptionEntryFormat1 02 <<<<----- we care about these. + (dataName + (cobolWord OIL-CODES)) .\n )) + (dataDescriptionEntry + (dataDescriptionEntryFormat1 03 <<<<----- we care about these. + (dataName + (cobolWord TYPE-REC)) + (dataPictureClause PIC + (pictureString + (pictureChars + (integerLiteral 9)))) .\n )) + ... + + N.B. Cannot ignore things w/o Picture Clause (PIC) because they could be redefines + + The following has no picture information but does indicate that it is redefining + another field. + + (dataDescriptionEntry + (dataDescriptionEntryFormat1 03 + (dataName + (cobolWord D-DATE)) + (dataRedefinesClause REDEFINES + (dataName + (cobolWord DISC-DATE))) .\n )) + ''' + + + if ctx.INTEGERLITERAL() is not None and ctx.dataName() is not None: + + _integer_literal = int(ctx.INTEGERLITERAL().getText()) + indent_chars = int(_integer_literal) * ' ' + _data_name = ctx.dataName().getText() + + # Flush current symbol to start building a new one + if _integer_literal == 1: + global_symbol_table.add_level() + + current_symbol.reset() + current_symbol.name = _data_name + current_symbol.level = _integer_literal + + # PIC + _picture = [] + if len(ctx.dataPictureClause()) > 0: + current_symbol.picture = '' + for cindex in ctx.dataPictureClause(): + cardinality_seen = False + for counter, pindex in enumerate(cindex.pictureString().pictureChars()): + # will be: 9, (, 06, ), with only the 9 and 06 being integerLiteral + integer_literal = pindex.integerLiteral() + if integer_literal is not None: + integer_text = integer_literal.getText() + if cardinality_seen: + # this is a cardinality number + _picture.append('Cardinality') + _picture.append(integer_text) + current_symbol.cardinality = integer_text + else: + # this is a PIC number + current_symbol.picture = integer_text + _picture.append(integer_text) + else: + cardinality_check = pindex.getText() + if cardinality_check == '(': + cardinality_seen = True + continue + elif cardinality_check == ')': + cardinality_seen = False + continue + else: + integer_text = pindex.getText() + current_symbol.picture += integer_text + _picture.append(integer_text) + + _picture_string = '' + if len(_picture) > 0: + _picture_string = ' Type: PIC ' + ' '.join(_picture) + + # data usage + _data_usage = [] + if len(ctx.dataUsageClause()) > 0: + for cindex in ctx.dataUsageClause(): + if (result := cindex.BINARY()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.BIT()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.COMP()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.COMP_1()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.COMP_2()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.COMP_3()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.COMP_4()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.COMP_5()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.COMPUTATIONAL()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.COMPUTATIONAL_1()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.COMPUTATIONAL_2()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.COMPUTATIONAL_3()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.COMPUTATIONAL_4()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.COMPUTATIONAL_5()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.CONTROL_POINT()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.DATE()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.DISPLAY()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.DISPLAY_1()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.DOUBLE()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.EVENT()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.FUNCTION_POINTER()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.INDEX()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.KANJI()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.LOCK()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.NATIONAL()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.PACKED_DECIMAL()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.POINTER()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.PROCEDURE_POINTER()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.REAL()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.TASK()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.USAGE()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.IS()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.TRUNCATED()) is not None: + _data_usage.append(result.getText()) + if (result := cindex.EXTENDED()) is not None: + _data_usage.append(result.getText()) + if len(_data_usage) > 0: + current_symbol.usage = _data_usage + + # REDEFINES + _redefines = [] + if len(ctx.dataRedefinesClause()) > 0: + for cindex in ctx.dataRedefinesClause(): + _redefines.append(cindex.REDEFINES().getText()) + redefines_symbol = cindex.dataName().getText() + current_symbol.redefines = redefines_symbol + _redefines.append(redefines_symbol) + _redefines_string = '' + if len(_redefines) > 0: + _redefines_string = ' Redefines: ' + ' '.join(_redefines) + + # OCCURS + _occurs = [] + if len(ctx.dataOccursClause()) > 0: + for cindex in ctx.dataOccursClause(): + _occurs.append(cindex.OCCURS().getText()) + occurs_number = str(cindex.integerLiteral().getText()) + _occurs.append(occurs_number) + current_symbol.occurs = int(occurs_number) + _occurs_string = '' + if len(_occurs) > 0: + _occurs_string = ' Occurs ' + ' '.join(_occurs) + + print(f'{indent_chars}Level:{_integer_literal} Name:{_data_name}{_picture_string}{_redefines_string}{_occurs_string}') + else: + raise Exception('unexpected result') + + if current_symbol.complete(): + global_symbol_table.add_symbol(current_symbol) + + return + + for idx in range(0, ctx.getChildCount()): + visit_to_generate_symbol_table(ctx.getChild(idx)) + + +# This class defines a complete listener for a parse tree produced by Cobol85Parser. +class DataDivisionCobol85Listener(Cobol85Listener): + + def __init__(self): + ''' + Create a Cobol85Listener, specialize it to walk the File Section, generate symbol table and return it + + Parameters: + ----------- + symbol_table: SymbolTable, this will be filled in and can then be returned. + ''' + + super().__init__() + self.symbol_table = None + + # Enter a parse tree produced by Cobol85Parser#fileSection. + def enterFileSection(self, ctx:Cobol85Parser.FileSectionContext): + visit_to_generate_symbol_table(ctx) + self.symbol_table = global_symbol_table + self.symbol_table.cleanup_redefined() + self.symbol_table.finalize() + + def get_symbol_table(self): + return self.symbol_table diff --git a/src/Dockerfile b/src/Dockerfile new file mode 100644 index 0000000..d3747ea --- /dev/null +++ b/src/Dockerfile @@ -0,0 +1,34 @@ +FROM ubuntu:latest +RUN apt-get update && apt-get install -y wget openjdk-11-jdk +RUN wget https://www.antlr.org/download/antlr-4.9.2-complete.jar -O /usr/local/lib/antlr4.jar +ENV CLASSPATH=".:/usr/local/lib/antlr4.jar:$CLASSPATH" + +# Use a base image with Python 3.11 and Node.js (latest version) +FROM nikolaik/python-nodejs:python3.12-nodejs22-slim + +# Set working directory +WORKDIR /app + +# Copy package.json and package-lock.json to the working directory +COPY package.json package-lock.json ./ + +# Install Node.js dependencies +RUN npm install + +# Copy Python requirements file to the working directory +COPY requirements.txt . + +# Install Python dependencies +RUN pip install -r requirements.txt + +# Install React dependencies (if needed) +# RUN npm install react react-dom + +# Copy the rest of the application files to the working directory +COPY . . + +# Expose the port your app runs on +EXPOSE 3000 + +# Command to run the application +CMD ["npm", "start"] diff --git a/src/OilMaster.py b/src/OilMaster.py new file mode 100644 index 0000000..3e6a20a --- /dev/null +++ b/src/OilMaster.py @@ -0,0 +1,38 @@ +import simplejson +from coboljsonifier.copybookextractor import CopybookExtractor +from coboljsonifier.parser import Parser +from coboljsonifier.config.parser_type_enum import ParseType + + +class OilMaster(object): + '''Parser for TX RRC Oil Master + 2024 location: https://mft.rrc.texas.gov/link/c5081c77-d32c-4ded-9b33-5aca3833306c# + + This class will read the COBOL copy book format from the defining PDF and derive the Python structure. + https://mft.rrc.texas.gov/link/c5081c77-d32c-4ded-9b33-5aca3833306c# + https://mft.rrc.texas.gov/link/c5081c77-d32c-4ded-9b33-5aca3833306c is index location + file name format in HTML output: olf{district_number}I.ebc.gz, where district number is a fixed 3 digit number with leading padded zeros + e.g. o + + Record and Field Definition: https://www.rrc.texas.gov/media/5mlpe0t2/ola013k.pdf + ''' + + def __init__(self, cobol_data_division_file): + self.record_definition_uri = 'https://www.rrc.texas.gov/media/5mlpe0t2/ola013k.pdf' + self.input_uri = 'https://www.rrc.texas.gov/media/5mlpe0t2/ola013k.pdf' + self.format = None + + # Extracting copybook structure + self.dict_structure = CopybookExtractor(cobol_data_division_file).dict_book_structure + + # Building a Parser + self.parser = Parser(self.dict_structure, ParseType.FLAT_ASCII).build() + + pass + + def get_format(self): + return self.dict_structure + + def parse(self, input_bytes): + self.parser(input_bytes) + return simplejson.dumps(self.parser.value) diff --git a/src/Symbol.py b/src/Symbol.py new file mode 100644 index 0000000..f6da9a2 --- /dev/null +++ b/src/Symbol.py @@ -0,0 +1,408 @@ +import copy + +import pandas as pd + +computationals = set(['COMP-1', 'COMP-2', 'COMP-3', 'COMP-4', 'COMP-5', + 'COMPUTATIONAL-1', 'COMPUTATIONAL-2', 'COMPUTATIONAL-3', + 'COMPUTATIONAL-4', 'COMPUTATIONAL-5', 'COMPUTATIONAL']) + +# native = '@' see python struct() +BYTE_ORDER = '@' + +def is_computational(usage): + + return (usage is not None) and (len(set(usage).intersection(computationals)) > 0) + +class Symbol: + level: int = None + name: str = None + picture: str = '' + cardinality: int = None + redefines: str = None + occurs: int = None + usage: str = None + size: int = None + occurs_adjusted_size: int = None + start: int = None + end: int = None + struct_format: str = None + packed: bool = False + + def __init__(self): + pass + + def complete(self): + return (self.name is not None) + + def reset(self): + self.level = None + self.name = None + self.picture = None + self.cardinality = None + self.redefines = None + self.occurs = None + self.usage = None + self.size = None + self.occurs_adjusted_size = None + self.start = None + self.end = None + self.struct = None + self.packed = False + + def create(symbol): + new_symbol = copy.deepcopy(symbol) + + if new_symbol.cardinality is not None: + new_symbol.cardinality = int(new_symbol.cardinality) + + # compute size. + # 9's - count = 9 occurrences + cardinality + size = 0 + if new_symbol.picture is not None and '9' in new_symbol.picture: + nines_count = str(new_symbol.picture).count('9') + if new_symbol.cardinality is None: + size = nines_count + else: + if nines_count == 1: + size += new_symbol.cardinality + elif nines_count > 1: + size = nines_count - 1 + new_symbol.cardinality + + # adjust for USAGE with computational (packed decimal) + if is_computational(new_symbol.usage): + new_symbol.packed = True + if size % 2 > 0: + size = (size / 2) + 1 + else: + size = int(size / 2) + + # X's - count X's or use cardinality + elif new_symbol.picture is not None and 'X' in new_symbol.picture: + if new_symbol.cardinality is not None: + size = new_symbol.cardinality + else: + size = new_symbol.picture.count('X') + + if new_symbol.occurs is not None: + size *= int(new_symbol.occurs) + + new_symbol.size = int(size) + + new_symbol.create_format() + + return new_symbol + + def __repr__(self): + return self.__str__() + + def __str__(self): + pr_level = None + if self.level is not None: + pr_level = f'Level: {self.level}' + + pr_name = None + if self.name is not None: + pr_name = f'Name: {self.name}' + + pr_picture = None + if self.picture is not None: + pr_picture = f'Picture: {self.picture}' + + pr_cardinality = None + if self.cardinality is not None: + pr_cardinality = f'Cardinality: {self.cardinality}' + + pr_redefines = None + if self.redefines is not None: + pr_redefines = f'Redefines: {self.redefines}' + + pr_occurs = None + if self.occurs is not None: + pr_occurs = f'Occurs: {self.occurs}' + + pr_usage = None + if self.usage is not None: + pr_usage = f'Usage: {self.usage}' + + pr_size = None + if self.size is not None: + pr_size = f'Size: {self.size}' + + pr_occurs_adjusted_size = None + if self.occurs_adjusted_size is not None: + pr_occurs_adjusted_size = f'Size: {self.occurs_adjusted_size}' + + pr_slice = None + if self.start is not None and self.end is not None: + pr_slice = f'Raw Memory Slice: {self.start}:{self.end}' + + pr_1_slice = None + if self.start is not None and self.end is not None: + pr_1_slice = f'Raw Memory Slice(1): {self.start+1}:{self.end+1}' + + pr_struct_format = None + if self.struct_format is not None: + pr_struct_format = f'Struct Format: {self.struct_format}' + + details = [pr_level, pr_name, pr_picture, pr_cardinality, pr_redefines, pr_occurs, pr_usage, pr_size, pr_struct_format, pr_occurs_adjusted_size, pr_slice, pr_1_slice] + pr_details = [x for x in details if x is not None] + pr_details = ', '.join(pr_details) + + return f"Symbol: {pr_details}" + + def create_format(self): + if self.size > 0: + self.struct_format = f'{self.size}s' + +class SymbolTable: + + def __init__(self): + # a completed symbol table will be a table of tables. + self.table = [] + self.current_level = None + self.redefined = set() + self.struct_format = [] + # column names for dataframe + self.columns = [] + + def add_level(self): + self.table.append([]) + self.current_level = self.table[-1] + + def add_symbol(self, symbol): + complete_symbol = Symbol.create(symbol) + if complete_symbol.redefines is not None: + self.redefined.add(complete_symbol.redefines) + self.current_level.append(complete_symbol) + + def cleanup_redefined(self): + ''' + Do not add to symbol table if symbol is REDEFINED + but also, any symbols under a REDEFINED level should + not be added either. So have to "descend" into + lower levels. + ''' + new_table = [] + redefined_level = None + for level in self.table: + new_table.append([]) + for symbol in level: + if redefined_level: + if symbol.level > redefined_level: + if symbol.size == 0: + redefined_level = None + else: + print(f'skipping enclosed Redefined {symbol}') + continue + else: + redefined_level = None + + if symbol.name in self.redefined: + redefined_level = symbol.level + print(f'Skipping this redefined {symbol}') + continue + else: + new_table[-1].append(symbol) + + self.table = new_table + + def complete(self): + return len(self.table) > 0 + + def validate(self): + pass + + def get(self): + return self.table + + def __str__(self): + _str = '' + for counter, level in enumerate(self.table): + _str += '\n\nLevel 01\n' + for symbol in level: + _str += str(symbol) + '\n' + + _str += f'\n.sizes[{counter}]={self.sizes[counter]}' + _str += f'\n.struct_format[{counter}] = {self.struct_format[counter]}' + + if self.redefined: + _str += f'\n.redefined={self.redefined}' + + return _str + + def count_size(self): + '''compute whole size of level and compute individual offsets for a struct generation + E.g. + Symbol: Level: 2, Name: OIL-CODES, Size: 0 Offset: 0 + Symbol: Level: 3, Name: TYPE-REC, Picture: 9, Size: 1 Offset: 1 + Symbol: Level: 3, Name: DIST, Picture: 999, Size: 3 Offset: 4 + Symbol: Level: 3, Name: FIELD, Picture: 9, Cardinality: 8, Size: 8 Start: 5 End: 13 + Symbol: Level: 3, Name: OPR, Picture: 9, Cardinality: 6, Size: 6 Offset: 18 + Symbol: Level: 3, Name: LEASE, Picture: 9, Cardinality: 5, Size: 5 Offset: 23 + Symbol: Level: 3, Name: LSE-FILLER, Picture: 99, Size: 2 Offset: 25 + Symbol: Level: 3, Name: OFFSHORE, Picture: 9, Size: 1 + Symbol: Level: 2, Name: FIELD-DATA, Size: 0 + ''' + self.sizes = [] + for level in self.table: + size = 0 + occurs_adjusted_size = 0 + for symbol in level: + # for the symbol + start = size + size += symbol.size + if symbol.occurs_adjusted_size is not None: + occurs_adjusted_size += symbol.occurs_adjusted_size + end = size + symbol.start = start + symbol.end = end + self.sizes.append(size + occurs_adjusted_size) + + def finalize_columns(self): + for level in self.table: + self.columns.append([]) + for index, symbol in enumerate(level): + if symbol.struct_format is not None: + self.columns[-1].append(symbol.name) + + def finalize_struct_format(self): + self.struct_format = [] + for level in self.table: + struct_format = BYTE_ORDER + self.struct_format.append([]) + for index, symbol in enumerate(level): + # 'Occurs' with size zero alreday has struct_format set + if symbol.struct_format is not None: + struct_format += symbol.struct_format + + self.struct_format[-1] = struct_format + + def set_occurs_format(self): + ''' + visit each symbol that has a size or occurs and compute the format from the size. + usually it will just be {size}s (or a string of size). + when occurs appears in a level variable that groups several other fields then + the format has to be repeated by the number of Occurs. + + Consider these levels (pseudo-Cobol code): + + Level:3 Name:F-MONTH Occurs OCCURS 14 + Level:5 Name:FM-DATE Type: PIC 9 Cardinality 6 + Level:5 Name:FM-DATE-REDF Redefines: REDEFINES FM-DATE + Level:7 Name:FM-CCYY Type: PIC 9 Cardinality 4 + Level:7 Name:FM-CCYY-REDF Redefines: REDEFINES FM-CCYY + Level:9 Name:FM-CC Type: PIC 99 + Level:9 Name:FM-YR Type: PIC 99 + Level:7 Name:FM-MO Type: PIC 99 + Level:5 Name:FM-PW Type: PIC S9 Cardinality 3 + Level:5 Name:FM-AC Type: PIC S999V9 Cardinality 4 + Level:5 Name:FILLER4 Type: PIC 9 Cardinality 4 + Level:5 Name:FM-OTHC Type: PIC 9 + Level:5 Name:FM-CHG Type: PIC 9 + Level:5 Name:FM-PROD-FACT Type: PIC S99V999 + Level:5 Name:FM-SPLIT-PROD-FACT Type: PIC S99V999 + Level:5 Name:FM-SPLIT-PROD-FACT-DATE Type: PIC 99 + Level:5 Name:FM-JOHN Type: PIC 9 + Level:5 Name:FM-OTH Type: PIC S99999999V9999999 + Level:5 Name:FILLER5 Type: PIC X Cardinality 15 + Level:1 Name:LEASE-MAST Redefines: REDEFINES FIELD-MAST + + In the example, the Level 5, 7 9 variables from FM-DATE thorugh FILLER5 + get repeated 14 times. + The resulting one-time format would be: + + Symbol: Level: 3, Name: F-MONTH, Occurs: 14, Size: 0, Raw Memory Slice(1): 501:501, Raw Memory Slice: 500:500 + Symbol: Level: 5, Name: FM-DATE-REDF, Redefines: FM-DATE, Size: 0, Raw Memory Slice(1): 501:501, Raw Memory Slice: 500:500 + Symbol: Level: 7, Name: FM-CCYY-REDF, Redefines: FM-CCYY, Size: 0, Raw Memory Slice(1): 501:501, Raw Memory Slice: 500:500 + Symbol: Level: 9, Name: FM-CC, Picture: 99, Size: 2, Raw Memory Slice(1): 501:503, Raw Memory Slice: 500:502 + Symbol: Level: 9, Name: FM-YR, Picture: 99, Size: 2, Raw Memory Slice(1): 503:505, Raw Memory Slice: 502:504 + Symbol: Level: 7, Name: FM-MO, Picture: 99, Size: 2, Raw Memory Slice(1): 505:507, Raw Memory Slice: 504:506 + Symbol: Level: 5, Name: FM-PW, Picture: S9, Cardinality: 3, Usage: ['COMP-3'], Size: 2, Raw Memory Slice(1): 507:509, Raw Memory Slice: 506:508 + Symbol: Level: 5, Name: FM-AC, Picture: S999V9, Cardinality: 4, Usage: ['COMP-3'], Size: 4, Raw Memory Slice(1): 509:513, Raw Memory Slice: 508:512 + Symbol: Level: 5, Name: FILLER4, Picture: 9, Cardinality: 4, Size: 4, Raw Memory Slice(1): 513:517, Raw Memory Slice: 512:516 + Symbol: Level: 5, Name: FM-OTHC, Picture: 9, Size: 1, Raw Memory Slice(1): 517:518, Raw Memory Slice: 516:517 + Symbol: Level: 5, Name: FM-CHG, Picture: 9, Size: 1, Raw Memory Slice(1): 518:519, Raw Memory Slice: 517:518 + Symbol: Level: 5, Name: FM-PROD-FACT, Picture: S99V999, Usage: ['COMP-3'], Size: 3, Raw Memory Slice(1): 519:522, Raw Memory Slice: 518:521 + Symbol: Level: 5, Name: FM-SPLIT-PROD-FACT, Picture: S99V999, Usage: ['COMP-3'], Size: 3, Raw Memory Slice(1): 522:525, Raw Memory Slice: 521:524 + Symbol: Level: 5, Name: FM-SPLIT-PROD-FACT-DATE, Picture: 99, Size: 2, Raw Memory Slice(1): 525:527, Raw Memory Slice: 524:526 + Symbol: Level: 5, Name: FM-JOHN, Picture: 9, Size: 1, Raw Memory Slice(1): 527:528, Raw Memory Slice: 526:527 + Symbol: Level: 5, Name: FM-OTH, Picture: S99999999V9999999, Usage: ['COMP-3'], Size: 8, Raw Memory Slice(1): 528:536, Raw Memory Slice: 527:535 + Symbol: Level: 5, Name: FILLER5, Picture: X, Cardinality: 15, Size: 15, Raw Memory Slice(1): 536:551, Raw Memory Slice: 535:550 + + ''' + for level in self.table: + # prepare for occurs handling (for multiplying format) + occurs_symbol = None + occurs_level = None + occurs_struct_format = None + occurs_contents_size = 0 + for index, symbol in enumerate(level): + + if symbol.occurs is not None and symbol.size == 0: + + if occurs_struct_format is not None: + print('flush last occurs') + occurs_struct_format = occurs_struct_format * occurs_symbol.occurs + occurs_symbol.struct_format = occurs_struct_format + # Accounts for the Occurs adjustment. So if Occurs - 15, this will be the size * 14 + occurs_symbol.occurs_adjusted_size = occurs_contents_size * (occurs_symbol.occurs - 1) + occurs_symbol = None + occurs_level = None + occurs_struct_format = None + occurs_contents_size = 0 + + print('start building occurs') + occurs_symbol = symbol + occurs_level = symbol.level + occurs_struct_format = '' + # save "occurs" symbol to update its "struct_format" + continue + + if occurs_level is not None and symbol.level <= occurs_level: + print('new level after occurs. flush.') + occurs_struct_format = occurs_struct_format * occurs_symbol.occurs + occurs_symbol.struct_format = occurs_struct_format + occurs_symbol.occurs_adjusted_size = occurs_contents_size * (occurs_symbol.occurs - 1) + occurs_symbol = None + occurs_level = None + occurs_struct_format = None + occurs_contents_size = 0 + + if symbol.struct_format is not None: + if occurs_symbol is not None: + print(f'collecting occurs format for level {occurs_level}, {occurs_symbol.name}\n\t from {symbol}') + occurs_struct_format += symbol.struct_format + occurs_contents_size += symbol.size + symbol.struct_format = None + + # if it was the last element + if occurs_struct_format is not None: + print('adding occurs format at end of symbol') + occurs_struct_format = occurs_struct_format * occurs_symbol.occurs + occurs_symbol.struct_format = occurs_struct_format + # Accounts for the Occurs adjustment. So if Occurs - 15, this will be the size * 14 + occurs_symbol.occurs_adjusted_size = occurs_contents_size * (occurs_symbol.occurs - 1) + + + def finalize(self): + self.set_occurs_format() + self.finalize_struct_format() + self.finalize_columns() + self.count_size() + + def __len__(self): + return len(self.table) + + def get_struct_format(self): + return self.struct_format + + def find_table_level_symbol(self, symbol_name): + for level_number, level in enumerate(self.table): + for index, symbol in enumerate(level): + if symbol.name == symbol_name: + return (self.table[level_number], level_number, symbol) + + return (None, None, None) + + def find_table(self, index): + return self.table[index] diff --git a/src/TX_OLA.yml b/src/TX_OLA.yml new file mode 100644 index 0000000..203e174 --- /dev/null +++ b/src/TX_OLA.yml @@ -0,0 +1,25 @@ +Shared-Field-Record-Type: + key_field_name: RECORD-TYPE-FIELD + key_position: [0, 1] + +# record type value +record_types: + '1': + name: Oil Field + key_field_name: TYPE-REC + record_definition_position: 0 + + '3': + name: Oil Lease + key_field_name: LEASE-REC-TYPE-REC + record_definition_position: 1 + + '4': + name: Oil Multi-Well + key_field_name: MULTI-W-REC-TYPE-REC + record_definition_position: 2 + + '5': + name: Oil Well + key_field_name: WELL-REC-TYPE-REC + record_definition_position: 3 diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/app.yaml b/src/app.yaml new file mode 100644 index 0000000..10c6631 --- /dev/null +++ b/src/app.yaml @@ -0,0 +1,3 @@ +service: producer-oil-gas-ml +runtime: custom +env: flex diff --git a/src/bintools.py b/src/bintools.py new file mode 100644 index 0000000..f439ba0 --- /dev/null +++ b/src/bintools.py @@ -0,0 +1,26 @@ +def in_situ_ebcdic_to_ascii(s): + etoa = ( + " " + " " + " .<(+|& !$*); " + "-/ ,%_>? `:#@'=\"" + " abcdefghi jklmnopqr " + " stuvwxyz " + " ABCDEFGHI JKLMNOPQR " + " STUVWXYZ 0123456789 " + ) + + # Convert the input bytes to a mutable list of characters + s_list = list(s) + + for i in range(len(s_list)): + s_list[i] = etoa[s_list[i]] + + return ''.join(s_list) + +def access_4bits(data, num): + # access 4 bits from num-th position in data + return bin(int(data, 2) >> num & 0b1111) + +def read_raw(filename): + return open(filename, "rb", buffering=0, ).read() diff --git a/src/cobol_data_parser.py b/src/cobol_data_parser.py new file mode 100644 index 0000000..6fecfcb --- /dev/null +++ b/src/cobol_data_parser.py @@ -0,0 +1,133 @@ +import re +import struct +import sys + +import click +import pandas as pd +import yaml + +from antlr4 import FileStream, CommonTokenStream, ParseTreeWalker + +from Cobol85Lexer import Cobol85Lexer +from DataDivisionCobol85Listener import DataDivisionCobol85Listener +from Cobol85Parser import Cobol85Parser + + +def extract_structures(copybook_file): + lexer = Cobol85Lexer(FileStream(copybook_file)) + tokens = CommonTokenStream(lexer) + parser = Cobol85Parser(tokens) + tree = parser.compilationUnit() + + extractor = DataDivisionCobol85Listener() + walker = ParseTreeWalker() + walker.walk(extractor, tree) + return extractor.get_symbol_table() + +def get_dataset_config(record_type_config_file): + + with open(record_type_config_file, 'r') as input_file: + + # Parsing + # 1. open record type config yaml + return yaml.safe_load(input_file) + +def is_negative(field): + # 'd$' is negative, all else + return re.match('d$', field) is not None + +def drop_positive(field): + return re.sub('[cf]$', '', field) + +def file_parser(data_file, key_start, key_end, record_definitions, formats, columns, sizes): + ''' + Parse an ebcdic file according to: + Parameters: + ----------- + data_file: str, name of file to parse + record definitions, + record type - + formats, + columns + and sizes + + + data_file - str, name of the file to read and parse + key_position - tuple, the start and end of the key value + record_definition - dict: { + : (size: int, format: str, columns: list, encodings: list), + : (size: int, format: str, columns: list, encodings: list), + } + x.decode('cp424') + x.hex() + + ** The last letter denotes the sign, C & F are positive, D is negative. For your program, check for negative (D) and if not, treat as positive. + + Example: + {'1': (1200, '1s2s...', ['FIELD-TYPE-OIL', 'WELL-APINO', ...], [ ) + ''' + records = {} + record_types = list(record_definitions['record_types'].keys()) + for record_type in record_types: + records[record_type] = [] + + # Read the key value position + total_bytes_read = 0 + f = open(data_file, 'rb', buffering=0) + record_type = f.read(key_end - key_start) + total_bytes_read += key_end - key_start + while len(record_type) > 0: + # 1. parse key field, key value + record_type_str = record_type.decode('cp424') + if record_type_str not in record_types: + raise Exception(f'field record number {record_type_str} not supported. must be in {record_types}') + + record_definition_position = record_definitions['record_types'][record_type_str]['record_definition_position'] + # 2. select structure from record type config + rec = record_type + f.read(sizes[record_definition_position] - 1) + total_bytes_read += sizes[record_definition_position] - 1 + rec = struct.unpack(formats[record_definition_position], rec) + records[record_type_str].append(rec) + # get next field + record_type = f.read(key_end - key_start) + total_bytes_read += key_end - key_start + + # 3. separate rows according to key value into N dataframes, combine into one dataframe + df_list = [] + for record_type in record_types: + record_definition_position = record_definitions['record_types'][record_type]['record_definition_position'] + record_type_columns = columns[record_definition_position] + df = pd.DataFrame(records[record_type], columns=record_type_columns) + df.loc[:, 'record_type_name'] = record_definitions['record_types'][record_type]['name'] + df_list.append(df) + + return pd.concat(df_list) + + +@click.command() +@click.option("--copybook-file", type=str) +@click.option("--data-file", type=str) +@click.option("--record-type-config-file", help='yaml file defining records for record_type field value', type=str) +def cobol_data_parser(copybook_file, data_file, record_type_config_file): + + # Get the symbol table for the Cobol copybook source code + symbol_table = extract_structures(copybook_file) + print(symbol_table) + + # Get configuration file for the key field and field types + dataset_parameters = get_dataset_config(record_type_config_file) + key_start = int(dataset_parameters['Shared-Field-Record-Type']['key_position'][0]) + key_end = int(dataset_parameters['Shared-Field-Record-Type']['key_position'][1]) + # Get the data from the EBCDIC input file. + datasets = file_parser(data_file, + key_start, + key_end, + dataset_parameters, + symbol_table.struct_format, + symbol_table.columns, + symbol_table.sizes) + print(f'length of datasets {len(datasets)}') + + +if __name__ == '__main__': + cobol_data_parser() diff --git a/src/cobol_parser.md b/src/cobol_parser.md new file mode 100644 index 0000000..dd221ba --- /dev/null +++ b/src/cobol_parser.md @@ -0,0 +1,44 @@ +# Impetus +Each of the RRC datasets has a Cobol copybook. +Rather than interpret and write custom parsing code, it should be +possible to write a general-purpose tool to read the copybook and +generate the python code needed to parse the raw EBCDIC file (after +reading one into a bytearray). + +# Ideas +## Generate a handgrown parser +The first idea was to write a parser that would use RE to figure +out sizes of fields, etc. But that proved to be to much work. +The work was in understanding the lexical and parsing rules. +Surely someone else had done the work to provide a COBOL grammar. + +## ANTLR4 Parser/Lexer +The second idea was to use an already-written grammar file +to generate a lexer and parser that could be customized. +I found ANTLR4, did some learning on YouTube about the listener +pattern, and customized a Listener to lex/parse and interpret the +items in the Data Division. Way less work to understand COBOL +but still work to derive sizes from PICTURE (PIC), Cardinality, +Occurs, Redefines, etc. Nonetheless, much less work than +writing a parser from scratch and "re-inventing the wheel". + +# Result +These are the steps to generate the Lexer, Parser, Listener and +customize the Listener. + +1. Generate the Lexer, Parser and Listener for python3:
`antlr4 -listener -Dlanguage=Python3 Cobol85.g4` +
Generates these:
`Cobol85Lexer.py Cobol85Listener.py Cobol85Parser.py` +1. There is a .g4 file for Cobol84Preprocessor but I did not find a use for it. It may have been handy for removing comments from the Cobol code, +like what I say to do manually below, but I'm not sure. +1. Subclass Cobol85Listener.py and add the listener/visitor code that will +be able to build a Symbol and SymbolTable. Write a wrapper `cobol.py` program +that will run the Lexer, Parser, and customized Listener so that the Symbol(s) +and SymbolTable can be built. The listener should fill in the symbol and symbol table +objects for later inspection for building the python [struct](https://docs.python.org/3/library/struct.html) formats +1. copy the copybook into a Cobol program and make the program complete by +adding other required divisions into the file `ola_copybook.cobol` +1. to generate tree for the Oil Ledger copybook for TX RRC + 1. copy the COBOL code and post process the line numbers off of the end of the file. + 1. Put in the proper structure based on the ola_copybook.txt example + It helped to generate a tree for the program
`pygrun -t Cobol85 startRule ola_copybook.cobol` +1. To generate the symbol table that can be used then for generating python structure:
`python cobol.py ola_copybook.txt` diff --git a/src/ola_copybook.cobol b/src/ola_copybook.cobol new file mode 100644 index 0000000..61cf502 --- /dev/null +++ b/src/ola_copybook.cobol @@ -0,0 +1,425 @@ +IDENTIFICATION DIVISION. + +PROGRAM-ID. SHOW-STRUCTURE. + +DATA DIVISION. +FILE SECTION. +FD oil_file. +01 FIELD-MAST. + 02 OIL-CODES. + 03 TYPE-REC PIC 9. + 03 DIST PIC 999. + 03 FIELD PIC 9(8). + 03 OPR PIC 9(6). + 03 LEASE PIC 9(5). + 03 LSE-FILLER PIC 99. + 03 OFFSHORE PIC 9. + 02 FIELD-DATA. + 03 F-NAME PIC X(32). + 03 COUNTY PIC 9(18). + 03 COUNTIES REDEFINES COUNTY + OCCURS 6 TIMES + PIC 9(3). + 03 DISC-DATE PIC 9(8). + 03 D-DATE REDEFINES DISC-DATE. + 05 DSC-CCYY PIC 9(4). + 05 DSC-CCYY-REDF REDEFINES DSC-CCYY. + 07 DSC-CC PIC 99. + 07 DSC-YR PIC 99. + 05 DSC-MO PIC 99. + 05 DSC-DAY PIC 99. + 03 F-DEPTH PIC 9(5). + 03 O-GRAV PIC 999. + 03 F-TYPE PIC 9. + 03 MULT-RES PIC 9. + 03 F-LPB PIC 9. + 03 F-XMT PIC 9. + 03 PRT-AS-IS PIC 9. + 03 YARD PIC 9. + 03 T-CODES PIC 9(12). + 03 TEST-CODE REDEFINES T-CODES OCCURS 12 TIMES PIC 9. + 03 ALLOCATION-PERCNT01 PIC V99. + 03 ALLOCATION-CODEF01 PIC 99. + 03 ALLOCATION-PERCNT02 PIC V99. + 03 ALLOCATION-CODEF02 PIC 99. + 03 ALLOCATION-PERCNT03 PIC V99. + 03 ALLOCATION-CODEF03 PIC 99. + 03 RES-AMT PIC 9(6). + 03 F-GOR PIC 9(6). + 03 F-LIMIT REDEFINES F-GOR. + 05 F-GOR-CODE PIC 9. + 05 F-GOR-AMT PIC 9(5). + 03 F-TOP PIC 9(5). + 03 F-MER REDEFINES F-TOP. + 05 F-TOP-CODE PIC 9. + 05 F-TOP-AMT PIC 9(4). + 03 F-NET PIC 9(6). + 03 F-NGOR REDEFINES F-NET. + 05 F-NET-CODE PIC 9. + 05 F-NET-AMT PIC 9(5). + 03 UNET PIC 999. + 03 TOL PIC 9999. + 03 TOLER REDEFINES TOL. + 05 F-TOL-CODE PIC 9. + 05 F-TOL-AMT PIC 999. + 03 SPAC PIC 9(8). + 03 SPAC1-2 REDEFINES SPAC. + 05 SPAC1 PIC 9999. + 05 SPAC2 PIC 9999. + 03 DIAG PIC 9999. + 03 CUM-PROD PIC S9(13) COMP-3. + 03 CASING PIC X(21). + 03 COL-HEAD PIC X. + 03 ALO-CODE PIC X. + 03 F-RMK1 PIC X(66). + 03 F-RMK2 PIC X(66). + 03 PERM-NO PIC X(5). + 03 SP-FHC PIC 9. + 03 AN-1 PIC X(66). + 03 AN-2 PIC X(59). + 03 F-OOIP PIC 9(08). + 03 FILLER1 PIC 9(07). + 03 FILLER2 PIC 9(15). + 03 FILLER3 PIC 9(13). + 03 F-MONTH OCCURS 14 TIMES. + 05 FM-DATE PIC 9(6). + 05 FM-DATE-REDF REDEFINES FM-DATE. + 07 FM-CCYY PIC 9(4). + 07 FM-CCYY-REDF REDEFINES FM-CCYY. + 09 FM-CC PIC 99. + 09 FM-YR PIC 99. + 07 FM-MO PIC 99. + 05 FM-PW PIC S9(3) COMP-3. + 05 FM-AC PIC S999V9(4) COMP-3. + 05 FILLER4 PIC 9(4). + 05 FM-OTHC PIC 9. + 05 FM-CHG PIC 9. + 05 FM-PROD-FACT PIC S99V999 COMP-3. + 05 FM-SPLIT-PROD-FACT PIC S99V999 COMP-3. + 05 FM-SPLIT-PROD-FACT-DATE PIC 99. + 05 FM-JOHN PIC 9. + 05 FM-OTH PIC S99999999V9999999 COMP-3. + 05 FILLER5 PIC X(15). + 01 LEASE-MAST REDEFINES FIELD-MAST. + 02 LSE-CODES. + 03 LEASE-REC-TYPE-REC PIC 9. + 03 LEASE-REC-DIST PIC XXX. + 03 LEASE-REC-FIELD PIC 9(8). + 03 LEASE-REC-OPR PIC 9(6). + 03 LEASE-REC-LEASE PIC 9(5). + 03 LEASE-REC-FILLER PIC XX. + 03 LEASE-REC-OFFSHORE PIC 9. + 02 LEASE-DATA. + 03 L-NAME PIC X(32). + 03 LSE-CO PIC 9(6). + 03 LEASE-CO REDEFINES LSE-CO. + 05 L-CO-1 PIC 999. + 05 L-CO-2 PIC 999. + 03 POGATH PIC X(5). + 03 PGGATH PIC X(5). + 03 OSPLIT PIC 9. + 03 GSPLIT PIC 9. + 03 OOGATH PIC X(5). + 03 OGGATH PIC X(5). + 03 OOPR PIC 9(6). + 03 BO-STATUS PIC S9(7) COMP-3. + 03 BG-STATUS PIC S9(7) COMP-3. + 03 MOVE-BAL PIC S9(7) COMP-3. + 03 PO-STATUS PIC S9(7) COMP-3. + 03 PG-STATUS PIC S9(7) COMP-3. + 03 SEC-REC PIC 9. + 03 CERT PIC 99. + 03 BATCH PIC X. + 03 L-LPB PIC 9. + 03 COMMINGLE-CD PIC 9. + 03 COMMINGLE PIC 9999. + 03 L-INFO PIC X(54). + 03 AD-BO-STATUS PIC S9(7) COMP-3. + 03 AD-BG-STATUS PIC S9(7) COMP-3. + 03 COMMINGLE-DATE PIC 9(6). + 03 COMMINGLE-DATE-REDF REDEFINES COMMINGLE-DATE. + 05 COMMINGLE-CCYY PIC 9(4). + 05 COMMINGLE-CCYY-REDF REDEFINES + COMMINGLE-CCYY. + 07 COMMINGLE-CC PIC 99. + 07 COMMINGLE-YR PIC 99. + 05 COMMINGLE-MO PIC 99. + 03 L-RMCD PIC 9. + 03 L-RMDT PIC 9(6). + 03 L-RMDT-REDF REDEFINES L-RMDT. + 05 L-RMDT-CCYY PIC 9(4). + 05 L-RMDT-CCYY-REDF REDEFINES L-RMDT-CCYY. + 07 L-RMCC PIC 99. + 07 L-RMYR PIC 99. + 05 L-RMMO PIC 99. + 03 SEV-CD-13 PIC 9. + 03 SEV-CD-14 PIC 9. + 03 CAS-RED. + 05 L-CAS-SI-LTR-DTE PIC 9(6). + 05 L-RED-RTE-DTE PIC 9(6). + 03 CAS-RED-A REDEFINES CAS-RED. + 05 L-CAS-CCYY PIC 9(4). + 05 L-CAS-CCYY-REDF REDEFINES L-CAS-CCYY. + 07 L-CAS-CC PIC 99. + 07 L-CAS-YR PIC 99. + 05 L-CAS-MO PIC 99. + 05 L-RED-CCYY PIC 9(4). + 05 L-RED-CCYY-REDF REDEFINES L-RED-CCYY. + 07 L-RED-CC PIC 99. + 07 L-RED-YR PIC 99. + 05 L-RED-MO PIC 99. + 03 L-EXC-TST PIC 9. + 03 L-RLTYCD PIC 9. + 03 L-ONE-WELL-LEASE PIC X. + 88 ONE-WELL-ON-SCHEDULE VALUE 'Y'. + 88 MULTIPLE-WELL-LEASE VALUE 'N'. + 03 L-PANHANDLE-GOR-EXC PIC X(01). + 03 L-PANHANDLE-GOR-AMT PIC 9(08)V9 COMP-3. + 03 FILLER6 PIC 9(04). + 03 L-MONTH OCCURS 12 TIMES. + 05 L-MONTH-DATE PIC 9(6). + 05 L-MONTH-DATE-REDF REDEFINES + L-MONTH-DATE. + 07 L-MONTH-CCYY PIC 9(4). + 07 L-MONTH-CCYY-REDF REDEFINES + L-MONTH-CCYY. + 09 LM-CC PIC 99. + 09 LM-YR PIC 99. + 07 LM-MO PIC 99. + 05 LM-SEV PIC 9. + 05 LM-RETRO PIC 9. + 05 LM-REC PIC 9. + 05 LM-CHG PIC 9. + 05 LM-ALLOW PIC S9(7) COMP-3. + 05 LM-PROD PIC S9(7) COMP-3. + 05 LM-FW PIC 999. + 05 LM-OW PIC 999. + 05 LM-PL PIC S9(7) COMP-3. + 05 LM-PLC PIC 9. + 05 LM-OTH PIC S9(7) COMP-3. + 05 LM-OTHC PIC 9. + 05 LM-STO PIC S9(7) COMP-3. + 05 LM-GL PIC S9(9) COMP-3. + 05 LM-GPROD PIC S9(9) COMP-3. + 05 LM-GLIFT PIC S9(7) COMP-3. + 05 LM-CSIL PIC 9. + 05 LM-JOHN PIC 9. + 05 LM-LTR-CODE PIC 9. + 05 FILLER7 PIC 9(13). + 05 FILLER8 PIC 9(13). + 03 FILLER9 PIC 9(04). + 01 MULTI-MAST REDEFINES FIELD-MAST. + 02 MULTI-CODES. + 03 MULTI-W-REC-TYPE-REC PIC 9. + 03 MULTI-W-REC-DIST PIC XXX. + 03 MULTI-W-REC-FIELD PIC 9(8). + 03 MULTI-W-REC-OPR PIC 9(6). + 03 MULTI-W-REC-LEASE PIC 9(5). + 03 MULTI-W-REC-FILLER PIC 99. + 03 MULTI-W-REC-OFFSHORE PIC 9. + 02 MULTI-DATA. + 03 M-RECORD PIC X(6). + 03 TYPEW PIC X. + 03 RESER PIC X(5). + 03 UNIT-YATES REDEFINES RESER. + 05 UNIT-NO-I PIC X. + 05 UNIT-VALUE PIC 9V999. + 03 M-COUNTY PIC 9(6). + 03 MULTI-CO REDEFINES M-COUNTY. + 05 M-CO-1 PIC 999. + 05 M-CO-2 PIC 999. + 03 M-TST-EFF PIC X. + 03 M-PNTR-1ST PIC 9(6). + 03 CAP PIC 9. + 03 PROD-WELL PIC 9(6). + 03 PI-WELLS REDEFINES PROD-WELL. + 05 M-PROD PIC 999. + 05 M-INJ PIC 999. + 03 MARG-WELL PIC 9(6). + 03 SM-WELLS REDEFINES MARG-WELL. + 05 M-SHUT PIC 999. + 05 M-MARG PIC 999. + 03 M-DEPTH PIC 9. + 03 M-PNTR-LST PIC 9(6). + 03 M-EXC-TEST PIC 9. + 03 FILLER10 PIC 9(6). + 03 M-WATER PIC 9(6). + 03 M-REMARK PIC X(55). + 03 MM-PRCNT PIC V999. + 03 FILLER11 PIC 9(11). + 03 FILLER12 PIC 9(11). + 03 M-MONTH OCCURS 14 TIMES. + 05 M-MONTH-DATE PIC 9(6). + 05 M-MONTH-DATE-REDF REDEFINES + M-MONTH-DATE. + 07 M-MONTH-CCYY PIC 9(4). + 07 M-MONTH-CCYY-REDF REDEFINES + M-MONTH-CCYY. + 09 MM-CC PIC 99. + 09 MM-YR PIC 99. + 07 MM-MO PIC 99. + 05 MM-CHG PIC 9. + 05 MM-NO PIC 9. + 05 MM-ALLOW PIC S9(7) COMP-3. + 05 MM-ACODE PIC 9. + 05 MM-TCODE PIC 9. + 05 MM-LIMIT PIC S9(9) COMP-3. + 05 MM-ALLOW2 PIC S9(7) COMP-3. + 05 MM-ACODE2 PIC 9. + 05 MM-TCODE2 PIC 9. + 05 MM-LIMIT2 PIC S9(9) COMP-3. + 05 MM-DATE2 PIC 99. + 05 MM-ALLOW3 PIC S9(7) COMP-3. + 05 MM-ACODE3 PIC 9. + 05 MM-TCODE3 PIC 9. + 05 MM-LIMIT3 PIC S9(9) COMP-3. + 05 MM-DATE3 PIC 99. + 05 MM-FORM-LCK PIC 9. + 05 MM-SPACE1 PIC S9(7) COMP-3. + 05 MM-KODE2 PIC 9. + 05 MM-SPACE2 PIC S9(7) COMP-3. + 05 MM-JOHN PIC 9. + 05 FILLER13 PIC 9(09). + 05 FILLER14 PIC 9(09). + 01 WELL-MAST REDEFINES FIELD-MAST. + 02 WELL-CODES. + 03 WELL-REC-TYPE-REC PIC 9. + 03 WELL-REC-DIST PIC XXX. + 03 WELL-REC-FIELD PIC 9(8). + 03 WELL-REC-OPR PIC 9(6). + 03 WELL-REC-LEASE PIC 9(5). + 03 WELL-REC-FILLER PIC 99. + 03 WELL-REC-OFFSHORE PIC 9. + 02 WELL-DATA. + 03 WELL-NO PIC X(6). + 03 W-TYPE-WELL PIC X(1). + 03 FILLER15. + 05 W-UNIT-NO PIC X. + 05 W-UNIT-VALUE PIC 9V999. + 03 W-KEY PIC 9. + 03 W-COUNTY PIC 999. + 03 PUMP PIC 9. + 03 PUMPX REDEFINES PUMP PIC X. + 03 W-SP PIC 9(5). + 03 W-NET PIC 9(6). + 03 W-NGOR REDEFINES W-NET. + 05 W-N-CODE PIC 9. + 05 W-N-AMT PIC 9(5). + 03 W-DEPTH PIC 9(5). + 03 SAND PIC 9(3). + 03 FROZEN PIC 9(5). + 03 PERF PIC 9(5). + 03 W-DATE PIC 9(8). + 03 WELL-D REDEFINES W-DATE. + 05 WELL-D-CC PIC 99. + 05 WELL-D-YR PIC 99. + 05 WELL-D-MO PIC 99. + 05 WELL-D-DAY PIC 99. + 03 EX-14B-CD PIC X. + 03 W-SUB-WELL PIC 9. + 03 W-SUB-WELL-ALPHA REDEFINES W-SUB-WELL + PIC X. + 03 W-NO-PROD-CD PIC 9. + 03 W-DELQ-FORM PIC 9. + 03 W-TST-EFF PIC X. + 03 W-EXC-TST PIC 9. + 88 ONE-WELL-LEASE-EXCEPTION VALUE 5. + 03 W-WATER PIC 9(4). + 03 EX-14B-DATE PIC 9(6). + 03 EX-14B-DATE-REDF REDEFINES EX-14B-DATE. + 05 EX-CC-14B PIC 99. + 05 EX-YR-14B PIC 99. + 05 EX-MO-14B PIC 99. + 03 W-RMKS PIC X(15). + 03 BONUS-AMT PIC 9(4). + 03 BONS REDEFINES BONUS-AMT. + 05 BONUS-CD PIC 9. + 05 BONUS PIC 999. + 03 FROZTSF PIC 999. + 03 W-WLSD PIC 9. + 03 W-TST-DT PIC 9(8). + 03 W-TEST-DATE REDEFINES W-TST-DT. + 05 W-TST-CC PIC 99. + 05 W-TST-YR PIC 99. + 05 W-TST-MO PIC 99. + 05 W-TST-DA PIC 99. + 03 W-DTE-LST-UTL PIC 9(6). + 03 W-DTE-LST-UTL-REDF REDEFINES W-DTE-LST-UTL. + 05 W-DTE-LST-UTL-CC PIC 99. + 05 W-DTE-LST-UTL-YY PIC 99. + 05 W-DTE-LST-UTL-MM PIC 99. + 03 W-NEW-WB-EXC PIC X(01). + 03 W-NEW-WB-CONNECT-DATE PIC 9(8). + 03 W-NEW-WB-CONNECT-DATE-REDF REDEFINES + W-NEW-WB-CONNECT-DATE. + 05 W-NEW-WB-CC PIC 99. + 05 W-NEW-WB-YR PIC 99. + 05 W-NEW-WB-MO PIC 99. + 05 W-NEW-WB-DA PIC 99. + 03 W-14B2-TYPE-COVERAGE PIC X(01). + 03 W-14B2-APP-NO PIC 9(06). + 03 FILLER17 PIC 9(04). + 03 FILLER18 PIC 9(18). + 03 FILLER19 PIC 9(07). + 03 W-MONTH OCCURS 14 TIMES. + 05 W-MONTH-DATE PIC 9(6). + 05 W-MONTH-DATE-REDF REDEFINES W-MONTH-DATE. + 07 WM-CC PIC 99. + 07 WM-YR PIC 99. + 07 WM-MO PIC 99. + 05 WM-CHG PIC 9. + 05 WM-NO PIC 9. + 05 WM-ALLOW PIC S9(5) COMP-3. + 05 WM-ACODE PIC X. + 05 WM-TCODE PIC X. + 05 WM-LIMIT PIC S9(7) COMP-3. + 05 WM-ALLOW2 PIC S9(5) COMP-3. + 05 WM-ACODE2 PIC X. + 05 WM-TCODE2 PIC X. + 05 WM-LIMIT2 PIC S9(7) COMP-3. + 05 WM-DATE2 PIC 99. + 05 WM-ALLOW3 PIC S9(5) COMP-3. + 05 WM-ACODE3 PIC X. + 05 WM-TCODE3 PIC X. + 05 WM-LIMIT3 PIC S9(7) COMP-3. + 05 WM-DATE3 PIC 99. + 05 WM-FORM-LCK PIC 9. + 05 WM-PGT PIC S999 COMP-3. + 05 WM-TSWA PIC 9. + 05 WM-EGT PIC S999 COMP-3. + 05 WM-ESWA PIC 9. + 05 WM-ACRE PIC S999V99 COMP-3. + 05 WM-POTE PIC S9999V9 COMP-3. + 05 WM-ACFT PIC S9(5) COMP-3. + 05 WM-GOR PIC S9(5) COMP-3. + 05 WM-OTRAN-CD PIC 9. + 05 WM-POT PIC S999 COMP-3. + 05 WM-EOT PIC S999 COMP-3. + 05 WM-JOHN PIC 9. + 05 WM-OOIP PIC 9(06). + 05 FILLER20 PIC 9(03). + +WORKING-STORAGE SECTION. +01 EndOfFile PIC X VALUE 'N'. +01 WS-EOF-FLAG PIC X VALUE 'N'. + +PROCEDURE DIVISION. + DISPLAY 'Start of Program'. + OPEN INPUT TXOilLedgerFile + PERFORM UNTIL WS-EOF-FLAG = 'Y' + READ MyFile INTO PersonRecord + AT END + MOVE 'Y' TO WS-EOF-FLAG + NOT AT END + PERFORM ProcessRecord + END-READ + END-PERFORM + CLOSE MyFile + DISPLAY 'End of Program'. + STOP RUN. + +ProcessRecord. + DISPLAY 'WM-DATE3: ' WM-DATE3 + DISPLAY 'F-TYPE: ' F-TYPE + DISPLAY 'SPAC: ' SPAC + DISPLAY '---------------------'. diff --git a/src/rrc_scrape.py b/src/rrc_scrape.py new file mode 100644 index 0000000..7a96039 --- /dev/null +++ b/src/rrc_scrape.py @@ -0,0 +1,60 @@ +import time + +import pandas as pd +from selenium import webdriver +from selenium.webdriver.common.by import By +from selenium.webdriver.common.action_chains import ActionChains +from selenium.webdriver.chrome.options import Options +chrome_options = Options() +chrome_options.add_argument("--headless=new") + + +# this program gets the URLs for the dataset section +# next it will make a list of URLs for each of the files section by section + +driver = webdriver.Chrome(options=chrome_options) +driver.get("https://www.rrc.texas.gov/resource-center/research/data-sets-available-for-download/") +settings = {'behavior': 'allow', 'downloadPath': '/Users/markyoung/data'} +driver.execute_cdp_cmd('Browser.setDownloadBehavior', settings) + +# Find the Data Sets H2 element. +h2 = driver.find_element(By.XPATH, "//article/h2[text()='Data Sets']") + +td_download_elements = h2.find_elements(By.XPATH, "following-sibling::table/tbody/tr/td[@data-label='Download']") +th_description = h2.find_elements(By.XPATH, "following-sibling::table/tbody/tr/th") +a_elements = [td.find_element(By.XPATH, "span/a") for td in td_download_elements] + +data_set_names = [x.text for x in th_description] + +download_types = [] +for file_type in a_elements: + file_type_words = file_type.text.split(' ') + try: + file_type_words.remove('File') + file_type_words.remove('Format') + except Exception as e: + pass + download_type = ' '.join(file_type_words) + download_types.append(download_type) + +href_list = [x.get_attribute('href') for x in a_elements] +df = pd.DataFrame(zip(download_types, href_list, data_set_names), + columns=['filetype', 'uri', 'dataset_description']) + +time_start = time.time() +oil_df = df[df['dataset_description'].str.contains('Oil')] +# for testing. remove next line +oil_df = oil_df.head(1) +for uri in list(oil_df['uri']): + driver.get(uri) + anchors = driver.find_elements(By.XPATH, "//a")[1:] + for anchor in anchors: + ac = (ActionChains(driver) + .move_to_element(anchor) + .click()).perform() + time.sleep(2) + + +time_end = time.time() +elapsed_sec = (time_end - time_start) / 60.0 +print(f'time for all pages: in minutes {elapsed_sec:.2f}') diff --git a/src/setup.cfg b/src/setup.cfg new file mode 100644 index 0000000..6386d18 --- /dev/null +++ b/src/setup.cfg @@ -0,0 +1,3 @@ +[flake8] +ignore = W504, E501, E303, E301, E231, E101, W291, W391, E202, E252, E225, E201, E222, E261, E275, E302, F401, W191, W293 +max-line-length = 127 diff --git a/src/test_OilMaster.py b/src/test_OilMaster.py new file mode 100644 index 0000000..ff2726e --- /dev/null +++ b/src/test_OilMaster.py @@ -0,0 +1,10 @@ +from OilMaster import OilMaster + +def test_OilMaster(): + data_division_file = 'ola_copybook.txt' + data_division_file = 'a.txt' + data_division_file = 'b.txt' + data_division_file = 'o.txt' + om = OilMaster(data_division_file) + + assert(om.get_format() is not None) diff --git a/src/test_cobol_data_parser.py b/src/test_cobol_data_parser.py new file mode 100644 index 0000000..f92cb8e --- /dev/null +++ b/src/test_cobol_data_parser.py @@ -0,0 +1,466 @@ +import tempfile + +import pytest + +from cobol_data_parser import extract_structures + + +@pytest.fixture +def test_1_copybook_file_contents(): + ''' + return a file object that contains the text below. + have it be temporary so that it goes away afterward + ''' + + file_text = ''' +IDENTIFICATION DIVISION. + +PROGRAM-ID. SHOW-STRUCTURE. + +DATA DIVISION. +FILE SECTION. +FD oil_file. +01 FIELD-MAST. + 02 OIL-CODES. + 03 TYPE-REC PIC 9. + 03 DIST PIC 999. + 03 FIELD PIC 9(8). + 03 OPR PIC 9(6). + 03 LEASE PIC 9(5). + 03 LSE-FILLER PIC 99. + 03 OFFSHORE PIC 9. + 02 FIELD-DATA. + 03 F-NAME PIC X(32). + 03 COUNTY PIC 9(18). + 03 COUNTIES REDEFINES COUNTY + OCCURS 6 TIMES + PIC 9(3). + 03 DISC-DATE PIC 9(8). + 03 D-DATE REDEFINES DISC-DATE. + 05 DSC-CCYY PIC 9(4). + 05 DSC-CCYY-REDF REDEFINES DSC-CCYY. + 07 DSC-CC PIC 99. + 07 DSC-YR PIC 99. + 05 DSC-MO PIC 99. + 05 DSC-DAY PIC 99. + 03 F-DEPTH PIC 9(5). + 03 O-GRAV PIC 999. + 03 F-TYPE PIC 9. + 03 MULT-RES PIC 9. + 03 F-LPB PIC 9. + 03 F-XMT PIC 9. + 03 PRT-AS-IS PIC 9. + 03 YARD PIC 9. + 03 T-CODES PIC 9(12). + 03 TEST-CODE REDEFINES T-CODES OCCURS 12 TIMES PIC 9. + 03 ALLOCATION-PERCNT01 PIC V99. + 03 ALLOCATION-CODEF01 PIC 99. + 03 ALLOCATION-PERCNT02 PIC V99. + 03 ALLOCATION-CODEF02 PIC 99. + 03 ALLOCATION-PERCNT03 PIC V99. + 03 ALLOCATION-CODEF03 PIC 99. + 03 RES-AMT PIC 9(6). + 03 F-GOR PIC 9(6). + 03 F-LIMIT REDEFINES F-GOR. + 05 F-GOR-CODE PIC 9. + 05 F-GOR-AMT PIC 9(5). + 03 F-TOP PIC 9(5). + 03 F-MER REDEFINES F-TOP. + 05 F-TOP-CODE PIC 9. + 05 F-TOP-AMT PIC 9(4). + 03 F-NET PIC 9(6). + 03 F-NGOR REDEFINES F-NET. + 05 F-NET-CODE PIC 9. + 05 F-NET-AMT PIC 9(5). + 03 UNET PIC 999. + 03 TOL PIC 9999. + 03 TOLER REDEFINES TOL. + 05 F-TOL-CODE PIC 9. + 05 F-TOL-AMT PIC 999. + 03 SPAC PIC 9(8). + 03 SPAC1-2 REDEFINES SPAC. + 05 SPAC1 PIC 9999. + 05 SPAC2 PIC 9999. + 03 DIAG PIC 9999. + 03 CUM-PROD PIC S9(13) COMP-3. + 03 CASING PIC X(21). + 03 COL-HEAD PIC X. + 03 ALO-CODE PIC X. + 03 F-RMK1 PIC X(66). + 03 F-RMK2 PIC X(66). + 03 PERM-NO PIC X(5). + 03 SP-FHC PIC 9. + 03 AN-1 PIC X(66). + 03 AN-2 PIC X(59). + 03 F-OOIP PIC 9(08). + 03 FILLER1 PIC 9(07). + 03 FILLER2 PIC 9(15). + 03 FILLER3 PIC 9(13). + 03 F-MONTH OCCURS 14 TIMES. + 05 FM-DATE PIC 9(6). + 05 FM-DATE-REDF REDEFINES FM-DATE. + 07 FM-CCYY PIC 9(4). + 07 FM-CCYY-REDF REDEFINES FM-CCYY. + 09 FM-CC PIC 99. + 09 FM-YR PIC 99. + 07 FM-MO PIC 99. + 05 FM-PW PIC S9(3) COMP-3. + 05 FM-AC PIC S999V9(4) COMP-3. + 05 FILLER4 PIC 9(4). + 05 FM-OTHC PIC 9. + 05 FM-CHG PIC 9. + 05 FM-PROD-FACT PIC S99V999 COMP-3. + 05 FM-SPLIT-PROD-FACT PIC S99V999 COMP-3. + 05 FM-SPLIT-PROD-FACT-DATE PIC 99. + 05 FM-JOHN PIC 9. + 05 FM-OTH PIC S99999999V9999999 COMP-3. + 05 FILLER5 PIC X(15). + 01 LEASE-MAST REDEFINES FIELD-MAST. + 02 LSE-CODES. + 03 LEASE-REC-TYPE-REC PIC 9. + 03 LEASE-REC-DIST PIC XXX. + 03 LEASE-REC-FIELD PIC 9(8). + 03 LEASE-REC-OPR PIC 9(6). + 03 LEASE-REC-LEASE PIC 9(5). + 03 LEASE-REC-FILLER PIC XX. + 03 LEASE-REC-OFFSHORE PIC 9. + 02 LEASE-DATA. + 03 L-NAME PIC X(32). + 03 LSE-CO PIC 9(6). + 03 LEASE-CO REDEFINES LSE-CO. + 05 L-CO-1 PIC 999. + 05 L-CO-2 PIC 999. + 03 POGATH PIC X(5). + 03 PGGATH PIC X(5). + 03 OSPLIT PIC 9. + 03 GSPLIT PIC 9. + 03 OOGATH PIC X(5). + 03 OGGATH PIC X(5). + 03 OOPR PIC 9(6). + 03 BO-STATUS PIC S9(7) COMP-3. + 03 BG-STATUS PIC S9(7) COMP-3. + 03 MOVE-BAL PIC S9(7) COMP-3. + 03 PO-STATUS PIC S9(7) COMP-3. + 03 PG-STATUS PIC S9(7) COMP-3. + 03 SEC-REC PIC 9. + 03 CERT PIC 99. + 03 BATCH PIC X. + 03 L-LPB PIC 9. + 03 COMMINGLE-CD PIC 9. + 03 COMMINGLE PIC 9999. + 03 L-INFO PIC X(54). + 03 AD-BO-STATUS PIC S9(7) COMP-3. + 03 AD-BG-STATUS PIC S9(7) COMP-3. + 03 COMMINGLE-DATE PIC 9(6). + 03 COMMINGLE-DATE-REDF REDEFINES COMMINGLE-DATE. + 05 COMMINGLE-CCYY PIC 9(4). + 05 COMMINGLE-CCYY-REDF REDEFINES + COMMINGLE-CCYY. + 07 COMMINGLE-CC PIC 99. + 07 COMMINGLE-YR PIC 99. + 05 COMMINGLE-MO PIC 99. + 03 L-RMCD PIC 9. + 03 L-RMDT PIC 9(6). + 03 L-RMDT-REDF REDEFINES L-RMDT. + 05 L-RMDT-CCYY PIC 9(4). + 05 L-RMDT-CCYY-REDF REDEFINES L-RMDT-CCYY. + 07 L-RMCC PIC 99. + 07 L-RMYR PIC 99. + 05 L-RMMO PIC 99. + 03 SEV-CD-13 PIC 9. + 03 SEV-CD-14 PIC 9. + 03 CAS-RED. + 05 L-CAS-SI-LTR-DTE PIC 9(6). + 05 L-RED-RTE-DTE PIC 9(6). + 03 CAS-RED-A REDEFINES CAS-RED. + 05 L-CAS-CCYY PIC 9(4). + 05 L-CAS-CCYY-REDF REDEFINES L-CAS-CCYY. + 07 L-CAS-CC PIC 99. + 07 L-CAS-YR PIC 99. + 05 L-CAS-MO PIC 99. + 05 L-RED-CCYY PIC 9(4). + 05 L-RED-CCYY-REDF REDEFINES L-RED-CCYY. + 07 L-RED-CC PIC 99. + 07 L-RED-YR PIC 99. + 05 L-RED-MO PIC 99. + 03 L-EXC-TST PIC 9. + 03 L-RLTYCD PIC 9. + 03 L-ONE-WELL-LEASE PIC X. + 88 ONE-WELL-ON-SCHEDULE VALUE 'Y'. + 88 MULTIPLE-WELL-LEASE VALUE 'N'. + 03 L-PANHANDLE-GOR-EXC PIC X(01). + 03 L-PANHANDLE-GOR-AMT PIC 9(08)V9 COMP-3. + 03 FILLER6 PIC 9(04). + 03 L-MONTH OCCURS 12 TIMES. + 05 L-MONTH-DATE PIC 9(6). + 05 L-MONTH-DATE-REDF REDEFINES + L-MONTH-DATE. + 07 L-MONTH-CCYY PIC 9(4). + 07 L-MONTH-CCYY-REDF REDEFINES + L-MONTH-CCYY. + 09 LM-CC PIC 99. + 09 LM-YR PIC 99. + 07 LM-MO PIC 99. + 05 LM-SEV PIC 9. + 05 LM-RETRO PIC 9. + 05 LM-REC PIC 9. + 05 LM-CHG PIC 9. + 05 LM-ALLOW PIC S9(7) COMP-3. + 05 LM-PROD PIC S9(7) COMP-3. + 05 LM-FW PIC 999. + 05 LM-OW PIC 999. + 05 LM-PL PIC S9(7) COMP-3. + 05 LM-PLC PIC 9. + 05 LM-OTH PIC S9(7) COMP-3. + 05 LM-OTHC PIC 9. + 05 LM-STO PIC S9(7) COMP-3. + 05 LM-GL PIC S9(9) COMP-3. + 05 LM-GPROD PIC S9(9) COMP-3. + 05 LM-GLIFT PIC S9(7) COMP-3. + 05 LM-CSIL PIC 9. + 05 LM-JOHN PIC 9. + 05 LM-LTR-CODE PIC 9. + 05 FILLER7 PIC 9(13). + 05 FILLER8 PIC 9(13). + 03 FILLER9 PIC 9(04). + 01 MULTI-MAST REDEFINES FIELD-MAST. + 02 MULTI-CODES. + 03 MULTI-W-REC-TYPE-REC PIC 9. + 03 MULTI-W-REC-DIST PIC XXX. + 03 MULTI-W-REC-FIELD PIC 9(8). + 03 MULTI-W-REC-OPR PIC 9(6). + 03 MULTI-W-REC-LEASE PIC 9(5). + 03 MULTI-W-REC-FILLER PIC 99. + 03 MULTI-W-REC-OFFSHORE PIC 9. + 02 MULTI-DATA. + 03 M-RECORD PIC X(6). + 03 TYPEW PIC X. + 03 RESER PIC X(5). + 03 UNIT-YATES REDEFINES RESER. + 05 UNIT-NO-I PIC X. + 05 UNIT-VALUE PIC 9V999. + 03 M-COUNTY PIC 9(6). + 03 MULTI-CO REDEFINES M-COUNTY. + 05 M-CO-1 PIC 999. + 05 M-CO-2 PIC 999. + 03 M-TST-EFF PIC X. + 03 M-PNTR-1ST PIC 9(6). + 03 CAP PIC 9. + 03 PROD-WELL PIC 9(6). + 03 PI-WELLS REDEFINES PROD-WELL. + 05 M-PROD PIC 999. + 05 M-INJ PIC 999. + 03 MARG-WELL PIC 9(6). + 03 SM-WELLS REDEFINES MARG-WELL. + 05 M-SHUT PIC 999. + 05 M-MARG PIC 999. + 03 M-DEPTH PIC 9. + 03 M-PNTR-LST PIC 9(6). + 03 M-EXC-TEST PIC 9. + 03 FILLER10 PIC 9(6). + 03 M-WATER PIC 9(6). + 03 M-REMARK PIC X(55). + 03 MM-PRCNT PIC V999. + 03 FILLER11 PIC 9(11). + 03 FILLER12 PIC 9(11). + 03 M-MONTH OCCURS 14 TIMES. + 05 M-MONTH-DATE PIC 9(6). + 05 M-MONTH-DATE-REDF REDEFINES + M-MONTH-DATE. + 07 M-MONTH-CCYY PIC 9(4). + 07 M-MONTH-CCYY-REDF REDEFINES + M-MONTH-CCYY. + 09 MM-CC PIC 99. + 09 MM-YR PIC 99. + 07 MM-MO PIC 99. + 05 MM-CHG PIC 9. + 05 MM-NO PIC 9. + 05 MM-ALLOW PIC S9(7) COMP-3. + 05 MM-ACODE PIC 9. + 05 MM-TCODE PIC 9. + 05 MM-LIMIT PIC S9(9) COMP-3. + 05 MM-ALLOW2 PIC S9(7) COMP-3. + 05 MM-ACODE2 PIC 9. + 05 MM-TCODE2 PIC 9. + 05 MM-LIMIT2 PIC S9(9) COMP-3. + 05 MM-DATE2 PIC 99. + 05 MM-ALLOW3 PIC S9(7) COMP-3. + 05 MM-ACODE3 PIC 9. + 05 MM-TCODE3 PIC 9. + 05 MM-LIMIT3 PIC S9(9) COMP-3. + 05 MM-DATE3 PIC 99. + 05 MM-FORM-LCK PIC 9. + 05 MM-SPACE1 PIC S9(7) COMP-3. + 05 MM-KODE2 PIC 9. + 05 MM-SPACE2 PIC S9(7) COMP-3. + 05 MM-JOHN PIC 9. + 05 FILLER13 PIC 9(09). + 05 FILLER14 PIC 9(09). + 01 WELL-MAST REDEFINES FIELD-MAST. + 02 WELL-CODES. + 03 WELL-REC-TYPE-REC PIC 9. + 03 WELL-REC-DIST PIC XXX. + 03 WELL-REC-FIELD PIC 9(8). + 03 WELL-REC-OPR PIC 9(6). + 03 WELL-REC-LEASE PIC 9(5). + 03 WELL-REC-FILLER PIC 99. + 03 WELL-REC-OFFSHORE PIC 9. + 02 WELL-DATA. + 03 WELL-NO PIC X(6). + 03 W-TYPE-WELL PIC X(1). + 03 FILLER15. + 05 W-UNIT-NO PIC X. + 05 W-UNIT-VALUE PIC 9V999. + 03 W-KEY PIC 9. + 03 W-COUNTY PIC 999. + 03 PUMP PIC 9. + 03 PUMPX REDEFINES PUMP PIC X. + 03 W-SP PIC 9(5). + 03 W-NET PIC 9(6). + 03 W-NGOR REDEFINES W-NET. + 05 W-N-CODE PIC 9. + 05 W-N-AMT PIC 9(5). + 03 W-DEPTH PIC 9(5). + 03 SAND PIC 9(3). + 03 FROZEN PIC 9(5). + 03 PERF PIC 9(5). + 03 W-DATE PIC 9(8). + 03 WELL-D REDEFINES W-DATE. + 05 WELL-D-CC PIC 99. + 05 WELL-D-YR PIC 99. + 05 WELL-D-MO PIC 99. + 05 WELL-D-DAY PIC 99. + 03 EX-14B-CD PIC X. + 03 W-SUB-WELL PIC 9. + 03 W-SUB-WELL-ALPHA REDEFINES W-SUB-WELL + PIC X. + 03 W-NO-PROD-CD PIC 9. + 03 W-DELQ-FORM PIC 9. + 03 W-TST-EFF PIC X. + 03 W-EXC-TST PIC 9. + 88 ONE-WELL-LEASE-EXCEPTION VALUE 5. + 03 W-WATER PIC 9(4). + 03 EX-14B-DATE PIC 9(6). + 03 EX-14B-DATE-REDF REDEFINES EX-14B-DATE. + 05 EX-CC-14B PIC 99. + 05 EX-YR-14B PIC 99. + 05 EX-MO-14B PIC 99. + 03 W-RMKS PIC X(15). + 03 BONUS-AMT PIC 9(4). + 03 BONS REDEFINES BONUS-AMT. + 05 BONUS-CD PIC 9. + 05 BONUS PIC 999. + 03 FROZTSF PIC 999. + 03 W-WLSD PIC 9. + 03 W-TST-DT PIC 9(8). + 03 W-TEST-DATE REDEFINES W-TST-DT. + 05 W-TST-CC PIC 99. + 05 W-TST-YR PIC 99. + 05 W-TST-MO PIC 99. + 05 W-TST-DA PIC 99. + 03 W-DTE-LST-UTL PIC 9(6). + 03 W-DTE-LST-UTL-REDF REDEFINES W-DTE-LST-UTL. + 05 W-DTE-LST-UTL-CC PIC 99. + 05 W-DTE-LST-UTL-YY PIC 99. + 05 W-DTE-LST-UTL-MM PIC 99. + 03 W-NEW-WB-EXC PIC X(01). + 03 W-NEW-WB-CONNECT-DATE PIC 9(8). + 03 W-NEW-WB-CONNECT-DATE-REDF REDEFINES + W-NEW-WB-CONNECT-DATE. + 05 W-NEW-WB-CC PIC 99. + 05 W-NEW-WB-YR PIC 99. + 05 W-NEW-WB-MO PIC 99. + 05 W-NEW-WB-DA PIC 99. + 03 W-14B2-TYPE-COVERAGE PIC X(01). + 03 W-14B2-APP-NO PIC 9(06). + 03 FILLER17 PIC 9(04). + 03 FILLER18 PIC 9(18). + 03 FILLER19 PIC 9(07). + 03 W-MONTH OCCURS 14 TIMES. + 05 W-MONTH-DATE PIC 9(6). + 05 W-MONTH-DATE-REDF REDEFINES W-MONTH-DATE. + 07 WM-CC PIC 99. + 07 WM-YR PIC 99. + 07 WM-MO PIC 99. + 05 WM-CHG PIC 9. + 05 WM-NO PIC 9. + 05 WM-ALLOW PIC S9(5) COMP-3. + 05 WM-ACODE PIC X. + 05 WM-TCODE PIC X. + 05 WM-LIMIT PIC S9(7) COMP-3. + 05 WM-ALLOW2 PIC S9(5) COMP-3. + 05 WM-ACODE2 PIC X. + 05 WM-TCODE2 PIC X. + 05 WM-LIMIT2 PIC S9(7) COMP-3. + 05 WM-DATE2 PIC 99. + 05 WM-ALLOW3 PIC S9(5) COMP-3. + 05 WM-ACODE3 PIC X. + 05 WM-TCODE3 PIC X. + 05 WM-LIMIT3 PIC S9(7) COMP-3. + 05 WM-DATE3 PIC 99. + 05 WM-FORM-LCK PIC 9. + 05 WM-PGT PIC S999 COMP-3. + 05 WM-TSWA PIC 9. + 05 WM-EGT PIC S999 COMP-3. + 05 WM-ESWA PIC 9. + 05 WM-ACRE PIC S999V99 COMP-3. + 05 WM-POTE PIC S9999V9 COMP-3. + 05 WM-ACFT PIC S9(5) COMP-3. + 05 WM-GOR PIC S9(5) COMP-3. + 05 WM-OTRAN-CD PIC 9. + 05 WM-POT PIC S999 COMP-3. + 05 WM-EOT PIC S999 COMP-3. + 05 WM-JOHN PIC 9. + 05 WM-OOIP PIC 9(06). + 05 FILLER20 PIC 9(03). + +WORKING-STORAGE SECTION. +01 EndOfFile PIC X VALUE 'N'. +01 WS-EOF-FLAG PIC X VALUE 'N'. + +PROCEDURE DIVISION. + DISPLAY 'Start of Program'. + OPEN INPUT TXOilLedgerFile + PERFORM UNTIL WS-EOF-FLAG = 'Y' + READ MyFile INTO PersonRecord + AT END + MOVE 'Y' TO WS-EOF-FLAG + NOT AT END + PERFORM ProcessRecord + END-READ + END-PERFORM + CLOSE MyFile + DISPLAY 'End of Program'. + STOP RUN. + +ProcessRecord. + DISPLAY 'WM-DATE3: ' WM-DATE3 + DISPLAY 'F-TYPE: ' F-TYPE + DISPLAY 'SPAC: ' SPAC + DISPLAY '---------------------'. + ''' + + return file_text + + +def test_extract_structures(test_1_copybook_file_contents): + tmp = tempfile.NamedTemporaryFile() + with open(tmp.name, 'w') as f: + f.write(test_1_copybook_file_contents) + symbol_table = extract_structures(tmp.name) + assert(len(symbol_table) == 4) + assert(symbol_table.sizes[0] == 1200) + assert(symbol_table.sizes[1] == 1200) + assert(symbol_table.sizes[2] == 1200) + assert(symbol_table.sizes[3] == 1200) + result = symbol_table.find_table_level_symbol('WM-JOHN') + symbol_info = 'Symbol: Level: 5, Name: WM-JOHN, Picture: 9, Size: 1, Raw Memory Slice: 241:242, Raw Memory Slice(1): 242:243' + assert(symbol_info == str(result[2])) + result = symbol_table.find_table_level_symbol('FIELD-MAST') + assert(result[0] is None) + result = symbol_table.find_table(0) + assert(len(result) == 81) + (table, level, symbol) = symbol_table.find_table_level_symbol('OIL-CODES') + assert(symbol_table.find_table_level_symbol('CAS-RED') == (None, None, None)) + _, level, _ = symbol_table.find_table_level_symbol('L-CAS-SI-LTR-DTE') + assert(level is None)